/// <summary> /// Overrides the set property. /// </summary> /// <param name="propertyAccessor">The property accessor.</param> /// <param name="baseType">Type of the base.</param> /// <param name="type">The type.</param> /// <param name="loadMeMethodBuilder">The load me method builder.</param> /// <returns></returns> protected virtual MethodBuilder OverrideSetProperty(PropertyInfo propertyAccessor, Type baseType, TypeBuilder type, MethodBuilder loadMeMethodBuilder) { System.Reflection.MethodAttributes methodAttributes = MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig; string methodName = "set_" + propertyAccessor.Name; MethodBuilder method = type.DefineMethod(methodName, methodAttributes); // Preparing Reflection instances MethodInfo baseMethod = baseType.GetMethod(methodName); // Setting return type method.SetReturnType(typeof(void)); // Adding parameters method.SetParameters(propertyAccessor.PropertyType); // Parameter value ParameterBuilder value = method.DefineParameter(1, ParameterAttributes.None, "value"); ILGenerator gen = method.GetILGenerator(); // Writing body //gen.Emit(OpCodes.Nop); //gen.Emit(OpCodes.Ldarg_0); //gen.Emit(OpCodes.Call, loadMeMethodBuilder); gen.Emit(OpCodes.Nop); gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Ldarg_1); gen.Emit(OpCodes.Call, baseMethod); gen.Emit(OpCodes.Nop); gen.Emit(OpCodes.Ret); return(method); }
private static MethodBuilder BuildMethodset_Id(TypeBuilder typeBuilder) { System.Reflection.MethodAttributes methodAttributes = System.Reflection.MethodAttributes.Public | System.Reflection.MethodAttributes.HideBySig; MethodBuilder method = typeBuilder.DefineMethod("set_Id", methodAttributes); // Preparing Reflection instances FieldInfo field1 = typeof(GraphDataEntity).GetField("_entityKey", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.GetField); // Setting return type method.SetReturnType(typeof(void)); // Adding parameters method.SetParameters( typeof(String) ); // Parameter value ParameterBuilder value = method.DefineParameter(1, ParameterAttributes.None, "value"); ILGenerator gen = method.GetILGenerator(); // Writing body gen.Emit(OpCodes.Nop); gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Ldarg_1); gen.Emit(OpCodes.Stfld, field1); gen.Emit(OpCodes.Ret); // finished return(method); }
static MethodBuilder CreatePropertyGetMethodWithBackingField( TypeBuilder typeBuilder, string name, MethodAttributes methodAttributes, FieldBuilder fieldBuilder) { MethodBuilder getMethodBuilder = typeBuilder.DefineMethod("get_" + name, methodAttributes, fieldBuilder.FieldType, Type.EmptyTypes); ILGenerator getMethodILGenerator = getMethodBuilder.GetILGenerator(); getMethodILGenerator.Emit(OpCodes.Ldarg_0); getMethodILGenerator.Emit(OpCodes.Ldfld, fieldBuilder); getMethodILGenerator.Emit(OpCodes.Ret); return(getMethodBuilder); }
static MethodBuilder CreatePropertySetMethodWithBackingField( TypeBuilder typeBuilder, string name, MethodAttributes methodAttributes, FieldBuilder fieldBuilder) { MethodBuilder setMethodBuilder = typeBuilder.DefineMethod("set_" + name, methodAttributes, null, new Type[] { fieldBuilder.FieldType }); ILGenerator setMethodILGenerator = setMethodBuilder.GetILGenerator(); setMethodILGenerator.Emit(OpCodes.Ldarg_0); setMethodILGenerator.Emit(OpCodes.Ldarg_1); setMethodILGenerator.Emit(OpCodes.Stfld, fieldBuilder); setMethodILGenerator.Emit(OpCodes.Ret); return(setMethodBuilder); }
public InterpretedConstructor( InterpretedType declaringType, string name, ParameterInfo[] parameters, MethodAttributes attributes, MethodInvoker invoker, object invokableDefinition ) { _declaringType = declaringType; _name = name; _parameters = parameters; _attributes = attributes; _invoker = invoker; InvokableDefinition = invokableDefinition; }
private void BuildAttributes() { if (method.IsStatic) { _Attributes |= System.Reflection.MethodAttributes.Static; } if (method.IsPublic) { _Attributes |= System.Reflection.MethodAttributes.Public; } else { _Attributes |= System.Reflection.MethodAttributes.Private; } }
private static MethodBuilder BuildMethod_Remove(TypeBuilder type, FieldInfo helperClassFieldInfo) { // Declaring method builder // Method attributes System.Reflection.MethodAttributes methodAttributes = System.Reflection.MethodAttributes.Public | System.Reflection.MethodAttributes.Virtual | System.Reflection.MethodAttributes.Final | System.Reflection.MethodAttributes.HideBySig | System.Reflection.MethodAttributes.NewSlot; MethodBuilder method = type.DefineMethod("Remove", methodAttributes); // Preparing Reflection instances FieldInfo field1 = helperClassFieldInfo; MethodInfo method2 = typeof(SqlDataContextHelperClass).GetMethod( "Remove", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { typeof(Object), typeof(String) }, null ); // Setting return type method.SetReturnType(typeof(void)); // Adding parameters method.SetParameters( typeof(Object), typeof(String) ); // Parameter entity ParameterBuilder entity = method.DefineParameter(1, ParameterAttributes.None, "entity"); // Parameter fieldName ParameterBuilder fieldName = method.DefineParameter(2, ParameterAttributes.None, "fieldName"); ILGenerator gen = method.GetILGenerator(); // Writing body gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Ldfld, field1); gen.Emit(OpCodes.Ldarg_1); gen.Emit(OpCodes.Ldarg_2); gen.Emit(OpCodes.Callvirt, method2); gen.Emit(OpCodes.Ret); // finished return(method); }
/// <summary> /// Overrides the get property. /// </summary> /// <param name="propertyAccessor">The property accessor.</param> /// <param name="baseType">Type of the base.</param> /// <param name="type">The type.</param> /// <param name="loadMeMethodBuilder">The load me method builder.</param> /// <returns></returns> protected virtual MethodBuilder OverrideGetProperty(PropertyInfo propertyAccessor, Type baseType, TypeBuilder type, MethodBuilder loadMeMethodBuilder) { System.Reflection.MethodAttributes methodAttributes = MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig; string methodName = "get_" + propertyAccessor.Name; MethodBuilder method = type.DefineMethod(methodName, methodAttributes); // Preparing Reflection instances MethodInfo baseMethod = baseType.GetMethod( methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { }, null ); // Setting return type method.SetReturnType(propertyAccessor.PropertyType); // Adding parameters ILGenerator gen = method.GetILGenerator(); // Preparing locals LocalBuilder localBuilder = gen.DeclareLocal(propertyAccessor.PropertyType); // Preparing labels Label label17 = gen.DefineLabel(); // Writing body gen.Emit(OpCodes.Nop); gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Call, loadMeMethodBuilder); gen.Emit(OpCodes.Nop); gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Call, baseMethod); gen.Emit(OpCodes.Stloc_0); gen.Emit(OpCodes.Br_S, label17); gen.MarkLabel(label17); gen.Emit(OpCodes.Ldloc_0); gen.Emit(OpCodes.Ret); return(method); }
public InterpretedMethod( Module module, InterpretedType declaringType, string name, Type returnType, ParameterInfo[] parameters, Lazy <MethodInfo[]> explicitOverrides, MethodAttributes attributes, GenericDetails generic, MethodInvoker invoker, object invokableDefinition ) { _module = module; _declaringType = declaringType; _name = name; _returnType = returnType; _parameters = parameters; _explicitOverrides = explicitOverrides; _attributes = attributes; _generic = generic; _invoker = invoker; InvokableDefinition = invokableDefinition; }
public static MethodBuilder DefineMethodReturningString(this TypeBuilder typeBuilder, string methodName, string returnValue, MethodAttributes methodAttributes) { MethodBuilder getMethodBuilder = typeBuilder.DefineMethod(methodName, methodAttributes, typeof(string), Type.EmptyTypes); ILGenerator ilGenerator = getMethodBuilder.GetILGenerator(); ilGenerator.DeclareLocal(returnValue.GetType()); ilGenerator.Emit(OpCodes.Nop); ilGenerator.Emit(OpCodes.Ldstr, returnValue); ilGenerator.Emit(OpCodes.Stloc_0); ilGenerator.Emit(OpCodes.Br_S, 2); ilGenerator.Emit(OpCodes.Ldloc_0); ilGenerator.Emit(OpCodes.Ret); return(getMethodBuilder); }
public System.Reflection.Emit.MethodBuilder DefineGlobalMethod(string name, System.Reflection.MethodAttributes attributes, System.Reflection.CallingConventions callingConvention, System.Type returnType, System.Type[] parameterTypes) { throw null; }
public System.Reflection.Emit.ConstructorBuilder DefineConstructor(System.Reflection.MethodAttributes attributes, System.Reflection.CallingConventions callingConvention, System.Type[] parameterTypes) { throw null; }
public System.Reflection.Emit.ConstructorBuilder DefineDefaultConstructor(System.Reflection.MethodAttributes attributes) { throw null; }
public static MethodBuilder DefineMethodReturningInt(this TypeBuilder typeBuilder, string methodName, int returnValue, MethodAttributes methodAttributes) { return(typeBuilder.DefineMethodReturningValueType(methodName, returnValue, methodAttributes)); }
public System.Reflection.Emit.MethodBuilder DefineMethod(string name, System.Reflection.MethodAttributes attributes, System.Type returnType, System.Type[] parameterTypes) { throw null; }
public DynamicMethod(string name, System.Reflection.MethodAttributes attributes, System.Reflection.CallingConventions callingConvention, System.Type returnType, System.Type[] parameterTypes, System.Type owner, bool skipVisibility) { }
public System.Reflection.Emit.MethodBuilder DefineMethod(string name, System.Reflection.MethodAttributes attributes, System.Reflection.CallingConventions callingConvention, System.Type returnType, System.Type[] returnTypeRequiredCustomModifiers, System.Type[] returnTypeOptionalCustomModifiers, System.Type[] parameterTypes, System.Type[][] parameterTypeRequiredCustomModifiers, System.Type[][] parameterTypeOptionalCustomModifiers) { throw null; }
public System.Reflection.Emit.MethodBuilder DefineMethod(string name, System.Reflection.MethodAttributes attributes, System.Reflection.CallingConventions callingConvention) { throw null; }
public System.Reflection.Emit.MethodBuilder DefineMethod(string name, System.Reflection.MethodAttributes attributes) { throw null; }
public static MethodBuilder DefineMethodReturningEnum(this TypeBuilder typeBuilder, string methodName, Enum returnValue, MethodAttributes methodAttributes) { MethodBuilder getMethodBuilder = typeBuilder.DefineMethod(methodName, MethodAttributes.Public | MethodAttributes.Virtual, returnValue.GetType(), Type.EmptyTypes); ILGenerator ilGenerator = getMethodBuilder.GetILGenerator(); ilGenerator.DeclareLocal(returnValue.GetType()); ilGenerator.Emit(OpCodes.Ldc_I4, (int)(object)returnValue); ilGenerator.Emit(OpCodes.Stloc_0); ilGenerator.Emit(OpCodes.Ldloc_0); ilGenerator.Emit(OpCodes.Ret); return(getMethodBuilder); }
//use this instead //https://github.com/ltrzesniewski/InlineIL.Fody public static void GenerateCil() { var aName = new AssemblyName("DynamicAssemblyExample"); var ab = AssemblyBuilder.DefineDynamicAssembly( aName, AssemblyBuilderAccess.RunAndCollect); // For a single-module assembly, the module name is usually // the assembly name plus an extension. var mb = ab.DefineDynamicModule(aName.Name); var tb = mb.DefineType( "MyDynamicType", TypeAttributes.Public); // Add a private field of type int (Int32). var fbNumber = tb.DefineField( "m_number", typeof(int), FieldAttributes.Private); // Define a constructor that takes an integer argument and // stores it in the private field. Type[] parameterTypes = { typeof(int) }; var ctor1 = tb.DefineConstructor( MethodAttributes.Public, CallingConventions.Standard, parameterTypes); var ctor1IL = ctor1.GetILGenerator(); // For a constructor, argument zero is a reference to the new // instance. Push it on the stack before calling the base // class constructor. Specify the default constructor of the // base class (System.Object) by passing an empty array of // types (Type.EmptyTypes) to GetConstructor. ctor1IL.Emit(OpCodes.Ldarg_0); ctor1IL.Emit(OpCodes.Call, typeof(object).GetConstructor(Type.EmptyTypes)); // Push the instance on the stack before pushing the argument // that is to be assigned to the private field m_number. ctor1IL.Emit(OpCodes.Ldarg_0); ctor1IL.Emit(OpCodes.Ldarg_1); ctor1IL.Emit(OpCodes.Stfld, fbNumber); ctor1IL.Emit(OpCodes.Ret); // Define a default constructor that supplies a default value // for the private field. For parameter types, pass the empty // array of types or pass null. var ctor0 = tb.DefineConstructor( MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes); var ctor0IL = ctor0.GetILGenerator(); // For a constructor, argument zero is a reference to the new // instance. Push it on the stack before pushing the default // value on the stack, then call constructor ctor1. ctor0IL.Emit(OpCodes.Ldarg_0); ctor0IL.Emit(OpCodes.Ldc_I4_S, 42); ctor0IL.Emit(OpCodes.Call, ctor1); ctor0IL.Emit(OpCodes.Ret); // Define a property named Number that gets and sets the private // field. // // The last argument of DefineProperty is null, because the // property has no parameters. (If you don't specify null, you must // specify an array of Type objects. For a parameterless property, // use the built-in array with no elements: Type.EmptyTypes) var pbNumber = tb.DefineProperty( "Number", PropertyAttributes.HasDefault, typeof(int), null); // The property "set" and property "get" methods require a special // set of attributes. const System.Reflection.MethodAttributes getSetAttr = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig; // Define the "get" accessor method for Number. The method returns // an integer and has no arguments. (Note that null could be // used instead of Types.EmptyTypes) var mbNumberGetAccessor = tb.DefineMethod( "get_Number", getSetAttr, typeof(int), Type.EmptyTypes); var numberGetIL = mbNumberGetAccessor.GetILGenerator(); // For an instance property, argument zero is the instance. Load the // instance, then load the private field and return, leaving the // field value on the stack. numberGetIL.Emit(OpCodes.Ldarg_0); numberGetIL.Emit(OpCodes.Ldfld, fbNumber); numberGetIL.Emit(OpCodes.Ret); // Define the "set" accessor method for Number, which has no return // type and takes one argument of type int (Int32). var mbNumberSetAccessor = tb.DefineMethod( "set_Number", getSetAttr, null, new Type[] { typeof(int) }); var numberSetIL = mbNumberSetAccessor.GetILGenerator(); // Load the instance and then the numeric argument, then store the // argument in the field. numberSetIL.Emit(OpCodes.Ldarg_0); numberSetIL.Emit(OpCodes.Ldarg_1); numberSetIL.Emit(OpCodes.Stfld, fbNumber); numberSetIL.Emit(OpCodes.Ret); // Last, map the "get" and "set" accessor methods to the // PropertyBuilder. The property is now complete. pbNumber.SetGetMethod(mbNumberGetAccessor); pbNumber.SetSetMethod(mbNumberSetAccessor); // Define a method that accepts an integer argument and returns // the product of that integer and the private field m_number. This // time, the array of parameter types is created on the fly. var meth = tb.DefineMethod( "MyMethod", MethodAttributes.Public, typeof(int), new Type[] { typeof(int) }); var methIL = meth.GetILGenerator(); // To retrieve the private instance field, load the instance it // belongs to (argument zero). After loading the field, load the // argument one and then multiply. Return from the method with // the return value (the product of the two numbers) on the // execution stack. methIL.Emit(OpCodes.Ldarg_0); methIL.Emit(OpCodes.Ldfld, fbNumber); methIL.Emit(OpCodes.Ldarg_1); methIL.Emit(OpCodes.Mul); methIL.Emit(OpCodes.Ret); // Finish the type. var t = tb.CreateType(); // The following line saves the single-module assembly. This // requires AssemblyBuilderAccess to include Save. You can now // type "ildasm MyDynamicAsm.dll" at the command prompt, and // examine the assembly. You can also write a program that has // a reference to the assembly, and use the MyDynamicType type. // var assembly = Assembly.GetAssembly(t); var generator = new Lokad.ILPack.AssemblyGenerator(); generator.GenerateAssembly(assembly, aName.Name + "_1.dll"); GetCil(aName.Name + "_1.dll"); var mi = t.GetMethod("MyMethod"); var pi = t.GetProperty("Number"); // Create an instance of MyDynamicType using the default // constructor. var o1 = Activator.CreateInstance(t); // Display the value of the property, then change it to 127 and // display it again. Use null to indicate that the property // has no index. Console.WriteLine("o1.Number: {0}", pi.GetValue(o1, null)); pi.SetValue(o1, 127, null); Console.WriteLine("o1.Number: {0}", pi.GetValue(o1, null)); // Call MyMethod, passing 22, and display the return value, 22 // times 127. Arguments must be passed as an array, even when // there is only one. object[] arguments = { 22 }; Console.WriteLine("o1.MyMethod(22): {0}", mi.Invoke(o1, arguments)); // Create an instance of MyDynamicType using the constructor // that specifies m_Number. The constructor is identified by // matching the types in the argument array. In this case, // the argument array is created on the fly. Display the // property value. var o2 = Activator.CreateInstance(t, new object[] { 5280 }); Console.WriteLine("o2.Number: {0}", pi.GetValue(o2, null)); }
public static MethodBuilder DefineMethodReturningValueType <TValue>(this TypeBuilder typeBuilder, string methodName, TValue returnValue, MethodAttributes methodAttributes) where TValue : struct { MethodBuilder getMethodBuilder = typeBuilder.DefineMethod(methodName, MethodAttributes.Public | MethodAttributes.Virtual, typeof(int), Type.EmptyTypes); ILGenerator ilGenerator = getMethodBuilder.GetILGenerator(); ilGenerator.DeclareLocal(typeof(int)); ilGenerator.Emit(OpCodes.Nop); var returnType = typeof(TValue); if (returnType == typeof(int) || typeof(Enum).IsAssignableFrom(returnType)) { ilGenerator.Emit(OpCodes.Ldc_I4, (int)(object)returnValue); } ilGenerator.Emit(OpCodes.Stloc_0); ilGenerator.Emit(OpCodes.Br_S, 2); ilGenerator.Emit(OpCodes.Ldloc_0); ilGenerator.Emit(OpCodes.Ret); return(getMethodBuilder); }
/// <summary> /// Generates code for the modifier. /// </summary> /// <param name="attr">The attribute.</param> /// <returns>System.String.</returns> public string Modifier(MethodAttributes attr) { // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/classes#methods /* * ReuseSlot = 0, * Final = 32, // 0x00000020 * Virtual = 64, // 0x00000040 * HideBySig = 128, // 0x00000080 * * VtableLayoutMask = 256, // 0x00000100 * NewSlot = VtableLayoutMask, // 0x00000100 * * CheckAccessOnOverride = 512, // 0x00000200 * Abstract = 1024, // 0x00000400 * SpecialName = 2048, // 0x00000800 * PinvokeImpl = 8192, // 0x00002000 * UnmanagedExport = 8, * RTSpecialName = 4096, // 0x00001000 * ReservedMask = 53248, // 0x0000D000 * HasSecurity = 16384, // 0x00004000 * RequireSecObject = 32768, // 0x00008000 */ // TODO 'partial' /* method_modifier * : 'new' | 'public' \ | 'protected' | access | 'internal' | | 'private' / | 'static' | 'virtual' | 'sealed' | 'override' | 'abstract' | 'extern' | 'async' //TODO async | method_modifier_unsafe | ; */ var sb = new StringBuilder(); const uint @virtual = (uint)MA.Virtual; const uint @newslot = (uint)MA.NewSlot; const MA mask = (MA)0x0000FFF0; if ((attr & mask) == (MA.HideBySig | MA.Static | MA.PinvokeImpl)) { sb.Append("static extern "); } else if ((attr & MA.Static) > 0) { sb.Append("static "); } if ((attr & MA.Abstract) > 0U) { sb.Append("abstract "); } if ((attr & MA.Final) > 0U) { sb.Append("sealed "); } if (((uint)attr & @virtual + @newslot) == @virtual + @newslot) { sb.Append("virtual "); } if (((uint)attr & @virtual + @newslot) == @virtual) { sb.Append("override "); } if ((attr & MA.UnmanagedExport) > 0U) { sb.Append("extern "); // TODO ?? } return(sb.ToString()); }
public static object CreateInstance() { AssemblyName aName = new AssemblyName("UploadSessionModelBinder"); AppDomain appDomain = System.Threading.Thread.GetDomain(); AssemblyBuilder aBuilder = appDomain.DefineDynamicAssembly(aName, AssemblyBuilderAccess.Run); ModuleBuilder module = aBuilder.DefineDynamicModule("UploadSessionModelBinder"); TypeBuilder type = module.DefineType( "Krystalware.SlickUpload.Web.Mvc.UploadSessionModelBinder", TypeAttributes.Public | TypeAttributes.Class, typeof(Object), new Type[] { typeof(IModelBinder) } ); //return type; // Declaring method builder // Method attributes System.Reflection.MethodAttributes methodAttributes = System.Reflection.MethodAttributes.Public | System.Reflection.MethodAttributes.Virtual | System.Reflection.MethodAttributes.Final | System.Reflection.MethodAttributes.HideBySig | System.Reflection.MethodAttributes.NewSlot; MethodBuilder method = type.DefineMethod("BindModel", methodAttributes); // Preparing Reflection instances MethodInfo method1 = typeof(SlickUploadContext).GetMethod( "get_CurrentUploadSession", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { }, null ); // Setting return type method.SetReturnType(typeof(Object)); // Adding parameters method.SetParameters( typeof(ControllerContext), typeof(ModelBindingContext) ); // Parameter controllerContext ParameterBuilder controllerContext = method.DefineParameter(1, ParameterAttributes.None, "controllerContext"); // Parameter bindingContext ParameterBuilder bindingContext = method.DefineParameter(2, ParameterAttributes.None, "bindingContext"); ILGenerator gen = method.GetILGenerator(); // Preparing locals LocalBuilder locals = gen.DeclareLocal(typeof(Object)); // Preparing labels Label label9 = gen.DefineLabel(); // Writing body gen.Emit(OpCodes.Nop); gen.Emit(OpCodes.Call, method1); gen.Emit(OpCodes.Stloc_0); gen.Emit(OpCodes.Br_S, label9); gen.MarkLabel(label9); gen.Emit(OpCodes.Ldloc_0); gen.Emit(OpCodes.Ret); // finished return(type.CreateType().InvokeMember(null, BindingFlags.CreateInstance, null, null, null)); }
public System.Reflection.Emit.ConstructorBuilder DefineConstructor(System.Reflection.MethodAttributes attributes, System.Reflection.CallingConventions callingConvention, System.Type[] parameterTypes, System.Type[][] requiredCustomModifiers, System.Type[][] optionalCustomModifiers) { throw null; }
public Type CreateDelegate(MethodInfo targetMethod, TypeBuilder parent, List <ParameterWrapper> methodParams) { typeCounter++; var typeBuilder = myModuleBuilder.DefineType(string.Format("TempModule.Controllers.{0}{1}{2}Delegate{3}", targetMethod.DeclaringType.Name, targetMethod.Name, targetMethod.GetParameters().Length, typeCounter), TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.Sealed | TypeAttributes.AnsiClass | TypeAttributes.AutoClass, typeof(object)); //var typeBuilder = myModuleBuilder.DefineType(string.Format("{0}{1}{2}Delegate", targetMethod.DeclaringType.Name, targetMethod.Name, targetMethod.GetParameters().Length), TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.Sealed | TypeAttributes.AnsiClass | TypeAttributes.AutoClass, typeof(object)); var imp = typeBuilder.DefineField("implementation", parent, FieldAttributes.Public); var baseController = typeof(ServiceWrapperBase <>).MakeGenericType(targetMethod.DeclaringType).GetField("implementation", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); var param = typeBuilder.DefineField("parameters", typeof(ParameterWrapper[]), FieldAttributes.Public); CreateDelegateCtor(typeBuilder); // Declaring method builder // Method attributes System.Reflection.MethodAttributes methodAttributes = System.Reflection.MethodAttributes.Assembly | System.Reflection.MethodAttributes.HideBySig; MethodBuilder method = typeBuilder.DefineMethod(targetMethod.Name, methodAttributes); // Preparing Reflection instances //FieldInfo field1 = typeof(<> c__DisplayClass2_0).GetField("<>4__this", BindingFlags.Public | BindingFlags.NonPublic); //FieldInfo field2 = typeof(Stardust.Interstellar.Rest.Service.ServiceWrapperBase<>).MakeGenericType(typeof(ITestApi)).GetField("implementation", BindingFlags.Public | BindingFlags.NonPublic); //FieldInfo field3 = typeof(<> c__DisplayClass2_0).GetField("serviceParameters", BindingFlags.Public | BindingFlags.NonPublic); MethodInfo method4 = typeof(ParameterWrapper).GetMethod( "get_value", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { }, null ); MethodInfo method5 = targetMethod; // Setting return type method.SetReturnType(targetMethod.ReturnType); // Adding parameters ILGenerator gen = method.GetILGenerator(); gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Ldfld, imp); gen.Emit(OpCodes.Ldfld, baseController); var iii = 0; foreach (var item in methodParams) { gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Ldfld, param); EmitHelpers.EmitInt32(gen, iii); gen.Emit(OpCodes.Ldelem_Ref); gen.Emit(OpCodes.Callvirt, method4); if (item.Type.IsValueType) { gen.Emit(OpCodes.Unbox_Any, item.Type); } else { gen.Emit(OpCodes.Castclass, item.Type); } iii++; } gen.Emit(OpCodes.Callvirt, method5); gen.Emit(OpCodes.Ret); // finished var t = typeBuilder.CreateType(); return(t); }
/// <summary> /// Reflection utility that implements a shader around any user defined shader. /// Creating code for any uniform defined. /// </summary> /// <param name="type">The shader type to derive from</param> /// <returns>A constructor to the derived type</returns> private static ConstructorInfo GetConstructor(Type type) { var baseBegin = ReflectionMarkerAttribute.FindMethod( typeof(Shader), ReflectionToken.ShaderBegin); if (type.IsNotPublic) { throw new Exception("Type " + type.Name + " must be public"); } ConstructorInfo ctor; if (_ctors.TryGetValue(type, out ctor)) { try { return(ctor); } catch (Exception e) { throw e.InnerException; } } var assemblyName = new AssemblyName { Name = "tmp_" + type.Name }; var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run); var module = assemblyBuilder.DefineDynamicModule("tmpModule"); var typeBuilder = module.DefineType(type.Name + "_impl", TypeAttributes.Public | TypeAttributes.Class, type); var beginFun = typeBuilder.DefineMethod(baseBegin.Name, MethodAttributes.Virtual | MethodAttributes.Public, typeof(void), Type.EmptyTypes); var ilBeg = beginFun.GetILGenerator(); var getName = ReflectionMarkerAttribute.FindProperty( typeof(Shader), ReflectionToken.ShaderName).GetGetMethod(); var nameIndex = ilBeg.DeclareLocal(typeof(IProgram)).LocalIndex; var shaderActivate = ReflectionMarkerAttribute.FindMethod( typeof(Shader), ReflectionToken.ShaderActivate); ilBeg.Emit(OpCodes.Ldarg, 0); ilBeg.Emit(OpCodes.Call, shaderActivate); ilBeg.Emit(OpCodes.Ldarg, 0); ilBeg.Emit(OpCodes.Call, getName); ilBeg.Emit(OpCodes.Stloc, nameIndex); foreach (var prop in type.GetProperties(BindingFlagsAny)) { var attr = prop.GetCustomAttributes(typeof(UniformAttribute), false); if (attr.Length == 0) { continue; } var info = TypeMap[prop.PropertyType.MetadataToken]; var uniformCall = Binding.Resolve(info.Token); var f = typeBuilder.DefineField("m_" + prop.Name, typeof(int), FieldAttributes.Private); //var visibility = prop.PropertyType.IsPublic ? MethodAttributes.Public : MethodAttributes.Family; const MethodAttributes visibility = MethodAttributes.Public; var getter = prop.GetSetMethod() != null?prop.GetGetMethod().Name : "get_" + prop.Name; var setter = prop.GetSetMethod() != null?prop.GetSetMethod().Name : "set_" + prop.Name; var m = typeBuilder.DefineMethod(setter, MethodAttributes.Virtual | visibility, typeof(void), new[] { prop.PropertyType }); var ilg = m.GetILGenerator(); ilg.Emit(OpCodes.Ldarg, 0); ilg.Emit(OpCodes.Ldfld, f); if (uniformCall.GetParameters().Length == 2) { ilg.Emit(OpCodes.Ldarg, 1); } ilg.Emit(OpCodes.Call, uniformCall); ilg.Emit(OpCodes.Ret); m = typeBuilder.DefineMethod(getter, MethodAttributes.Virtual | visibility, prop.PropertyType, Type.EmptyTypes); ilg = m.GetILGenerator(); ilg.Emit(OpCodes.Newobj, typeof(NotImplementedException)); ilg.Emit(OpCodes.Throw); } ilBeg.Emit(OpCodes.Ldarg, 0); ilBeg.Emit(OpCodes.Call, type.GetMethod(baseBegin.Name, Type.EmptyTypes)); ilBeg.Emit(OpCodes.Ret); // implement in accessors foreach (var prop in type.GetProperties(BindingFlagsAny)) { var attr = prop.GetCustomAttributes(typeof(VertexInAttribute), false); if (attr.Length == 0) { continue; } var getter = prop.GetSetMethod() != null?prop.GetGetMethod().Name : "get_" + prop.Name; var setter = prop.GetSetMethod() != null?prop.GetSetMethod().Name : "set_" + prop.Name; //var visibility = prop.PropertyType.IsPublic ? MethodAttributes.Public : MethodAttributes.Family; const MethodAttributes visibility = MethodAttributes.Public; var m = typeBuilder.DefineMethod(setter, MethodAttributes.Virtual | visibility, typeof(void), new[] { prop.PropertyType }); var ilg = m.GetILGenerator(); ilg.Emit(OpCodes.Newobj, typeof(NotImplementedException)); ilg.Emit(OpCodes.Throw); m = typeBuilder.DefineMethod(getter, MethodAttributes.Virtual | visibility, prop.PropertyType, Type.EmptyTypes); ilg = m.GetILGenerator(); ilg.Emit(OpCodes.Newobj, typeof(NotImplementedException)); ilg.Emit(OpCodes.Throw); } var timpl = typeBuilder.CreateType(); ctor = timpl.GetConstructor(Type.EmptyTypes); _ctors[type] = ctor; return(ctor); }