private Deserializer(Type t) : base(t)
{
bool canSerializeNull = CanSerializeNull;
if (canSerializeNull)
{
Target target = DefineLabel();
Ldarg(0);
Callvirt(ReadNull);
Brfalse(target);
bool isClass = T.IsClass;
if (isClass)
{
Ldnull();
Ret();
}
else
{
Ldarg(1);
Initobj(T);
Ret();
}
MarkLabel(target);
}
bool isNullable = IsNullable;
if (isNullable)
{
FieldInfo f = T.GetFieldPrivate("value");
SerializerInfo reader = GetReader(f.FieldType);
EmitFieldDeserializer(reader, delegate
{
Ldarg(1);
}, delegate
{
Ldflda(f);
}, delegate
{
Stfld(f);
});
Ldarg(1);
Ldc(1);
Stfld(T.GetFieldPrivate("hasValue"));
Ret();
}
else
{
bool isArray = T.IsArray;
if (isArray)
{
var elementType = T.GetElementType();
SerializerInfo reader2 = GetReader(elementType);
SerializerCall(ReadOpenArray);
Local local = DeclareLocal <int>(false);
Ldarg(0);
Ldloca(local);
Callvirt(ReadInt32);
var target = DeclareLocal(T, false);
Ldloc(local);
Newarr(elementType);
Stloc(target);
using (IndexLoop loop = Loop(local))
{
EmitFieldDeserializer(reader2
, LdTarget: () =>
{
Ldloc(target);
Ldloc(loop.Index);
}
, LdAddress: () =>
{
Ldelema(elementType);
}
, StValue: () =>
{
Stelem(ObjectReference);
});
}
SerializerCall(ReadCloseArray);
Ldloc(target);
Ret();
}
else
{
bool isClass2 = T.IsClass;
if (isClass2)
{
var target = DeclareLocal(T, false);
Newobj(T);
Stloc(target);
SerializerCall(ReadOpenObject);
FieldInfo[] fields = T.GetFields();
for (int i = 0; i < fields.Length; i++)
{
FieldInfo f3 = fields[i];
FieldInfo f = f3;
SerializerInfo reader3 = GetReader(f.FieldType);
SerializerInfo arg_36B_1 = reader3;
EmitFieldDeserializer(arg_36B_1
, LdTarget: () => { Ldloc(target); }
, LdAddress: () => { Ldflda(f); }
, StValue: () => { Stfld(f); });
}
SerializerCall(ReadCloseObject);
Ldloc(target);
Ret();
}
else
{
SerializerCall(ReadOpenObject);
FieldInfo[] fields2 = T.GetFields();
for (int j = 0; j < fields2.Length; j++)
{
FieldInfo f2 = fields2[j];
FieldInfo f = f2;
SerializerInfo reader4 = GetReader(f.FieldType);
EmitFieldDeserializer(reader4, delegate
{
Ldarg(1);
}, delegate
{
Ldflda(f);
}, delegate
{
Stfld(f);
});
}
SerializerCall(ReadCloseObject);
Ret();
}
}
}
}
private Serializer(Type t) : base(t)
{
bool canSerializeNull = CanSerializeNull;
if (canSerializeNull)
{
bool isClass = T.IsClass;
if (isClass)
{
Ldarg(1);
}
else
{
Ldarg(1);
Ldfld(T.GetFieldPrivate("hasValue"));
}
Target target = DefineLabel();
Brtrue(target);
Ldarg(0);
Callvirt(WriteNull);
Ret();
MarkLabel(target);
}
bool isNullable = IsNullable;
if (isNullable)
{
FieldInfo f = T.GetFieldPrivate("value");
SerializerInfo writer = GetWriter(f.FieldType);
EmitFieldSerializer(writer
, LdTarget: () => Ldarg(1)
, LdAddress: () => Ldflda(f)
, LdValue: () => Ldfld(f)
);
Ret();
}
else
{
bool isArray = T.IsArray;
if (isArray)
{
var elementType = T.GetElementType();
SerializerInfo writer2 = GetWriter(elementType);
SerializerCall(WriteOpenArray);
Local local = DeclareLocal(typeof(int), false);
Ldarg(1);
Ldlen();
Conv <int>(false, true);
Stloc(local);
Ldarg(0);
Ldloca(local);
Callvirt(WriteInt32);
using (IndexLoop loop = Loop(local))
{
this.EmitFieldSerializer(writer2
, LdTarget: () =>
{
Ldarg(1);
Ldloc(loop.Index);
}
, LdAddress: () =>
{
Ldelema(elementType);
}
, LdValue: delegate
{
Ldelem(ObjectReference);
});
}
SerializerCall(WriteCloseArray);
Ret();
}
else
{
SerializerCall(WriteOpenObject);
FieldInfo[] fields = T.GetFields();
for (int i = 0; i < fields.Length; i++)
{
FieldInfo f2 = fields[i];
FieldInfo f = f2;
SerializerInfo writer3 = GetWriter(f.FieldType);
EmitFieldSerializer(writer3, delegate
{
Ldarg(1);
}, delegate
{
Ldflda(f);
}, delegate
{
Ldfld(f);
});
}
SerializerCall(WriteCloseObject);
Ret();
}
}
}
