private static System.Delegate CreateTypeSerializer(Type type)
{
InternalSerializationStuff.ValidateSupportedTypes(type);
var variables = new List <ParameterExpression>();
var expressions = new List <Expression>();
var outputStream = Expression.Parameter(typeof(Stream), "outputStream");
var objToSerialize = Expression.Parameter(type, "objToSerialize");
var objTracking = Expression.Parameter(typeof(SerializerObjectTracker), "objTracking");
var primitiveWriter = GetPrimitiveWriter(type);
if (primitiveWriter != null)
{
Debug.Assert(type.IsPrimitive || type.IsValueType, "Value is not a primitive");
expressions.Add(primitiveWriter(outputStream, objToSerialize, objTracking));
}
else if (type == typeof(string))
{
expressions.Add(GenerateStringExpression(outputStream, objToSerialize, objTracking));
}
else if (InternalSerializationStuff.ImplementsISerializableWithSerializationConstructor(type))
{
expressions.Add(ISerializableSerializer.GenerateISerializableExpression(type, variables, outputStream, objToSerialize, objTracking));
}
else if (InternalSerializationStuff.ImplementsDictionaryGeneric(type))
{
expressions.Add(DictionarySerializer.GenerateDictionaryGenericExpression(type, variables, outputStream, objToSerialize, objTracking));
}
else if (type == typeof(ExpandoObject))
{
expressions.Add(ExpandoSerializer.GenerateExpandoObjectExpression(type, variables, outputStream, objToSerialize, objTracking));
}
else if (type.IsArray)
{
expressions.Add(GenerateArrayExpression(type, outputStream, objToSerialize, objTracking));
}
else
{
expressions.Add(GenerateClassExpression(type, outputStream, objToSerialize, objTracking));
}
var block = Expression.Block(variables, expressions);
var a = typeof(Action <, ,>).MakeGenericType(typeof(Stream), type, typeof(SerializerObjectTracker));
return(Expression.Lambda(a, block, outputStream, objToSerialize, objTracking).Compile());
}
private static Expression DeserializeISerializable(Type type,
List <ParameterExpression> variables,
ParameterExpression inputStream,
ParameterExpression objTracker,
ParameterExpression newInstance)
{
var length = Expression.Parameter(typeof(int), "length");
var i = Expression.Parameter(typeof(int), "i");
var key = Expression.Parameter(typeof(string), "key");
var value = Expression.Parameter(typeof(object), "value");
var typeName = Expression.Parameter(typeof(string), "typeName");
var typeExpr = Expression.Parameter(typeof(TypeWithHashCode), "type");
var deserializer = Expression.Parameter(typeof(Func <Stream, DeserializerObjectTracker, object>), "deserializer");
var typeHashCode = Expression.Parameter(typeof(int), "typeHashCode");
var fc = Expression.Parameter(typeof(FormatterConverter), "fc");
var context = Expression.Parameter(typeof(StreamingContext), "context");
var si = Expression.Parameter(typeof(SerializationInfo), "si");
variables.Add(fc);
variables.Add(context);
variables.Add(si);
variables.Add(key);
variables.Add(value);
variables.Add(length);
variables.Add(i);
variables.Add(deserializer);
variables.Add(typeName);
variables.Add(typeExpr);
variables.Add(typeHashCode);
var loopExpressions = new List <Expression>();
DictionaryDeserializer.GetReadExpression(inputStream, objTracker, typeof(string), loopExpressions, key, typeExpr, typeName, typeHashCode, deserializer);
DictionaryDeserializer.GetReadExpression(inputStream, objTracker, typeof(object), loopExpressions, value, typeExpr, typeName, typeHashCode, deserializer);
loopExpressions.Add(Expression.Call(si, SerializationInfoMih.AddValue(), key, value));
loopExpressions.Add(Expression.Assign(i, Expression.Add(i, Expression.Constant(1))));
var cond = Expression.LessThan(i, length);
var loopBody = Expression.Block(loopExpressions);
var breakLabel = Expression.Label("breakLabel");
var loop = Expression.Loop(Expression.IfThenElse(cond,
loopBody,
Expression.Break(breakLabel)),
breakLabel);
var notTrackedExpressions = new List <Expression>();
notTrackedExpressions.Add(Expression.Assign(fc, Expression.New(typeof(FormatterConverter))));
notTrackedExpressions.Add(Expression.Assign(context, Expression.New(StreamingContextMih.Constructor(), Expression.Constant(StreamingContextStates.All))));
notTrackedExpressions.Add(Expression.Assign(si, Expression.New(SerializationInfoMih.Constructor(), Expression.Constant(type), fc)));
notTrackedExpressions.Add(Expression.Assign(length, PrimitiveHelpers.ReadInt32(inputStream, objTracker)));
notTrackedExpressions.Add(Expression.Assign(i, Expression.Constant(0)));
notTrackedExpressions.Add(loop);
notTrackedExpressions.Add(Expression.Assign(newInstance, Expression.New(ISerializableSerializer.GetSerializationConstructor(type), si, context)));
if (type.IsClass)
{
notTrackedExpressions.Add(Expression.Call(objTracker, DeserializerObjectTrackerMih.TrackedObject(), newInstance));
}
notTrackedExpressions.AddRange(SerializationCallbacksHelper.GenerateOnDeserializedAttributeExpression(type, newInstance, context));
notTrackedExpressions.Add(SerializationCallbacksHelper.GenerateCallIDeserializationExpression(type, newInstance));
notTrackedExpressions.Add(newInstance);
return(Expression.Block(notTrackedExpressions));
}