public static SerializationMethodProviders Combine(SerializationMethodProviders first,
SerializationMethodProviders second)
{
return(new SerializationMethodProviders(
FallbackMethodProvider.Combine(first.ValueTypeSerializeMethods, second.ValueTypeSerializeMethods),
FallbackMethodProvider.Combine(first.ValueTypeDeserializeMethods, second.ValueTypeDeserializeMethods),
FallbackMethodProvider.Combine(first.ReferenceTypeSerializeMethods,
second.ReferenceTypeSerializeMethods),
FallbackMethodProvider.Combine(first.ReferenceTypeDeserializeMethods,
second.ReferenceTypeDeserializeMethods),
FallbackMethodProvider.Combine(first.ReferenceFieldSerializeMethods,
second.ReferenceFieldSerializeMethods),
FallbackMethodProvider.Combine(first.ReferenceFieldDeserializeMethods,
second.ReferenceFieldDeserializeMethods),
FallbackMethodProvider.Combine(first.ReferenceTypeInitializeMethods,
second.ReferenceTypeInitializeMethods)));
}
public GeneratorResult Generate(MethodCreatorCreator methodCreatorCreator)
{
#region Declare Value Type Serializer Methods
var valueTypeSerializerType = methodCreatorCreator.Create("ValueTypeSerializer");
var valueTypeDeserializerType = methodCreatorCreator.Create("ValueTypeDeserializer");
var generatedValueTypeSerializeMethods = new Dictionary <Type, MethodInfo>();
var generatedValueTypeDeserializeMethods = new Dictionary <Type, MethodInfo>();
foreach (var valueType in typeClassifier.ValueTypes)
{
if (customMethods.HasTypeSerializer(valueType))
{
continue; // Don't generate serializers where custom methods exist
}
var serializeMethod = valueTypeSerializerType.CreateMethod(valueType, "ValueTypeSerialize",
typeof(void), new[] { typeof(SerializeContext), typeof(BinaryWriter), valueType.MakeByRefType() });
generatedValueTypeSerializeMethods.Add(valueType, serializeMethod);
var deserializeMethod = valueTypeDeserializerType.CreateMethod(valueType, "ValueTypeDeserialize",
typeof(void), new[] { typeof(DeserializeContext), typeof(BinaryReader), valueType.MakeByRefType() });
generatedValueTypeDeserializeMethods.Add(valueType, deserializeMethod);
}
#endregion
#region Declare Reference Type Serializer Methods
// Note: These methods have no type check/dispatch - fields that could reference derived types must go through the field methods instead of these!
var referenceTypeSerializerType = methodCreatorCreator.Create("ReferenceTypeSerializer");
var referenceTypeDeserializerType = methodCreatorCreator.Create("ReferenceTypeDeserializer");
var generatedReferenceTypeSerializeMethods = new Dictionary <Type, MethodInfo>();
var generatedReferenceTypeDeserializeMethods = new Dictionary <Type, MethodInfo>();
foreach (var referenceType in typeClassifier.ReferenceTypes)
{
Debug.Assert(!referenceType.IsArray);
if (customMethods.HasTypeSerializer(referenceType))
{
continue; // Don't generate serializers where custom methods exist
}
var serializeMethod = referenceTypeSerializerType.CreateMethod(referenceType, "ReferenceTypeSerialize",
typeof(void), new[] { typeof(SerializeContext), typeof(BinaryWriter), referenceType });
generatedReferenceTypeSerializeMethods.Add(referenceType, serializeMethod);
var deserializeMethod = referenceTypeDeserializerType.CreateMethod(referenceType,
"ReferenceTypeDeserialize", typeof(void),
new[] { typeof(DeserializeContext), typeof(BinaryReader), referenceType });
generatedReferenceTypeDeserializeMethods.Add(referenceType, deserializeMethod);
}
#endregion
#region Declare Field Serializer Methods
var fieldSerializerType = methodCreatorCreator.Create("FieldSerializer");
var fieldDeserializerType = methodCreatorCreator.Create("FieldDeserializer");
var generatedReferenceFieldSerializeMethods = new Dictionary <Type, MethodInfo>();
var generatedReferenceFieldDeserializeMethods = new Dictionary <Type, MethodInfo>();
foreach (var fieldType in typeClassifier.fieldSerializerDispatchLookup.Keys)
{
if (customMethods.HasFieldSerializer(fieldType))
{
continue; // Don't create field serializers where custom ones exist
}
var serializeMethod = fieldSerializerType.CreateMethod(fieldType, "FieldSerialize", typeof(void),
new[] { typeof(SerializeContext), typeof(BinaryWriter), fieldType });
generatedReferenceFieldSerializeMethods.Add(fieldType, serializeMethod);
var deserializeMethod = fieldDeserializerType.CreateMethod(fieldType, "FieldDeserialize", typeof(void),
new[] { typeof(DeserializeContext), typeof(BinaryReader), fieldType.MakeByRefType() });
generatedReferenceFieldDeserializeMethods.Add(fieldType, deserializeMethod);
}
#endregion
#region Declare Dispatch Methods
var serializerDispatchType = methodCreatorCreator.Create("SerializerDispatch");
var deserializerDispatchType = methodCreatorCreator.Create("DeserializerDispatch");
// These are dispatched by ID#, so this is a lookup by that ID#
var dynamicDispatchMethods = new List <SerializationMethods>(typeClassifier.dispatchableTypes.Count);
// Dispatch to types that require actual dispatch (from type classification) as well as any suplemental types
// (Suplemental types come from delegates, at the moment, a few of which require dynamic dispatch (see DelegateSerialization.SerializeDelegate)
// and I haven't written a direct-dispatch path yet)
HashSet <Type> dispatchTypes;
if (suplementalDispatchTypes == null)
{
dispatchTypes = typeClassifier.dispatchableTypes;
}
else
{
dispatchTypes = new HashSet <Type>(typeClassifier.dispatchableTypes.Concat(suplementalDispatchTypes));
}
foreach (var type in dispatchTypes.NetworkOrder(t => t.Module.Name + t.FullName))
{
var idString = dynamicDispatchMethods.Count.ToString("0000");
SerializationMethods sm;
sm.type = type;
sm.serializer = serializerDispatchType.CreateMethod(type, "SerializeWithId_" + idString, typeof(void),
new[] { typeof(SerializeContext), typeof(BinaryWriter), typeof(object) });
sm.deserializer = deserializerDispatchType.CreateMethod(type, "DeserializeFromId_" + idString, type,
new[] { typeof(DeserializeContext), typeof(BinaryReader) });
dynamicDispatchMethods.Add(sm); // Defines the ID#
}
// Deserialization dispatch method (this could reasonably use a table like serialization, but it was original a giant switch statement - so let's keep it that way)
deserializationDispatcherMethod = deserializerDispatchType.CreateMethod(null, "DeserializationDispatcher",
typeof(object), new[] { typeof(DeserializeContext), typeof(BinaryReader) });
#endregion
#region Lookup Hookup
// These are all used to do lookup during IL generation (should probably be switched to a SerializationMethodProviders)
fieldSerializeMethods = FallbackMethodProvider.Combine(customMethods.ValueTypeSerializeMethods,
customMethods.ReferenceFieldSerializeMethods,
new LookupMethodProvider(generatedValueTypeSerializeMethods),
new LookupMethodProvider(generatedReferenceFieldSerializeMethods));
fieldDeserializeMethods = FallbackMethodProvider.Combine(
customMethods.ValueTypeDeserializeMethods,
customMethods.ReferenceFieldDeserializeMethods,
new LookupMethodProvider(generatedValueTypeDeserializeMethods),
new LookupMethodProvider(generatedReferenceFieldDeserializeMethods));
referenceTypeSerializeMethods = FallbackMethodProvider.Combine(
customMethods.ReferenceTypeSerializeMethods,
new LookupMethodProvider(generatedReferenceTypeSerializeMethods));
referenceTypeDeserializeMethods = FallbackMethodProvider.Combine(
customMethods.ReferenceTypeDeserializeMethods,
new LookupMethodProvider(generatedReferenceTypeDeserializeMethods));
var serializeContext =
new ILGenContext(Direction.Serialize, fieldSerializeMethods, referenceTypeSerializeMethods);
var deserializeContext = new ILGenContext(Direction.Deserialize, fieldDeserializeMethods,
referenceTypeDeserializeMethods);
#endregion
#region Generate Dynamic Dispatch Method IL
for (var i = 0; i < dynamicDispatchMethods.Count; i++)
{
// SerializeWithId Method:
#region Generate IL
{
var il = dynamicDispatchMethods[i].serializer.GetILGenerator();
// br.Write('i');
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldc_I4, i);
il.Emit(OpCodes.Callvirt, Methods.BinaryWriter_WriteInt32);
// ReferenceTypeSerializer.Serialize(context, bw, (Class)obj);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Castclass, dynamicDispatchMethods[i].type);
il.Emit(OpCodes.Call, referenceTypeSerializeMethods[dynamicDispatchMethods[i].type]);
il.Emit(OpCodes.Ret);
}
#endregion
// DeserializeFromId Method:
#region Generate IL
{
var il = dynamicDispatchMethods[i].deserializer.GetILGenerator();
il.DeclareLocal(dynamicDispatchMethods[i].type); // Class obj
// Class obj = /* create object */
GenerateTypeCreation(il, dynamicDispatchMethods[i].type);
il.Emit(OpCodes.Stloc_0);
// ReferenceTypeDeserializer.Deserialize(context, br, (Class)obj);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldloc_0);
il.Emit(OpCodes.Call, referenceTypeDeserializeMethods[dynamicDispatchMethods[i].type]);
// return obj;
il.Emit(OpCodes.Ldloc_0);
il.Emit(OpCodes.Ret);
}
#endregion
}
#endregion
#region Generate Reference Field Serializer Method IL
foreach (var fieldDispatch in typeClassifier.fieldSerializerDispatchLookup)
{
var fieldType = fieldDispatch.Key;
var dispatchToTypes = fieldDispatch.Value;
var serializeMethod = generatedReferenceFieldSerializeMethods[fieldType];
var deserializeMethod = generatedReferenceFieldDeserializeMethods[fieldType];
GenerateReferenceFieldSerializer(serializeMethod.GetILGenerator(), fieldType, dispatchToTypes);
GenerateReferenceFieldDeserializer(deserializeMethod.GetILGenerator(), fieldType, dispatchToTypes);
}
#endregion
#region Generate Reference and Value Type Serializers
foreach (var sm in generatedValueTypeSerializeMethods)
{
TypeSerializeILGeneration.GenerateValueTypeSerializationMethod(sm.Key, sm.Value.GetILGenerator(),
serializeContext);
}
foreach (var sm in generatedValueTypeDeserializeMethods)
{
TypeSerializeILGeneration.GenerateValueTypeSerializationMethod(sm.Key, sm.Value.GetILGenerator(),
deserializeContext);
}
foreach (var sm in generatedReferenceTypeSerializeMethods)
{
TypeSerializeILGeneration.GenerateReferenceTypeSerializationMethod(sm.Key, sm.Value.GetILGenerator(),
serializeContext);
}
foreach (var sm in generatedReferenceTypeDeserializeMethods)
{
TypeSerializeILGeneration.GenerateReferenceTypeSerializationMethod(sm.Key, sm.Value.GetILGenerator(),
deserializeContext);
}
#endregion
#region Generate Deserialization Dispatcher (IL)
{
var il = deserializationDispatcherMethod.GetILGenerator();
var dispatchLabels = new Label[dynamicDispatchMethods.Count];
for (var i = 0; i < dispatchLabels.Length; i++)
{
dispatchLabels[i] = il.DefineLabel();
}
var failLabel = il.DefineLabel();
// br.ReadInt32()
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Callvirt,
typeof(BinaryReader)
.GetMethod("ReadInt32")); // NOTE: C# compiler loads this into two locals for no reason
// switch(...)
il.Emit(OpCodes.Switch, dispatchLabels);
il.Emit(OpCodes.Br,
failLabel); // default case // NOTE: C# compiler emits br.s, but I bet it's not short with our huge table!
for (var i = 0; i < dynamicDispatchMethods.Count; i++)
{
// case 'i':
il.MarkLabel(dispatchLabels[i]);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Call, dynamicDispatchMethods[i].deserializer);
il.Emit(OpCodes.Ret);
}
// throw new Exception("...");
il.MarkLabel(failLabel);
il.Emit(OpCodes.Ldstr, "Unknown Type");
il.Emit(OpCodes.Newobj, typeof(Exception).GetConstructor(new[] { typeof(string) }));
il.Emit(OpCodes.Throw);
}
#endregion
#region Fill Serialization Dispatch Table
// We used to generate a table with IL in the serializer assembly (fancy). Now we can just do it directly.
// (But we do have to do it last, so the methods are actually ready to convert to delegates)
var dispatchTable = new Dictionary <Type, SerializeDispatchDelegate>();
// Only dynamic methods can be converted to delegates (because the dynamic assembly we create in assembly-generating mode is save-only)
if (methodCreatorCreator is DynamicMethodCreatorCreator)
{
for (var i = 0; i < dynamicDispatchMethods.Count; i++)
{
var serializerMethod = dynamicDispatchMethods[i].serializer as DynamicMethod;
Debug.Assert(serializerMethod != null);
var serializerDelegate =
(SerializeDispatchDelegate)serializerMethod.CreateDelegate(typeof(SerializeDispatchDelegate));
dispatchTable.Add(dynamicDispatchMethods[i].type, serializerDelegate);
}
}
#endregion
#region Return
var generatedMethodProviders = new SerializationMethodProviders(
new LookupMethodProvider(generatedValueTypeSerializeMethods),
new LookupMethodProvider(generatedValueTypeDeserializeMethods),
new LookupMethodProvider(generatedReferenceTypeSerializeMethods),
new LookupMethodProvider(generatedReferenceTypeDeserializeMethods),
new LookupMethodProvider(generatedReferenceFieldSerializeMethods),
new LookupMethodProvider(generatedReferenceFieldDeserializeMethods),
new EmptyMethodProvider());
// Note: custom methods come before generated methods:
var combinedMethodProviders = SerializationMethodProviders
.Combine(customMethods, generatedMethodProviders);
DeserializeDispatchDelegate deserializeDispatchDelegate = null;
if (methodCreatorCreator is DynamicMethodCreatorCreator
) // Only dynamic methods can be converted to delegates (our dynamic assembly is save-only)
{
deserializeDispatchDelegate =
(DeserializeDispatchDelegate)(deserializationDispatcherMethod as DynamicMethod).CreateDelegate(
typeof(DeserializeDispatchDelegate));
}
return(new GeneratorResult(combinedMethodProviders, dispatchTable, deserializeDispatchDelegate,
null)); // module table gets filled later
#endregion
}