private void Write(Type value)
{
if (value == null)
{
SerializeWriterHelper <Guid, SerializeWriter> .Serialize(ref this, Guid.Empty);
return;
}
if (value.IsArray)
{
SerializeWriterHelper <Guid, SerializeWriter> .Serialize(ref this, SerializeWriter.arrayGuid);
this.Write(value.GetElementType());
this.WriteCount(value.Name.EndsWith("[]") ? 0 : value.GetArrayRank());
return;
}
if (value.IsGenericType)
{
SerializeWriterHelper <Guid, SerializeWriter> .Serialize(ref this, value.GetGenericTypeDefinition().GUID);
Type[] genericArguments = value.GetGenericArguments();
int i = 0;
int num = genericArguments.Length;
while (i < num)
{
this.Write(genericArguments[i]);
i++;
}
return;
}
SerializeWriterHelper <Guid, SerializeWriter> .Serialize(ref this, value.GUID);
}
private void Write <T>(T?value) where T : struct
{
this.Write(value != null);
if (value != null)
{
SerializeWriterHelper <T, SerializeWriter> .Serialize(ref this, value.Value);
}
}
public static Packet ToBinary(object value)
{
int length = SerializedSizeCalculator.Calculate <object>(value);
SerializeWriter serializeWriter = new SerializeWriter(length, 0);
SerializeWriterHelper <object, SerializeWriter> .Serialize(ref serializeWriter, value);
return(serializeWriter.data);
}
private void Write <T>(ICollection <T> values)
{
if (values == null)
{
this.WriteCount(0);
return;
}
this.WriteCount(values.Count + 1);
foreach (T value in values)
{
SerializeWriterHelper <T, SerializeWriter> .Serialize(ref this, value);
}
}
public static Packet ToBinary <T>(T value)
{
int categoryId = ClassInfo <T> .CategoryId;
if (categoryId == 0)
{
return(SerializeWriter.ToBinary(value));
}
int length = SerializedSizeCalculator.Calculate <T>(value);
SerializeWriter serializeWriter = new SerializeWriter(length, categoryId);
SerializeWriterHelper <T, SerializeWriter> .Serialize(ref serializeWriter, value);
return(serializeWriter.data);
}
private void Write <T>(ArraySegment <T> value)
{
if (value.Array == null)
{
this.WriteCount(0);
return;
}
this.WriteCount(value.Count + 1);
int i = value.Offset;
int num = value.Offset + value.Count;
while (i < num)
{
SerializeWriterHelper <T, SerializeWriter> .Serialize(ref this, value.Array[i]);
i++;
}
}
private void Write <T>(IList <T> value)
{
if (value == null)
{
this.WriteCount(0);
return;
}
this.WriteCount(value.Count + 1);
int i = 0;
int count = value.Count;
while (i < count)
{
SerializeWriterHelper <T, SerializeWriter> .Serialize(ref this, value[i]);
i++;
}
}
private static void SerializeCoreVirtual(ref W writer, T value)
{
Type type = (value == null) ? typeof(T) : value.GetType();
SerializeWriterHelper <Type, W> .Serialize(ref writer, type);
if (SerializeWriterHelper <T, W> .serializers == null)
{
SerializeWriterHelper <T, W> .serializers = new Dictionary <Type, SerializeWriterHelper <T, W> .SerializeDelegate>();
}
SerializeWriterHelper <T, W> .SerializeDelegate serializeDelegate;
if (!SerializeWriterHelper <T, W> .serializers.TryGetValue(type, out serializeDelegate))
{
MethodInfo method = typeof(SerializeWriterHelper <, >).MakeGenericType(new Type[]
{
type,
typeof(W)
}).GetMethod("SerializeCore", BindingFlags.Static | BindingFlags.NonPublic);
DynamicMethod dynamicMethod = new DynamicMethod(string.Format("{0}.{1}.SerializeAs[{2}.{3}]", new object[]
{
typeof(SerializeWriterHelper <Type, W>).Namespace,
typeof(SerializeWriterHelper <Type, W>).Name,
typeof(T).Namespace,
typeof(T)
}), null, new Type[]
{
typeof(W).MakeByRefType(),
typeof(T)
}, typeof(SerializeWriterHelper <Type, W>), true);
dynamicMethod.DefineParameter(1, ParameterAttributes.In | ParameterAttributes.Out, "writer");
dynamicMethod.DefineParameter(2, ParameterAttributes.In, "value");
ILGenerator ilgenerator = dynamicMethod.GetILGenerator();
ilgenerator.Emit(OpCodes.Ldarg_0);
ilgenerator.Emit(OpCodes.Ldarg_1);
ilgenerator.Emit(OpCodes.Unbox_Any, method.GetParameters()[1].ParameterType);
ilgenerator.EmitCall(OpCodes.Call, method, null);
ilgenerator.Emit(OpCodes.Ret);
serializeDelegate = (dynamicMethod.CreateDelegate(typeof(SerializeWriterHelper <T, W> .SerializeDelegate)) as SerializeWriterHelper <T, W> .SerializeDelegate);
SerializeWriterHelper <T, W> .serializers.Add(type, serializeDelegate);
}
serializeDelegate(ref writer, value);
}
