private void EmitFieldSerializer(SerializerInfo writer, Action LdTarget, Action LdAddress, Action LdValue)
{
bool isBasic = writer.IsBasic;
if (isBasic)
{
Ldarg(0);
LdTarget();
LdAddress();
Callvirt(writer.Method);
}
else
{
bool isClass = writer.IsClass;
if (isClass)
{
Ldarg(0);
LdTarget();
LdValue();
Call(writer.Method);
}
else
{
Ldarg(0);
LdTarget();
LdAddress();
Call(writer.Method);
}
}
}
private void EmitFieldDeserializer(SerializerInfo reader, Action LdTarget, Action LdAddress, Action StValue)
{
bool isBasic = reader.IsBasic;
if (isBasic)
{
Ldarg(0);
LdTarget();
LdAddress();
Callvirt(reader.Method);
}
else
{
bool isClass = reader.IsClass;
if (isClass)
{
LdTarget();
Ldarg(0);
Call(reader.Method);
StValue();
}
else
{
Ldarg(0);
LdTarget();
LdAddress();
Call(reader.Method);
}
}
}
private static SerializerInfo GetSerializerInfo(Type type, IEnumerable <Type> knownTypes)
{
SerializerInfo info = new SerializerInfo();
info.ObjectType = type;
info.XmlSerializer = new DataContractSerializer(type, knownTypes);
return(info);
}
/// <summary>
/// Serializes an unknown object type.
/// </summary>
/// <typeparam name="T">The type of the object. This may not reflect the exact object type.</typeparam>
/// <param name="value">The object value.</param>
/// <returns>The serialized <see cref="JToken"/>.</returns>
protected virtual JToken SerializeUnknown <T>(T value)
{
if (ReferenceEquals(value, null))
{
return(null);
}
var mySerializers = _mySerializers;
if (mySerializers == null)
{
Thread.MemoryBarrier();
mySerializers = _serializers.GetOrAdd(GetType().TypeHandle, th => new SerializerInfo(Type.GetTypeFromHandle(th)));
_mySerializers = mySerializers;
}
return(_mySerializers.Serialize(this, value));
}
/// <summary>
/// Serializes an unknown object type.
/// </summary>
/// <typeparam name="T">The type of the object. This may not reflect the exact object type.</typeparam>
/// <param name="value">The object value.</param>
/// <returns>The serialized <see cref="JsonValue"/>.</returns>
protected virtual JsonValue SerializeUnknown <T>(T value)
{
#pragma warning disable S1168 // Empty arrays and collections should be returned instead of null
// Null is significant in JSON.
if (ReferenceEquals(value, null))
{
return(null);
}
#pragma warning restore S1168 // Empty arrays and collections should be returned instead of null
var mySerializers = _mySerializers;
if (mySerializers == null)
{
Thread.MemoryBarrier();
mySerializers = _serializers.GetOrAdd(GetType().TypeHandle, th => new SerializerInfo(Type.GetTypeFromHandle(th)));
_mySerializers = mySerializers;
}
return(_mySerializers.Serialize(this, value));
}
private static SerializerInfo GetSerializerInfo(Type type, IEnumerable<Type> knownTypes)
{
SerializerInfo info = new SerializerInfo();
info.ObjectType = type;
info.XmlSerializer = new DataContractSerializer(type, knownTypes);
return info;
}
internal MissingDeserializerInfo(Snapshot snapshot, SerializerInfo serializerInfo)
{
_snapshot = snapshot;
_serializerInfo = serializerInfo;
}
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();
}
}
}
private bool ExistsDeserializerFor(SerializerInfo serializerInfo)
{
return(_deserializers.ContainsKey(serializerInfo.Key));
}
/// <summary>
/// Initializes a new instance of the <see cref="SerializeeInfo"/> class.
/// </summary>
/// <param name="serializeeType">Type of the serializee.</param>
/// <param name="serializerInfo">Information about the serializer handling the serializee.</param>
/// <param name="serializer">The external object serializer instance.</param>
public SerializeeInfo(Type serializeeType, SerializerInfo serializerInfo, IExternalObjectSerializer serializer)
{
SerializeeType = serializeeType;
SerializerInfo = serializerInfo;
Serializer = serializer;
}
