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 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>(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 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 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));
}
