public DefineMethod ( string name, System attributes ) : System.Reflection.Emit.MethodBuilder | ||
name | string | |
attributes | System | |
Résultat | System.Reflection.Emit.MethodBuilder |
public void CreateProxiedMethod(FieldInfo field, MethodInfo method, TypeBuilder typeBuilder) { const MethodAttributes methodAttributes = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Virtual; ParameterInfo[] parameters = method.GetParameters(); MethodBuilder methodBuilder = typeBuilder.DefineMethod(method.Name, methodAttributes, CallingConventions.HasThis, method.ReturnType, parameters.Select(param => param.ParameterType).ToArray()); System.Type[] typeArgs = method.GetGenericArguments(); if (typeArgs.Length > 0) { var typeNames = new List<string>(); for (int index = 0; index < typeArgs.Length; index++) { typeNames.Add(string.Format("T{0}", index)); } methodBuilder.DefineGenericParameters(typeNames.ToArray()); } ILGenerator IL = methodBuilder.GetILGenerator(); Debug.Assert(MethodBodyEmitter != null); MethodBodyEmitter.EmitMethodBody(IL, method, field); }
private static FieldBuilder CréeAttributs(TypeBuilder constructeurDeType, DataColumn colonne) { FieldBuilder champBldr = null; PropertyBuilder constructeurPropriété; #region Création de l'attribut champBldr = constructeurDeType.DefineField(colonne.ColumnName.ToLower(), colonne.DataType, FieldAttributes.Private); #endregion #region Création de la Propriété associée constructeurPropriété = constructeurDeType.DefineProperty(colonne.ColumnName, System.Reflection.PropertyAttributes.HasDefault, colonne.DataType, null); // Choix des attributs MethodAttributes attrGetSet = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig; #region Définition du "getter". MethodBuilder constructeurGet = constructeurDeType.DefineMethod("get_" + colonne.ColumnName, attrGetSet, colonne.DataType, Type.EmptyTypes); ILGenerator champGetIL = constructeurGet.GetILGenerator(); champGetIL.Emit(OpCodes.Ldarg_0); champGetIL.Emit(OpCodes.Ldfld, champBldr); champGetIL.Emit(OpCodes.Ret); #endregion #region Définition du "setter". MethodBuilder constructeurSet = constructeurDeType.DefineMethod("set_" + colonne.ColumnName, attrGetSet, null, new Type[] { colonne.DataType }); ILGenerator champSetIL = constructeurSet.GetILGenerator(); champSetIL.Emit(OpCodes.Ldarg_0); champSetIL.Emit(OpCodes.Ldarg_1); champSetIL.Emit(OpCodes.Stfld, champBldr); champSetIL.Emit(OpCodes.Ret); #endregion #region Association des accesseurs à la propriété constructeurPropriété.SetGetMethod(constructeurGet); constructeurPropriété.SetSetMethod(constructeurSet); #endregion #endregion return champBldr; }
public PropertyEmitter(TypeBuilder owner, string name, Type propertyType, FieldBuilder propertyChangedField) { this.owner = owner; this.propertyChangedField = propertyChangedField; fieldBuilder = owner.DefineField(String.Format("<{0}>", name), propertyType, FieldAttributes.Private); getterBuilder = owner.DefineMethod(String.Format("get_{0}", name), MethodAttributes.Public|MethodAttributes.Virtual|MethodAttributes.HideBySig|MethodAttributes.SpecialName, propertyType, Type.EmptyTypes); ILGenerator getterIl = getterBuilder.GetILGenerator(); getterIl.Emit(OpCodes.Ldarg_0); getterIl.Emit(OpCodes.Ldfld, fieldBuilder); getterIl.Emit(OpCodes.Ret); setterBuilder = owner.DefineMethod(String.Format("set_{0}", name), MethodAttributes.Public|MethodAttributes.Virtual|MethodAttributes.HideBySig|MethodAttributes.SpecialName, typeof(void), new[] {propertyType}); ILGenerator setterIl = setterBuilder.GetILGenerator(); setterIl.Emit(OpCodes.Ldarg_0); setterIl.Emit(OpCodes.Ldarg_1); setterIl.Emit(OpCodes.Stfld, fieldBuilder); if (propertyChangedField != null) { setterIl.Emit(OpCodes.Ldarg_0); setterIl.Emit(OpCodes.Dup); setterIl.Emit(OpCodes.Ldfld, propertyChangedField); setterIl.Emit(OpCodes.Ldstr, name); setterIl.Emit(OpCodes.Call, proxyBase_NotifyPropertyChanged); } setterIl.Emit(OpCodes.Ret); propertyBuilder = owner.DefineProperty(name, PropertyAttributes.None, propertyType, null); propertyBuilder.SetGetMethod(getterBuilder); propertyBuilder.SetSetMethod(setterBuilder); }
public void ImplementProxy(TypeBuilder typeBuilder) { typeBuilder.AddInterfaceImplementation(typeof (IProxy)); InterceptorField = typeBuilder .DefineField("__interceptor", typeof (Proxy.DynamicProxy.IInterceptor), FieldAttributes.Private); var getterMethod = typeBuilder .DefineMethod("get_Interceptor", InterceptorMethodsAttributes, CallingConventions.HasThis, typeof (Proxy.DynamicProxy.IInterceptor), new System.Type[0]); getterMethod.SetImplementationFlags(MethodImplAttributes.IL); var il = getterMethod.GetILGenerator(); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldfld, InterceptorField); il.Emit(OpCodes.Ret); var setterMethod = typeBuilder .DefineMethod("set_Interceptor", InterceptorMethodsAttributes, CallingConventions.HasThis, typeof (void), new[] {typeof (Proxy.DynamicProxy.IInterceptor)}); setterMethod.SetImplementationFlags(MethodImplAttributes.IL); il = setterMethod.GetILGenerator(); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldarg_1); il.Emit(OpCodes.Stfld, InterceptorField); il.Emit(OpCodes.Ret); var originalSetter = typeof (IProxy).GetMethod("set_Interceptor"); var originalGetter = typeof (IProxy).GetMethod("get_Interceptor"); typeBuilder.DefineMethodOverride(setterMethod, originalSetter); typeBuilder.DefineMethodOverride(getterMethod, originalGetter); }
private static void MakeProperty(TypeBuilder typeBuilder, string name, Type type) { var fieldBuilder = typeBuilder.DefineField("_" + name, type, FieldAttributes.Private); var propertyBuilder = typeBuilder.DefineProperty(name, PropertyAttributes.None, CallingConventions.HasThis, type, null); var getSetAttr = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Virtual; var getter = typeBuilder.DefineMethod("get_" + name, getSetAttr, type, Type.EmptyTypes); var getIL = getter.GetILGenerator(); getIL.Emit(OpCodes.Ldarg_0); getIL.Emit(OpCodes.Ldfld, fieldBuilder); getIL.Emit(OpCodes.Ret); var setter = typeBuilder.DefineMethod("set_" + name, getSetAttr, null, new[] {type}); var setIL = setter.GetILGenerator(); setIL.Emit(OpCodes.Ldarg_0); setIL.Emit(OpCodes.Ldarg_1); setIL.Emit(OpCodes.Stfld, fieldBuilder); setIL.Emit(OpCodes.Ret); propertyBuilder.SetGetMethod(getter); propertyBuilder.SetSetMethod(setter); }
/// <summary> /// 动态创建类的属性 /// </summary> /// <param name="tb">承载该属性的类型</param> /// <param name="properityName">属性名,首字母应大写</param> /// <param name="properityType">属性数据类型</param> public static FieldBuilder createProperty(TypeBuilder tb, string propertyName, Type propertyType) { //定义属性对应的私有字段 FieldBuilder fieldBuilder = tb.DefineField("_" + propertyName, propertyType, FieldAttributes.Private); //定义属性 PropertyBuilder propertyBuilder = tb.DefineProperty(propertyName, PropertyAttributes.HasDefault, propertyType, null); //定义与属性相关的get方法 MethodBuilder getPropMthdBldr = tb.DefineMethod("get_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, propertyType, Type.EmptyTypes); ILGenerator getIL = getPropMthdBldr.GetILGenerator();//获取il 生成器 getIL.Emit(OpCodes.Ldarg_0); getIL.Emit(OpCodes.Ldfld, fieldBuilder); getIL.Emit(OpCodes.Ret); //定义与属性相关的set方法 MethodBuilder setPropMthdBldr = tb.DefineMethod("set_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, null, new Type[] { propertyType }); ILGenerator setIL = setPropMthdBldr.GetILGenerator(); /* * OpCodes.Ldarg_0:Ldarg是加载方法参数的意思。这里Ldarg_0事实上是对当前对象的引用即this。 * 因为类的实例方法(非静态方法)在调用时,this 是会作为第一个参数传入的。 */ setIL.Emit(OpCodes.Ldarg_0); setIL.Emit(OpCodes.Ldarg_1);//OpCodes.Ldarg_1:加载参数列表的第一个参数了。 setIL.Emit(OpCodes.Stfld, fieldBuilder);//OpCodes.Stfld:用新值替换在对象引用或指针的字段中存储的值。 setIL.Emit(OpCodes.Ret); //把get/set方法和属性联系起来 propertyBuilder.SetGetMethod(getPropMthdBldr); propertyBuilder.SetSetMethod(setPropMthdBldr); return fieldBuilder; }
public void ImplementProxy(TypeBuilder typeBuilder) { // Implement the IProxy interface typeBuilder.AddInterfaceImplementation(typeof (IProxy)); field = typeBuilder.DefineField("__interceptor", typeof (IInterceptor), FieldAttributes.Private); // Implement the getter MethodBuilder getterMethod = typeBuilder.DefineMethod("get_Interceptor", InterceptorMethodsAttributes, CallingConventions.HasThis, typeof(IInterceptor), new System.Type[0]); getterMethod.SetImplementationFlags(MethodImplAttributes.Managed | MethodImplAttributes.IL); ILGenerator IL = getterMethod.GetILGenerator(); // This is equivalent to: // get { return __interceptor; IL.Emit(OpCodes.Ldarg_0); IL.Emit(OpCodes.Ldfld, field); IL.Emit(OpCodes.Ret); // Implement the setter MethodBuilder setterMethod = typeBuilder.DefineMethod("set_Interceptor", InterceptorMethodsAttributes, CallingConventions.HasThis, typeof (void), new[] {typeof (IInterceptor)}); setterMethod.SetImplementationFlags(MethodImplAttributes.Managed | MethodImplAttributes.IL); IL = setterMethod.GetILGenerator(); IL.Emit(OpCodes.Ldarg_0); IL.Emit(OpCodes.Ldarg_1); IL.Emit(OpCodes.Stfld, field); IL.Emit(OpCodes.Ret); MethodInfo originalSetter = typeof (IProxy).GetMethod("set_Interceptor"); MethodInfo originalGetter = typeof (IProxy).GetMethod("get_Interceptor"); typeBuilder.DefineMethodOverride(setterMethod, originalSetter); typeBuilder.DefineMethodOverride(getterMethod, originalGetter); }
private FieldInfo[] GenerateProperties(TypeBuilder tb, DynamicProperty[] properties) { FieldInfo[] array = new FieldBuilder[properties.Length]; for (int i = 0; i < properties.Length; i++) { DynamicProperty dynamicProperty = properties[i]; FieldBuilder fieldBuilder = tb.DefineField("_" + dynamicProperty.Name, dynamicProperty.Type, FieldAttributes.Private); PropertyBuilder propertyBuilder = tb.DefineProperty(dynamicProperty.Name, PropertyAttributes.HasDefault, dynamicProperty.Type, null); MethodBuilder methodBuilder = tb.DefineMethod("get_" + dynamicProperty.Name, MethodAttributes.FamANDAssem | MethodAttributes.Family | MethodAttributes.HideBySig | MethodAttributes.SpecialName, dynamicProperty.Type, Type.EmptyTypes); ILGenerator iLGenerator = methodBuilder.GetILGenerator(); iLGenerator.Emit(OpCodes.Ldarg_0); iLGenerator.Emit(OpCodes.Ldfld, fieldBuilder); iLGenerator.Emit(OpCodes.Ret); MethodBuilder methodBuilder2 = tb.DefineMethod("set_" + dynamicProperty.Name, MethodAttributes.FamANDAssem | MethodAttributes.Family | MethodAttributes.HideBySig | MethodAttributes.SpecialName, null, new Type[] { dynamicProperty.Type }); ILGenerator iLGenerator2 = methodBuilder2.GetILGenerator(); iLGenerator2.Emit(OpCodes.Ldarg_0); iLGenerator2.Emit(OpCodes.Ldarg_1); iLGenerator2.Emit(OpCodes.Stfld, fieldBuilder); iLGenerator2.Emit(OpCodes.Ret); propertyBuilder.SetGetMethod(methodBuilder); propertyBuilder.SetSetMethod(methodBuilder2); array[i] = fieldBuilder; } return array; }
private static FieldInfo[] GenerateProperties(TypeBuilder tb, IDictionary<string, Type> properties) { const MethodAttributes getSetAttr = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig; FieldInfo[] fields = new FieldBuilder[properties.Count]; int i = 0; foreach (string key in properties.Keys) { string name = key; Type type = properties[key]; FieldBuilder fb = tb.DefineField("_" + key, type, FieldAttributes.Public); PropertyBuilder pb = tb.DefineProperty(key, PropertyAttributes.HasDefault, type, null); MethodBuilder mbGet = tb.DefineMethod("get_" + name, getSetAttr, type, Type.EmptyTypes); ILGenerator genGet = mbGet.GetILGenerator(8); genGet.Emit(OpCodes.Ldarg_0); genGet.Emit(OpCodes.Ldfld, fb); genGet.Emit(OpCodes.Ret); pb.SetGetMethod(mbGet); MethodBuilder mbSet = tb.DefineMethod("set_" + name, getSetAttr, null, new Type[] { type }); ILGenerator genSet = mbSet.GetILGenerator(8); genSet.Emit(OpCodes.Ldarg_0); genSet.Emit(OpCodes.Ldarg_1); genSet.Emit(OpCodes.Stfld, fb); genSet.Emit(OpCodes.Ret); pb.SetSetMethod(mbSet); fields[i] = fb; } return fields; }
private static void BuildProperty(TypeBuilder typeBuilder, string name, Type type) { FieldBuilder field = typeBuilder.DefineField("m" + name, type, FieldAttributes.Private); PropertyBuilder propertyBuilder = typeBuilder.DefineProperty(name, PropertyAttributes.None, type, null); MethodAttributes getSetAttr = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.Virtual; MethodBuilder getter = typeBuilder.DefineMethod("get_" + name, getSetAttr, type, Type.EmptyTypes); ILGenerator getIL = getter.GetILGenerator(); getIL.Emit(OpCodes.Ldarg_0); getIL.Emit(OpCodes.Ldfld, field); getIL.Emit(OpCodes.Ret); MethodBuilder setter = typeBuilder.DefineMethod("set_" + name, getSetAttr, null, new Type[] { type }); ILGenerator setIL = setter.GetILGenerator(); setIL.Emit(OpCodes.Ldarg_0); setIL.Emit(OpCodes.Ldarg_1); setIL.Emit(OpCodes.Stfld, field); setIL.Emit(OpCodes.Ret); propertyBuilder.SetGetMethod(getter); propertyBuilder.SetSetMethod(setter); }
public override void Extend(Type baseType, TypeBuilder typeBuilder) { //build field FieldBuilder field = typeBuilder.DefineField(FieldName, Type, FieldAttributes.Private); //define property PropertyBuilder property = typeBuilder.DefineProperty(Name, PropertyAttributes.None, Type, null); //build setter MethodBuilder setter = typeBuilder.DefineMethod("set_" + Name, MethodAttributes.Public | MethodAttributes.Virtual, null, new Type[] { Type }); ILGenerator setterILG = setter.GetILGenerator(); setterILG.Emit(OpCodes.Ldarg_0); setterILG.Emit(OpCodes.Ldarg_1); setterILG.Emit(OpCodes.Stfld, field); setterILG.Emit(OpCodes.Ret); property.SetSetMethod(setter); //build getter MethodBuilder getter = typeBuilder.DefineMethod("get_" + Name, MethodAttributes.Public | MethodAttributes.Virtual, Type, Type.EmptyTypes); ILGenerator getterILG = getter.GetILGenerator(); getterILG.Emit(OpCodes.Ldarg_0); getterILG.Emit(OpCodes.Ldfld, field); getterILG.Emit(OpCodes.Ret); property.SetGetMethod(getter); }
private static void CreateProperty(TypeBuilder tb, string propertyName, Type propertyType) { FieldBuilder fieldBuilder = tb.DefineField("_" + propertyName, propertyType, FieldAttributes.Private); PropertyBuilder propertyBuilder = tb.DefineProperty(propertyName, PropertyAttributes.HasDefault, propertyType, null); MethodBuilder getPropMthdBldr = tb.DefineMethod("get_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, propertyType, Type.EmptyTypes); ILGenerator getIl = getPropMthdBldr.GetILGenerator(); getIl.Emit(OpCodes.Ldarg_0); getIl.Emit(OpCodes.Ldfld, fieldBuilder); getIl.Emit(OpCodes.Ret); MethodBuilder setPropMthdBldr = tb.DefineMethod("set_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, null, new[] { propertyType }); ILGenerator setIl = setPropMthdBldr.GetILGenerator(); Label modifyProperty = setIl.DefineLabel(); Label exitSet = setIl.DefineLabel(); setIl.MarkLabel(modifyProperty); setIl.Emit(OpCodes.Ldarg_0); setIl.Emit(OpCodes.Ldarg_1); setIl.Emit(OpCodes.Stfld, fieldBuilder); setIl.Emit(OpCodes.Nop); setIl.MarkLabel(exitSet); setIl.Emit(OpCodes.Ret); propertyBuilder.SetGetMethod(getPropMthdBldr); propertyBuilder.SetSetMethod(setPropMthdBldr); }
public void DefineProperty(TypeBuilder builder, Type type, string name) { if (string.IsNullOrWhiteSpace(name)) { throw new ArgumentException("propertyName"); } string fieldName = Char.ToLowerInvariant(name[0]) + name.Substring(1); string propertyName = Char.ToUpperInvariant(name[0]) + name.Substring(1); FieldBuilder fieldBuilder = builder.DefineField( fieldName, type, FieldAttributes.Private); PropertyBuilder propertyBuilder = builder.DefineProperty( propertyName, PropertyAttributes.HasDefault, type, null); //Getter MethodBuilder getMethodBuilder = builder.DefineMethod( "get_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, type, Type.EmptyTypes); ILGenerator getILGenerator = getMethodBuilder.GetILGenerator(); getILGenerator.Emit(OpCodes.Ldarg_0); getILGenerator.Emit(OpCodes.Ldfld, fieldBuilder); getILGenerator.Emit(OpCodes.Ret); //Setter MethodBuilder setMethodBuilder = builder.DefineMethod( "set_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, null, new Type[] { type }); ILGenerator setILGenerator = setMethodBuilder.GetILGenerator(); setILGenerator.Emit(OpCodes.Ldarg_0); setILGenerator.Emit(OpCodes.Ldarg_1); setILGenerator.Emit(OpCodes.Stfld, fieldBuilder); setILGenerator.Emit(OpCodes.Ret); propertyBuilder.SetGetMethod(getMethodBuilder); propertyBuilder.SetSetMethod(setMethodBuilder); }
public MethodWriter(TypeBuilder Parent, CodeMemberMethod Member, MethodCollection Lookup, ILMirror Mirror) { Loops = new Stack<LoopMetadata>(); this.Member = Member; this.Lookup = Lookup; this.Mirror = Mirror; if(Member is CodeEntryPointMethod) { Method = Parent.DefineMethod("Main", MethodAttributes.Private | MethodAttributes.Static, typeof(void), null); IsEntryPoint = true; } else Method = Parent.DefineMethod(Member.Name, MethodAttributes.Public | MethodAttributes.Static, typeof(object), new[] { typeof(object[]) }); Generator = Method.GetILGenerator(); ForceString = typeof(Script).GetMethod("ForceString"); ForceDecimal = typeof(Script).GetMethod("ForceDecimal"); ForceLong = typeof(Script).GetMethod("ForceLong"); ForceInt = typeof(Script).GetMethod("ForceInt"); ForceBool = typeof(Script).GetMethod("ForceBool"); Locals = new Dictionary<string, LocalBuilder>(); Labels = new Dictionary<string, LabelMetadata>(); Type Variables = typeof(Script.Variables); if(IsEntryPoint) GenerateEntryPointHeader(Generator); SetVariable = typeof(Script.Variables).GetMethod("SetVariable"); GetVariable = typeof(Script.Variables).GetMethod("GetVariable"); MethodInfo GetVars = typeof(Script).GetMethod("get_Vars"); if(Mirror != null) { ForceString = Mirror.GrabMethod(ForceString); ForceDecimal = Mirror.GrabMethod(ForceDecimal); ForceLong = Mirror.GrabMethod(ForceLong); ForceInt = Mirror.GrabMethod(ForceInt); ForceBool = Mirror.GrabMethod(ForceBool); SetVariable = Mirror.GrabMethod(SetVariable); GetVariable = Mirror.GrabMethod(GetVariable); Variables = Mirror.GrabType(Variables); GetVars = Mirror.GrabMethod(GetVars); } VarsProperty = Generator.DeclareLocal(Variables); Generator.Emit(OpCodes.Call, GetVars); Generator.Emit(OpCodes.Stloc, VarsProperty); }
private static void ImplementAddInterceptionBehavior(TypeBuilder typeBuilder, FieldInfo proxyInterceptorPipelineField) { // Declaring method builder // Method attributes const MethodAttributes MethodAttributes = MethodAttributes.Private | MethodAttributes.Virtual | MethodAttributes.Final | MethodAttributes.HideBySig | MethodAttributes.NewSlot; MethodBuilder methodBuilder = typeBuilder.DefineMethod( "Microsoft.Practices.Unity.InterceptionExtension.IInterceptingProxy.AddInterceptionBehavior", MethodAttributes); // Setting return type methodBuilder.SetReturnType(typeof(void)); // Adding parameters methodBuilder.SetParameters(typeof(IInterceptionBehavior)); // Parameter method methodBuilder.DefineParameter(1, ParameterAttributes.None, "interceptor"); ILGenerator il = methodBuilder.GetILGenerator(); // Writing body il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldfld, proxyInterceptorPipelineField); il.Emit(OpCodes.Ldarg_1); il.EmitCall(OpCodes.Callvirt, InterceptionBehaviorPipelineMethods.Add, null); il.Emit(OpCodes.Ret); typeBuilder.DefineMethodOverride(methodBuilder, IInterceptingProxyMethods.AddInterceptionBehavior); }
protected void SetUp () { AssemblyName assemblyName = new AssemblyName(); assemblyName.Name = GetType().FullName; AssemblyBuilder assembly = Thread.GetDomain().DefineDynamicAssembly( assemblyName, AssemblyBuilderAccess.Run); module = assembly.DefineDynamicModule("module1"); tb = module.DefineType("class1", TypeAttributes.Public); eb = tb.DefineEvent ("event1", EventAttributes.None, typeof (AnEvent)); mb = tb.DefineMethod ("OnAnEvent", MethodAttributes.Public, typeof (void), new Type [] { typeof (AnEvent) }); ILGenerator ilgen = mb.GetILGenerator(); ilgen.Emit (OpCodes.Ret); // These two are required eb.SetAddOnMethod (mb); eb.SetRemoveOnMethod (mb); }
private void GenerateEquals(TypeBuilder tb, FieldInfo[] fields) { ILGenerator iLGenerator = tb.DefineMethod("Equals", MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.Public, typeof(bool), new Type[] { typeof(object) }).GetILGenerator(); LocalBuilder local = iLGenerator.DeclareLocal(tb); Label label = iLGenerator.DefineLabel(); iLGenerator.Emit(OpCodes.Ldarg_1); iLGenerator.Emit(OpCodes.Isinst, tb); iLGenerator.Emit(OpCodes.Stloc, local); iLGenerator.Emit(OpCodes.Ldloc, local); iLGenerator.Emit(OpCodes.Brtrue_S, label); iLGenerator.Emit(OpCodes.Ldc_I4_0); iLGenerator.Emit(OpCodes.Ret); iLGenerator.MarkLabel(label); foreach (FieldInfo info in fields) { Type fieldType = info.FieldType; Type type2 = typeof(EqualityComparer<>).MakeGenericType(new Type[] { fieldType }); label = iLGenerator.DefineLabel(); iLGenerator.EmitCall(OpCodes.Call, type2.GetMethod("get_Default"), null); iLGenerator.Emit(OpCodes.Ldarg_0); iLGenerator.Emit(OpCodes.Ldfld, info); iLGenerator.Emit(OpCodes.Ldloc, local); iLGenerator.Emit(OpCodes.Ldfld, info); iLGenerator.EmitCall(OpCodes.Callvirt, type2.GetMethod("Equals", new Type[] { fieldType, fieldType }), null); iLGenerator.Emit(OpCodes.Brtrue_S, label); iLGenerator.Emit(OpCodes.Ldc_I4_0); iLGenerator.Emit(OpCodes.Ret); iLGenerator.MarkLabel(label); } iLGenerator.Emit(OpCodes.Ldc_I4_1); iLGenerator.Emit(OpCodes.Ret); }
private static void ImplementInterfaceMethod(TypeBuilder newType, MethodInfo interfaceMethod) { var parameters = interfaceMethod.GetParameters(); var parameterTypes = (from p in parameters select p.ParameterType).ToArray(); var newMethod = newType.DefineMethod(interfaceMethod.DeclaringType.Name + "." + interfaceMethod.Name, MethodAttributes.Private | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.Final, interfaceMethod.ReturnType, parameterTypes); var baseMethod = newType.BaseType.GetMethod(interfaceMethod.Name, parameterTypes); // parameter 0 is 'this', so we start at index 1 for (int i = 0; i < parameters.Length; i++) { newMethod.DefineParameter(i + 1, parameters[i].Attributes, parameters[i].Name); } // load all arguments (including 'this') in proper order, then call and return var ilGenerator = newMethod.GetILGenerator(); for (int i = 0; i <= parameterTypes.Length; i++) { ilGenerator.Emit(OpCodes.Ldarg_S, (byte)i); } ilGenerator.Emit(OpCodes.Call, baseMethod); ilGenerator.Emit(OpCodes.Ret); // finally, hook the new method up to the interface mapping newType.DefineMethodOverride(newMethod, interfaceMethod); }
private void ImplementBaseSetter(TypeBuilder typeBuilder) { var setterBuilder = typeBuilder.DefineMethod( "SetBasePropertyValue", MethodAttributes.Public | MethodAttributes.HideBySig, typeof(void), new[] { typeof(string), typeof(object) }); var gen = setterBuilder.GetILGenerator(); var labels = new Label[_baseSetters.Count]; for (var i = 0; i < _baseSetters.Count; i++) { labels[i] = gen.DefineLabel(); gen.Emit(OpCodes.Ldarg_1); gen.Emit(OpCodes.Ldstr, _baseSetters[i].Name); gen.Emit(OpCodes.Call, _stringEquals); gen.Emit(OpCodes.Brfalse_S, labels[i]); gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Ldarg_2); gen.Emit(OpCodes.Castclass, _baseSetters[i].PropertyType); gen.Emit(OpCodes.Call, _baseSetters[i].GetSetMethod(true)); gen.Emit(OpCodes.Ret); gen.MarkLabel(labels[i]); } gen.Emit(OpCodes.Newobj, _invalidOperationConstructor); gen.Emit(OpCodes.Throw); }
private static void AddContainmentEntitiesMethod(TypeBuilder typeBuilder, Type parentType, PropertyInfo propertyInfo) { var methodBuilder = typeBuilder.DefineMethod("Get" + propertyInfo.Name, MethodAttributes.Public , typeof(IHttpActionResult), new[] { typeof(long) }); var keyParameter = methodBuilder.DefineParameter(1, ParameterAttributes.None, "key"); var dynamicEnableQueryAttribute = typeof(DynamicEnableQueryAttribute).GetConstructor(Type.EmptyTypes); if (dynamicEnableQueryAttribute == null) { throw new ArgumentException(); } methodBuilder.SetCustomAttribute(new CustomAttributeBuilder(dynamicEnableQueryAttribute, new object[0])); var fromODataUriAttribute = typeof(FromODataUriAttribute).GetConstructor(Type.EmptyTypes); if (fromODataUriAttribute == null) { throw new ArgumentException(); } keyParameter.SetCustomAttribute(new CustomAttributeBuilder(fromODataUriAttribute, new object[0])); var getContainedEntityMethodInfo = parentType.GetMethod("GetContainedEntity", BindingFlags.Instance | BindingFlags.NonPublic).MakeGenericMethod(propertyInfo.PropertyType.GetGenericArguments()); var generator = methodBuilder.GetILGenerator(); // push "this" generator.Emit(OpCodes.Ldarg_0); // push "key" generator.Emit(OpCodes.Ldarg_1); // push propertyName generator.Emit(OpCodes.Ldstr, propertyInfo.Name); // call generator.Emit(OpCodes.Call, getContainedEntityMethodInfo); generator.Emit(OpCodes.Ret); }
/// <summary> /// Implements a method as a no operation method. Method can be virtual, abstract or not. /// </summary> /// <param name="tB">The <see cref="TypeBuilder"/> for the new type.</param> /// <param name="method">The method to implement.</param> /// <param name="isVirtual">Defaults to false: the method is sealed. True to keep the method virtual. </param> /// <returns>The <see cref="MethodBuilder"/> to enable, for instance, creation of custom attributes on the method.</returns> public static MethodBuilder ImplementEmptyStubMethod( TypeBuilder tB, MethodInfo method, bool isVirtual = false ) { if( tB == null ) throw new ArgumentNullException( "tB" ); if( method == null ) throw new ArgumentNullException( "method" ); ParameterInfo[] parameters = method.GetParameters(); Type[] parametersTypes = ReflectionHelper.CreateParametersType( parameters ); Type returnType = method.ReturnType; MethodAttributes mA = method.Attributes & ~(MethodAttributes.Abstract | MethodAttributes.VtableLayoutMask); if( isVirtual ) mA |= MethodAttributes.Virtual; MethodBuilder mB = tB.DefineMethod( method.Name, mA ); if( method.ContainsGenericParameters ) { int i = 0; Type[] genericArguments = method.GetGenericArguments(); string[] names = genericArguments.Select( t => String.Format( "T{0}", i++ ) ).ToArray(); var genericParameters = mB.DefineGenericParameters( names ); for( i = 0; i < names.Length; ++i ) { var genericTypeArgument = genericArguments[i].GetTypeInfo(); GenericTypeParameterBuilder genericTypeBuilder = genericParameters[i]; genericTypeBuilder.SetGenericParameterAttributes( genericTypeArgument.GenericParameterAttributes ); genericTypeBuilder.SetInterfaceConstraints( genericTypeArgument.GetGenericParameterConstraints() ); } } mB.SetReturnType( method.ReturnType ); mB.SetParameters( ReflectionHelper.CreateParametersType( parameters ) ); EmitEmptyImplementation( mB, returnType, parameters ); return mB; }
internal static void CreateReadOnlyLazyProperty(TypeBuilder tb, PropertyInfo property, ILGenerator ctor, bool isInterfaceImplementation = true) { var propertyName = property.Name; var propertyType = property.PropertyType; //backing field var lazyType = typeof(Lazy<>).MakeGenericType(propertyType); var fb = tb.DefineField("_backing_" + propertyName, lazyType, FieldAttributes.Private); //property var pb = tb.DefineProperty(propertyName, PropertyAttributes.None, propertyType, null); //getter var getterAttributes = isInterfaceImplementation ? InterfaceImplementationAttributes : OverrideAttributes; var getMethod = tb.DefineMethod("get_" + propertyName, getterAttributes, propertyType, Type.EmptyTypes); var getIL = getMethod.GetILGenerator(); getIL.DeclareLocal(propertyType); getIL.Emit(OpCodes.Nop); getIL.Emit(OpCodes.Ldarg_0); getIL.Emit(OpCodes.Ldfld, fb); getIL.EmitCall(OpCodes.Callvirt, lazyType.GetProperty("Value").GetGetMethod(), null); getIL.Emit(OpCodes.Stloc_0); getIL.Emit(OpCodes.Nop); //originally a br.s to the next line getIL.Emit(OpCodes.Ldloc_0); getIL.Emit(OpCodes.Ret); //combine getter and property pb.SetGetMethod(getMethod); //initialize Lazy<T> in .ctor ctor.Emit(OpCodes.Ldarg_0); ctor.Emit(OpCodes.Newobj, lazyType.GetConstructor(Type.EmptyTypes)); ctor.Emit(OpCodes.Stfld, fb); }
public CodeGenerator(Expression pExpression, String pModuleName, ref LogHandler rLogHandler) { _symbolTable = new Dictionary <String, Emit.LocalBuilder>(); _assemblyName = new Reflect.AssemblyName(Path.GetFileNameWithoutExtension(pModuleName)); _statement = pExpression; //Init Assembly _assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(_assemblyName, Emit.AssemblyBuilderAccess.Save); _moduleBuilder = _assemblyBuilder.DefineDynamicModule(pModuleName); _typeBuilder = _moduleBuilder.DefineType("PascalCompilerType"); _methodBuilder = _typeBuilder.DefineMethod ( "Main", Reflect.MethodAttributes.Static, typeof(void), Type.EmptyTypes ); _ilGenerator = _methodBuilder.GetILGenerator(); //Actual Work GenerateStatement(_statement, null); _ilGenerator.Emit(Emit.OpCodes.Ret); //Finalizing Work _typeBuilder.CreateType(); _moduleBuilder.CreateGlobalFunctions(); _assemblyBuilder.SetEntryPoint(_methodBuilder); _assemblyBuilder.Save(pModuleName); }
public ILGenerator CreateFunction(TypeBuilder a_TypeBuilder, string a_Name, MethodAttributes a_MethodAttributes, Type a_ReturnType, Type[] a_Parameters) { MethodBuilder methodBuilder = a_TypeBuilder.DefineMethod(a_Name, a_MethodAttributes, a_ReturnType, a_Parameters); ILGenerator ilGenerator = methodBuilder.GetILGenerator(); return ilGenerator; }
private static void WriteProperty(Type parentType, TypeBuilder builder, string name, Type type) { const BindingFlags BindingFlag = BindingFlags.Public | BindingFlags.Instance; const MethodAttributes MethodAttribute = MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.NewSlot; string getName = "get_" + name; string setName = "set_" + name; MethodInfo parentGetMethod = parentType.GetMethod(getName, BindingFlag); MethodBuilder implementedGetMethod = builder.DefineMethod(getName, MethodAttribute, type, Type.EmptyTypes); ILGenerator getIl = implementedGetMethod.GetILGenerator(); getIl.Emit(OpCodes.Ldarg_0); getIl.Emit(OpCodes.Call, parentGetMethod); getIl.Emit(OpCodes.Ret); MethodInfo interfaceGetMethod = authorizeAttributeType.GetMethod(getName, BindingFlag); builder.DefineMethodOverride(implementedGetMethod, interfaceGetMethod); MethodInfo parentSetMethod = parentType.GetMethod(setName, BindingFlag); MethodBuilder implementedSetMethod = builder.DefineMethod(setName, MethodAttribute, typeof(void), new[] { type }); ILGenerator setIl = implementedSetMethod.GetILGenerator(); setIl.Emit(OpCodes.Ldarg_0); setIl.Emit(OpCodes.Ldarg_1); setIl.Emit(OpCodes.Call, parentSetMethod); setIl.Emit(OpCodes.Ret); MethodInfo interfaceSetMethod = authorizeAttributeType.GetMethod(setName, BindingFlag); builder.DefineMethodOverride(implementedSetMethod, interfaceSetMethod); }
public static MethodBuilder GenerateStaticSerializerStub(TypeBuilder tb, Type type) { var mb = tb.DefineMethod("Serialize", MethodAttributes.Public | MethodAttributes.Static, null, new Type[] { typeof(Stream), type }); mb.DefineParameter(1, ParameterAttributes.None, "stream"); mb.DefineParameter(2, ParameterAttributes.None, "value"); return mb; }
static void DefineDelegateFieldAndOverride(TypeBuilder tb, int numArgs) { Type fieldType = FuncTypeHelpers.GetFFuncType(numArgs); string fieldName = "_fn" + numArgs; FieldBuilder fb = tb.DefineField(fieldName, fieldType, FieldAttributes.Public); MethodBuilder mb = tb.DefineMethod("invoke", MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Virtual, typeof(object), CreateObjectTypeArray(numArgs)); ILGenerator gen = mb.GetILGenerator(); Label eqLabel = gen.DefineLabel(); // this._fni == null ? gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Ldfld, fb); gen.Emit(OpCodes.Ldnull); gen.Emit(OpCodes.Beq, eqLabel); //Not equal to Null, invoke it. gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Ldfld, fb); for (int i = 0; i < numArgs; i++) gen.Emit(OpCodes.Ldarg, i+1); gen.Emit(OpCodes.Call,fb.FieldType.GetMethod("Invoke")); gen.Emit(OpCodes.Ret); gen.MarkLabel(eqLabel); // Equal to Null: throw WrongArityException gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Call, Method_AFn_WrongArityException); gen.Emit(OpCodes.Throw); }
private static void CreateProperty(string name, TypeBuilder tb, MethodInfo bgcmi, MethodInfo bscmi) { // define getter var gmb = tb.DefineMethod("get_" + name, MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Public, typeof(string), null); var g = gmb.GetILGenerator(); g.Emit(OpCodes.Ldarg_0); g.Emit(OpCodes.Ldstr, name); g.Emit(OpCodes.Call, bgcmi); g.Emit(OpCodes.Ret); // define setter var smb = tb.DefineMethod("set_" + name, MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Public, null, new Type[] { typeof(string) }); g = smb.GetILGenerator(); g.Emit(OpCodes.Ldarg_0); g.Emit(OpCodes.Ldstr, name); g.Emit(OpCodes.Ldarg_1); g.Emit(OpCodes.Call, bscmi); g.Emit(OpCodes.Ret); // define properties var pb = tb.DefineProperty(name, PropertyAttributes.None, typeof(string), null); pb.SetGetMethod(gmb); pb.SetSetMethod(smb); }
public ILDynamicMethodDebugImpl(string name, Type delegateType, Type thisType) { _delegateType = delegateType; _expectedLength = 64; var mi = delegateType.GetMethod("Invoke"); var uniqueName = ILDynamicTypeDebugImpl.UniqueName(name); _assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(uniqueName), AssemblyBuilderAccess.RunAndSave, DynamicILDirectoryPath.DynamicIL); _moduleBuilder = _assemblyBuilder.DefineDynamicModule(uniqueName + ".dll", true); var sourceCodeFileName = Path.Combine(DynamicILDirectoryPath.DynamicIL, uniqueName + ".il"); _symbolDocumentWriter = _moduleBuilder.DefineDocument(sourceCodeFileName, SymDocumentType.Text, SymLanguageType.ILAssembly, SymLanguageVendor.Microsoft); _sourceCodeWriter = new SourceCodeWriter(sourceCodeFileName, _symbolDocumentWriter); Type[] parameterTypes; if (thisType != null) { parameterTypes = new[] { thisType }.Concat(mi.GetParameters().Select(pi => pi.ParameterType)).ToArray(); } else { parameterTypes = mi.GetParameters().Select(pi => pi.ParameterType).ToArray(); } _sourceCodeWriter.StartMethod(name, mi.ReturnType, parameterTypes, MethodAttributes.Static); _typeBuilder = _moduleBuilder.DefineType(name, TypeAttributes.Public, typeof(object), Type.EmptyTypes); _forbidenInstructions = new ILGenForbidenInstructionsCheating(_typeBuilder); _dynamicMethod = _typeBuilder.DefineMethod("Invoke", MethodAttributes.Public | MethodAttributes.Static, mi.ReturnType, parameterTypes); for (int i = 0; i < parameterTypes.Length; i++) { _dynamicMethod.DefineParameter(i + 1, ParameterAttributes.In, string.Format("arg{0}", i)); } }
/// <summary> /// Creates a <see cref="MethodBuilder"/> and implements a default wrapper. /// </summary> /// <param name="owner">The type that will own this method.</param> /// <param name="interfaceType">Type of interface implemented by the <paramref name="owner"/>.</param> /// <param name="overrideMethod">Method to override.</param> /// <param name="fieldBuilders">Fields specified by the <see paramref="owner"/>.</param> /// <returns>MethodBuilder with an already implemented wrapper.</returns> public MethodBuilder GenerateInvocation(TypeBuilder owner, Type interfaceType, MethodInfo overrideMethod, IEnumerable<FieldBuilder> fieldBuilders) { var result = owner.DefineMethod ( overrideMethod.Name, MethodAttributes.Private | MethodAttributes.Virtual | MethodAttributes.Final | MethodAttributes.HideBySig | MethodAttributes.NewSlot, overrideMethod.ReturnType, overrideMethod.GetParameters().OrderBy(p => p.Position).Select(t => t.ParameterType).ToArray() ); result.SetImplementationFlags(MethodImplAttributes.AggressiveInlining); var generator = result.GetILGenerator(); var fieldName = LibraryInterfaceMapper.GetFieldNameForMethodInfo(overrideMethod); var field = fieldBuilders.First(f => f.Name == fieldName); var parameters = overrideMethod.GetParameters(); OnInvokeBegin(owner, interfaceType, generator, overrideMethod); generator.Emit(OpCodes.Ldarg_0); // this generator.Emit(OpCodes.Ldfld, field); // MethodNameProc _glMethodName. Initialized by constructor. foreach (var item in parameters.Where(p => !p.IsRetval).Select((p, i) => new { Type = p, Index = i })) { generator.Emit(OpCodes.Ldarg, item.Index + 1); } generator.EmitCall(OpCodes.Callvirt, field.FieldType.GetMethod("Invoke"), null); OnInvokeEnd(owner, interfaceType, generator, overrideMethod); generator.Emit(OpCodes.Ret); owner.DefineMethodOverride(result, overrideMethod); return result; }
private void CompileMainClass(Node ActiveNode) { Emit.TypeBuilder _TypeBuilder = TypeTable[ActiveNode.Nodes[1].Value]; Emit.MethodBuilder MethBuilder = _TypeBuilder.DefineMethod("Main", Reflect.MethodAttributes.Static, typeof(void), System.Type.EmptyTypes); this.AssemblerGenerator = MethBuilder.GetILGenerator(); CurrentType = _TypeBuilder; OpenBlockVariables(); CreateCode(ActiveNode.Nodes[14]); CreateCode(ActiveNode.Nodes[15]); CloseBlockVariables(); // Отладочные команды AssemblerGenerator.Emit(Emit.OpCodes.Ldstr, "Programm was finished. Press Enter key to quit..."); AssemblerGenerator.Emit(Emit.OpCodes.Call, typeof(System.Console).GetMethod("WriteLine", new System.Type[] { typeof(string) })); AssemblerGenerator.Emit(Emit.OpCodes.Call, typeof(System.Console).GetMethod("ReadLine", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static, null, new System.Type[] { }, null)); AssemblerGenerator.Emit(Emit.OpCodes.Pop); AssemblerGenerator.Emit(Emit.OpCodes.Ret); CreatedTypeTable[ActiveNode.Nodes[1].Value] = _TypeBuilder.CreateType(); ModBuilder.CreateGlobalFunctions(); AsmBuilder.SetEntryPoint(MethBuilder); }
private static void BuildStringProperty(TypeBuilder typeBuilder, string property) { //implement properties from interface FieldBuilder fieldBuilder = typeBuilder.DefineField(property.ToLower(), typeof(string), FieldAttributes.Private); PropertyBuilder propertyBuilder = typeBuilder.DefineProperty(property, PropertyAttributes.HasDefault, typeof(string), null); const MethodAttributes getSetAttributes = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Virtual; //define 'get' accessor MethodBuilder getPropertyBuilder = typeBuilder.DefineMethod("get_" + property, getSetAttributes, typeof(string), Type.EmptyTypes); //create IL code for get ILGenerator genusGetIL = getPropertyBuilder.GetILGenerator(); genusGetIL.Emit(OpCodes.Ldarg_0); genusGetIL.Emit(OpCodes.Ldfld, fieldBuilder); genusGetIL.Emit(OpCodes.Ret); //define 'set' accessor MethodBuilder setPropertyBuilder = typeBuilder.DefineMethod("set_" + property, getSetAttributes, null, new[] { typeof(String) }); //create IL code for set ILGenerator genusSetIL = setPropertyBuilder.GetILGenerator(); genusSetIL.Emit(OpCodes.Ldarg_0); genusSetIL.Emit(OpCodes.Ldarg_1); genusSetIL.Emit(OpCodes.Stfld, fieldBuilder); genusSetIL.Emit(OpCodes.Ret); //map get and set to property 'methods' propertyBuilder.SetGetMethod(getPropertyBuilder); propertyBuilder.SetSetMethod(setPropertyBuilder); }
public CodeGen(Stmt stmt, string moduleName) { if (IO.Path.GetFileName(moduleName) != moduleName) { throw new System.Exception("can only output into current directory!"); } Reflect.AssemblyName name = new Reflect.AssemblyName(IO.Path.GetFileNameWithoutExtension(moduleName)); Emit.AssemblyBuilder asmb = System.AppDomain.CurrentDomain.DefineDynamicAssembly(name, Emit.AssemblyBuilderAccess.Save); Emit.ModuleBuilder modb = asmb.DefineDynamicModule(moduleName); Emit.TypeBuilder typeBuilder = modb.DefineType("SC"); Emit.MethodBuilder methb = typeBuilder.DefineMethod("Main", Reflect.MethodAttributes.Static, typeof(void), System.Type.EmptyTypes); // CodeGenerator this.il = methb.GetILGenerator(); this.symbolTable = new Collections.Dictionary <string, Emit.LocalBuilder>(); // Go Compile! this.GenStmt(stmt); this.il.Emit(Emit.OpCodes.Call, typeof(System.Console).GetMethod("ReadLine", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static, null, new System.Type[] { }, null)); this.il.Emit(Emit.OpCodes.Call, typeof(System.Console).GetMethod("WriteLine", new System.Type[] { typeof(string) })); il.Emit(Emit.OpCodes.Ret); typeBuilder.CreateType(); modb.CreateGlobalFunctions(); asmb.SetEntryPoint(methb); asmb.Save(moduleName); this.symbolTable = null; this.il = null; }
private static void CreateProperty(System.Reflection.Emit.TypeBuilder tb, string propertyName, Type propertyType, bool required) { FieldBuilder fieldBuilder = tb.DefineField("_" + propertyName, propertyType, FieldAttributes.Private); PropertyBuilder propertyBuilder = tb.DefineProperty(propertyName, PropertyAttributes.HasDefault, propertyType, null); MethodBuilder getPropMthdBldr = tb.DefineMethod("get_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, propertyType, Type.EmptyTypes); ILGenerator getIl = getPropMthdBldr.GetILGenerator(); getIl.Emit(OpCodes.Ldarg_0); getIl.Emit(OpCodes.Ldfld, fieldBuilder); getIl.Emit(OpCodes.Ret); MethodBuilder setPropMthdBldr = tb.DefineMethod("set_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, null, new[] { propertyType }); ILGenerator setIl = setPropMthdBldr.GetILGenerator(); Label modifyProperty = setIl.DefineLabel(); Label exitSet = setIl.DefineLabel(); setIl.MarkLabel(modifyProperty); setIl.Emit(OpCodes.Ldarg_0); setIl.Emit(OpCodes.Ldarg_1); setIl.Emit(OpCodes.Stfld, fieldBuilder); setIl.Emit(OpCodes.Nop); setIl.MarkLabel(exitSet); setIl.Emit(OpCodes.Ret); Type[] ctorParams = { }; ConstructorInfo contructorInfo = typeof(DataMemberAttribute).GetConstructor(ctorParams); CustomAttributeBuilder customAttrBuilder = new CustomAttributeBuilder(contructorInfo, new object[] { }); //TODO: set IsRequired here ?? propertyBuilder.SetCustomAttribute(customAttrBuilder); propertyBuilder.SetGetMethod(getPropMthdBldr); propertyBuilder.SetSetMethod(setPropMthdBldr); }
private Emit.MethodBuilder GenerateMethod(Emit.TypeBuilder typeBuilder, MethodDeclaration method) { Emit.MethodBuilder methb = typeBuilder.DefineMethod(method.MethodName, Reflect.MethodAttributes.Static, typeof(void), System.Type.EmptyTypes); this.il = methb.GetILGenerator(); this.symbolTable = new Collections.Dictionary <string, Emit.LocalBuilder>(); this.GenStmt(method.stmt); return(methb); }
public static Type BuildPropertyObject(System.Collections.Generic.IEnumerable <System.Collections.Generic.KeyValuePair <string, Type> > obj) { string nameOfDLL = "magic.dll"; string nameOfAssembly = "magic_Assembly"; string nameOfModule = "magic_Module"; string nameOfType = "magic_Type"; System.Reflection.AssemblyName assemblyName = new System.Reflection.AssemblyName { Name = nameOfAssembly }; System.Reflection.Emit.AssemblyBuilder assemblyBuilder = System.Threading.Thread.GetDomain().DefineDynamicAssembly(assemblyName, System.Reflection.Emit.AssemblyBuilderAccess.RunAndSave); System.Reflection.Emit.ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(nameOfModule, nameOfDLL); System.Reflection.Emit.TypeBuilder typeBuilder = moduleBuilder.DefineType(nameOfType, System.Reflection.TypeAttributes.Public | System.Reflection.TypeAttributes.Class); foreach (var prop in obj) { string Name = prop.Key; Type DataType = prop.Value; System.Reflection.Emit.FieldBuilder field = typeBuilder.DefineField("_" + Name, DataType, System.Reflection.FieldAttributes.Private); System.Reflection.Emit.PropertyBuilder propertyBuilder = typeBuilder.DefineProperty(Name, System.Reflection.PropertyAttributes.SpecialName, DataType, null); System.Reflection.MethodAttributes methodAttributes = System.Reflection.MethodAttributes.Public | System.Reflection.MethodAttributes.HideBySig | System.Reflection.MethodAttributes.SpecialName; System.Reflection.Emit.MethodBuilder methodBuilderGetter = typeBuilder.DefineMethod("get_" + Name, methodAttributes, DataType, new Type[] { }); System.Reflection.Emit.MethodBuilder methodBuilderSetter = typeBuilder.DefineMethod("set_" + Name, methodAttributes, typeof(void), new Type[] { DataType }); System.Reflection.Emit.ILGenerator ilGeneratorGetter = methodBuilderGetter.GetILGenerator(); ilGeneratorGetter.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); ilGeneratorGetter.Emit(System.Reflection.Emit.OpCodes.Ldfld, field); ilGeneratorGetter.Emit(System.Reflection.Emit.OpCodes.Ret); System.Reflection.Emit.ILGenerator ilGeneratorSetter = methodBuilderSetter.GetILGenerator(); ilGeneratorSetter.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); ilGeneratorSetter.Emit(System.Reflection.Emit.OpCodes.Ldarg_1); ilGeneratorSetter.Emit(System.Reflection.Emit.OpCodes.Stfld, field); ilGeneratorSetter.Emit(System.Reflection.Emit.OpCodes.Ret); propertyBuilder.SetGetMethod(methodBuilderGetter); propertyBuilder.SetSetMethod(methodBuilderSetter); } // Yes! you must do this, it should not be needed but it is! Type dynamicType = typeBuilder.CreateType(); // Save to file assemblyBuilder.Save(nameOfDLL); return(dynamicType); }
private void AddGetter(System.Reflection.Emit.TypeBuilder typeBuilder, FieldBuilder fieldBuilder, PropertyBuilder propertyBuilder) { MethodBuilder propertyGetter = typeBuilder.DefineMethod("get_" + _propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, _propertyType, Type.EmptyTypes); var ilGenerator = propertyGetter.GetILGenerator(); ilGenerator.Emit(OpCodes.Ldarg_0); ilGenerator.Emit(OpCodes.Ldfld, fieldBuilder); ilGenerator.Emit(OpCodes.Ret); propertyBuilder.SetGetMethod(propertyGetter); }
private void AddSetter(System.Reflection.Emit.TypeBuilder typeBuilder, FieldBuilder fieldBuilder, PropertyBuilder propertyBuilder) { MethodBuilder propertySetter = typeBuilder.DefineMethod("set_" + _propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, null, new Type[] { _propertyType }); var propertySetterIl = propertySetter.GetILGenerator(); propertySetterIl.Emit(OpCodes.Ldarg_0); propertySetterIl.Emit(OpCodes.Ldarg_1); propertySetterIl.Emit(OpCodes.Stfld, fieldBuilder); propertySetterIl.Emit(OpCodes.Ret); propertyBuilder.SetSetMethod(propertySetter); }
private void AddGetter(System.Reflection.Emit.TypeBuilder typeBuilder, PropertyBuilder propertyBuilder) { MethodBuilder propertyGetter = typeBuilder.DefineMethod("get_" + _propertyInfo.Name, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, _propertyInfo.PropertyType, Type.EmptyTypes); var ilGenerator = propertyGetter.GetILGenerator(); ilGenerator.Emit(OpCodes.Ldarg_0); ilGenerator.Emit(OpCodes.Ldfld, _aggregate); MethodInfo getter = _propertyInfo.GetAccessors().First(accessor => accessor.ReturnType != typeof(void)); ilGenerator.Emit(OpCodes.Callvirt, getter); ilGenerator.Emit(OpCodes.Ret); propertyBuilder.SetGetMethod(propertyGetter); }
private void inicializar(string nombreCodigoFuente, string nombrePrograma) { if (TablaDireccionesSimbolos.Count > 0) { throw new System.Exception("ERROR-0002: Tabla de direcciones de variables ha sido inicializada previamente"); } String rutaEjecutable = IO.Path.GetDirectoryName(nombrePrograma); //Describo el identificador unico del ensamblado que se esta generando nombre = new Reflect.AssemblyName(IO.Path.GetFileNameWithoutExtension(nombrePrograma)); //Creo la representacion basica del ensamblado creado de forma dinamica (assembly) if (rutaEjecutable.Length > 0) { asmb = System.AppDomain.CurrentDomain.DefineDynamicAssembly(nombre, Emit.AssemblyBuilderAccess.RunAndSave, rutaEjecutable); } else { asmb = System.AppDomain.CurrentDomain.DefineDynamicAssembly(nombre, Emit.AssemblyBuilderAccess.RunAndSave); } Console.WriteLine("Common Runtime usado para generar el ejecutable del programa: " + asmb.ImageRuntimeVersion); Console.WriteLine("Se esta ejecutando el compilador bajo el CLR version {0}", Environment.Version); //Defino un nuevo modulo de .net de forma dinamica modb = asmb.DefineDynamicModule(IO.Path.GetFileName(nombrePrograma), false); //Creo una nueva clase en el Il Generator stream typeBuilder = modb.DefineType("pseudoGenerado"); //Debido a que los programas en este tiny solo cuentan con un unico metodo principal (Main) de forma estructurada //como un truco defino el metodo Main en un objeto por defecto para ejecutar todas las acciones //expresadas por el lenguaje alli. //formato: NOMBRE -> Main TIPO-> Static RETORNA-> void PARAMETROS-> vacios methb = typeBuilder.DefineMethod("Main", Reflect.MethodAttributes.HideBySig | Reflect.MethodAttributes.Static | Reflect.MethodAttributes.Public, typeof(void), System.Type.EmptyTypes); //Inicializo/Creo el generador/stream de codigo IL con el metodo donde generare el codigo actualmente this.il = methb.GetILGenerator(); //Para iniciar el programa Emito una primera instruccion vacia (no hace nada) il.Emit(Emit.OpCodes.Nop); }
private void AddSetter(System.Reflection.Emit.TypeBuilder typeBuilder, PropertyBuilder propertyBuilder) { MethodBuilder propertySetter = typeBuilder.DefineMethod("set_" + _propertyInfo.Name, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, null, new Type[] { _propertyInfo.PropertyType }); var propertySetterIl = propertySetter.GetILGenerator(); propertySetterIl.Emit(OpCodes.Ldarg_0); propertySetterIl.Emit(OpCodes.Ldfld, _aggregate); propertySetterIl.Emit(OpCodes.Ldarg_1); MethodInfo setter = _propertyInfo.GetAccessors().First(accessor => accessor.ReturnType == typeof(void)); propertySetterIl.Emit(OpCodes.Callvirt, setter); propertySetterIl.Emit(OpCodes.Ret); propertyBuilder.SetSetMethod(propertySetter); }
public Emit.MethodBuilder GenerateCode(MethodDeclaration methodDec) { MethodAttributes methodAttributes = MethodAttributes.Public; if (methodDec.IsStatic) { methodAttributes = methodAttributes | MethodAttributes.Static; } //Type[] types = { typeof(string) }; //Emit.MethodBuilder methb = typeBuilder.DefineMethod(methodDec.MethodName, methodAttributes, typeof(void), types); Emit.MethodBuilder methb = typeBuilder.DefineMethod(methodDec.MethodName, methodAttributes, typeof(void), System.Type.EmptyTypes); child = new CodeGen(methb, methodDec, typefieldList, dllProbeDirectory, this); child.GenerateCode(); return(methb); }
protected override void OnPropertyGenerationComplete(TypeDefinition proxyType) { const string initPropertyWrappersMethodName = "InitPropertyWrappers"; var initPropertyWrappersMethod = proxyType.DefineMethod( initPropertyWrappersMethodName, MethodAttributes.Static | MethodAttributes.Private, null, Type.EmptyTypes); var il = initPropertyWrappersMethod.GetILGenerator(); this.initPropertyWrapperIlAction.ForEach(m => m(il)); il.Emit(OpCodes.Ret); var cctor = proxyType.DefineTypeInitializer(); var cctorIl = cctor.GetILGenerator(); cctorIl.Emit(OpCodes.Call, initPropertyWrappersMethod); cctorIl.Emit(OpCodes.Ret); }
/// <summary> /// CreateMethod /// </summary> /// <param name="methodInfo"></param> /// <param name="typeBuilder"></param> private static void CreateMethod(this MethodInfo methodInfo, System.Reflection.Emit.TypeBuilder typeBuilder) { // Define the method var methodBuilder = typeBuilder.DefineMethod(methodInfo.Name, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.Virtual, methodInfo.ReturnType, methodInfo.GetParameters().Select(parameterInfo => parameterInfo.ParameterType).ToArray()); // The ILGenerator class is used to put op-codes (similar to assembly) into the method // ReSharper disable once InconsistentNaming var IL = methodBuilder.GetILGenerator(); // If there's a return type, create a default value or null to return if (methodInfo.ReturnType != typeof(void)) { var localBuilder = IL.DeclareLocal(methodInfo.ReturnType); // this declares the local object, // int, long, float, ect IL.Emit(OpCodes.Ldloc, localBuilder); // load the value on the stack to return } IL.Emit(OpCodes.Ret); // return // We need to associate our new type's method with the setter method in the interface typeBuilder.DefineMethodOverride(methodBuilder, methodInfo); }
public CodeGen(stmt stmt, string moduleName, int count) { if (IO.Path.GetFileName(moduleName) != moduleName) { throw new System.Exception("can only output into current directory!"); } stmts = stmt; Reflect.AssemblyName name = new Reflect.AssemblyName("FAJF"); //name of the assembly Emit.AssemblyBuilder asmb = System.AppDomain.CurrentDomain.DefineDynamicAssembly(name, Emit.AssemblyBuilderAccess.Save); Emit.ModuleBuilder modb = asmb.DefineDynamicModule(moduleName); Emit.TypeBuilder typeBuilder = modb.DefineType("resister"); //name of the class Emit.MethodBuilder methb = typeBuilder.DefineMethod("Main", Reflect.MethodAttributes.Static, typeof(void), System.Type.EmptyTypes); // CodeGenerator this.il = methb.GetILGenerator(); this.symbolTable = new Collections.Dictionary <string, Emit.LocalBuilder>(); counting = 0; counter = count; counters = 0; // Go Compile! this.GenStmt(stmt); il.Emit(Emit.OpCodes.Ret); typeBuilder.CreateType(); modb.CreateGlobalFunctions(); asmb.SetEntryPoint(methb); asmb.Save(moduleName); // this.il.EmitWriteLine("press any key to continue"); this.symbolTable = null; this.il = null; System.Diagnostics.Process.Start(moduleName); }
/// <summary> /// Generate the declaration for the IgnoresAccessChecksToAttribute type. /// This attribute will be both defined and used in the dynamic assembly. /// Each usage identifies the name of the assembly containing non-public /// types the dynamic assembly needs to access. Normally those types /// would be inaccessible, but this attribute allows them to be visible. /// It works like a reverse InternalsVisibleToAttribute. /// This method returns the ConstructorInfo of the generated attribute. /// </summary> public static ConstructorInfo AddToModule(ModuleBuilder mb) { TypeBuilder attributeTypeBuilder = mb.DefineType("System.Runtime.CompilerServices.IgnoresAccessChecksToAttribute", TypeAttributes.Public | TypeAttributes.Class, typeof(Attribute)); // Create backing field as: // private string assemblyName; FieldBuilder assemblyNameField = attributeTypeBuilder.DefineField("assemblyName", typeof(string), FieldAttributes.Private); // Create ctor as: // public IgnoresAccessChecksToAttribute(string) ConstructorBuilder constructorBuilder = attributeTypeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, new Type[] { assemblyNameField.FieldType }); ILGenerator il = constructorBuilder.GetILGenerator(); // Create ctor body as: // this.assemblyName = {ctor parameter 0} il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldarg, 1); il.Emit(OpCodes.Stfld, assemblyNameField); // return il.Emit(OpCodes.Ret); // Define property as: // public string AssemblyName {get { return this.assemblyName; } } _ = attributeTypeBuilder.DefineProperty( "AssemblyName", PropertyAttributes.None, CallingConventions.HasThis, returnType: typeof(string), parameterTypes: null); MethodBuilder getterMethodBuilder = attributeTypeBuilder.DefineMethod( "get_AssemblyName", MethodAttributes.Public, CallingConventions.HasThis, returnType: typeof(string), parameterTypes: null); // Generate body: // return this.assemblyName; il = getterMethodBuilder.GetILGenerator(); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldfld, assemblyNameField); il.Emit(OpCodes.Ret); // Generate the AttributeUsage attribute for this attribute type: // [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] TypeInfo attributeUsageTypeInfo = typeof(AttributeUsageAttribute).GetTypeInfo(); // Find the ctor that takes only AttributeTargets ConstructorInfo attributeUsageConstructorInfo = attributeUsageTypeInfo.DeclaredConstructors .Single(c => c.GetParameters().Count() == 1 && c.GetParameters()[0].ParameterType == typeof(AttributeTargets)); // Find the property to set AllowMultiple PropertyInfo allowMultipleProperty = attributeUsageTypeInfo.DeclaredProperties .Single(f => string.Equals(f.Name, "AllowMultiple")); // Create a builder to construct the instance via the ctor and property CustomAttributeBuilder customAttributeBuilder = new CustomAttributeBuilder(attributeUsageConstructorInfo, new object[] { AttributeTargets.Assembly }, new PropertyInfo[] { allowMultipleProperty }, new object[] { true }); // Attach this attribute instance to the newly defined attribute type attributeTypeBuilder.SetCustomAttribute(customAttributeBuilder); // Make the TypeInfo real so the constructor can be used. return(attributeTypeBuilder.CreateTypeInfo() !.DeclaredConstructors.Single()); }
public void genMethod(Symbol s) { System.Type[] parameters; System.Type returnType = null; Procedure p = null; //Debemos poner el ret correcto if (this.il != null) { this.il.Emit(Emit.OpCodes.Ret); } if (s is Procedure) { p = (Procedure)s; } if (s is Function) { Function f = (Function)s; returnType = getSystemTypeFormat(f.TypeReturn); p = (Procedure)f; } parameters = new System.Type[p.Parameters.Count]; int i = 0; int cont = p.Parameters.Count; object[] keys = new object[cont]; p.Parameters.Keys.CopyTo(keys, 0); Array.Reverse(keys); for (i = 0; i < cont; i++) { Param param = (Param)p.Parameters[keys[i]]; parameters[i] = getSystemTypeFormat(param.Type); if (param.Reference) { parameters[i] = parameters[i].MakeByRefType(); } } this.methb = typeBuilder.DefineMethod(s.Name, Reflect.MethodAttributes.Public | Reflect.MethodAttributes.Static, returnType, parameters); mbuilderTable.Add(s.Name, methb); this.il = methb.GetILGenerator(); //Local variables if (p.Locales.Count > 0) { Hashtable h = new Hashtable(); foreach (Symbol local in p.Locales.Values) { Emit.LocalBuilder lbuilder = this.il.DeclareLocal(getSystemTypeFormat(local.Type)); h.Add(local.Name, lbuilder); } lbuilderTable.Add(s.Name, h); } }
private MethodBuilder _Compile(FluentMethodBuilder method, int index) { var compiledMethodType = method._Precompile(); MethodAttributes methodAttributes = MethodAttributes.Public; if (method.IsStatic) { methodAttributes |= MethodAttributes.Static; } else { methodAttributes |= MethodAttributes.Virtual; } // the originalParameterTypes don't include a Box<> or ByRef because // they come from a field. Type[] originalParameterTypes; // the parameterTypesForDelegate may have Box<> types. Type[] parameterTypesForDelegate; // the parameterTypesForGeneratedMethod will replace Box<> parameter by ref parameters. Type[] parameterTypesForGeneratedMethod; int parameterCount = method._parameters.Count; int parameterIndex = -1; using (var enumerator = method._parameters.GetEnumerator()) { if (!method.IsStatic) { parameterCount--; enumerator.MoveNext(); } originalParameterTypes = new Type[parameterCount]; parameterTypesForDelegate = new Type[parameterCount]; parameterTypesForGeneratedMethod = new Type[parameterCount]; while (enumerator.MoveNext()) { parameterIndex++; var pair = enumerator.Current; var fieldInfoAndSourcePair = pair.Key; var parameterExpression = pair.Value; var fieldType = fieldInfoAndSourcePair.Key.FieldType; var parameterType = parameterExpression.Type; originalParameterTypes[parameterIndex] = fieldType; parameterTypesForDelegate[parameterIndex] = parameterType; var parameterTypeForGeneratedMethod = fieldType; if (parameterExpression.IsByRef || fieldType != parameterType) { parameterTypeForGeneratedMethod = fieldType.MakeByRefType(); } parameterTypesForGeneratedMethod[parameterIndex] = parameterTypeForGeneratedMethod; } } var methodBuilder = _type.DefineMethod(method.Name, methodAttributes, method.ReturnType, parameterTypesForGeneratedMethod); foreach (var interfaceType in _interfaceTypes) { var methodToOverride = interfaceType.GetMethod(method.Name, originalParameterTypes); if (methodToOverride != null) { _type.DefineMethodOverride(methodBuilder, methodToOverride); } } var methodGenerator = methodBuilder.GetILGenerator(); int count = originalParameterTypes.Length; if (!method.IsStatic) { count++; } if (method._respectVisibility) { if (method.IsStatic) { method._Compile(null, methodBuilder); } else { var allParameterTypes = new Type[parameterTypesForGeneratedMethod.Length + 1]; allParameterTypes[0] = _type; parameterTypesForGeneratedMethod.CopyTo(allParameterTypes, 1); var otherMethod = _type.DefineMethod("." + method._delegateIndex, MethodAttributes.Static, method.ReturnType, allParameterTypes); method._Compile(null, otherMethod); _EmitDirectCall(methodBuilder, otherMethod, allParameterTypes.Length); } } else { methodGenerator.Emit(OpCodes.Ldsfld, _delegatesField); methodGenerator.Emit(OpCodes.Ldc_I4, index); methodGenerator.Emit(OpCodes.Ldelem, compiledMethodType); var locals = new List <LocalBuilder>(); _GeneratePreCall(method, originalParameterTypes, methodGenerator, count, locals, parameterTypesForDelegate); methodGenerator.Emit(OpCodes.Callvirt, compiledMethodType.GetMethod("Invoke")); if (locals.Count > 0) { _GeneratePosCall(method, originalParameterTypes, methodGenerator, count, locals, parameterTypesForDelegate); } methodGenerator.Emit(OpCodes.Ret); } return(methodBuilder); }
private void GenerateProxyMethods(IEnumerable <Type> interfaces, TypeDefinition proxyType) { var methodsExcludingGetters = interfaces .SelectMany(x => x.GetMethods().Except(x.GetProperties().SelectMany(GetPropertyMethods))); foreach (var targetMethod in methodsExcludingGetters) { var baseDef = this.proxyBaseTypeDef; if (BaseTypeHasMatchingPublicMethod(baseDef, targetMethod)) { continue; } var genArgMapping = new Dictionary <Type, Type>(); if (targetMethod.DeclaringType == null) { throw new InvalidOperationException($"{targetMethod} has no declaring type."); } if (targetMethod.DeclaringType.IsGenericType) { var declTypeGenArgs = targetMethod.DeclaringType .GetGenericArguments() .Zip(targetMethod.DeclaringType.GetGenericTypeDefinition().GetGenericArguments(), (a, p) => new { a, p }); foreach (var declTypeGenArg in declTypeGenArgs) { genArgMapping.Add(declTypeGenArg.p, declTypeGenArg.a); } } Func <Type, Type> typeReplacer = t => TypeUtils.ReplaceInGenericArguments(t, x => genArgMapping.SafeGet(x, x)); var parameters = targetMethod.GetParameters(); var paramTypes = parameters.Select(x => x.ParameterType).ToArray(); var method = proxyType.DefineMethod(targetMethod.Name, MethodAttributes.NewSlot | MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.Public, targetMethod.ReturnType, paramTypes); CopyGenericMethodParameters(targetMethod, method, genArgMapping, typeReplacer); AdjustParameterTypes(parameters, typeReplacer, method); var proxyOnGetMethod = baseDef .GetMethods(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public) .FirstOrDefault(x => x.Name == "OnInvokeMethod"); if (proxyOnGetMethod == null) { var message = $"Unable to generate proxy for {targetMethod.GetFullNameWithSignature()} because {baseDef.FullName}.OnInvokeMethod() is missing."; throw new MissingMethodException(message); } GenerateInvokeMethodIl(method, paramTypes, parameters, proxyOnGetMethod); } }
/// <summary> /// Adds a new method to the class, with the given name and method signature. /// </summary> /// <param name="name">The name of the method. name cannot contain embedded nulls. </param> /// <param name="attributes">The attributes of the method. </param> /// <param name="returnType">The return type of the method.</param> /// <param name="parameterTypes">The types of the parameters of the method.</param> /// <returns>The defined method.</returns> public MethodBuilderHelper DefineMethod( string name, MethodAttributes attributes, Type returnType, params Type[] parameterTypes) { return(new MethodBuilderHelper(this, _typeBuilder.DefineMethod(name, attributes, returnType, parameterTypes))); }