| public GetILGenerator ( ) : System.Reflection.Emit.ILGenerator | ||
| return | System.Reflection.Emit.ILGenerator | |
internal static GenericGetter CreateGetField(Type type, FieldInfo fieldInfo)
{
DynamicMethod dynamicGet = new DynamicMethod("_", typeof(object), new Type[] { typeof(object) }, type);
ILGenerator il = dynamicGet.GetILGenerator();
if (!type.IsClass) // structs
{
var lv = il.DeclareLocal(type);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Unbox_Any, type);
il.Emit(OpCodes.Stloc_0);
il.Emit(OpCodes.Ldloca_S, lv);
il.Emit(OpCodes.Ldfld, fieldInfo);
if (fieldInfo.FieldType.IsValueType)
il.Emit(OpCodes.Box, fieldInfo.FieldType);
}
else
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, fieldInfo);
if (fieldInfo.FieldType.IsValueType)
il.Emit(OpCodes.Box, fieldInfo.FieldType);
}
il.Emit(OpCodes.Ret);
return (GenericGetter)dynamicGet.CreateDelegate(typeof(GenericGetter));
}
/// <summary>
/// Initializes a new instance of the <see cref="DelegateFieldSetAccessor"/> class
/// for field get access via DynamicMethod.
/// </summary>
/// <param name="targetObjectType">Type of the target object.</param>
/// <param name="fieldName">Name of the field.</param>
public DelegateFieldSetAccessor(Type targetObjectType, string fieldName)
{
// this.targetType = targetObjectType;
_fieldName = fieldName;
FieldInfo fieldInfo = targetObjectType.GetField(fieldName, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public);
// Make sure the field exists
if (fieldInfo == null)
{
throw new NotSupportedException(
string.Format("Field \"{0}\" does not exist for type "
+ "{1}.", fieldName, targetObjectType));
}
_fieldType = fieldInfo.FieldType;
nullInternal = GetNullInternal(_fieldType);
// Emit the IL for set access.
DynamicMethod dynamicMethodSet = new DynamicMethod("SetImplementation", null, new Type[] { typeof(object), typeof(object) }, GetType().Module, false);
ILGenerator ilgen = dynamicMethodSet.GetILGenerator();
ilgen = dynamicMethodSet.GetILGenerator();
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ldarg_1);
UnboxIfNeeded(fieldInfo.FieldType, ilgen);
ilgen.Emit(OpCodes.Stfld, fieldInfo);
ilgen.Emit(OpCodes.Ret);
_set = (SetValue)dynamicMethodSet.CreateDelegate(typeof(SetValue));
}
public static DynamicMemberSetter CreateFieldSetter(FieldInfo field)
{
if (field == null)
{
throw new ArgumentNullException("field");
}
var dm = new System.Reflection.Emit.DynamicMethod("flds", null,
new[] { typeof(object), typeof(object) },
field.DeclaringType, true);
ILGenerator il = dm.GetILGenerator();
if (!field.IsStatic)
{
il.Emit(OpCodes.Ldarg_0);
}
il.Emit(OpCodes.Ldarg_1);
EmitCastToReference(il, field.FieldType);
if (!field.IsStatic)
{
il.Emit(OpCodes.Stfld, field);
}
else
{
il.Emit(OpCodes.Stsfld, field);
}
il.Emit(OpCodes.Ret);
return((DynamicMemberSetter)dm.CreateDelegate(typeof(DynamicMemberSetter)));
}
private static SetControlsDelegate GetSetControlsDelegate()
{
SetControlsDelegate handler = null;
FieldInfo controls = GetField("_controls");
FieldInfo occasionalFields = GetField("_occasionalFields");
MethodInfo ensureOccasionalFields = GetMethod("EnsureOccasionalFields");
SecurityCritical.ExecutePrivileged(new PermissionSet(PermissionState.Unrestricted), delegate
{
System.Reflection.Emit.DynamicMethod dm = new System.Reflection.Emit.DynamicMethod("set_Controls ", null, new Type[] { typeof(Control), typeof(ControlCollection) }, typeof(Control).Module, true);
ILGenerator il = dm.GetILGenerator();
Label occFieldsNull = il.DefineLabel();
Label setControls = il.DefineLabel();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, occasionalFields);
il.Emit(OpCodes.Brfalse_S, occFieldsNull);
il.MarkLabel(setControls);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Stfld, controls);
il.Emit(OpCodes.Ret);
il.MarkLabel(occFieldsNull);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Call, ensureOccasionalFields);
il.Emit(OpCodes.Br, setControls);
handler = (SetControlsDelegate)dm.CreateDelegate(typeof(SetControlsDelegate));
});
return(handler);
}
public static DynamicConstructor CreateConstructor(ConstructorInfo constructor)
{
if (constructor == null)
{
throw new ArgumentNullException("constructor");
}
if (constructor.GetParameters().Length > 0)
{
throw new NotSupportedException("Constructor with parameters are not supported.");
}
var dm = new System.Reflection.Emit.DynamicMethod(
"ctor",
MethodAttributes.Static | MethodAttributes.Public,
CallingConventions.Standard,
constructor.DeclaringType,
Type.EmptyTypes,
(Type)null,
true);
ILGenerator il = dm.GetILGenerator();
il.Emit(OpCodes.Nop);
il.Emit(OpCodes.Newobj, constructor);
il.Emit(OpCodes.Ret);
return((DynamicConstructor)dm.CreateDelegate(typeof(DynamicConstructor)));
}
private static object GetDynamicInstance(Type type) {
if (typeof (MulticastDelegate).IsAssignableFrom(type)) {
DynamicMethod method = new DynamicMethod("XStreamDynamicDelegate", typeof (void), GetDelegateParameterTypes(type), typeof (object));
ILGenerator generator = method.GetILGenerator();
generator.Emit(OpCodes.Ret);
return method.CreateDelegate(type);
}
if (type.IsSealed)
throw new ConversionException("Impossible to construct type: " + type);
// Check if we already have the type defined
string typeName = prefix + type;
lock (typeMap) {
Type dynamicType = typeMap[typeName] as Type;
if (dynamicType == null) {
TypeBuilder typeBuilder = ModuleBuilder.DefineType(typeName, TypeAttributes.Class | TypeAttributes.NotPublic, type);
ConstructorBuilder cb = typeBuilder.DefineConstructor(MethodAttributes.Private, CallingConventions.Standard, new Type[0]);
cb.GetILGenerator().Emit(OpCodes.Ret);
dynamicType = typeBuilder.CreateType();
typeMap[typeName] = dynamicType;
}
return Activator.CreateInstance(dynamicType, true);
}
}
/// <summary>
/// Gets or creates an injector for the specified property.
/// </summary>
/// <param name="property">The property.</param>
/// <returns>The created injector.</returns>
public PropertyInjector Create(PropertyInfo property)
{
#if NO_SKIP_VISIBILITY
var dynamicMethod = new DynamicMethod(GetAnonymousMethodName(), typeof(void), new[] { typeof(object), typeof(object) });
#else
var dynamicMethod = new DynamicMethod(GetAnonymousMethodName(), typeof(void), new[] { typeof(object), typeof(object) }, true);
#endif
ILGenerator il = dynamicMethod.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
EmitUnboxOrCast(il, property.DeclaringType);
il.Emit(OpCodes.Ldarg_1);
EmitUnboxOrCast(il, property.PropertyType);
#if !SILVERLIGHT
bool injectNonPublic = Settings.InjectNonPublic;
#else
const bool injectNonPublic = false;
#endif // !SILVERLIGHT
EmitMethodCall(il, property.GetSetMethod(injectNonPublic));
il.Emit(OpCodes.Ret);
return (PropertyInjector) dynamicMethod.CreateDelegate(typeof(PropertyInjector));
}
public BehaviorModel()
{
var modelType = GetType();
if (!s_data.TryGetValue(modelType, out m_data))
{
lock (s_data)
{
if (!s_data.TryGetValue(modelType, out m_data))
{
m_data = new BehaviorModelData
{
BhvModelAttr = modelType.GetAttribute<BehaviorModelAttribute>()
};
var bhvType = m_data.BhvModelAttr != null
? m_data.BhvModelAttr.BehaviorType
: SupplementBehaviorType; // virtual function call to get the most derived value
var dynMethod = new DynamicMethod("DM$OBJ_FACTORY_" + bhvType.FullName, bhvType, null, bhvType);
var ilGen = dynMethod.GetILGenerator();
ilGen.Emit(OpCodes.Newobj, bhvType.GetConstructor(Type.EmptyTypes));
ilGen.Emit(OpCodes.Ret);
m_data.BehaviorType = bhvType;
m_data.BhvFactory = (Func<IBehavior>)dynMethod.CreateDelegate(typeof(Func<IBehavior>));
m_data.IsBehaviorStatic = BehaviorModel.GetIsBehaviorStatic(bhvType);
s_data.Add(modelType, m_data);
}
}
}
m_name = null;
}
public RedisFactory(bool saveDynamicAssembly = false)
{
var redisTypes = RedisTypeBuilder.BuildRedisTypes();
if (saveDynamicAssembly)
{
redisTypes.SaveAssembly();
}
// Build CreateRedis dynamic method
var createRedisDynamicMethod = new DynamicMethod("CreateRedis", typeof(IRedis), new[] { typeof(IRedisConnection) });
var redisConstructor = redisTypes.RedisType.GetConstructor(new[] { typeof(IRedisConnection) });
var createRedisGenerator = createRedisDynamicMethod.GetILGenerator();
createRedisGenerator.Emit(OpCodes.Ldarg_0);
createRedisGenerator.Emit(OpCodes.Newobj, redisConstructor);
createRedisGenerator.Emit(OpCodes.Ret);
// Build CreateRedisExec dynamic method
var createRedisPipelineDynamicMethod = new DynamicMethod("CreateRedisPipeline", typeof(IRedisPipeline), new[] { typeof(IRedisConnection), typeof(bool) });
var redisPipelineConstructor = redisTypes.RedisPipelineType.GetConstructor(new[] { typeof(IRedisConnection), typeof(bool) });
var createRedisPipelineGenerator = createRedisPipelineDynamicMethod.GetILGenerator();
createRedisPipelineGenerator.Emit(OpCodes.Ldarg_0);
createRedisPipelineGenerator.Emit(OpCodes.Ldarg_1);
createRedisPipelineGenerator.Emit(OpCodes.Newobj, redisPipelineConstructor);
createRedisPipelineGenerator.Emit(OpCodes.Ret);
// Create delegates from dynamic methods
this.createRedis = (CreateRedisDelegate) createRedisDynamicMethod.CreateDelegate(typeof (CreateRedisDelegate));
this.createRedisPipeline = (CreateRedisPipelineDelegate)createRedisPipelineDynamicMethod.CreateDelegate(typeof(CreateRedisPipelineDelegate));
}
/// <summary>
/// Creates a dynamic getter for the property
/// </summary>
/// <param name="propertyInfo"></param>
/// <returns></returns>
public static GenericGetter CreateGetMethod(PropertyInfo propertyInfo)
{
/*
* If there's no getter return null
*/
MethodInfo getMethod = propertyInfo.GetGetMethod();
if (getMethod == null)
return null;
/*
* Create the dynamic method
*/
Type[] arguments = new Type[1];
arguments[0] = typeof(object);
DynamicMethod getter = new DynamicMethod(
String.Concat("_Get", propertyInfo.Name, "_"),
typeof(object), arguments, propertyInfo.DeclaringType,false);
ILGenerator generator = getter.GetILGenerator();
generator.DeclareLocal(typeof(object));
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Castclass, propertyInfo.DeclaringType);
generator.EmitCall(OpCodes.Callvirt, getMethod, null);
if (!propertyInfo.PropertyType.IsClass)
generator.Emit(OpCodes.Box, propertyInfo.PropertyType);
generator.Emit(OpCodes.Ret);
/*
* Create the delegate and return it
*/
return (GenericGetter)getter.CreateDelegate(typeof(GenericGetter));
}
public static Action GetEntryDelegate(this MethodInfo entryPoint)
{
if (!entryPoint.IsPublic || !entryPoint.DeclaringType.IsPublic)
{
Log.WriteLine(LogLevel.Error, "Entry point: {0}.{1} is not public. This may cause errors with Mono.",
entryPoint.DeclaringType.FullName, entryPoint.Name);
}
var dm = new DynamicMethod(entryPoint.DeclaringType.Assembly.GetName().Name + "_entrypoint_" + entryPoint.DeclaringType.FullName + entryPoint.Name, null, null, true);
var il = dm.GetILGenerator();
var args = entryPoint.GetParameters();
if (args.Length > 1) throw new ArgumentException("Cannot handle entry points with more than 1 parameter.");
if (args.Length == 1)
{
if (args[0].ParameterType != typeof(string[])) throw new ArgumentException("Entry point paramter must be a string array.");
il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Newarr, typeof(string));
}
il.EmitCall(OpCodes.Call, entryPoint, null);
if (entryPoint.ReturnType != typeof(void))
{
il.Emit(OpCodes.Pop);
}
il.Emit(OpCodes.Ret);
return (Action)dm.CreateDelegate(typeof(Action));
}
private static DynamicGetter CreateGetMethod(PropertyInfo propertyInfo, Type type)
{
var getMethod = propertyInfo.GetGetMethod();
if (getMethod == null)
throw new InvalidOperationException(string.Format("Could not retrieve GetMethod for the {0} property of {1} type", propertyInfo.Name, type.FullName));
var arguments = new Type[1]
{
typeof (object)
};
var getterMethod = new DynamicMethod(string.Concat("_Get", propertyInfo.Name, "_"), typeof(object), arguments, propertyInfo.DeclaringType);
var generator = getterMethod.GetILGenerator();
generator.DeclareLocal(typeof(object));
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Castclass, propertyInfo.DeclaringType);
generator.EmitCall(OpCodes.Callvirt, getMethod, null);
if (propertyInfo.PropertyType.IsClass == false)
generator.Emit(OpCodes.Box, propertyInfo.PropertyType);
generator.Emit(OpCodes.Ret);
return (DynamicGetter) getterMethod.CreateDelegate(typeof (DynamicGetter));
}
//todo: temporary public
public FillingDelegate GetFiller(TypeMappingInfo mapping, Table table)
{
var ct = typeof(object);
// Fill(reader, obj, offset)
Type[] methodArgs2 = { typeof(IDataRecord), ct, typeof(int) };
var method = new DynamicMethod(
"ct",
null,
methodArgs2, typeof(SqlValueMapper));
var generator = method.GetILGenerator();
Type type = mapping.Type;
var i = 0;
foreach(var prop in table.Columns)
{
var navigation = prop as NavigationPropertyMapping;
if (navigation != null)
{
GenerateForNavigationProperty(navigation, type, generator, i);
}
else
{
GenerateForPrimitive(type, prop, generator, i);
}
i++;
}
// return
generator.Emit(OpCodes.Ret);
return (FillingDelegate)method.CreateDelegate(typeof(FillingDelegate));
}
internal static Func<object, SqlArgument[]> CreateGetInsertValues(IObjectInfo objectInfo)
{
var dynamicMethod = new DynamicMethod(
name: "MicroLite" + objectInfo.ForType.Name + "GetInsertValues",
returnType: typeof(SqlArgument[]),
parameterTypes: new[] { typeof(object) }, // arg_0
m: typeof(ObjectInfo).Module);
var ilGenerator = dynamicMethod.GetILGenerator();
ilGenerator.DeclareLocal(objectInfo.ForType); // loc_0 - {Type} instance;
ilGenerator.DeclareLocal(typeof(SqlArgument[])); // loc_1 - SqlArgument[] sqlArguments;
// instance = ({Type})arg_0;
ilGenerator.Emit(OpCodes.Ldarg_0);
ilGenerator.Emit(OpCodes.Castclass, objectInfo.ForType);
ilGenerator.Emit(OpCodes.Stloc_0);
// sqlArguments = new SqlArgument[count];
ilGenerator.EmitEfficientInt(objectInfo.TableInfo.InsertColumnCount);
ilGenerator.Emit(OpCodes.Newarr, typeof(SqlArgument));
ilGenerator.Emit(OpCodes.Stloc_1);
EmitGetPropertyValues(ilGenerator, objectInfo, c => c.AllowInsert);
// return sqlArguments;
ilGenerator.Emit(OpCodes.Ldloc_1);
ilGenerator.Emit(OpCodes.Ret);
var getInsertValues = (Func<object, SqlArgument[]>)dynamicMethod.CreateDelegate(typeof(Func<object, SqlArgument[]>));
return getInsertValues;
}
static ResXProjectFile() {
// Mono doesn't support the constructors that we need
Type[] paramTypes;
ConstructorInfo ctorInfo;
paramTypes = new Type[] { typeof(string), typeof(Func<Type, string>) };
ctorInfo = typeof(ResXResourceWriter).GetConstructor(paramTypes);
if (ctorInfo != null) {
var dynMethod = new DynamicMethod("ResXResourceWriter-ctor", typeof(ResXResourceWriter), paramTypes);
var ilg = dynMethod.GetILGenerator();
ilg.Emit(OpCodes.Ldarg_0);
ilg.Emit(OpCodes.Ldarg_1);
ilg.Emit(OpCodes.Newobj, ctorInfo);
ilg.Emit(OpCodes.Ret);
delegateResXResourceWriterConstructor = (Func<string, Func<Type, string>, ResXResourceWriter>)dynMethod.CreateDelegate(typeof(Func<string, Func<Type, string>, ResXResourceWriter>));
}
paramTypes = new Type[] { typeof(string), typeof(object), typeof(Func<Type, string>) };
ctorInfo = typeof(ResXDataNode).GetConstructor(paramTypes);
if (ctorInfo != null) {
var dynMethod = new DynamicMethod("ResXDataNode-ctor", typeof(ResXDataNode), paramTypes);
var ilg = dynMethod.GetILGenerator();
ilg.Emit(OpCodes.Ldarg_0);
ilg.Emit(OpCodes.Ldarg_1);
ilg.Emit(OpCodes.Ldarg_2);
ilg.Emit(OpCodes.Newobj, ctorInfo);
ilg.Emit(OpCodes.Ret);
delegateResXDataNodeConstructor = (Func<string, object, Func<Type, string>, ResXDataNode>)dynMethod.CreateDelegate(typeof(Func<string, object, Func<Type, string>, ResXDataNode>));
}
}
private void GenerateMethodBody(DynamicMethod method, Operation operation)
{
ILGenerator generator = method.GetILGenerator();
generator.DeclareLocal(typeof(double));
GenerateMethodBody(generator, operation);
generator.Emit(OpCodes.Ret);
}
public Activator CreateActivator(Type type, out List<Type> dependencies)
{
dependencies = new List<Type>();
ConstructorInfo constructorInfo = type.GetConstructors()[0];
ParameterInfo[] parameters = constructorInfo.GetParameters();
var method = new DynamicMethod("CreateInstance", typeof(object), new[] { typeof(object[]) });
ILGenerator generator = method.GetILGenerator();
for (int index = 0; index < parameters.Length; index++)
{
Type parameterType = parameters[index].ParameterType;
dependencies.Add(parameterType);
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldc_I4, index);
generator.Emit(OpCodes.Ldelem_Ref);
generator.Emit(parameterType.IsValueType ? OpCodes.Unbox_Any : OpCodes.Castclass, parameterType);
}
generator.Emit(OpCodes.Newobj, constructorInfo);
generator.Emit(OpCodes.Ret);
var activator = method.CreateDelegate(typeof(Activator)) as Activator;
return activator;
}
/// <summary>
/// Generates a dynamic method which creates a new instance of <paramref name="type" />
/// when invoked.
/// </summary>
private CreateInstanceInvoker CreateCreateInstanceMethod(System.Type type)
{
if (type.IsInterface || type.IsAbstract)
{
return null;
}
DynamicMethod method = new DynamicMethod(string.Empty, typeof(object), null, type, true);
ILGenerator il = method.GetILGenerator();
if (type.IsValueType)
{
LocalBuilder tmpLocal = il.DeclareLocal(type);
il.Emit(OpCodes.Ldloca, tmpLocal);
il.Emit(OpCodes.Initobj, type);
il.Emit(OpCodes.Ldloc, tmpLocal);
il.Emit(OpCodes.Box, type);
}
else
{
ConstructorInfo constructor = ReflectHelper.GetDefaultConstructor(type);
if (constructor == null)
{
throw new InstantiationException("Object class " + type + " must declare a default (no-argument) constructor", type);
}
il.Emit(OpCodes.Newobj, constructor);
}
il.Emit(OpCodes.Ret);
return (CreateInstanceInvoker)method.CreateDelegate(typeof(CreateInstanceInvoker));
}
/// <summary>
/// 指定したイベントに追加出来るようなイベントハンドラを作成し、<see cref="System.Delegate"/> として返します。
/// イベントハンドラ内では、 this.OnChanged(sender) を呼び出します。
/// </summary>
/// <param name="e">追加先のイベントの情報を指定します。</param>
/// <returns>作成したメソッドを参照するデリゲートを返します。</returns>
protected System.Delegate CreateEventHandler(System.Reflection.EventInfo e)
{
System.Reflection.MethodInfo minfo = e.EventHandlerType.GetMethod("Invoke");
if (minfo.ReturnType != typeof(void))
{
throw new System.ApplicationException(@"このイベントには返値を指定しなければ為りません。
現在、返値を必要とするイベントへのフックには対応していません。");
}
//-- 引数の型
System.Reflection.ParameterInfo[] infoParams = minfo.GetParameters();
System.Type[] tParams = new System.Type[infoParams.Length];
tParams[0] = typeof(PropertyAccessor); // this-parameter
for (int i = 0; i < infoParams.Length; i++)
{
tParams[i + 1] = infoParams[i].ParameterType;
}
Emit.DynamicMethod eh = new Emit.DynamicMethod("eh", null, tParams, typeof(PropertyAccessor));
System.Reflection.Emit.ILGenerator ilgen = eh.GetILGenerator();
ilgen.Emit(Emit.OpCodes.Ldarg_0); // load this
ilgen.Emit(infoParams.Length == 0?Emit.OpCodes.Ldnull:Emit.OpCodes.Ldarg_1); // load sender (引数がない場合には null)
ilgen.Emit(Emit.OpCodes.Callvirt, typeof(PropertyAccessor).GetMethod("OnChanged")); // this.OnChnaged(sender);
ilgen.Emit(Emit.OpCodes.Ret); // return;
return(eh.CreateDelegate(e.EventHandlerType, this));
}
private void Compile()
{
DynamicMethod isMatch = new DynamicMethod("IsMatch", typeof(bool), new Type[] { typeof(int), typeof(int) }, typeof(Schedule));
ILGenerator il = isMatch.GetILGenerator();
Label matched = il.DefineLabel();
Label failed = il.DefineLabel();
Console.WriteLine(mPositiveRules.Length);
for (int i = 0; i < mPositiveRules.Length; i++)
{
ScheduleRuleSpan ruleSpan = mPositiveRules[i];
for (int j = 0; j < ruleSpan.Rules.Length; j++)
{
ruleSpan.Rules[j].Compile(il);
il.Emit(OpCodes.Brtrue, matched);
}
}
il.Emit(OpCodes.Br, failed);
il.MarkLabel(matched);
il.Emit(OpCodes.Ldc_I4_1);
il.Emit(OpCodes.Ret);
il.MarkLabel(failed);
il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Ret);
mMatch = (IsDateMatch)isMatch.CreateDelegate(typeof(IsDateMatch));
}
private static CreateInstanceInvoker CreateCreateInstanceMethod(Type type)
{
if (type.IsInterface || type.IsAbstract)
return null;
DynamicMethod method = new DynamicMethod(string.Empty, typeof (object), null, type, true);
ILGenerator il = method.GetILGenerator();
if (type.IsValueType)
{
LocalBuilder tmpLocal = il.DeclareLocal(type);
il.Emit(OpCodes.Ldloca, tmpLocal);
il.Emit(OpCodes.Initobj, type);
il.Emit(OpCodes.Ldloc, tmpLocal);
il.Emit(OpCodes.Box, type);
}
else
{
ConstructorInfo constructor = type.GetConstructor(AnyVisibilityInstance, null, CallingConventions.HasThis, NoClasses, null);
if (constructor == null)
throw new ApplicationException("Object class " + type + " must declare a default (no-argument) constructor");
il.Emit(OpCodes.Newobj, constructor);
}
il.Emit(OpCodes.Ret);
return (CreateInstanceInvoker) method.CreateDelegate(typeof (CreateInstanceInvoker));
}
internal static void CreateMethodBody(Emit.DynamicMethod dynamicMethod, DynamicMethodRequest methodRequest, Type[] args)
{
var generator = dynamicMethod.GetILGenerator();
for (var i = 0; i < args.Length; i++)
{
generator.Emit(OpCodes.Ldarg, i);
}
if (methodRequest.Member is MethodInfo)
{
var method = (MethodInfo)methodRequest.Member;
var opCode = methodRequest.IsStatic ? OpCodes.Call : OpCodes.Callvirt;
generator.EmitCall(opCode, method, null);
}
else if (methodRequest.Member is FieldInfo)
{
var method = (FieldInfo)methodRequest.Member;
var isInput = methodRequest.DataFlowDirection == DataFlowDirection.Input;
var opCode = methodRequest.IsStatic
? (isInput ? OpCodes.Stsfld : OpCodes.Ldsfld)
: (isInput ? OpCodes.Stfld : OpCodes.Ldfld);
generator.Emit(opCode, method);
}
generator.Emit(OpCodes.Ret);
}
public void TestCall2()
{
var parameters = new[] { typeof(int), typeof(int) };
var dm = new DynamicMethod("soma", typeof(int), parameters);
var gen = dm.GetILGenerator();
gen.DeclareLocal (typeof(Math));
var ctor = typeof(Math).GetConstructors () [0];
gen.Emit (OpCodes.Newobj, ctor);
gen.Emit (OpCodes.Stloc, 0);
gen.Emit (OpCodes.Ldobj, 0);
//gen.Emit(OpCodes.Ldarg_0);
//gen.Emit(OpCodes.Ldarg_1);
//var soma = GetType ().GetMethod ("Soma");
//gen.EmitCall (OpCodes.Callvirt, soma, new Type[] { });
gen.Emit (OpCodes.Ldc_I4, 2);
gen.Emit(OpCodes.Ret);
var result = dm.Invoke(null, new object[] { 1, 1 });
//var func = (Func<int, int, int>)dm.CreateDelegate(typeof(Func<int, int, int>));
Assert.AreEqual (2, result);
}
private static void CtorProxy(RuntimeFieldHandle f)
{
var fld = FieldInfo.GetFieldFromHandle(f);
var asm = Assembly.GetExecutingAssembly();
char[] ch = new char[fld.Name.Length];
for (int i = 0; i < ch.Length; i++)
{
ch[i] = (char)((byte)fld.Name[i] ^ i);
}
var mtd = asm.GetModules()[0].ResolveMethod(BitConverter.ToInt32(Convert.FromBase64String(new string(ch)), 0) ^ 0x12345678) as System.Reflection.ConstructorInfo;
var args = mtd.GetParameters();
Type[] arg = new Type[args.Length];
for (int i = 0; i < args.Length; i++)
{
arg[i] = args[i].ParameterType;
}
var dm = new System.Reflection.Emit.DynamicMethod("", mtd.DeclaringType, arg, mtd.DeclaringType, true);
var gen = dm.GetILGenerator();
for (int i = 0; i < arg.Length; i++)
{
gen.Emit(System.Reflection.Emit.OpCodes.Ldarg_S, i);
}
gen.Emit(System.Reflection.Emit.OpCodes.Newobj, mtd);
gen.Emit(System.Reflection.Emit.OpCodes.Ret);
fld.SetValue(null, dm.CreateDelegate(fld.FieldType));
}
/// <summary>Gets the instance creator delegate that can be use to create instances of the specified type.</summary>
/// <param name="type">The type of the objects we want to create.</param>
/// <returns>A delegate that can be used to create the objects.</returns>
public static FastCreateInstanceHandler GetInstanceCreator(Type type)
{
lock (dictCreator)
{
if (dictCreator.ContainsKey(type)) return (FastCreateInstanceHandler)dictCreator[type];
// generates a dynamic method to generate a FastCreateInstanceHandler delegate
DynamicMethod dynamicMethod = new DynamicMethod(string.Empty, type, new Type[0], typeof(DynamicCalls).Module);
ILGenerator ilGenerator = dynamicMethod.GetILGenerator();
// generates code to create a new object of the specified type using the default constructor
ilGenerator.Emit(OpCodes.Newobj, type.GetConstructor(Type.EmptyTypes));
// returns the value to the caller
ilGenerator.Emit(OpCodes.Ret);
// converts the DynamicMethod to a FastCreateInstanceHandler delegate to create the object
FastCreateInstanceHandler creator = (FastCreateInstanceHandler)dynamicMethod.CreateDelegate(typeof(FastCreateInstanceHandler));
dictCreator.Add(type, creator);
return creator;
}
}
internal static Func<object, object> CreateGetIdentifier(IObjectInfo objectInfo)
{
var dynamicMethod = new DynamicMethod(
name: "MicroLite" + objectInfo.ForType.Name + "GetIdentifier",
returnType: typeof(object),
parameterTypes: new[] { typeof(object) }); // arg_0
var ilGenerator = dynamicMethod.GetILGenerator();
// var instance = ({Type})arg_0;
ilGenerator.Emit(OpCodes.Ldarg_0);
ilGenerator.Emit(OpCodes.Castclass, objectInfo.ForType);
// var identifier = instance.Id;
ilGenerator.Emit(OpCodes.Callvirt, objectInfo.TableInfo.IdentifierColumn.PropertyInfo.GetGetMethod());
// value = (object)identifier;
ilGenerator.EmitBoxIfValueType(objectInfo.TableInfo.IdentifierColumn.PropertyInfo.PropertyType);
// return identifier;
ilGenerator.Emit(OpCodes.Ret);
var getIdentifierValue = (Func<object, object>)dynamicMethod.CreateDelegate(typeof(Func<object, object>));
return getIdentifierValue;
}
public static GetValueDelegate CreateFieldGetter(FieldInfo field)
{
if (field == null)
throw new ArgumentNullException("field");
DynamicMethod dm = new DynamicMethod("FieldGetter", typeof(object),
new Type[] { typeof(object) },
field.DeclaringType, true);
ILGenerator il = dm.GetILGenerator();
if (!field.IsStatic)
{
il.Emit(OpCodes.Ldarg_0);
EmitCastToReference(il, field.DeclaringType); //to handle struct object
il.Emit(OpCodes.Ldfld, field);
}
else
il.Emit(OpCodes.Ldsfld, field);
if (field.FieldType.IsValueType)
il.Emit(OpCodes.Box, field.FieldType);
il.Emit(OpCodes.Ret);
return (GetValueDelegate)dm.CreateDelegate(typeof(GetValueDelegate));
}
private static CloneHandler CreateCloneWrapper(Type type)
{
var cloneMethod = new DynamicMethod
(
"NativeClone",
MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig | MethodAttributes.Final | MethodAttributes.NewSlot,
CallingConventions.Standard,
typeof(IntPtr), new Type[] { type },
type, false
);
var ilGenerator = cloneMethod.GetILGenerator();
ilGenerator.Emit(OpCodes.Ldarg_0); // Step 1: Push the object to clone on the stack
// Just to be clean, don't suppose ICloneable only has one member…
var cloneableInterfaceMap = type.GetInterfaceMap(typeof(ICloneable));
for (int i = 0; i < cloneableInterfaceMap.InterfaceMethods.Length; i++)
if (cloneableInterfaceMap.InterfaceMethods[i].Name == "Clone")
{
ilGenerator.Emit(OpCodes.Call, cloneableInterfaceMap.TargetMethods[i]); // Step 2: clone it
goto CloneMethodFound; // Finish the job once we found the Clone method (which should always be found)
}
throw new InvalidOperationException(); // This line should never be reached
CloneMethodFound:
ilGenerator.Emit(OpCodes.Isinst, type); // Step 3: Cast it to the correct type
var nativePointerProperty = type.GetProperty
(
"NativePointer",
BindingFlags.NonPublic | BindingFlags.Instance, Type.DefaultBinder,
typeof(IntPtr), Type.EmptyTypes, null
);
ilGenerator.Emit(OpCodes.Call, nativePointerProperty.GetGetMethod(true)); // Step 4: Get the native pointer
ilGenerator.Emit(OpCodes.Ret); // Step 5: Return the value
return cloneMethod.CreateDelegate(typeof(CloneHandler)) as CloneHandler;
}
/// <summary>
/// the address of a field relative to the address an object reference of that type points to. this function is very expensive to call.
/// </summary>
/// <param name="field"></param>
/// <returns></returns>
public static IntPtr GetManagedOffset(this FieldInfo field)
{
Type type = field.DeclaringType;
var dyn = new System.Reflection.Emit.DynamicMethod(
"xxz0", typeof(IntPtr), new Type[] { typeof(object) }, typeof(ReflectionExtensions).Module, true);
var il = dyn.GetILGenerator();
var pin = il.DeclareLocal(type, true);
var baseaddr = il.DeclareLocal(typeof(IntPtr));
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Stloc, pin); // force cast object to type (invalid), and pin
il.Emit(OpCodes.Ldloc, pin); // base address of reference (points to typeinfo)
il.Emit(OpCodes.Conv_I); // convert object ref to intptr (invalid)
il.Emit(OpCodes.Stloc, baseaddr);
il.Emit(OpCodes.Ldloc, pin);
il.Emit(OpCodes.Ldflda, field); // address of desired field
il.Emit(OpCodes.Conv_I); // convert field& to intptr (invalid)
il.Emit(OpCodes.Ldloc, baseaddr);
il.Emit(OpCodes.Sub);
il.Emit(OpCodes.Ret);
return((IntPtr)dyn.Invoke(null, new object[] { new object() }));
}
static Action<IDbCommand, bool> GetBindByName(Type commandType)
{
if (commandType == null) return null; // GIGO
Action<IDbCommand, bool> action;
if (Link<Type, Action<IDbCommand, bool>>.TryGet(bindByNameCache, commandType, out action))
{
return action;
}
var prop = commandType.GetProperty("BindByName", BindingFlags.Public | BindingFlags.Instance);
action = null;
ParameterInfo[] indexers;
MethodInfo setter;
if (prop != null && prop.CanWrite && prop.PropertyType == typeof(bool)
&& ((indexers = prop.GetIndexParameters()) == null || indexers.Length == 0)
&& (setter = prop.GetSetMethod()) != null
)
{
var method = new DynamicMethod(commandType.Name + "_BindByName", null, new Type[] { typeof(IDbCommand), typeof(bool) });
var il = method.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Castclass, commandType);
il.Emit(OpCodes.Ldarg_1);
il.EmitCall(OpCodes.Callvirt, setter, null);
il.Emit(OpCodes.Ret);
action = (Action<IDbCommand, bool>)method.CreateDelegate(typeof(Action<IDbCommand, bool>));
}
// cache it
Link<Type, Action<IDbCommand, bool>>.TryAdd(ref bindByNameCache, commandType, ref action);
return action;
}
protected virtual Delegate CreateCastDelegate()
{
var paramTypes = _delegateParams.Select(x => x.ParameterType).ToArray();
var m = new DynamicMethod(string.Empty, _delegateReturn, paramTypes,
typeof (DelegateBuilder), SimpleReflection.PrivateAccess);
var cg = m.GetILGenerator();
// Prepare parameters...
foreach (var parameterMap in _parametersMap)
{
parameterMap.EmitPrepare(cg);
}
// Load parameters, stack should be empty here
foreach (var parameterMap in _parametersMap)
{
parameterMap.EmitLoad(cg);
}
// Emit invoke
EmitInvoke(cg);
// Emit finish, stack should contain return value here (if not void)
foreach (var parameterMap in _parametersMap)
{
parameterMap.EmitFinish(cg);
}
// Emit return
cg.Emit(OpCodes.Ret);
return m.CreateDelegate(_delegateType);
}
private static PropertyMapper GenerateDelegate(Type sourceType, Type targetType, bool ignoreMappings)
{
var method = new DynamicMethod("Map_" + sourceType.FullName + "_" + targetType.FullName, null, new[] { typeof(object), typeof(object) });
var il = method.GetILGenerator();
var sourceProperties = Reflector.GetAllProperties(sourceType);
var targetProperties = Reflector.GetAllProperties(targetType);
var entityMap = MappingFactory.GetEntityMap(targetType);
var matches = sourceProperties.CrossJoin(targetProperties).Where(t => t.Item2.Name == MappingFactory.GetPropertyOrColumnName(t.Item3, ignoreMappings, entityMap, false)
&& t.Item2.PropertyType == t.Item3.PropertyType
&& t.Item2.PropertyType.IsPublic
&& t.Item3.PropertyType.IsPublic
//&& (t.Item3.PropertyType.IsValueType || t.Item3.PropertyType == typeof(string))
&& t.Item2.CanRead && t.Item3.CanWrite);
foreach (var match in matches)
{
il.Emit(OpCodes.Ldarg_1);
il.EmitCastToReference(targetType);
il.Emit(OpCodes.Ldarg_0);
il.EmitCastToReference(sourceType);
il.Emit(OpCodes.Callvirt, match.Item2.GetGetMethod());
il.Emit(OpCodes.Callvirt, match.Item3.GetSetMethod());
}
il.Emit(OpCodes.Ret);
var mapper = (PropertyMapper)method.CreateDelegate(typeof(PropertyMapper));
return mapper;
}
private void GenerateMethodBody(DynamicMethod dynamicMethod) {
var ilGenerator = dynamicMethod.GetILGenerator();
ilGenerator.Emit(OpCodes.Ldarg_0); // Load templateControl argument onto stack
ilGenerator.Emit(OpCodes.Ldarg_1); // Load virtualPath argument onto stack
ilGenerator.Emit(OpCodes.Call, invoker); // Invoke LoadControlInvoker with the loaded two arguments
ilGenerator.Emit(OpCodes.Ret); // End method
}
public static SetValueDelegate CreateFieldSetter(FieldInfo field)
{
if( field == null )
throw new ArgumentNullException("field");
DynamicMethod dm = new DynamicMethod("FieldSetter", null,
new Type[] { typeof(object), typeof(object) },
field.DeclaringType, true);
ILGenerator il = dm.GetILGenerator();
if( !field.IsStatic ) {
il.Emit(OpCodes.Ldarg_0);
}
il.Emit(OpCodes.Ldarg_1);
EmitCastToReference(il, field.FieldType);
if( !field.IsStatic )
il.Emit(OpCodes.Stfld, field);
else
il.Emit(OpCodes.Stsfld, field);
il.Emit(OpCodes.Ret);
return (SetValueDelegate)dm.CreateDelegate(typeof(SetValueDelegate));
}
public static Delegate Transcribe(Type sourceEventHandlerType, Delegate destinationEventHandler)
{
if (destinationEventHandler == null)
throw new ArgumentNullException("destinationEventHandler");
if (destinationEventHandler.GetType() == sourceEventHandlerType)
return destinationEventHandler; // already OK
var sourceArgs = VerifyStandardEventHandler(sourceEventHandlerType);
var destinationArgs = VerifyStandardEventHandler(destinationEventHandler.GetType());
var name = "_wrap" + Interlocked.Increment(ref methodIndex);
var paramTypes = new Type[sourceArgs.Length + 1];
paramTypes[0] = destinationEventHandler.GetType();
for (int i = 0; i < sourceArgs.Length; i++)
{
paramTypes[i + 1] = sourceArgs[i].ParameterType;
}
var dynamicMethod = new DynamicMethod(name, null, paramTypes);
var invoker = paramTypes[0].GetMethod("Invoke");
var ilGenerator = dynamicMethod.GetILGenerator();
ilGenerator.Emit(OpCodes.Ldarg_0);
ilGenerator.Emit(OpCodes.Ldarg_1);
ilGenerator.Emit(OpCodes.Ldarg_2);
if (!destinationArgs[1].ParameterType.IsAssignableFrom(sourceArgs[1].ParameterType))
{
ilGenerator.Emit(OpCodes.Castclass, destinationArgs[1].ParameterType);
}
ilGenerator.Emit(OpCodes.Call, invoker);
ilGenerator.Emit(OpCodes.Ret);
return dynamicMethod.CreateDelegate(sourceEventHandlerType, destinationEventHandler);
}
internal static Delegate CreateEmptyDelegate(this Type delegateType)
{
if (delegateType == null) {
throw new ArgumentNullException("delegateType");
}
if (delegateType.BaseType != typeof (MulticastDelegate)) {
throw new ArgumentException("must be a delegate", "delegateType");
}
return _emptyDelegates.GetOrAdd(delegateType, () => {
var delegateReturnType = delegateType.GetDelegateReturnType();
var dynamicMethod = new DynamicMethod(string.Empty, delegateReturnType, delegateType.GetDelegateParameterTypes().ToArray());
var il = dynamicMethod.GetILGenerator();
if (delegateReturnType.FullName != "System.Void") {
if (delegateReturnType.IsValueType) {
il.Emit(OpCodes.Ldc_I4, 0);
} else {
il.Emit(OpCodes.Ldnull);
}
}
il.Emit(OpCodes.Ret);
return dynamicMethod.CreateDelegate(delegateType);
});
}
internal override Delegate CreateDelegate () {
DynamicMethod method = new DynamicMethod (Guid.NewGuid ().ToString (), typeof (IntPtr), ParameterTypes, module, true);
ILGenerator il = method.GetILGenerator ();
il.DeclareLocal (typeof (object));
il.Emit (OpCodes.Ldtoken, cinfo.DeclaringType);
il.Emit (OpCodes.Call, gettype);
il.Emit (OpCodes.Call, newobject);
il.Emit (OpCodes.Stloc_0);
il.Emit (OpCodes.Ldloc_0);
il.Emit (OpCodes.Ldarg_0);
il.Emit (OpCodes.Stfld, handlefld);
il.Emit (OpCodes.Ldloc_0);
for (int i = 2; i < ParameterTypes.Length; i++) {
il.Emit (OpCodes.Ldarg, i);
}
il.Emit (OpCodes.Call, cinfo);
il.Emit (OpCodes.Ldarg_0);
il.Emit (OpCodes.Ret);
return method.CreateDelegate (DelegateType);
}
internal Execute GetDelegateIL(MethodInfo methodInfo)
{
//http://www.cnblogs.com/daizhj/archive/2008/06/20/1224818.html
//http://www.cnblogs.com/xuanhun/archive/2012/06/22/2558698.html
// 生成 方法
/*
* public T invoke( Class2 cls, object[] par)
* {
* return cls.mothd(par[0], par[1]);
* }
* IL_0000: nop
* IL_0001: ldarg.1
* IL_0002: ldarg.2
* IL_0003: ldc.i4.0
* IL_0004: ldelem.ref
* IL_0005: ldarg.2
* IL_0006: ldc.i4.1
* IL_0007: ldelem.ref
* IL_0008: callvirt instance object HY.Frame.Bis.Class2::mothd(string, string)
* IL_000d: stloc.0
* IL_000e: br.s IL_0010
*
* IL_0010: ldloc.0
* IL_0011: ret
*/
//Type[] methodArgs = methodInfo.GetParameters().Select(a => a.ParameterType).ToArray();
Type[] methodArgs = { typeof(object), typeof(object[]) };
System.Reflection.Emit.DynamicMethod invoke = new System.Reflection.Emit.DynamicMethod("Invoke", typeof(object), methodArgs);
ILGenerator il = invoke.GetILGenerator();
il.Emit(OpCodes.Nop);
il.Emit(OpCodes.Ldarg_1);
for (int i = 0; i < methodArgs.Length; i++)
{
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Ldc_I4, i);
il.Emit(OpCodes.Ldelem_Ref);
}
il.Emit(OpCodes.Callvirt, methodInfo);
il.Emit(OpCodes.Ret);
var exec = (Execute)invoke.CreateDelegate(typeof(Execute));
/*
* var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(, AssemblyBuilderAccess.RunAndSave);
* var moduleBuilder = assemblyBuilder.DefineDynamicModule("MvcAdviceProviderModule", "test.dll", true);
* TypeBuilder typeBuilder = moduleBuilder.DefineType("MvcAdviceProvider.MvcAdviceProviderType",
* TypeAttributes.Public, typeof(object), new Type[] { typeof(IAssessmentAopAdviceProvider) });
* assemblyBuilder.Save("runass");
*/
return(exec);
}
internal MethodBuilder(MethodName name)
{
Name = name;
var invokeInfo = typeof(Invokable).GetMethod("Invoke");
var parameterTypes = (from param in invokeInfo.GetParameters() select param.ParameterType).ToArray();
_dynamicMethod = new DynamicMethod(name.Simple, invokeInfo.ReturnType, parameterTypes, this.GetType());
_g = _dynamicMethod.GetILGenerator();
}
public static System.Reflection.Emit.DynamicMethod Eval(Node n)
{
var type = GetTypeFromNode(n["DotName"]);
var name = n["Name"].Text;
var types = n["ArgList"].GetNodes("Arg").Select(arg => GetTypeFromNode(arg["TypeName"])).ToArray();
var r = new System.Reflection.Emit.DynamicMethod(name, type, types, true);
var e = new ILCompiler(r.GetILGenerator());
e.EmitTerm(n["Block"]);
return(r);
}
/// <summary>
/// Create a new method delegate for the specified method using <see cref="System.Reflection.Emit.DynamicMethod"/>
/// </summary>
/// <param name="methodInfo">the method to create the delegate for</param>
/// <returns>a delegate that can be used to invoke the method.</returns>
public static MethodDelegate CreateMethod(MethodInfo methodInfo)
{
Guard.ArgumentNotNull(methodInfo, "You cannot create a delegate for a null value.");
bool skipVisibility = true; // !IsPublic(methodInfo);
NetDynamicMethod dm = CreateDynamicMethod(methodInfo.Name, typeof(object), new Type[] { typeof(object), typeof(object[]) }, methodInfo, skipVisibility);
ILGenerator il = dm.GetILGenerator();
EmitInvokeMethod(il, methodInfo, false);
return((MethodDelegate)dm.CreateDelegate(typeof(MethodDelegate)));
}
/// <summary>
/// Create a new Set method delegate for the specified field using <see cref="System.Reflection.Emit.DynamicMethod"/>
/// </summary>
/// <param name="fieldInfo">the field to create the delegate for</param>
/// <returns>a delegate that can be used to read the field.</returns>
/// <remarks>
/// If the field's <see cref="FieldInfo.IsLiteral"/> returns true, the returned method
/// will throw an <see cref="InvalidOperationException"/> when called.
/// </remarks>
public static FieldSetterDelegate CreateFieldSetter(FieldInfo fieldInfo)
{
AssertUtils.ArgumentNotNull(fieldInfo, "You cannot create a delegate for a null value.");
bool skipVisibility = true; // !IsPublic(fieldInfo);
System.Reflection.Emit.DynamicMethod dmSetter = CreateDynamicMethod("set_" + fieldInfo.Name, null, new Type[] { typeof(object), typeof(object) }, fieldInfo, skipVisibility);
ILGenerator il = dmSetter.GetILGenerator();
EmitFieldSetter(il, fieldInfo, false);
return((FieldSetterDelegate)dmSetter.CreateDelegate(typeof(FieldSetterDelegate)));
}
/// <summary>
/// Create a new Get method delegate for the specified property using <see cref="System.Reflection.Emit.DynamicMethod"/>
/// </summary>
/// <param name="propertyInfo">the property to create the delegate for</param>
/// <returns>a delegate that can be used to read the property.</returns>
/// <remarks>
/// If the property's <see cref="PropertyInfo.CanRead"/> returns false, the returned method
/// will throw an <see cref="InvalidOperationException"/> when called.
/// </remarks>
public static PropertyGetterDelegate CreatePropertyGetter(PropertyInfo propertyInfo)
{
Guard.ArgumentNotNull(propertyInfo, "You cannot create a delegate for a null value.");
MethodInfo getMethod = propertyInfo.GetGetMethod();
bool skipVisibility = true; // (null == getMethod || !IsPublic(getMethod)); // getter is public
NetDynamicMethod dm = CreateDynamicMethod("get_" + propertyInfo.Name, typeof(object), new Type[] { typeof(object), typeof(object[]) }, propertyInfo, skipVisibility);
ILGenerator il = dm.GetILGenerator();
EmitPropertyGetter(il, propertyInfo, false);
return((PropertyGetterDelegate)dm.CreateDelegate(typeof(PropertyGetterDelegate)));
}
/// <summary>
/// Create a new Set method delegate for the specified property using <see cref="System.Reflection.Emit.DynamicMethod"/>
/// </summary>
/// <param name="propertyInfo">the property to create the delegate for</param>
/// <returns>a delegate that can be used to write the property.</returns>
/// <remarks>
/// If the property's <see cref="PropertyInfo.CanWrite"/> returns false, the returned method
/// will throw an <see cref="InvalidOperationException"/> when called.
/// </remarks>
public static PropertySetterDelegate CreatePropertySetter(PropertyInfo propertyInfo)
{
AssertUtils.ArgumentNotNull(propertyInfo, "You cannot create a delegate for a null value.");
MethodInfo setMethod = propertyInfo.GetSetMethod();
bool skipVisibility = true; // (null == setMethod || !IsPublic(setMethod)); // setter is public
Type[] argumentTypes = new Type[] { typeof(object), typeof(object), typeof(object[]) };
NetDynamicMethod dm = CreateDynamicMethod("set_" + propertyInfo.Name, null, argumentTypes, propertyInfo, skipVisibility);
ILGenerator il = dm.GetILGenerator();
EmitPropertySetter(il, propertyInfo, false);
return((PropertySetterDelegate)dm.CreateDelegate(typeof(PropertySetterDelegate)));
}
private static GetControlsDelegate GetGetControlsDelegate()
{
GetControlsDelegate handler = null;
FieldInfo controls = GetField("_controls");
SecurityCritical.ExecutePrivileged(new PermissionSet(PermissionState.Unrestricted), delegate
{
System.Reflection.Emit.DynamicMethod dm = new System.Reflection.Emit.DynamicMethod("get_Controls", typeof(ControlCollection), new Type[] { typeof(Control) }, typeof(Control).Module, true);
ILGenerator il = dm.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, controls);
il.Emit(OpCodes.Ret);
handler = (GetControlsDelegate)dm.CreateDelegate(typeof(GetControlsDelegate));
});
return(handler);
}
private static GetControlsDelegate GetGetControlsDelegate()
{
GetControlsDelegate handler = null;
if (SystemUtils.Clr4Runtime)
{
FieldInfo controls = GetField("_controls");
SecurityCritical.ExecutePrivileged(new PermissionSet(PermissionState.Unrestricted), delegate
{
System.Reflection.Emit.DynamicMethod dm = new System.Reflection.Emit.DynamicMethod("get_Controls", typeof(ControlCollection), new Type[] { typeof(Control) }, typeof(Control).Module, true);
ILGenerator il = dm.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, controls);
il.Emit(OpCodes.Ret);
handler = (GetControlsDelegate)dm.CreateDelegate(typeof(GetControlsDelegate));
});
}
else
{
FieldInfo occasionalFields = GetField("_occasionalFields");
MethodInfo ensureOccasionalFields = GetMethod("EnsureOccasionalFields");
FieldInfo controls = occasionalFields.FieldType.GetField("Controls");
SecurityCritical.ExecutePrivileged(new PermissionSet(PermissionState.Unrestricted), delegate
{
System.Reflection.Emit.DynamicMethod dm = new System.Reflection.Emit.DynamicMethod("get_Controls", typeof(ControlCollection), new Type[] { typeof(Control) }, typeof(Control).Module, true);
ILGenerator il = dm.GetILGenerator();
Label occFieldsNull = il.DefineLabel();
Label retControls = il.DefineLabel();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, occasionalFields);
il.Emit(OpCodes.Brfalse_S, occFieldsNull);
il.MarkLabel(retControls);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, occasionalFields);
il.Emit(OpCodes.Ldfld, controls);
il.Emit(OpCodes.Ret);
il.MarkLabel(occFieldsNull);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Call, ensureOccasionalFields);
il.Emit(OpCodes.Br, retControls);
handler = (GetControlsDelegate)dm.CreateDelegate(typeof(GetControlsDelegate));
});
}
return handler;
}
private static Func <IServiceFactory, IQuery <TResult>, Task <TResult> > CreateDelegate <TResult>(Type queryType)
{
// Define the signature of the dynamic method.
var dynamicMethod = new System.Reflection.Emit.DynamicMethod("Sql", typeof(Task <TResult>), new[] { typeof(IServiceFactory), typeof(IQuery <TResult>) });
System.Reflection.Emit.ILGenerator generator = dynamicMethod.GetILGenerator();
// Create the closed generic query handler type.
Type queryHandlerType = typeof(IQueryHandler <,>).MakeGenericType(queryType, typeof(TResult));
// Get the MethodInfo that represents the HandleAsync method.
MethodInfo method = queryHandlerType.GetMethod("HandleAsync");
// Push the service factory onto the evaluation stack.
generator.Emit(OpCodes.Ldarg_0);
// Push the query handler type onto the evaluation stack.
generator.Emit(OpCodes.Ldtoken, queryHandlerType);
generator.Emit(OpCodes.Call, GetTypeFromHandleMethod);
// Call the GetInstance method and push the query handler
// instance onto the evaluation stack.
generator.Emit(OpCodes.Callvirt, GetInstanceMethod);
// Since the GetInstance method returns an object,
// we need to cast it to the actual query handler type.
generator.Emit(OpCodes.Castclass, queryHandlerType);
// Push the query onto the evaluation stack.
generator.Emit(OpCodes.Ldarg_1);
// The query is passed in as an IQuery<TResult> instance
// and we need to cast it to the actual query type.
generator.Emit(OpCodes.Castclass, queryType);
// Call the Sql method and push the Task<TResult>
// onto the evaluation stack.
generator.Emit(OpCodes.Callvirt, method);
// Mark the end of the dynamic method.
generator.Emit(OpCodes.Ret);
var getQueryHandlerDelegate =
dynamicMethod.CreateDelegate(typeof(Func <IServiceFactory, IQuery <TResult>, Task <TResult> >));
return((Func <IServiceFactory, IQuery <TResult>, Task <TResult> >)getQueryHandlerDelegate);
}
private ConstructorDelegate GetConstructor(string typeName)
{
Type t = Type.GetType(typeName);
ConstructorInfo ctor = t.GetConstructor(new Type[0]);
var methodName = t.Name + "Ctor";
System.Reflection.Emit.DynamicMethod dm = new System.Reflection.Emit.DynamicMethod(methodName, t, new Type[0], typeof(Activator));
ILGenerator lgen = dm.GetILGenerator();
lgen.Emit(OpCodes.Newobj, ctor);
lgen.Emit(OpCodes.Ret);
ConstructorDelegate creator = (ConstructorDelegate)dm.CreateDelegate(typeof(ConstructorDelegate));
return(creator);
}
public static DynamicMemberSetter CreatePropertySetter(PropertyInfo property)
{
if (property == null)
{
throw new ArgumentNullException("property");
}
if (!property.CanWrite)
{
return(null);
}
MethodInfo setMethod = property.GetSetMethod();
if (setMethod == null) //maybe is private
{
setMethod = property.GetSetMethod(true);
}
var dm = new System.Reflection.Emit.DynamicMethod("props", null,
new[] { typeof(object), typeof(object) },
property.DeclaringType, true);
ILGenerator il = dm.GetILGenerator();
if (!setMethod.IsStatic)
{
il.Emit(OpCodes.Ldarg_0);
}
il.Emit(OpCodes.Ldarg_1);
EmitCastToReference(il, property.PropertyType);
if (!setMethod.IsStatic && !property.DeclaringType.IsValueType)
{
il.EmitCall(OpCodes.Callvirt, setMethod, null);
}
else
{
il.EmitCall(OpCodes.Call, setMethod, null);
}
il.Emit(OpCodes.Ret);
return((DynamicMemberSetter)dm.CreateDelegate(typeof(DynamicMemberSetter)));
}
/// <summary>
/// Fill the DynamicMethod with a stub.
/// </summary>
public static SRE.DynamicMethod Stub(this SRE.DynamicMethod dm)
{
SRE.ILGenerator il = dm.GetILGenerator();
for (int i = 0; i < 32; i++)
{
// Prevent mono from inlining the DynamicMethod.
il.Emit(SRE.OpCodes.Nop);
}
if (dm.ReturnType != typeof(void))
{
il.DeclareLocal(dm.ReturnType);
il.Emit(SRE.OpCodes.Ldloca_S, (sbyte)0);
il.Emit(SRE.OpCodes.Initobj, dm.ReturnType);
il.Emit(SRE.OpCodes.Ldloc_0);
}
il.Emit(SRE.OpCodes.Ret);
return(dm);
}
public static DynamicMemberGetter CreatePropertyGetter(PropertyInfo property)
{
if (property == null)
{
throw new ArgumentNullException("property");
}
if (!property.CanRead)
{
return(null);
}
MethodInfo getMethod = property.GetGetMethod();
if (getMethod == null) //maybe is private
{
getMethod = property.GetGetMethod(true);
}
var dm = new System.Reflection.Emit.DynamicMethod("propg", typeof(object),
new[] { typeof(object) },
property.DeclaringType, true);
ILGenerator il = dm.GetILGenerator();
if (!getMethod.IsStatic)
{
il.Emit(OpCodes.Ldarg_0);
il.EmitCall(OpCodes.Callvirt, getMethod, null);
}
else
{
il.EmitCall(OpCodes.Call, getMethod, null);
}
if (property.PropertyType.IsValueType)
{
il.Emit(OpCodes.Box, property.PropertyType);
}
il.Emit(OpCodes.Ret);
return((DynamicMemberGetter)dm.CreateDelegate(typeof(DynamicMemberGetter)));
}
static T CreateCaller <T>()
{
var sig = typeof(T).GetTypeInfo().GetMethod("Invoke");
var prms = sig.GetParameters().Select(p => p.ParameterType).ToArray();
var dm = new System.Reflection.Emit.DynamicMethod("Caller", sig.ReturnType, prms, typeof(LocalInterop).GetTypeInfo().Assembly.ManifestModule);
var gen = dm.GetILGenerator();
for (var c = 1; c < prms.Length; c++)
{
gen.Emit(OpCodes.Ldarg, c);
}
gen.Emit(OpCodes.Ldarg_0);
gen.EmitCalli(OpCodes.Calli, CallingConventions.Standard, sig.ReturnType, prms.Skip(1).ToArray(), null);
gen.Emit(OpCodes.Ret);
return((T)(object)dm.CreateDelegate(typeof(T)));
}
private int GetSize(string target)
{
Type targetType = Type.GetType(target, false);
if (targetType == null)
{
return(-1);
}
SRE.DynamicMethod dm = new SRE.DynamicMethod("", typeof(int), null);
SRE.ILGenerator gen = dm.GetILGenerator();
gen.Emit(SRE.OpCodes.Sizeof, targetType);
gen.Emit(SRE.OpCodes.Ret);
SizeDM del = (SizeDM)dm.CreateDelegate(typeof(SizeDM));
return(del());
}
public void TestCallingParentsMethod()
{
var c = new TestChild();
Assert.AreEqual("child", c.Test());
var m = typeof(TestChild).GetMethod("Test").GetBaseDefinition();
Assert.AreEqual(typeof(TestBase), m.DeclaringType);
Assert.AreEqual(typeof(TestBase).GetMethod("Test"), m);
Assert.AreEqual("child", m.Invoke(c, new object[0]));
Assert.AreEqual("child", ((TestBase)c).Test());
var dm = new System.Reflection.Emit.DynamicMethod(
"", typeof(string), new Type[] { typeof(TestBase) }, typeof(YamlNodeTest));
System.Reflection.Emit.ILGenerator ilgen = dm.GetILGenerator();
ilgen.Emit(System.Reflection.Emit.OpCodes.Ldarg_0);
ilgen.Emit(System.Reflection.Emit.OpCodes.Call, typeof(TestBase).GetMethod("Test"));
ilgen.Emit(System.Reflection.Emit.OpCodes.Ret);
var callTest = (Call)dm.CreateDelegate(typeof(Call));
Assert.AreEqual("base", callTest.Invoke(c));
}
public void LeaveDataOnStackBetweenBranches_OldSchool()
{
var dm = new System.Reflection.Emit.DynamicMethod("foo", typeof(int), null);
var il = dm.GetILGenerator();
System.Reflection.Emit.Label b0 = il.DefineLabel(), b1 = il.DefineLabel(), b2 = il.DefineLabel();
il.Emit(System.Reflection.Emit.OpCodes.Ldstr, "abc");
il.Emit(System.Reflection.Emit.OpCodes.Br, b0); // jump to b0 with "abc"
il.MarkLabel(b1); // incoming: 3
il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_4);
il.EmitCall(System.Reflection.Emit.OpCodes.Call, typeof(Math).GetMethod("Max", new[] { typeof(int), typeof(int) }), null);
il.Emit(System.Reflection.Emit.OpCodes.Br, b2); // jump to b2 with 4
il.MarkLabel(b0); // incoming: "abc"
il.EmitCall(System.Reflection.Emit.OpCodes.Callvirt, typeof(string).GetProperty("Length").GetGetMethod(), null);
il.Emit(System.Reflection.Emit.OpCodes.Br, b1); // jump to b1 with 3
il.MarkLabel(b2); // incoming: 4
il.Emit(System.Reflection.Emit.OpCodes.Ret);
int i = ((Func <int>)dm.CreateDelegate(typeof(Func <int>)))();
Assert.AreEqual(4, i);
}
public static DynamicMemberMethod CreateMethod(MethodInfo method)
{
ParameterInfo[] pi = method.GetParameters();
var dm = new System.Reflection.Emit.DynamicMethod("dm", typeof(object),
new[] { typeof(object), typeof(object[]) },
typeof(DynamicMethodHandlerFactory), true);
ILGenerator il = dm.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
for (int index = 0; index < pi.Length; index++)
{
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldc_I4, index);
Type parameterType = pi[index].ParameterType;
if (parameterType.IsByRef)
{
parameterType = parameterType.GetElementType();
if (parameterType.IsValueType)
{
il.Emit(OpCodes.Ldelem_Ref);
il.Emit(OpCodes.Unbox, parameterType);
}
else
{
il.Emit(OpCodes.Ldelema, parameterType);
}
}
else
{
il.Emit(OpCodes.Ldelem_Ref);
if (parameterType.IsValueType)
{
il.Emit(OpCodes.Unbox, parameterType);
il.Emit(OpCodes.Ldobj, parameterType);
}
}
}
if ((method.IsAbstract || method.IsVirtual) &&
!method.IsFinal && !method.DeclaringType.IsSealed)
{
il.Emit(OpCodes.Callvirt, method);
}
else
{
il.Emit(OpCodes.Call, method);
}
if (method.ReturnType == typeof(void))
{
il.Emit(OpCodes.Ldnull);
}
else if (method.ReturnType.IsValueType)
{
il.Emit(OpCodes.Box, method.ReturnType);
}
il.Emit(OpCodes.Ret);
return((DynamicMemberMethod)dm.CreateDelegate(typeof(DynamicMemberMethod)));
}
/// <summary>
/// Compiles a function that copies fields with the same name and type from one object to the other.
/// Be sure to only compile a single function for a set of types and re-use it, because this is slow and the function does not get garbage collected, but extremely fast after compiled.
/// </summary>
public static CopyIntoDelegate <T, S> GetShallowFieldCopier <T, S>()
{
if (RCCache_Copiers <T, S> .ShallowFieldCopier is null)
{
lock (RCCache_Copiers <T, S> .Lock) {
if (RCCache_Copiers <T, S> .ShallowFieldCopier != null)
{
return(RCCache_Copiers <T, S> .ShallowFieldCopier);
}
RCCache_Copiers <T, S> .ShallowFieldCopier = (CopyIntoDelegate <T, S>)CreateDelegate();
}
}
return(RCCache_Copiers <T, S> .ShallowFieldCopier);
Delegate CreateDelegate()
{
Type targetType = typeof(T);
Type srcType = typeof(S);
BindingFlags flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
FieldInfo[] targetFields = targetType.GetFields(flags);
FieldInfo[] srcFields = targetType == srcType ? targetFields : srcType.GetFields(flags);
DynamicMethod dynmethod = new System.Reflection.Emit.DynamicMethod("ShallowFieldCopy", typeof(void), new Type[2] {
targetType, srcType
}, true);
ILGenerator gen = dynmethod.GetILGenerator();
foreach (FieldInfo targetField in targetFields)
{
FieldInfo srcField = targetType == srcType ? targetField : srcFields.FirstOrDefault(f => f.Name.EqIgCase(targetField.Name));
if (srcField is null)
{
continue;
}
if (targetField.FieldType == srcField.FieldType)
{
gen.Emit(OpCodes.Ldarg_0);
gen.Emit(OpCodes.Ldarg_1);
gen.Emit(OpCodes.Ldfld, srcField);
gen.Emit(OpCodes.Stfld, targetField);
}
else
{
TypeConverter converter = targetField.FieldType.GetTypeConverter();
FieldInfo converterField = GetStaticConverterFieldByConverter(converter);
if (converterField != null && converter.CanConvertFrom(srcField.FieldType))
{
gen.Emit(OpCodes.Ldarg_0);
gen.Emit(OpCodes.Ldsfld, converterField);
gen.Emit(OpCodes.Ldarg_1);
gen.Emit(OpCodes.Ldfld, srcField);
gen.Emit(OpCodes.Box, srcField.FieldType);
gen.Emit(OpCodes.Callvirt, converter.GetType().GetMethod(nameof(TypeConverter.ConvertFrom), new Type[] { typeof(object) }));
gen.Emit(OpCodes.Unbox_Any, targetField.FieldType);
gen.Emit(OpCodes.Stfld, targetField);
}
}
}
gen.Emit(OpCodes.Ret);
return(dynmethod.CreateDelegate(typeof(CopyIntoDelegate <T, S>)));
}
}
public int GetTokenFor(string literal)
{
return(method.GetILGenerator().TokenGenerator.GetToken(literal));
}
public EvalDelegate CreateDelegate()
{
var type = module.Find(evalClassName, isReflectionName: true);
Debug.Assert(type != null);
var method = type?.FindMethod(evalMethodName);
Debug.Assert(method?.Body != null);
if (!(method?.Body is CilBody body))
{
return(null);
}
if (method.ReturnType.ElementType != ElementType.Boolean)
{
return(null);
}
if (body.HasExceptionHandlers)
{
return(null);
}
Debug.Assert(method.MethodSig.Params.Count == evalDelegateParamTypes.Length);
if (method.MethodSig.Params.Count != evalDelegateParamTypes.Length)
{
return(null);
}
var dm = new SRE.DynamicMethod("compiled filter expr", typeof(bool), evalDelegateParamTypes, typeof(FilterExpressionMethods), skipVisibility: false);
var ilg = dm.GetILGenerator();
var labelsDict = new Dictionary <Instruction, SRE.Label>();
var instrs = body.Instructions;
for (int i = 0; i < instrs.Count; i++)
{
var instr = instrs[i];
switch (instr.Operand)
{
case Instruction targetInstr:
if (!labelsDict.ContainsKey(targetInstr))
{
labelsDict.Add(targetInstr, ilg.DefineLabel());
}
break;
case IList <Instruction> targetInstrs:
foreach (var targetInstr in targetInstrs)
{
if (!labelsDict.ContainsKey(targetInstr))
{
labelsDict.Add(targetInstr, ilg.DefineLabel());
}
}
break;
}
}
Dictionary <Local, SRE.LocalBuilder> localsDict = null;
if (body.Variables.Count > 0)
{
localsDict = new Dictionary <Local, SRE.LocalBuilder>(body.Variables.Count);
foreach (var local in body.Variables)
{
var lb = ilg.DeclareLocal(Import(local.Type), local.Type.IsPinned);
if (local.Index != lb.LocalIndex)
{
return(null);
}
if (local.Name != null)
{
lb.SetLocalSymInfo(local.Name);
}
localsDict.Add(local, lb);
}
}
foreach (var instr in body.Instructions)
{
if (labelsDict.TryGetValue(instr, out var label))
{
ilg.MarkLabel(label);
}
if (!toReflectionOpCode.TryGetValue(instr.OpCode, out var sreOpCode))
{
return(null);
}
switch (instr.OpCode.OperandType)
{
case OperandType.InlineBrTarget:
case OperandType.ShortInlineBrTarget:
var targetInstr = (Instruction)instr.Operand;
ilg.Emit(sreOpCode, labelsDict[targetInstr]);
break;
case OperandType.InlineSwitch:
var targets = (IList <Instruction>)instr.Operand;
var newTargets = new SRE.Label[targets.Count];
for (int i = 0; i < newTargets.Length; i++)
{
newTargets[i] = labelsDict[targets[i]];
}
ilg.Emit(sreOpCode, newTargets);
break;
case OperandType.InlineNone:
ilg.Emit(sreOpCode);
break;
case OperandType.InlineI:
ilg.Emit(sreOpCode, (int)instr.Operand);
break;
case OperandType.InlineI8:
ilg.Emit(sreOpCode, (long)instr.Operand);
break;
case OperandType.InlineR:
ilg.Emit(sreOpCode, (double)instr.Operand);
break;
case OperandType.ShortInlineR:
ilg.Emit(sreOpCode, (float)instr.Operand);
break;
case OperandType.ShortInlineI:
if (instr.OpCode.Code == Code.Ldc_I4_S)
{
ilg.Emit(sreOpCode, (sbyte)instr.Operand);
}
else
{
ilg.Emit(sreOpCode, (byte)instr.Operand);
}
break;
case OperandType.InlineString:
ilg.Emit(sreOpCode, (string)instr.Operand);
break;
case OperandType.InlineVar:
case OperandType.ShortInlineVar:
Parameter p;
switch (instr.OpCode.Code)
{
case Code.Ldarg:
case Code.Ldarga:
case Code.Starg:
p = (Parameter)instr.Operand;
if (p.Index > ushort.MaxValue)
{
return(null);
}
ilg.Emit(sreOpCode, (short)p.Index);
break;
case Code.Ldarg_S:
case Code.Ldarga_S:
case Code.Starg_S:
p = (Parameter)instr.Operand;
if (p.Index > byte.MaxValue)
{
return(null);
}
ilg.Emit(sreOpCode, (byte)p.Index);
break;
case Code.Ldloc:
case Code.Ldloca:
case Code.Stloc:
case Code.Ldloc_S:
case Code.Ldloca_S:
case Code.Stloc_S:
ilg.Emit(sreOpCode, localsDict[(Local)instr.Operand]);
break;
default:
return(null);
}
break;
case OperandType.InlineMethod:
var m = Import((IMethod)instr.Operand);
if (m is SR.ConstructorInfo ci)
{
ilg.Emit(sreOpCode, ci);
}
else
{
ilg.Emit(sreOpCode, (SR.MethodInfo)m);
}
break;
case OperandType.InlineTok:
case OperandType.InlineType:
case OperandType.InlineField:
case OperandType.InlinePhi:
case OperandType.InlineSig:
default:
return(null);
}
}
return((EvalDelegate)dm.CreateDelegate(typeof(EvalDelegate)));
}