private static int CalculateSize(Type value)
{
if (value == null)
{
return(SerializedSizeCalculatorHelper <Guid, SerializedSizeCalculator> .CalculateSerializedSize(Guid.Empty));
}
if (value.IsArray)
{
int num = SerializedSizeCalculatorHelper <Guid, SerializedSizeCalculator> .CalculateSerializedSize(SerializedSizeCalculator.arrayGuid);
num += SerializedSizeCalculator.CalculateSize(value.GetElementType());
return(num + SerializedSizeCalculator.CalculateSizeCount(value.Name.EndsWith("[]") ? 0 : value.GetArrayRank()));
}
if (value.IsGenericType)
{
int num2 = SerializedSizeCalculatorHelper <Guid, SerializedSizeCalculator> .CalculateSerializedSize(value.GetGenericTypeDefinition().GUID);
foreach (Type value2 in value.GetGenericArguments())
{
num2 += SerializedSizeCalculator.CalculateSize(value2);
}
return(num2);
}
return(SerializedSizeCalculatorHelper <Guid, SerializedSizeCalculator> .CalculateSerializedSize(value.GUID));
}
private static int CalculateSize <T>(T?value) where T : struct
{
int num = 1;
if (value != null)
{
num += SerializedSizeCalculatorHelper <T, SerializedSizeCalculator> .CalculateSerializedSize(value.Value);
}
return(num);
}
private static int CalculateSize <T>(ICollection <T> values)
{
if (values == null)
{
return(1);
}
int num = SerializedSizeCalculator.CalculateSizeCount(values.Count + 1);
foreach (T value in values)
{
num += SerializedSizeCalculatorHelper <T, SerializedSizeCalculator> .CalculateSerializedSize(value);
}
return(num);
}
private static int CalculateSize <T>(ArraySegment <T> value)
{
int num = SerializedSizeCalculator.CalculateSizeCount(value.Count + 1);
int i = value.Offset;
int num2 = value.Offset + value.Count;
while (i < num2)
{
num += SerializedSizeCalculatorHelper <T, SerializedSizeCalculator> .CalculateSerializedSize(value.Array[i]);
i++;
}
return(num);
}
private int CalculateSize(ICollection values)
{
if (values == null)
{
return(1);
}
int num = SerializedSizeCalculator.CalculateSizeCount(values.Count + 1);
foreach (object value in values)
{
num += SerializedSizeCalculatorHelper <object, SerializedSizeCalculator> .CalculateSerializedSize(value);
}
return(num);
}
private static int CalculateSize <T>(IList <T> value)
{
if (value == null)
{
return(1);
}
int num = SerializedSizeCalculator.CalculateSizeCount(value.Count + 1);
int i = 0;
int count = value.Count;
while (i < count)
{
num += SerializedSizeCalculatorHelper <T, SerializedSizeCalculator> .CalculateSerializedSize(value[i]);
i++;
}
return(num);
}
private static void EmitCalculateFields(ILGenerator il, Type type)
{
int num = 0;
foreach (FieldInfo fieldInfo in type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
{
if (!fieldInfo.IsInitOnly && !fieldInfo.IsLiteral && !fieldInfo.IsNotSerialized)
{
Type fieldType = fieldInfo.FieldType;
int staticSize = SerializedSizeCalculatorHelper <T, C> .GetStaticSize(fieldType);
if (0 < staticSize)
{
num += staticSize;
}
else
{
MethodInfo methodInfo = SerializedSizeCalculatorHelper <T, C> .FindDefinedCalculateMethod(fieldType);
if (methodInfo == null)
{
methodInfo = typeof(SerializedSizeCalculatorHelper <, >).MakeGenericType(new Type[]
{
fieldType,
typeof(C)
}).GetMethod("CalculateSerializedSize");
}
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, fieldInfo);
il.EmitCall(OpCodes.Call, methodInfo, null);
il.Emit(OpCodes.Add);
}
}
}
if (0 < num)
{
il.Emit(OpCodes.Ldc_I4, num);
il.Emit(OpCodes.Add);
}
}
private static int CalculateSerializedSizeVirtual(T value)
{
Type type = (value == null) ? typeof(T) : value.GetType();
int num = SerializedSizeCalculatorHelper <Type, C> .CalculateSerializedSize(type);
if (SerializedSizeCalculatorHelper <T, C> .calculators == null)
{
SerializedSizeCalculatorHelper <T, C> .calculators = new Dictionary <Type, SerializedSizeCalculatorHelper <T, C> .CalculateSerializedSizeDelegate>();
}
SerializedSizeCalculatorHelper <T, C> .CalculateSerializedSizeDelegate calculateSerializedSizeDelegate;
if (!SerializedSizeCalculatorHelper <T, C> .calculators.TryGetValue(type, out calculateSerializedSizeDelegate))
{
MethodInfo method = typeof(SerializedSizeCalculatorHelper <, >).MakeGenericType(new Type[]
{
type,
typeof(C)
}).GetMethod("CalculateSerializedSizeCore", BindingFlags.Static | BindingFlags.NonPublic);
DynamicMethod dynamicMethod = new DynamicMethod(string.Format("{0}.{1}.CalculateSerializedSizeAs[{2}.{3}]", new object[]
{
typeof(SerializedSizeCalculatorHelper <T, C>).Namespace,
typeof(SerializedSizeCalculatorHelper <T, C>).Name,
typeof(T).Namespace,
typeof(T).Name
}), typeof(int), new Type[]
{
typeof(T)
}, typeof(SerializedSizeCalculatorHelper <T, C>), true);
dynamicMethod.DefineParameter(1, ParameterAttributes.In, "value");
ILGenerator ilgenerator = dynamicMethod.GetILGenerator();
ilgenerator.Emit(OpCodes.Ldarg_0);
ilgenerator.Emit(OpCodes.Unbox_Any, method.GetParameters()[0].ParameterType);
ilgenerator.EmitCall(OpCodes.Call, method, null);
ilgenerator.Emit(OpCodes.Ret);
calculateSerializedSizeDelegate = (dynamicMethod.CreateDelegate(typeof(SerializedSizeCalculatorHelper <T, C> .CalculateSerializedSizeDelegate)) as SerializedSizeCalculatorHelper <T, C> .CalculateSerializedSizeDelegate);
SerializedSizeCalculatorHelper <T, C> .calculators.Add(type, calculateSerializedSizeDelegate);
}
return(num + calculateSerializedSizeDelegate(value));
}
public static int Calculate <T>(T value)
{
return(SerializedSizeCalculatorHelper <T, SerializedSizeCalculator> .CalculateSerializedSize(value));
}
public static int CalculateSerializedSize(T value)
{
return(SerializedSizeCalculatorHelper <T, C> .calculateSerializedSize(value));
}
private static void GenerateCalculator()
{
DynamicMethod dynamicMethod = new DynamicMethod(string.Format("{0}.{1}.CalculateSerializedSizeCore[{2}.{3}]", new object[]
{
typeof(SerializedSizeCalculatorHelper <T, C>).Namespace,
typeof(SerializedSizeCalculatorHelper <T, C>).Name,
typeof(T).Namespace,
typeof(T).Name
}), typeof(int), new Type[]
{
typeof(T)
}, typeof(SerializedSizeCalculatorHelper <T, C>), true);
dynamicMethod.DefineParameter(1, ParameterAttributes.In, "value");
ILGenerator ilgenerator = dynamicMethod.GetILGenerator();
Type type = typeof(T);
Label? label = null;
if (!type.IsValueType && SerializedSizeCalculatorHelper <T, C> .FindDefinedCalculateMethod(type) == null)
{
ilgenerator.Emit(OpCodes.Ldc_I4_1);
ilgenerator.Emit(OpCodes.Ldarg_0);
label = new Label?(ilgenerator.DefineLabel());
ilgenerator.Emit(OpCodes.Brfalse, label.Value);
}
while (type != null)
{
MethodInfo methodInfo = SerializedSizeCalculatorHelper <T, C> .FindDefinedCalculateMethod(type);
if (methodInfo != null)
{
ilgenerator.Emit(OpCodes.Ldarg_0);
ilgenerator.EmitCall(OpCodes.Call, methodInfo, null);
if (type != typeof(T))
{
ilgenerator.Emit(OpCodes.Add);
break;
}
break;
}
else
{
if (type == typeof(T))
{
int staticSize = SerializedSizeCalculatorHelper <T, C> .GetStaticSize(type);
if (staticSize >= 1)
{
ilgenerator.Emit(OpCodes.Ldc_I4, staticSize);
break;
}
ilgenerator.Emit(OpCodes.Ldc_I4_0);
}
SerializedSizeCalculatorHelper <T, C> .EmitCalculateFields(ilgenerator, type);
type = type.BaseType;
}
}
if (label != null)
{
ilgenerator.Emit(OpCodes.Add);
ilgenerator.MarkLabel(label.Value);
}
ilgenerator.Emit(OpCodes.Ret);
SerializedSizeCalculatorHelper <T, C> .calculateSerializedSizeCore = (dynamicMethod.CreateDelegate(typeof(SerializedSizeCalculatorHelper <T, C> .CalculateSerializedSizeDelegate)) as SerializedSizeCalculatorHelper <T, C> .CalculateSerializedSizeDelegate);
if (typeof(T).IsSealed || SerializedSizeCalculatorHelper <T, C> .FindDefinedCalculateMethod(typeof(T)) != null)
{
SerializedSizeCalculatorHelper <T, C> .calculateSerializedSize = SerializedSizeCalculatorHelper <T, C> .calculateSerializedSizeCore;
return;
}
SerializedSizeCalculatorHelper <T, C> .calculateSerializedSize = new SerializedSizeCalculatorHelper <T, C> .CalculateSerializedSizeDelegate(SerializedSizeCalculatorHelper <T, C> .CalculateSerializedSizeVirtual);
}
static SerializedSizeCalculatorHelper()
{
SerializedSizeCalculatorHelper <T, C> .GenerateCalculator();
}
