Game/Fishing2Server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert "框架更新"

Browse Source 
This reverts commit a2cb248512.
This commit is contained in:
BobSong
2025-10-29 22:41:19 +08:00
parent a2cb248512
commit 9572cf1955
429 changed files with 38758 additions and 7183 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
Fantasy/Fantays.Console/Runtime/Core/Serialize/ProtoBufPackHelper/IProto.cs Normal file
View File

@@ -0,0 +1,9 @@
namespace Fantasy.Serialize
{
/// <summary>
/// 代表是一个ProtoBuf协议
/// </summary>
public interface IProto
{
}
}

223
Fantasy/Fantays.Console/Runtime/Core/Serialize/ProtoBufPackHelper/ProtoBufPackHelperNet.cs Normal file
View File

@@ -0,0 +1,223 @@
#if FANTASY_NET || FANTASY_EXPORTER
using System.Buffers;
using Fantasy.Assembly;
using ProtoBuf.Meta;
namespace Fantasy.Serialize
{
/// <summary>
/// ProtoBufP帮助类，Net平台使用
/// </summary>
public sealed class ProtoBufPackHelper : ISerialize
{
/// <summary>
/// 序列化器的名字
/// </summary>
public string SerializeName { get; } = "ProtoBuf";
/// <summary>
/// 构造函数
/// </summary>
public ProtoBufPackHelper ()
{
#if FANTASY_NET
RuntimeTypeModel.Default.AutoAddMissingTypes = true;
RuntimeTypeModel.Default.AllowParseableTypes = true;
RuntimeTypeModel.Default.AutoAddMissingTypes = true;
RuntimeTypeModel.Default.AutoCompile = true;
RuntimeTypeModel.Default.UseImplicitZeroDefaults = true;
RuntimeTypeModel.Default.InferTagFromNameDefault = true;
foreach (var type in AssemblySystem.ForEach(typeof(IProto)))
{
RuntimeTypeModel.Default.Add(type, true);
}
RuntimeTypeModel.Default.CompileInPlace();
#endif
}
/// <summary>
/// 使用ProtoBuf反序列化数据到实例
/// </summary>
/// <param name="bytes"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public T Deserialize<T>(byte[] bytes)
{
var memory = new ReadOnlyMemory<byte>(bytes);
var @object = RuntimeTypeModel.Default.Deserialize<T>(memory);
if (@object is ASerialize aSerialize)
{
aSerialize.AfterDeserialization();
}
return @object;
}
/// <summary>
/// 使用ProtoBuf反序列化数据到实例
/// </summary>
/// <param name="buffer"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public T Deserialize<T>(MemoryStreamBuffer buffer)
{
var @object = RuntimeTypeModel.Default.Deserialize<T>(buffer);
if (@object is ASerialize aSerialize)
{
aSerialize.AfterDeserialization();
}
return @object;
}
/// <summary>
/// 使用ProtoBuf反序列化数据到实例
/// </summary>
/// <param name="type"></param>
/// <param name="bytes"></param>
/// <returns></returns>
public object Deserialize(Type type, byte[] bytes)
{
var memory = new ReadOnlyMemory<byte>(bytes);
var @object = RuntimeTypeModel.Default.Deserialize(type, memory);
if (@object is ASerialize aSerialize)
{
aSerialize.AfterDeserialization();
}
return @object;
}
/// <summary>
/// 使用ProtoBuf反序列化数据到实例
/// </summary>
/// <param name="type"></param>
/// <param name="buffer"></param>
/// <returns></returns>
public object Deserialize(Type type, MemoryStreamBuffer buffer)
{
var @object = RuntimeTypeModel.Default.Deserialize(type, buffer);
if (@object is ASerialize aSerialize)
{
aSerialize.AfterDeserialization();
}
return @object;
}
/// <summary>
/// 使用ProtoBuf反序列化数据到实例
/// </summary>
/// <param name="bytes"></param>
/// <param name="index"></param>
/// <param name="count"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public T Deserialize<T>(byte[] bytes, int index, int count)
{
var memory = new ReadOnlyMemory<byte>(bytes, index, count);
var @object = RuntimeTypeModel.Default.Deserialize<T>(memory);
if (@object is ASerialize aSerialize)
{
aSerialize.AfterDeserialization();
}
return @object;
}
/// <summary>
/// 使用ProtoBuf反序列化数据到实例
/// </summary>
/// <param name="type"></param>
/// <param name="bytes"></param>
/// <param name="index"></param>
/// <param name="count"></param>
/// <returns></returns>
public object Deserialize(Type type, byte[] bytes, int index, int count)
{
var memory = new ReadOnlyMemory<byte>(bytes, index, count);
var @object = RuntimeTypeModel.Default.Deserialize(type, memory);
if (@object is ASerialize aSerialize)
{
aSerialize.AfterDeserialization();
}
return @object;
}
/// <summary>
/// 使用ProtoBuf序列化某一个实例到IBufferWriter中
/// </summary>
/// <param name="object"></param>
/// <param name="buffer"></param>
/// <typeparam name="T"></typeparam>
public void Serialize<T>(T @object, IBufferWriter<byte> buffer)
{
if (@object is ASerialize aSerialize)
{
aSerialize.BeginInit();
}
RuntimeTypeModel.Default.Serialize<T>(buffer, @object);
}
/// <summary>
/// 使用ProtoBuf序列化某一个实例到IBufferWriter中
/// </summary>
/// <param name="object"></param>
/// <param name="buffer"></param>
public void Serialize(object @object, IBufferWriter<byte> buffer)
{
if (@object is ASerialize aSerialize)
{
aSerialize.BeginInit();
}
RuntimeTypeModel.Default.Serialize(buffer, @object);
}
/// <summary>
/// 使用ProtoBuf序列化某一个实例到IBufferWriter中
/// </summary>
/// <param name="type"></param>
/// <param name="object"></param>
/// <param name="buffer"></param>
public void Serialize(Type type, object @object, IBufferWriter<byte> buffer)
{
if (@object is ASerialize aSerialize)
{
aSerialize.BeginInit();
}
RuntimeTypeModel.Default.Serialize(buffer, @object);
}
internal byte[] Serialize(object @object)
{
if (@object is ASerialize aSerialize)
{
aSerialize.BeginInit();
}
using (var buffer = new MemoryStream())
{
RuntimeTypeModel.Default.Serialize(buffer, @object);
return buffer.ToArray();
}
}
private byte[] Serialize<T>(T @object)
{
if (@object is ASerialize aSerialize)
{
aSerialize.BeginInit();
}
using (var buffer = new MemoryStream())
{
RuntimeTypeModel.Default.Serialize<T>(buffer, @object);
return buffer.ToArray();
}
}
/// <summary>
/// 克隆
/// </summary>
/// <param name="t"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public T Clone<T>(T t)
{
return Deserialize<T>(Serialize(t));
}
}
}
#endif

202
Fantasy/Fantays.Console/Runtime/Core/Serialize/ProtoBufPackHelper/ProtoBufPackHelperUnity.cs Normal file
View File

@@ -0,0 +1,202 @@
#if FANTASY_UNITY || FANTASY_CONSOLE
using System;
using System.Buffers;
using System.IO;
using Fantasy.Assembly;
using ProtoBuf;
using ProtoBuf.Meta;
namespace Fantasy.Serialize
{
/// <summary>
/// ProtoBufP帮助类，Unity平台使用
/// </summary>
public sealed class ProtoBufPackHelper : ISerialize
{
/// <summary>
/// 序列化器的名字
/// </summary>
public string SerializeName { get; } = "ProtoBuf";
/// <summary>
/// 使用ProtoBuf反序列化数据到实例
/// </summary>
/// <param name="bytes"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public unsafe T Deserialize<T>(byte[] bytes)
{
fixed (byte* ptr = bytes)
{
using var stream = new UnmanagedMemoryStream(ptr, bytes.Length);
var @object = ProtoBuf.Serializer.Deserialize<T>(stream);
if (@object is ASerialize aSerialize)
{
aSerialize.AfterDeserialization();
}
return @object;
}
}
/// <summary>
/// 使用ProtoBuf反序列化数据到实例
/// </summary>
/// <param name="buffer"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public T Deserialize<T>(MemoryStreamBuffer buffer)
{
var @object = ProtoBuf.Serializer.Deserialize<T>(buffer);
if (@object is ASerialize aSerialize)
{
aSerialize.AfterDeserialization();
}
return @object;
}
/// <summary>
/// 使用ProtoBuf反序列化数据到实例
/// </summary>
/// <param name="type"></param>
/// <param name="bytes"></param>
/// <returns></returns>
public unsafe object Deserialize(Type type, byte[] bytes)
{
fixed (byte* ptr = bytes)
{
using var stream = new UnmanagedMemoryStream(ptr, bytes.Length);
var @object = ProtoBuf.Serializer.Deserialize(type, stream);
if (@object is ASerialize aSerialize)
{
aSerialize.AfterDeserialization();
}
return @object;
}
}
/// <summary>
/// 使用ProtoBuf反序列化数据到实例
/// </summary>
/// <param name="type"></param>
/// <param name="buffer"></param>
/// <returns></returns>
public object Deserialize(Type type, MemoryStreamBuffer buffer)
{
var @object = ProtoBuf.Serializer.Deserialize(type, buffer);
if (@object is ASerialize aSerialize)
{
aSerialize.AfterDeserialization();
}
return @object;
}
/// <summary>
/// 使用ProtoBuf反序列化数据到实例
/// </summary>
/// <param name="bytes"></param>
/// <param name="index"></param>
/// <param name="count"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public unsafe T Deserialize<T>(byte[] bytes, int index, int count)
{
fixed (byte* ptr = &bytes[index])
{
using var stream = new UnmanagedMemoryStream(ptr, count);
var @object = ProtoBuf.Serializer.Deserialize<T>(stream);
if (@object is ASerialize aSerialize)
{
aSerialize.AfterDeserialization();
}
return @object;
}
}
/// <summary>
/// 使用ProtoBuf反序列化数据到实例
/// </summary>
/// <param name="type"></param>
/// <param name="bytes"></param>
/// <param name="index"></param>
/// <param name="count"></param>
/// <returns></returns>
public unsafe object Deserialize(Type type, byte[] bytes, int index, int count)
{
fixed (byte* ptr = &bytes[index])
{
using var stream = new UnmanagedMemoryStream(ptr, count);
var @object = ProtoBuf.Serializer.Deserialize(type, stream);
if (@object is ASerialize aSerialize)
{
aSerialize.AfterDeserialization();
}
return @object;
}
}
/// <summary>
/// 使用ProtoBuf序列化某一个实例到IBufferWriter中
/// </summary>
/// <param name="object"></param>
/// <param name="buffer"></param>
/// <typeparam name="T"></typeparam>
public void Serialize<T>(T @object, IBufferWriter<byte> buffer)
{
if (@object is ASerialize aSerialize)
{
aSerialize.BeginInit();
}
RuntimeTypeModel.Default.Serialize((MemoryStream)buffer, @object);
}
/// <summary>
/// 使用ProtoBuf序列化某一个实例到IBufferWriter中
/// </summary>
/// <param name="object"></param>
/// <param name="buffer"></param>
public void Serialize(object @object, IBufferWriter<byte> buffer)
{
if (@object is ASerialize aSerialize)
{
aSerialize.BeginInit();
}
RuntimeTypeModel.Default.Serialize((MemoryStream)buffer, @object);
}
/// <summary>
/// 使用ProtoBuf序列化某一个实例到IBufferWriter中
/// </summary>
/// <param name="type"></param>
/// <param name="object"></param>
/// <param name="buffer"></param>
public void Serialize(Type type, object @object, IBufferWriter<byte> buffer)
{
if (@object is ASerialize aSerialize)
{
aSerialize.BeginInit();
}
RuntimeTypeModel.Default.Serialize((MemoryStream)buffer, @object);
}
private byte[] Serialize<T>(T @object)
{
if (@object is ASerialize aSerialize)
{
aSerialize.BeginInit();
}
using (var buffer = new MemoryStream())
{
RuntimeTypeModel.Default.Serialize(buffer, @object);
return buffer.ToArray();
}
}
/// <summary>
/// 克隆
/// </summary>
/// <param name="t"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public T Clone<T>(T t)
{
return Deserialize<T>(Serialize(t));
}
}
}
#endif