protected override ILStatement GenerateReadInternal(ILValue prop, ILValue liaison, ILValue buffer)
{
return(new ILAssign(
liaison.GetILField(target_field),
ILSerialize.GenerateObjectRead(prop.GetValueType(), buffer)
));
}
public ILStatement GenerateWrite(ILValue target, ILValue buffer)
{
return(target_props
.Convert(p => target.GetILProp(p))
.Convert(p => ILSerialize.GenerateObjectWrite(p, buffer))
.ToBlock());
}
public ILPerformance()
{
var c = new Compiler <Test>();
var modules = c.Compile((i) =>
{
return(new Container(new Member((PropertyInfo)i)));
});
_ilDes = c.CompileILDeserialize(modules);
_ilSer = c.CompileILSerialize(modules);
_class = new Test
{
StringA = "a"
};
_data = DConverter <Test> .Serialize(_class);
foreach (var benchmark in GetType()
.GetMethods()
.Where(x => x.GetCustomAttributes(true)
.OfType <BenchmarkAttribute>()
.Count() > 0))
{
benchmark.Invoke(this, null);
}
}
static public ILMethodInvokation GenerateInvokeRead(MethodInfo to_invoke, ILValue caller, ILValue buffer)
{
return(new ILMethodInvokation(
caller,
to_invoke,
to_invoke.GetEffectiveParameterTypes().Convert(p => ILSerialize.GenerateObjectRead(p, buffer))
));
}
public ILConverter(BaseModule[] members, ILSerialize <T> ilSerialize, ILDeserialize <T> ilDeserialize)
{
Serialize = ilSerialize;
Deserialize = ilDeserialize;
_members = members;
Members = new ReadOnlyCollection <BaseModule>(_members);
}
IConverter <T> IConverterInstanceCreator.Create <T>(BaseModule[] members, ILSerialize <T> ilSer, ILDeserialize <T> ilDes)
{
if (ilSer == null || ilDes == null)
{
return(new Converter <T>(members));
}
else
{
return(new ILConverter <T>(members, ilSer, ilDes));
}
}
protected void WriteArguments(object[] arguments, Buffer buffer)
{
if (argument_writer == null)
{
argument_writer = method.DeclaringType.CreateDynamicMethodDelegate <ArgumentWriter>(delegate(ILValue il_arguments, ILValue il_buffer) {
return(il_arguments.GetILExpandedParams(method)
.Convert(v => ILSerialize.GenerateObjectWrite(v, il_buffer))
.ToBlock());
});
}
argument_writer(arguments, buffer);
}
public IConverter <T> RequestConverter <T>()
where T : new()
{
var compiler = RequestCompiler <T>();
var compiled = compiler.Compile(_genContainer);
ILSerialize <T> ilSer = null;
ILDeserialize <T> ilDes = null;
if (compiler.SupportsIL(compiled))
{
ilSer = compiler.CompileILSerialize(compiled);
ilDes = compiler.CompileILDeserialize(compiled);
}
return(_instantiator.Create <T>(compiled, ilSer, ilDes));
}
protected override ILStatement GenerateWriteInternal(ILValue prop, ILValue liaison, ILValue buffer)
{
return(ILSerialize.GenerateObjectWrite(prop, buffer));
}
public IConverter <T> Create <T>(BaseModule[] members, ILSerialize <T> ilSer, ILDeserialize <T> ilDes) where T : new() => new MockConverter <T>(_counter++);
protected object[] ReadArguments(Buffer buffer)
{
if (argument_reader == null)
{
argument_reader = method.DeclaringType.CreateDynamicMethodDelegate <ArgumentReader>(delegate(ILValue il_buffer) {
return(new ILReturn(
new ILNewPopulatedArray(
typeof(object),
method.GetEffectiveParameterTypes().Convert(t => ILSerialize.GenerateObjectRead(t, il_buffer))
)
));
});
}
return(argument_reader(buffer));
}
static public ILStatement GenerateInvokeWrite(IEnumerable <ILValue> arguments, ILValue buffer)
{
return(arguments
.Convert(a => ILSerialize.GenerateObjectWrite(a, buffer))
.ToBlock());
}
