public static int GetObjectSize(Type type, object instance)
{
try
{
return(RawSerializer.GetFieldSize(type, null, instance));
}
catch (Exception value)
{
Console.WriteLine(value);
}
return(-1);
}
public SerializableAttribute(Type type)
{
this.objectSize = RawSerializer.GetObjectSize(type);
}
private bool Deserialize(byte[] source, int baseIndex, object target, out int writtenBytes)
{
if (target == null)
{
writtenBytes = 0;
return(false);
}
Type type = target.GetType();
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
int num = baseIndex;
FieldInfo[] array = fields;
for (int i = 0; i < array.Length; i++)
{
FieldInfo fieldInfo = array[i];
if (!RawSerializer.IsIngoreField(fieldInfo))
{
Type fieldType = fieldInfo.FieldType;
object obj = null;
if (fieldType.IsArray)
{
Array array2 = null;
LengthAttribute lengthAttribute = Attribute.GetCustomAttribute(fieldInfo, typeof(LengthAttribute)) as LengthAttribute;
if (lengthAttribute != null)
{
if (lengthAttribute.LengthField != null)
{
FieldInfo lengthField = this.GetLengthField(fields, lengthAttribute.LengthField);
if (lengthField != null)
{
object value = lengthField.GetValue(target);
Type type2 = value.GetType();
if (type2 == typeof(byte))
{
lengthAttribute.Length = (int)((byte)value);
}
else if (type2 == typeof(short))
{
lengthAttribute.Length = (int)((short)value);
}
else if (type2 == typeof(int))
{
lengthAttribute.Length = (int)value;
}
}
}
array2 = (fieldInfo.GetValue(target) as Array);
lengthAttribute.ResizeArray(fieldType, ref array2);
}
if (fieldType == typeof(bool[]))
{
obj = this.BytesToArray <bool>(source, ref num, array2, 1, new Func <byte[], int, bool>(BitConverter.ToBoolean));
}
else if (fieldType == typeof(char[]))
{
obj = this.BytesToChars(source, ref num, array2);
}
else if (fieldType == typeof(byte[]))
{
obj = this.BytesToArray <byte>(source, ref num, array2, 1, (byte[] buf, int off) => buf[off]);
}
else if (fieldType == typeof(sbyte[]))
{
obj = this.BytesToArray <byte>(source, ref num, array2, 1, (byte[] buf, int off) => buf[off]);
}
else if (fieldType == typeof(short[]))
{
obj = this.BytesToArray <short>(source, ref num, array2, 2, new Func <byte[], int, short>(BitConverter.ToInt16));
}
else if (fieldType == typeof(ushort[]))
{
obj = this.BytesToArray <ushort>(source, ref num, array2, 2, new Func <byte[], int, ushort>(BitConverter.ToUInt16));
}
else if (fieldType == typeof(int[]))
{
obj = this.BytesToArray <int>(source, ref num, array2, 4, new Func <byte[], int, int>(BitConverter.ToInt32));
}
else if (fieldType == typeof(uint[]))
{
obj = this.BytesToArray <uint>(source, ref num, array2, 4, new Func <byte[], int, uint>(BitConverter.ToUInt32));
}
else if (fieldType == typeof(long[]))
{
obj = this.BytesToArray <long>(source, ref num, array2, 8, new Func <byte[], int, long>(BitConverter.ToInt64));
}
else if (fieldType == typeof(ulong[]))
{
obj = this.BytesToArray <ulong>(source, ref num, array2, 8, new Func <byte[], int, ulong>(BitConverter.ToUInt64));
}
else if (fieldType == typeof(float[]))
{
obj = this.BytesToArray <float>(source, ref num, array2, 4, new Func <byte[], int, float>(BitConverter.ToSingle));
}
else if (fieldType == typeof(double[]))
{
obj = this.BytesToArray <double>(source, ref num, array2, 8, new Func <byte[], int, double>(BitConverter.ToDouble));
}
else if (!fieldType.GetElementType().IsPrimitive)
{
Array array3 = fieldInfo.GetValue(target) as Array;
if (array3 == null || array3.Length != array2.Length)
{
array3 = array2;
}
int num2 = 0;
foreach (object current in array3)
{
int num3;
this.Deserialize(source, num, current, out num3);
array3.SetValue(current, num2++);
num += num3;
}
fieldInfo.SetValue(target, array3);
}
}
else if (fieldType == typeof(bool))
{
obj = BitConverter.ToBoolean(source, num);
num++;
}
else if (fieldType == typeof(int))
{
obj = BitConverter.ToInt32(source, num);
num += 4;
}
else if (fieldType == typeof(uint))
{
obj = BitConverter.ToUInt32(source, num);
num += 4;
}
else if (fieldType == typeof(short))
{
obj = BitConverter.ToInt16(source, num);
num += 2;
}
else if (fieldType == typeof(ushort))
{
obj = BitConverter.ToUInt16(source, num);
num += 2;
}
else if (fieldType == typeof(long))
{
obj = BitConverter.ToInt64(source, num);
num += 8;
}
else if (fieldType == typeof(ulong))
{
obj = BitConverter.ToUInt64(source, num);
num += 8;
}
else if (fieldType == typeof(byte))
{
obj = source[num++];
}
else if (fieldType == typeof(sbyte))
{
obj = (sbyte)source[num++];
}
else if (fieldType == typeof(char))
{
obj = BitConverter.ToChar(source, num);
num += 2;
}
else if (fieldType == typeof(float))
{
obj = BitConverter.ToSingle(source, num);
num += 4;
}
else if (fieldType == typeof(double))
{
obj = BitConverter.ToDouble(source, num);
num += 8;
}
else if (fieldType == typeof(string))
{
char[] orgVal = null;
LengthAttribute lengthAttribute2 = Attribute.GetCustomAttribute(fieldInfo, typeof(LengthAttribute)) as LengthAttribute;
if (lengthAttribute2 != null)
{
lengthAttribute2.ResizeArray <char>(ref orgVal);
}
char[] array4 = this.BytesToChars(source, ref num, orgVal);
string text = new string(array4, 0, this.GetCompactLength(array4));
obj = text;
}
else if (!fieldType.IsPrimitive)
{
object value2 = fieldInfo.GetValue(target);
int num4;
this.Deserialize(source, num, value2, out num4);
fieldInfo.SetValue(target, value2);
num += num4;
}
if (obj != null)
{
fieldInfo.SetValue(target, obj);
}
}
}
writtenBytes = num - baseIndex;
return(writtenBytes > 0);
}
public RawSerializer(Type targetType, bool useFixedBufferSize)
{
this.mTargetType = targetType;
this.mObjectSize = RawSerializer.GetObjectSize(this.mTargetType);
this.UsingFixedSize = useFixedBufferSize;
}
private bool Serialize(object obj, int rawDataBaseIndex, out int writtenLength)
{
if (obj == null)
{
Console.WriteLine("Serialize() >> input object is null");
writtenLength = 0;
return(false);
}
Type type = obj.GetType();
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (fields == null)
{
Console.WriteLine("Serialize() >> GetFileds() is null");
writtenLength = 0;
return(false);
}
int num = rawDataBaseIndex;
FieldInfo[] array = fields;
for (int i = 0; i < array.Length; i++)
{
FieldInfo fieldInfo = array[i];
if (!RawSerializer.IsIngoreField(fieldInfo))
{
Type fieldType = fieldInfo.FieldType;
object value = fieldInfo.GetValue(obj);
byte[] array2 = null;
if (fieldType.IsArray)
{
Array array3 = value as Array;
LengthAttribute lengthAttribute = Attribute.GetCustomAttribute(fieldInfo, typeof(LengthAttribute)) as LengthAttribute;
if (lengthAttribute != null)
{
lengthAttribute.ResizeArray(fieldType, ref array3);
}
bool isWriteLength = lengthAttribute == null;
if (fieldType == typeof(bool[]))
{
array2 = this.ArrayToBytes <bool>(array3 as bool[], isWriteLength, 1, new Func <bool, byte[]>(BitConverter.GetBytes));
}
else if (fieldType == typeof(char[]))
{
array2 = this.CharsToBytes(array3 as char[], isWriteLength);
}
else if (fieldType == typeof(byte[]))
{
array2 = this.ArrayToBytes <byte>(array3 as byte[], isWriteLength, 1, (byte v) => new byte[]
{
v
});
}
else if (fieldType == typeof(sbyte[]))
{
array2 = this.ArrayToBytes <sbyte>(array3 as sbyte[], isWriteLength, 1, (sbyte v) => new byte[]
{
(byte)v
});
}
else if (fieldType == typeof(short[]))
{
array2 = this.ArrayToBytes <short>(array3 as short[], isWriteLength, 2, new Func <short, byte[]>(BitConverter.GetBytes));
}
else if (fieldType == typeof(ushort[]))
{
array2 = this.ArrayToBytes <ushort>(array3 as ushort[], isWriteLength, 2, new Func <ushort, byte[]>(BitConverter.GetBytes));
}
else if (fieldType == typeof(int[]))
{
array2 = this.ArrayToBytes <int>(array3 as int[], isWriteLength, 4, new Func <int, byte[]>(BitConverter.GetBytes));
}
else if (fieldType == typeof(uint[]))
{
array2 = this.ArrayToBytes <uint>(array3 as uint[], isWriteLength, 4, new Func <uint, byte[]>(BitConverter.GetBytes));
}
else if (fieldType == typeof(long[]))
{
array2 = this.ArrayToBytes <long>(array3 as long[], isWriteLength, 8, new Func <long, byte[]>(BitConverter.GetBytes));
}
else if (fieldType == typeof(ulong[]))
{
array2 = this.ArrayToBytes <ulong>(array3 as ulong[], isWriteLength, 8, new Func <ulong, byte[]>(BitConverter.GetBytes));
}
else if (fieldType == typeof(float[]))
{
array2 = this.ArrayToBytes <float>(array3 as float[], isWriteLength, 4, new Func <float, byte[]>(BitConverter.GetBytes));
}
else if (fieldType == typeof(double[]))
{
array2 = this.ArrayToBytes <double>(array3 as double[], isWriteLength, 8, new Func <double, byte[]>(BitConverter.GetBytes));
}
else if (!fieldType.GetElementType().IsPrimitive)
{
foreach (object current in array3)
{
int num2;
this.Serialize(current, num, out num2);
num += num2;
}
}
}
else if (fieldType == typeof(int))
{
array2 = BitConverter.GetBytes((int)value);
}
else if (fieldType == typeof(uint))
{
array2 = BitConverter.GetBytes((uint)value);
}
else if (fieldType == typeof(short))
{
array2 = BitConverter.GetBytes((short)value);
}
else if (fieldType == typeof(ushort))
{
array2 = BitConverter.GetBytes((ushort)value);
}
else if (fieldType == typeof(long))
{
array2 = BitConverter.GetBytes((long)value);
}
else if (fieldType == typeof(ulong))
{
array2 = BitConverter.GetBytes((ulong)value);
}
else if (fieldType == typeof(byte))
{
array2 = new byte[]
{
(byte)value
};
}
else if (fieldType == typeof(sbyte))
{
sbyte b = (sbyte)value;
array2 = new byte[]
{
(byte)b
};
}
else if (fieldType == typeof(float))
{
array2 = BitConverter.GetBytes((float)value);
}
else if (fieldType == typeof(double))
{
array2 = BitConverter.GetBytes((double)value);
}
else if (fieldType == typeof(bool))
{
array2 = BitConverter.GetBytes((bool)value);
}
else if (fieldType == typeof(char))
{
array2 = BitConverter.GetBytes((char)value);
}
else if (fieldType == typeof(string))
{
string text = value as string;
char[] chars = text.ToCharArray();
LengthAttribute lengthAttribute2 = Attribute.GetCustomAttribute(fieldInfo, typeof(LengthAttribute)) as LengthAttribute;
if (lengthAttribute2 != null)
{
lengthAttribute2.ResizeArray <char>(ref chars);
}
array2 = this.CharsToBytes(chars, lengthAttribute2 == null);
}
else if (!fieldType.IsPrimitive)
{
int num3;
this.Serialize(value, num, out num3);
num += num3;
}
if (array2 != null)
{
Buffer.BlockCopy(array2, 0, RawSerializer.mRawData, num, array2.Length);
num += array2.Length;
}
}
}
writtenLength = num - rawDataBaseIndex;
return(writtenLength > 0);
}
public static int GetObjectSize(Type type)
{
return(RawSerializer.GetObjectSize(type, null));
}
private static int GetFieldSize(Type type, FieldInfo ownerFieldInfo, object instance)
{
int num = 0;
if (type.IsPrimitive)
{
if (!RawSerializer.TryGetPrimitiveSize(type, out num))
{
throw new UnknownLengthException(ownerFieldInfo);
}
}
else if (type == typeof(string))
{
if (instance == null)
{
throw new UnknownLengthException(ownerFieldInfo);
}
num += 2;
num += (instance as string).Length * 2;
}
else
{
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
FieldInfo[] array = fields;
for (int i = 0; i < array.Length; i++)
{
FieldInfo fieldInfo = array[i];
if (!RawSerializer.IsIngoreField(fieldInfo))
{
Type fieldType = fieldInfo.FieldType;
LengthAttribute lengthAttribute = Attribute.GetCustomAttribute(fieldInfo, typeof(LengthAttribute)) as LengthAttribute;
if (fieldType.IsArray)
{
if (lengthAttribute != null)
{
num += lengthAttribute.Length * RawSerializer.GetFieldSize(fieldType.GetElementType(), fieldInfo, instance);
}
else
{
if (instance == null)
{
throw new UnknownLengthException(fieldInfo);
}
int fieldSize = RawSerializer.GetFieldSize(fieldType.GetElementType(), fieldInfo, instance);
Array array2 = fieldInfo.GetValue(instance) as Array;
num += 2;
num += array2.Length * fieldSize;
}
}
else if (lengthAttribute != null && fieldType == typeof(string))
{
num += lengthAttribute.Length * 2;
}
else
{
num += RawSerializer.GetFieldSize(fieldType, fieldInfo, instance);
}
}
}
}
return(num);
}
private static bool EqualFields(RawSerializer.OwnerFieldPair left, RawSerializer.OwnerFieldPair right)
{
if (left.field != null && right.field != null)
{
if (!object.Equals(left.field, right.field))
{
return(false);
}
}
else
{
Type type = left.owner.GetType();
Type type2 = right.owner.GetType();
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
FieldInfo[] fields2 = type2.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
for (int i = 0; i < fields.Length; i++)
{
FieldInfo fieldInfo = fields[i];
FieldInfo fieldInfo2 = fields2[i];
if (fieldInfo == null || fieldInfo2 == null)
{
return(false);
}
if (!RawSerializer.IsIngoreField(fieldInfo))
{
if (fieldInfo.FieldType.IsArray)
{
Array array = fieldInfo.GetValue(left.owner) as Array;
Array array2 = fieldInfo2.GetValue(right.owner) as Array;
int num = Math.Min(array.Length, array2.Length);
for (int j = 0; j < num; j++)
{
RawSerializer.OwnerFieldPair left2 = new RawSerializer.OwnerFieldPair(left.owner, array.GetValue(j));
RawSerializer.OwnerFieldPair right2 = new RawSerializer.OwnerFieldPair(right.owner, array2.GetValue(j));
if (!RawSerializer.EqualFields(left2, right2))
{
return(false);
}
}
}
else
{
object value = fieldInfo.GetValue(left.owner);
object value2 = fieldInfo2.GetValue(right.owner);
RawSerializer.OwnerFieldPair left3;
RawSerializer.OwnerFieldPair right3;
if (type.IsPrimitive || type == typeof(string))
{
left3 = new RawSerializer.OwnerFieldPair(left.owner, value);
right3 = new RawSerializer.OwnerFieldPair(right.owner, value2);
}
else
{
left3 = new RawSerializer.OwnerFieldPair(value, null);
right3 = new RawSerializer.OwnerFieldPair(value2, null);
}
if (!RawSerializer.EqualFields(left3, right3))
{
return(false);
}
}
}
}
}
return(true);
}
public new static bool Equals(object left, object right)
{
return(left.GetType() == right.GetType() && RawSerializer.EqualFields(new RawSerializer.OwnerFieldPair(left, null), new RawSerializer.OwnerFieldPair(right, null)));
}
