private static PropertyValueMethod GenerateSetPropertyValueMethod(Type objectType, string propertyName)
{
var propertyInfo = objectType.ResolveProperty(propertyName);
var propertyType = propertyInfo.PropertyType;
DynamicMethod method = new DynamicMethod(string.Format("SetPropertyValue_{0}", Guid.NewGuid().ToString("n"))
, null
, new Type[] { typeof(object), typeof(object) } //obj value
, true);
MethodGenerator g = new MethodGenerator(method);
g.LoadParameter(0);
g.Cast(objectType);
g.Assign(propertyName, () =>
{
g.LoadParameter(1);
g.Cast(propertyType);
});
g.Return();
var invoke = method.CreateDelegate(typeof(Action <object, object>));
return(new PropertyValueMethod(propertyName, invoke));
}
public void Foreach()
{
DynamicMethod method = new DynamicMethod("temp", typeof(int), new Type[] { typeof(List <int>) });
MethodGenerator g = new MethodGenerator(method);
List <int> list = new List <int> {
1, 2, 3, 4, 5
};
g.LoadParameter(0);
var count = g.Declare <int>();
g.ForEach(item =>
{
g.Load(item);
g.Store(count);
});
g.Load(count);
g.Return();
var result = (int)method.Invoke(null, new object[] { list });
Assert.AreEqual(5, result);
}
private static PropertyValueMethod GenerateGetPropertyValueMethod <T>(Type objectType, string propertyName)
{
DynamicMethod method = new DynamicMethod(string.Format("GetPropertyValue_{0}", Guid.NewGuid().ToString("n"))
, typeof(T)
, new Type[] { typeof(object) }
, true);
MethodGenerator g = new MethodGenerator(method);
var result = g.Declare <T>("result");
g.Assign(result, () =>
{
g.LoadParameter(0);
g.Cast(objectType);
g.LoadMember(propertyName);
});
g.LoadVariable("result");
g.Return();
var invoke = method.CreateDelegate(typeof(Func <object, T>));
return(new PropertyValueMethod(propertyName, invoke));
}
public void For()
{
DynamicMethod method = new DynamicMethod("temp", typeof(int), new Type[] { typeof(List <int>) });
MethodGenerator g = new MethodGenerator(method);
IVariable array = g.Declare <List <int> >();
g.Assign(array, () =>
{
g.LoadParameter(0);
});
var count = g.Declare <int>();
var number = g.Declare(0);
g.Assign(count, () => {
g.LoadParameter(0);
g.LoadMember("Count");
});
g.For(count, (index) =>
{
g.Assign(number, () =>
{
g.LoadParameter(0);
g.Load(index);
g.Call(typeof(List <int>).ResolveMethod("get_Item", typeof(int)));
g.Load(number);
g.Add <int>();
});
});
g.Load(number);
g.Return();
List <int> list = new List <int> {
1, 2, 3, 4, 5
};
var result = (int)method.Invoke(null, new object[] { list });
Assert.AreEqual(15, result);
}
/// <summary>
/// 读取数组的长度
/// </summary>
/// <param name="g"></param>
/// <param name="dtoMemberName"></param>
/// <param name="valueType"></param>
public static void ReadLength(MethodGenerator g, string dtoMemberName)
{
var method = typeof(IDTOReader).ResolveMethod("ReadLength", _readArgs);
var prmIndex = SerializationArgs.ReaderIndex;
g.Call(method, () =>
{
g.LoadParameter(prmIndex);
g.Load(dtoMemberName);
});
}
/// <summary>
/// 声明强类型的instance变量留待后续代码使用，避免频繁类型转换
/// </summary>
private static void DeclareInstance(MethodGenerator g, TypeSerializationInfo typeInfo)
{
//TypeClassName instance = (TypeClassName)instance;
var instance = g.Declare(typeInfo.ClassType, SerializationArgs.InstanceName);
g.Assign(instance, () =>
{
g.LoadParameter(SerializationArgs.InstanceIndex);
g.UnboxAny(typeInfo.ClassType);
});
}
public static void ReadElement(MethodGenerator g, string dtoMemberName, Type elementType, IVariable index)
{
var method = typeof(IDTOReader).ResolveMethod("ReadElement", new Type[] { elementType }, MethodParameter.Create <string>(), MethodParameter.Create <int>());
var prmIndex = SerializationArgs.ReaderIndex;
g.Call(method, () =>
{
g.LoadParameter(prmIndex);
g.Load(dtoMemberName);
g.LoadVariable(index, LoadOptions.Default);
});
}
public static void WriteArray(MethodGenerator g, string dtoMemberName)
{
var method = typeof(IDTOWriter).ResolveMethod("WriteArray",
new Type[] { typeof(string) });
var prmIndex = SerializationArgs.WriterIndex;
g.Call(method, () =>
{
g.LoadParameter(prmIndex);
g.Load(dtoMemberName);
});
}
public static void WriteBlob(MethodGenerator g, string dtoMemberName, Action loadValue)
{
var method = typeof(IDTOWriter).ResolveMethod("WriteBlob",
new Type[] { typeof(string), typeof(byte[]) });
var prmIndex = SerializationArgs.WriterIndex;
g.Call(method, () =>
{
g.LoadParameter(prmIndex);
g.Load(dtoMemberName);
loadValue();
});
}
/// <summary>
/// <para>得到读取某个类型的IL代码</para>
/// <para>reader.ReadXXX(); 或 deserialzer.Deserialze();</para>
/// </summary>
/// <param name="g"></param>
/// <param name="valueType"></param>
/// <param name="loadValue"></param>
public static void Read(MethodGenerator g, string dtoMemberName, Type valueType)
{
var method = SerializationMethodHelper.GetTypeMethod(valueType, SerializationMethodType.Deserialize);
var prmIndex = SerializationMethodHelper.GetParameterIndex(method, SerializationMethodType.Deserialize);
g.Call(method, () =>
{
g.LoadParameter(prmIndex);
g.Load(dtoMemberName);
//if (prmIndex == SerializationArgs.DeserializerIndex)
//{
// //是deserializer.Deserializ();
// g.LoadVariable(SerializationArgs.TypeNameTable);
//}
});
}
public static void WriteElement(MethodGenerator g, string dtoMemberName, Type elementType, Action loadValue)
{
var method = typeof(IDTOWriter).ResolveMethod("WriteElement",
new Type[] { elementType },
MethodParameter.Create <string>(),
MethodParameter.Create <bool>(),
MethodParameter.CreateGeneric(elementType));
var prmIndex = SerializationArgs.WriterIndex;
g.Call(method, () =>
{
g.LoadParameter(prmIndex);
g.Load(dtoMemberName);
g.Load(IsPrimitive(elementType));
loadValue();
});
}
public void CallNonStatic()
{
DynamicMethod method = new DynamicMethod("temp", typeof(int), new Type[] { typeof(SampleCls) });
MethodGenerator g = new MethodGenerator(method);
g.Call(typeof(SampleCls).ResolveMethod("Increase", typeof(int)), () =>
{
g.LoadParameter(0);
g.Load(5);
});
g.Return();
int result = (int)method.Invoke(null, new object[] { new SampleCls() });
Assert.AreEqual(5, result);
}
private static CreateInstanceMethod GenerateCreateInstanceMethod(ConstructorInfo constructor)
{
var objectType = constructor.DeclaringType;
DynamicMethod method = new DynamicMethod(string.Format("CreateInstanceByConstructor_{0}", Guid.NewGuid().ToString("n"))
, typeof(object)
, new Type[] { typeof(object[]) }
, true);
MethodGenerator g = new MethodGenerator(method);
//以下代码把数组参数转成，new T(arg0,arg1)的形式
var result = g.Declare(objectType, "result");
var objs = g.Declare <object[]>();
g.Assign(objs, () =>
{
g.LoadParameter(0);
});
g.Assign(result, () =>
{
g.NewObject(constructor, () =>
{
var index = g.Declare <int>();
var prms = constructor.GetParameters();
for (var i = 0; i < prms.Length; i++)
{
g.Assign(index, () =>
{
g.Load(i);
});
g.LoadElement(objs, index);
g.Cast(prms[i].ParameterType);
}
});
});
g.LoadVariable("result");
g.Cast(typeof(object));
g.Return();
var invoke = method.CreateDelegate(typeof(Func <object[], object>));
return(new CreateInstanceMethod(invoke));
}
/// <summary>
/// <para>得到写入某个类型的IL代码</para>
/// <para>writer.Write(value); 或 serialzer.Serialze(value);</para>
/// </summary>
/// <param name="g"></param>
/// <param name="valueType"></param>
/// <param name="loadValue"></param>
public static void Write(MethodGenerator g, string dtoMemberName, Type valueType, Action <Type> loadValue)
{
var method = SerializationMethodHelper.GetTypeMethod(valueType, SerializationMethodType.Serialize);
var prmIndex = SerializationMethodHelper.GetParameterIndex(method, SerializationMethodType.Serialize);
g.Call(method, () =>
{
g.LoadParameter(prmIndex);
g.Load(dtoMemberName);
var argType = method.GetParameters()[1].ParameterType;
loadValue(argType);
//if (prmIndex == SerializationArgs.SerializerIndex)
//{
// //是serializer.Serializ();
// g.LoadVariable(SerializationArgs.TypeNameTable);
//}
});
}
