public PresentationBuilder <TContract> UseSerializer(SerializationRule rule)
{
if (rule == null)
{
throw new ArgumentNullException(nameof(rule));
}
UserSerializationRules.Add(rule);
return(this);
}
public static SerializationRule GetThrowsSerializationRuleFor <T>()
{
var fakeSerializer = new Mock <ISerializer>();
fakeSerializer
.Setup(s => s.Serialize(It.IsAny <object>(), It.IsAny <MemoryStream>()))
.Callback(() => { throw new Exception("Fake exception"); });
var throwsRule = new SerializationRule((t) => t == typeof(T), (t) => fakeSerializer.Object);
return(throwsRule);
}
public SerializationRuleTests()
{
target = new SerializationRule(true, ctor);
}
public void Compile()
{
if (!globalContext.EnableClassesTypes)
{
if (type.IsClass)
{
throw new ArgumentException($"Can't compile serialization functions for type {type}. To enable classes types use SMAB(enableClassesTypes = true) constructor");
}
}
var serializeGen = new ILGen <Action <SerializeStream, object, SerializationContext, SerializationMethodsBase[]> >(type + "_serialize", true);
var deserializeGen = new ILGen <Func <SerializeStream, DeserializationContext, SerializationMethodsBase[], object> >(type + "_deserialize", true);
SerializationRule typeRule = (SerializationRule)type.GetCustomAttribute(typeof(SerializationRule));
bool defaultIsSerializable = typeRule != null ? typeRule.IsSerializable : true;
ILVar optimizationResult = deserializeGen.DeclareVar(typeof((bool, object)));
//Context optimization
if (!type.IsValueType)
{
serializeGen.If(serializeGen.args[2].CallMethod(OptimizeSerializationContextMethodInfo, serializeGen.args[0], serializeGen.args[1]));
serializeGen.Return();
serializeGen.EndIf();
deserializeGen.Line(optimizationResult.Set(deserializeGen.args[1].CallMethod(OptimizeDeserializationContextMethodInfo, deserializeGen.args[0])));
deserializeGen.If(optimizationResult.Field(OptimizationResultItem1));
deserializeGen.Return(optimizationResult.Field(OptimizationResultItem2));
deserializeGen.EndIf();
}
ILVar serializeObject = serializeGen.DeclareVar(type);
ILVar deserializeObject = deserializeGen.DeclareVar(type);
serializeGen.Line(serializeObject.Set(Expr.Cast(serializeGen.args[1], type)));
deserializeGen.Line(deserializeObject.Set(Expr.CreateUninitialized(type)));
if (!type.IsValueType)
{
deserializeGen.Line(deserializeGen.args[1].CallMethod(AddObjectDesreializationContextMethodInfo, deserializeObject));
}
foreach (FieldInfo fieldInfo in type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).OrderBy((FieldInfo fieldInfo) => fieldInfo.MetadataToken))
{
SerializationRule fieldRule = (SerializationRule)fieldInfo.GetCustomAttribute(typeof(SerializationRule));
if (!(fieldRule != null ? fieldRule.IsSerializable : defaultIsSerializable))
{
continue;
}
Type fieldType = fieldInfo.FieldType;
if (SerializeStream.GetBaseTypeRWMethodsIfExists(fieldType, out RWMethodsInfo rwMethods))
{
serializeGen.Line(serializeGen.args[0].CallMethod(rwMethods.writeMethodInfo, serializeObject.Field(fieldInfo)));
deserializeGen.Line(deserializeObject.Field(fieldInfo).Set(deserializeGen.args[0].CallMethod(rwMethods.readMethodInfo)));
}
else
{
int fieldTypeSerializationIndex = GetTypeSerializationMethodsIndex(fieldType);
serializeGen.Line(serializeGen.args[3].Index(Expr.Const(fieldTypeSerializationIndex)).CallMethod(SerializeMethodInfo, serializeGen.args[0], serializeObject.Field(fieldInfo), serializeGen.args[2]));
deserializeGen.Line(deserializeObject.Field(fieldInfo).Set(Expr.Cast(deserializeGen.args[2].Index(Expr.Const(fieldTypeSerializationIndex)).CallMethod(DeserializeMethodInfo, serializeGen.args[0], serializeGen.args[1]), fieldType)));
}
}
deserializeGen.Return(deserializeObject);
serializationMethods.TypeSerializeMethod = new SerializationMethodsWithDependencies.SerializeMethod(serializeGen.compile(globalContext.WithComments));
serializationMethods.TypeDeserializeMethod = new SerializationMethodsWithDependencies.DeserializeMethod(deserializeGen.compile(globalContext.WithComments));
}
