private void GenerateSerialization(FreudManager manager, Type type, List <MemberInfo> dataMembers,
List <ITypeInfo> parts)
{
var serializeStatements = new List <Expression>();
var deserializeStatements = new List <Expression>();
var instVariable = Expression.Variable(type, "instance");
for (int i = 0; i < dataMembers.Count; i++)
{
Expression serialization_call = null;
Expression deserialization_call = null;
GenerateReferenceExpressions(type, instVariable, dataMembers[i], parts[i], out serialization_call,
out deserialization_call);
serializeStatements.Add(serialization_call);
deserializeStatements.Add(deserialization_call);
}
_serialize = Expression.Lambda <Action <object, Stream> >(Expression.Block(serializeStatements.ToArray()),
"serialize_ref<" + type.FullName + ">", true,
new[] { _parameterExpression, ParameterExpression }).Compile();
_deserialize = Expression.Lambda <Func <Stream, object> >(
Expression.Block(new[] { instVariable },
new[] { Expression.Assign(instVariable, Expression.New(type)) }
.Concat(deserializeStatements.ToArray())
.Concat(new[] { Expression.Convert(instVariable, typeof(Object)) }).ToArray()),
"derialize_ref<" + type.FullName + ">", true,
new[] { ParameterExpression })
.Compile();
}
private void registerGeneral(Type type, FreudManager manager)
{
var dataMembers = GetAllowedTypeMembers(type);
var parts = SelectMemberSerializers(manager, dataMembers);
GenerateSerialization(manager, type, dataMembers, parts);
}
private void registerArray(Type type, FreudManager manager)
{
registerType(type.GetElementType(), manager);
var elementInfo = manager.TypeInfoCache[type.GetElementType()];
var arraySerializer = new ArrayTypeInfo(type, elementInfo);
_serialize = arraySerializer.Serialize;
_deserialize = arraySerializer.Deserialize;
}
private static List <ITypeInfo> SelectMemberSerializers(FreudManager manager, List <MemberInfo> dataMembers)
{
var parts = new List <ITypeInfo>();
foreach (var dataMember in dataMembers)
{
var memberType = dataMember.PropertyOrFieldType();
var newInstance = new ExpressionTypeInfo(memberType, manager);
parts.Add(manager.TypeInfoCache[memberType]);
}
return(parts);
}
private void registerType(Type type, FreudManager manager)
{
if (manager.TypeInfoCache.ContainsKey(type))
{
return;
}
checkType(type);
if (type.IsArray)
{
registerArray(type, manager);
}
else
{
registerGeneral(type, manager);
}
manager.TypeInfoCache[type] = this;
}
public ExpressionTypeInfo(Type targetType, FreudManager manager)
{
TargetType = targetType;
registerType(targetType, manager);
}
public ITypeInfo Create(Type type, FreudManager manager)
{
return(new ExpressionTypeInfo(type, manager));
}
