public static ITypeSerialize GetByType(FieldInfo fieldInfo)
{
var type = fieldInfo.FieldType;
ITypeSerialize ts = null;
string fullname = type.FullName;
if (AllTypes.TryGetValue(fullname, out ts))
{
return(ts);
}
if (Help.IsType(type, typeof(Object)))
{
return(AllTypes[typeof(Object).FullName]);
}
if (type.IsArray)
{
ts = new ArrayAnyType(type);
AllTypes.Add(fullname, ts);
}
else if (type.IsGenericType && fullname.StartsWith("System.Collections.Generic.List`1[["))
{
ts = new ListAnyType(fieldInfo);
AllTypes.Add(fullname, ts);
}
else
{
List <FieldInfo> fieldinfos = Help.GetSerializeField(type);
ts = new AnyType(type, fieldinfos);
AllTypes.Add(fullname, ts);
}
return(ts);
}
public static void MergeFrom(ITypeSerialize typeSerialize, IStream stream, ref object value)
{
int count = ReadLength(stream);
int endpos = stream.WritePos;
stream.WritePos = stream.ReadPos + count;
try
{
typeSerialize.MergeFrom(ref value, stream);
#if UNITY_EDITOR
if (stream.ReadSize != 0)
{
L.LogErrorFormat("IListAnyType stream.ReadSize != 0");
}
#endif
}
catch (System.Exception ex)
{
L.LogException(ex);
}
finally
{
stream.WritePos = endpos;
}
}
void ITypeSerialize.WriteTo(object value, IStream stream)
{
if (value == null)
{
stream.WriteByte(0);
return;
}
var cnt = fieldInfos.Count;
stream.WriteByte(cnt == 0 ? (byte)2 : (byte)1);
if (cnt == 0)
{
return;
}
ITypeSerialize ts = this;
for (int i = 0; i < cnt; ++i)
{
var field = fieldInfos[i];
object cv = field.GetValue(value);
ts = BinarySerializable.GetByFieldInfo(field);
stream.WriteByte(ts.typeFlag); // 类型标识
stream.WriteString(field.Name);
using (new RLStream(stream))
{
ts.WriteTo(cv, stream);
}
}
}
public static ITypeSerialize GetByType(System.Type type)
{
ITypeSerialize ts = null;
string fullname = type.FullName;
if (AllTypes.TryGetValue(fullname, out ts))
{
return(ts);
}
if (Help.isType(type, typeof(UnityEngine.Object)))
{
ts = unityObjectSerialize;
}
else
{
if (type.IsEnum)
{
#if USE_HOT
if (type is ILRuntimeType)
{
ts = new HotEnumTypeSerialize((ILRuntimeType)type);
}
else
{
#endif
ts = new EnumTypeSerialize(type);
#if USE_HOT
}
#endif
}
else if (type.IsArray)
{
ts = new ArrayAnyType(type);
}
else if (Help.isListType(type))
{
ts = new ListAnyType(type);
}
else
{
var atts = type.GetCustomAttributes(typeof(SmartAttribute), false);
if (atts != null && atts.Length > 0)
{
ts = new SmartSerializer(type, new AnyTypeSerialize(type, Help.GetSerializeField(type)));
}
else
{
List <FieldInfo> fieldinfos = Help.GetSerializeField(type);
ts = new AnyTypeSerialize(type, fieldinfos);
}
}
}
AllTypes.Add(fullname, ts);
return(ts);
}
public static void Release()
{
unityObjectSerialize = null;
#if USE_HOT
FieldInfoTypes.Clear();
#endif
RefTypes.Clear();
AllTypes.Clear();
Init();
}
void ITypeSerialize.WriteTo(object value, MonoStream ms)
{
if (value == null)
{
return;
}
var stream = ms.Stream;
ITypeSerialize ts = this;
for (int i = 0; i < fieldInfos.Count; ++i)
{
var field = fieldInfos[i];
object cv = field.GetValue(value);
if (cv == null)
{
continue;
}
ts = MonoSerialize.GetByType(field);
stream.WriteString(field.Name);
int count = ts.CalculateSize(cv);
if (count == 0)
{
continue;
}
stream.WriteLength(count);
#if UNITY_EDITOR
int write_pos = stream.WritePos;
#endif
ts.WriteTo(cv, ms);
#if UNITY_EDITOR
if (stream.WritePos != write_pos + count)
{
UnityEngine.Debug.LogErrorFormat("type:{0} CalculateSize error!", ts.GetType().Name);
}
#endif
}
}
static void Init()
{
unityObjectSerialize = new UnityObjectSerialize();
// int,uint
Reg(TypeFlags.intType, (value, ms) => { ms.WriteVarInt32(value); }, (ms) => { return(ms.ReadVarInt32()); });
Reg(TypeFlags.uintType, (value, ms) => { ms.WriteVarUInt32(value); }, (ms) => { return(ms.ReadVarUInt32()); });
// sbyte,byte
Reg(TypeFlags.sbyteType, (value, ms) => { ms.WriteSByte(value); }, (ms) => { return(ms.ReadSByte()); });
Reg(TypeFlags.byteType, (value, ms) => { ms.WriteByte(value); }, (ms) => { return(ms.ReadByte()); });
// char
Reg(TypeFlags.charType, (value, ms) => { ms.WriteChar(value); }, (ms) => { return(ms.ReadChar()); });
// long,ulong
Reg(TypeFlags.longType, (value, ms) => { ms.WriteVarInt64(value); }, (ms) => { return(ms.ReadVarInt64()); });
Reg(TypeFlags.ulongType, (value, ms) => { ms.WriteVarUInt64(value); }, (ms) => { return(ms.ReadVarUInt64()); });
// short,ushort
Reg(TypeFlags.shortType, (value, ms) => { ms.WriteShort(value); }, (ms) => { return(ms.ReadShort()); });
Reg(TypeFlags.ushortType, (value, ms) => { ms.WriteUShort(value); }, (ms) => { return(ms.ReadUShort()); });
// float
Reg(TypeFlags.floatType, (value, ms) => { ms.WriteFloat(value); }, (ms) => { return(ms.ReadFloat()); });
// double
Reg(TypeFlags.doubleType, (value, ms) => { ms.WriteDouble(value); }, (ms) => { return(ms.ReadDouble()); });
// DateTime
Reg(TypeFlags.DateTimeType, (value, ms) => { ms.WriteLong(value.Ticks); }, (ms) => { return(new DateTime(ms.ReadLong())); });
// string
Reg(TypeFlags.stringType, (value, ms) => { ms.WriteString(value); }, (ms) => { return(ms.ReadString()); });
// bool
Reg <bool>(TypeFlags.boolType, (value, ms) => { ms.WriteByte(value ? (byte)1 : (byte)0); }, (ms) => { return(ms.ReadByte() == 0 ? false : true); });
}
public SmartSerializer(System.Type baseType, ITypeSerialize baseTypeSerialize)
{
this.baseType = baseType;
this.baseTypeSerialize = baseTypeSerialize;
}
static void Init()
{
unityObjectSerialize = new UnityObjectSerialize();
objectSerialize = new ObjectSerialize();
// int,uint
Reg(TypeFlags.intType, (value, ms) => ms.WriteVarInt32(value), (ms) => ms.ReadVarInt32(), (value) => value.ToString(), (str) => int.Parse(str));
Reg(TypeFlags.uintType, (value, ms) => ms.WriteVarUInt32(value), (ms) => ms.ReadVarUInt32(), (value) => value.ToString(), (str) => uint.Parse(str));
// sbyte,byte
Reg(TypeFlags.sbyteType, (value, ms) => ms.WriteSByte(value), (ms) => ms.ReadSByte(), (value) => value.ToString(), (str) => sbyte.Parse(str));
Reg(TypeFlags.byteType, (value, ms) => ms.WriteByte(value), (ms) => ms.ReadByte(), (value) => value.ToString(), (str) => byte.Parse(str));
// char
Reg(TypeFlags.charType, (value, ms) => ms.WriteChar(value), (ms) => ms.ReadChar(), (value) => value.ToString(), (str) => char.Parse(str));
// long,ulong
Reg(TypeFlags.longType, (value, ms) => ms.WriteVarInt64(value), (ms) => ms.ReadVarInt64(), (value) => value.ToString(), (str) => long.Parse(str));
Reg(TypeFlags.ulongType, (value, ms) => ms.WriteVarUInt64(value), (ms) => ms.ReadVarUInt64(), (value) => value.ToString(), (str) => ulong.Parse(str));
// short,ushort
Reg(TypeFlags.shortType, (value, ms) => ms.WriteShort(value), (ms) => ms.ReadShort(), (value) => value.ToString(), (str) => short.Parse(str));
Reg(TypeFlags.ushortType, (value, ms) => ms.WriteUShort(value), (ms) => ms.ReadUShort(), (value) => value.ToString(), (str) => ushort.Parse(str));
// float
Reg(TypeFlags.floatType, (value, ms) => ms.WriteFloat(value), (ms) => ms.ReadFloat(), (value) => value.ToString(), (str) => float.Parse(str));
// double
Reg(TypeFlags.doubleType, (value, ms) => ms.WriteDouble(value), (ms) => ms.ReadDouble(), (value) => value.ToString(), (str) => double.Parse(str));
// DateTime
Reg(TypeFlags.DateTimeType, (value, ms) => { ms.WriteLong(value.Ticks); }, (ms) => new DateTime(ms.ReadLong()), (value) => value.ToString(), (str) => DateTime.Parse(str));
// string
Reg(TypeFlags.stringType, (value, ms) => { ms.WriteString(value); }, (ms) => { return(ms.ReadString()); }, (value) => value, (str) => str);
// bool
Reg <bool>(TypeFlags.boolType, (value, ms) => ms.WriteByte(value ? (byte)1 : (byte)0), (ms) => ms.ReadByte() == 0 ? false : true, (value) => value.ToString(), (str) => bool.Parse(str));
Reg <Vector2Int>(TypeFlags.vector2Int,
(value, ms) =>
{
ms.WriteInt32(value.x);
ms.WriteInt32(value.y);
},
(ms) =>
{
Vector2Int vi = new Vector2Int();
vi.x = ms.ReadInt32();
vi.y = ms.ReadInt32();
return(vi);
},
(value) => $"{value.x},{value.y}",
(value) =>
{
Vector2Int vi = new Vector2Int();
string[] ss = value.Split(',');
vi.x = int.Parse(ss[0]);
vi.y = int.Parse(ss[1]);
return(vi);
});
Reg <Vector3Int>(TypeFlags.vector3Int,
(value, ms) =>
{
ms.WriteInt32(value.x);
ms.WriteInt32(value.y);
ms.WriteInt32(value.z);
},
(ms) =>
{
Vector3Int vi = new Vector3Int();
vi.x = ms.ReadInt32();
vi.y = ms.ReadInt32();
vi.z = ms.ReadInt32();
return(vi);
},
(value) => $"{value.x},{value.y},{value.z}",
(value) =>
{
Vector3Int vi = new Vector3Int();
string[] ss = value.Split(',');
vi.x = int.Parse(ss[0]);
vi.y = int.Parse(ss[1]);
vi.z = int.Parse(ss[2]);
return(vi);
});
}
protected bool isSmartType = false; // 数组是否保存一样的类型
public IListAnyType(ITypeSerialize elementTypeSerialize)
{
this.elementTypeSerialize = elementTypeSerialize;
}
public IListAnyType(System.Type arrayType, System.Type elementType)
{
this.arrayType = arrayType;
this.elementType = elementType;
elementTypeSerialize = MonoSerialize.GetByType(elementType);
}
