private void EmitReadBuiltInType(ISerializationMethodStorage <AbstractMethodsCompiler> methodStorage)
{
var gen = Method.GetILGenerator();
EmitReadValue(gen, _context.TypeDescription, methodStorage);
gen.Emit(OpCodes.Ret);
}
private void EmitReadFields(ILGenerator gen,
LocalBuilder local,
ISerializationMethodStorage <AbstractMethodsCompiler> methodStorage)
{
foreach (var fieldDescription in _context.TypeDescription.Fields)
{
try
{
EmitBeginReadField(gen, fieldDescription);
if (_context.TypeDescription.IsValueType)
{
gen.Emit(OpCodes.Ldloca_S, local);
}
else
{
gen.Emit(OpCodes.Ldloc, local);
}
EmitReadValue(gen, fieldDescription.FieldType, methodStorage);
gen.Emit(OpCodes.Stfld, fieldDescription.Field);
EmitEndReadField(gen, fieldDescription);
}
catch (SerializationException)
{
throw;
}
}
/// <inheritdoc />
public override void Compile(AbstractMethodsCompiler methods, ISerializationMethodStorage <AbstractMethodsCompiler> methodStorage)
{
var serializationType = _context.TypeDescription.SerializationType;
switch (serializationType)
{
case SerializationType.ByValue:
if (_context.TypeDescription.IsBuiltIn)
{
EmitReadBuiltInType(methodStorage);
}
else
{
EmitReadByValue(methodStorage);
}
break;
case SerializationType.ByReference:
EmitReadByReference();
break;
case SerializationType.Singleton:
EmitReadSingleton();
break;
case SerializationType.NotSerializable:
throw new NotImplementedException();
case SerializationType.Unknown:
throw new NotImplementedException();
default:
throw new InvalidEnumArgumentException("", (int)serializationType, typeof(SerializationType));
}
}
/// <inheritdoc />
public override void Compile(AbstractMethodsCompiler methods,
ISerializationMethodStorage <AbstractMethodsCompiler> methodStorage)
{
var requiresBoxing = _context.Type.IsPrimitive || _context.Type.IsValueType;
var gen = _method.GetILGenerator();
//var hasValue = gen.DefineLabel();
//var end = gen.DefineLabel();
//
//// If value != null: goto hasValue
//EmitReadIsNull(gen);
//gen.Emit(OpCodes.Ldc_I4_0);
//gen.Emit(OpCodes.Ceq);
//gen.Emit(OpCodes.Brfalse, hasValue);
//
//// return null
//gen.Emit(OpCodes.Ldnull);
//gen.Emit(OpCodes.Br_S, end);
// :hasValue
// return ReadValueNotNull(reader, serializer, remoteEndPoint);
//gen.MarkLabel(hasValue);
gen.Emit(OpCodes.Ldarg_0);
gen.Emit(OpCodes.Ldarg_1);
gen.Emit(OpCodes.Ldarg_2);
gen.Emit(OpCodes.Call, methods.ReadValueMethod);
if (requiresBoxing)
{
gen.Emit(OpCodes.Box, _context.Type);
}
//gen.MarkLabel(end);
gen.Emit(OpCodes.Ret);
}
private void EmitWriteFields(ILGenerator gen,
Action loadValue,
ISerializationMethodStorage <AbstractMethodsCompiler> methodStorage)
{
foreach (var field in _context.TypeDescription.Fields)
{
try
{
EmitBeginWriteField(gen, field);
EmitWriteValue(gen, field.TypeDescription, () =>
{
loadValue();
gen.Emit(OpCodes.Ldfld, field.Field);
}, () =>
{
loadValue();
gen.Emit(OpCodes.Ldflda, field.Field);
}, methodStorage);
EmitEndWriteField(gen, field);
}
catch (SerializationException)
{
throw;
}
}
private void EmitWriteByValue(ISerializationMethodStorage <AbstractMethodsCompiler> methodStorage)
{
var gen = Method.GetILGenerator();
// The very first thing we want to do is to call the PreDeserializationCallback, if available.
EmitCallBeforeSerialization(gen);
Action loadValue = () =>
{
if (_context.TypeDescription.IsValueType)
{
gen.Emit(OpCodes.Ldarga_S, arg: 1);
}
else
{
gen.Emit(OpCodes.Ldarg_1);
}
};
//Followed by the list of serializable fields
EmitWriteFields(gen, loadValue, methodStorage);
// Then the serializable properties
EmitWriteProperties(gen, loadValue, methodStorage);
// And finally call the PostDeserializationCallback, if available.
EmitCallAfterSerialization(gen);
gen.Emit(OpCodes.Ret);
}
/// <summary>
///
/// </summary>
/// <param name="methodStorage"></param>
private void EmitWriteBuiltInType(ISerializationMethodStorage <AbstractMethodsCompiler> methodStorage)
{
var gen = Method.GetILGenerator();
var type = _context.TypeDescription;
Action loadMember = () =>
{
gen.Emit(OpCodes.Ldarg_1);
};
Action loadMemberAddress = () =>
{
if (type.IsValueType)
{
gen.Emit(OpCodes.Ldarga_S, 1);
}
else
{
gen.Emit(OpCodes.Ldarg_1);
}
};
EmitWriteValue(gen, type, loadMember, loadMemberAddress, methodStorage);
gen.Emit(OpCodes.Ret);
}
/// <summary>
/// Emits il-code for all methods.
/// </summary>
protected void Compile(ISerializationMethodStorage <AbstractMethodsCompiler> methodStorage)
{
foreach (var compiler in _compilers)
{
compiler.Compile(this, methodStorage);
}
_typeBuilder.CreateType();
}
private void EmitReadByValue(ISerializationMethodStorage <AbstractMethodsCompiler> methodStorage)
{
var gen = Method.GetILGenerator();
var tmp = gen.DeclareLocal(_context.Type);
if (_context.Type.IsValueType)
{
gen.Emit(OpCodes.Ldloca, tmp);
gen.Emit(OpCodes.Initobj, _context.Type);
}
else
{
var ctor = _context.Type.GetConstructor(new Type[0]);
if (ctor == null)
{
throw new ArgumentException(string.Format("Type '{0}' is missing a parameterless constructor", _context.Type));
}
gen.Emit(OpCodes.Newobj, ctor);
gen.Emit(OpCodes.Stloc, tmp);
}
EmitBeginRead(gen);
// tmp.BeforeDeserializationCallback();
EmitCallBeforeDeserialization(gen, tmp);
EmitReadFields(gen, tmp, methodStorage);
EmitReadProperties(gen, tmp, methodStorage);
// tmp.AfterDeserializationCallback();
EmitCallAfterSerialization(gen, tmp);
EmitEndRead(gen);
// return tmp
gen.Emit(OpCodes.Ldloc, tmp);
gen.Emit(OpCodes.Ret);
}
public void Compile(XmlMethodsCompiler methods, ISerializationMethodStorage <XmlMethodsCompiler> storage)
{
methods.Compile(storage);
}
/// <inheritdoc />
public abstract void Compile(AbstractMethodsCompiler methods,
ISerializationMethodStorage <AbstractMethodsCompiler> methodStorage);
