public DefineField ( string fieldName, System type, System attributes ) : System.Reflection.Emit.FieldBuilder | ||
fieldName | string | |
type | System | |
attributes | System | |
return | System.Reflection.Emit.FieldBuilder |
private void DefineClassVaribale(Emit.TypeBuilder typeBuilder, TypeDeclaration _type) { fieldList = new Dictionary <string, Emit.FieldBuilder>(); Emit.FieldBuilder classVariable; foreach (KeyValuePair <string, Type> para in _type.instanceVariable) { classVariable = typeBuilder.DefineField(para.Key, para.Value, FieldAttributes.Private); fieldList.Add(para.Key, classVariable); } foreach (KeyValuePair <string, Type> para in _type.classVariable) { classVariable = typeBuilder.DefineField(para.Key, para.Value, FieldAttributes.Private | FieldAttributes.Static); fieldList.Add(para.Key, classVariable); } //mthdIL.Emit(OpCodes.Ldarg_0); //mthdIL.Emit(OpCodes.Ldarg_0); //mthdIL.Emit(OpCodes.Ldfld, balanceAmtBldr); //mthdIL.Emit(OpCodes.Ldarg_2); //mthdIL.Emit(OpCodes.Add); }
public BFMemory(TypeBuilder typeBuilder) { PointerFieldBuilder = typeBuilder.DefineField("pointer", typeof(short), FieldAttributes.Static | FieldAttributes.Private); MemoryFieldBuilder = typeBuilder.DefineField("memory", typeof(byte[]), FieldAttributes.Static | FieldAttributes.Private); var staticConstructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Static,CallingConventions.Standard, null); GenerateStaticConstructorBody(staticConstructorBuilder.GetILGenerator()); }
public ProxyClassFieldCache(TypeBuilder typeBuilder) { this.typeBuilder = typeBuilder; manualCodecFields = new Dictionary<Type, FieldBuilder>(); Processor = typeBuilder.DefineField("methodCallProcessor", typeof(IOutgoingRequestProcessor), FieldAttributes.Private | FieldAttributes.InitOnly); Scope = typeBuilder.DefineField("scope", typeof(string), FieldAttributes.Private | FieldAttributes.InitOnly); TimeoutSettings = typeBuilder.DefineField("timeoutSettings", typeof(TimeoutSettings), FieldAttributes.Private | FieldAttributes.InitOnly); CodecContainer = typeBuilder.DefineField("codecContainer", typeof(ICodecContainer), FieldAttributes.Private | FieldAttributes.InitOnly); }
private void ImplementInterfaceProperties(Type interfaceOfTypeToCreate, System.Reflection.Emit.TypeBuilder typeBuilder) { typeBuilder.AddInterfaceImplementation(interfaceOfTypeToCreate); foreach (var implementedInterfaceType in interfaceOfTypeToCreate.GetInterfaces()) { ImplementInterfaceProperties(implementedInterfaceType, typeBuilder); } foreach (var pi in interfaceOfTypeToCreate.GetProperties()) { var backingFieldBuilder = typeBuilder.DefineField($"{interfaceOfTypeToCreate.Name}._{ToCamelCase(pi.Name)}", pi.PropertyType, FieldAttributes.Private); var accessorAttributes = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.Virtual | MethodAttributes.HideBySig; var mbGetAccessor = typeBuilder.DefineMethod($"get_{pi.Name}", accessorAttributes, pi.PropertyType, Type.EmptyTypes); var mbGetIL = mbGetAccessor.GetILGenerator(); mbGetIL.Emit(OpCodes.Ldarg_0); mbGetIL.Emit(OpCodes.Ldfld, backingFieldBuilder); mbGetIL.Emit(OpCodes.Ret); var mbSetAccessor = typeBuilder.DefineMethod($"set_{pi.Name}", accessorAttributes, null, new[] { pi.PropertyType }); var mbSetIL = mbSetAccessor.GetILGenerator(); mbSetIL.Emit(OpCodes.Ldarg_0); mbSetIL.Emit(OpCodes.Ldarg_1); mbSetIL.Emit(OpCodes.Stfld, backingFieldBuilder); mbSetIL.Emit(OpCodes.Ret); var propertyBuilder = typeBuilder.DefineProperty(pi.Name, PropertyAttributes.HasDefault, pi.PropertyType, null); propertyBuilder.SetGetMethod(mbGetAccessor); propertyBuilder.SetSetMethod(mbSetAccessor); } }
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); }
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); }
public void CreateDynamicMethod() { #if SAVE_ASSEMBLY if (_assemblyBuilder == null) { AssemblyName assemblyName = new AssemblyName("ExpressionAssembly"); _assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave, "I:\\Trash"); _moduleBuilder = _assemblyBuilder.DefineDynamicModule("ExpressionModule", "ExpressionModule.module"); } string typeName = String.Format("Expression{0}", _typeCount); _typeCount++; _typeBuilder = _moduleBuilder.DefineType(typeName, TypeAttributes.Class | TypeAttributes.Public); FieldBuilder filedBuilder = _typeBuilder.DefineField("Source", typeof(string), FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.Literal); filedBuilder.SetConstant(_source); _methodBuilder = _typeBuilder.DefineMethod("Evaluate", MethodAttributes.Public | MethodAttributes.Static, typeof(object), new Type[] { typeof(object[]) }); _ilGenerator = _methodBuilder.GetILGenerator(); #else _dynamicMethod = new DynamicMethod("Expression", typeof(object), new Type[] { typeof(object[]) }, GetType().Module); _ilGenerator = _dynamicMethod.GetILGenerator(); #endif }
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); }
public void genVariable(Symbol s) { Emit.FieldBuilder fbuilder = typeBuilder.DefineField(s.Name, getSystemTypeFormat(s.Type), Reflect.FieldAttributes.Private | Reflect.FieldAttributes.Static); fbuilderTable.Add(s.Name, fbuilder); }
/// <summary> /// CreateProperty /// </summary> /// <param name="pi"></param> /// <param name="methods"></param> /// <param name="typeBuilder"></param> /// <param name="privateSetters"></param> private static FieldBuilder CreateProperty(this PropertyInfo pi, ICollection <MethodInfo> methods, System.Reflection.Emit.TypeBuilder typeBuilder, bool privateSetters) { // Create underlying field; all properties have a field of the same type var backingField = typeBuilder.DefineField($"<{pi.Name}>k_BackingField", pi.PropertyType, FieldAttributes.Private); // Attribute: // [CompilerGenerated] var compilerGeneratedAttr = typeof(CompilerGeneratedAttribute).GetConstructor(Type.EmptyTypes); if (compilerGeneratedAttr != null) { // ReSharper disable once InconsistentNaming var fieldCABuilder = new CustomAttributeBuilder(compilerGeneratedAttr, new object[] { }); backingField.SetCustomAttribute(fieldCABuilder); } // 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 an array with no elements: new Type[] {}) var propBldr = typeBuilder.DefineProperty(pi.Name, PropertyAttributes.HasDefault, CallingConventions.HasThis, pi.PropertyType, Type.EmptyTypes); var container = new BuilderData { _typeBuilder = typeBuilder, _fieldBuilder = backingField, _propertyBuilder = propBldr }; // Disregard exceptions so that the custom defined properties can be used with the same algorithms even though their backing methods have not yet been defined. MethodInfo getter = null, setter = null; try { getter = pi.GetGetMethod(); setter = pi.GetSetMethod(); } catch (Exception) { // ignored } var jmpTable = new Dictionary <Instr, KeyValuePair <MethodInfo, PropertyType> > { { Instr.Getter, new KeyValuePair <MethodInfo, PropertyType>(getter, GetProperty) }, { Instr.Setter, new KeyValuePair <MethodInfo, PropertyType>(setter, SetProperty) } }; foreach (var z in jmpTable) { if (z.Key == Instr.Setter && privateSetters) { container._methodAttributes = MethodAttributes.Private | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Virtual; } // If there is a getter in the interface, create a getter in the new type if (pi.ReflectedType != null) { if (z.Value.Key != null) { methods.Remove(z.Value.Key); } } z.Value.Value(z.Value.Key, container); } return(backingField); }
private static void CreateProperty(System.Reflection.Emit.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); }
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; }
internal static Dictionary<string, FieldBuilder> Build(TypeBuilder proxyBuilder, Type proxyType) { return new Dictionary<string, FieldBuilder> { { ProxyFieldBuilder.InvokeHandlerField, proxyBuilder.DefineField( ProxyFieldBuilder.InvokeHandlerField, typeof(IInvocationHandler[]), FieldAttributes.Private) }, { ProxyFieldBuilder.WrappedObjectField, proxyBuilder.DefineField( ProxyFieldBuilder.WrappedObjectField, proxyType, FieldAttributes.Private) } }; }
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); }
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; }
/// <summary> /// Adds a new field to the class, with the given name, attributes and field type. /// </summary> /// <param name="fieldName">The name of the field. <paramref name="fieldName"/> cannot contain embedded nulls.</param> /// <param name="type">The type of the field.</param> /// <param name="attributes">The attributes of the field.</param> /// <returns>The defined field.</returns> public FieldBuilder DefineField( string fieldName, Type type, FieldAttributes attributes) { return(_typeBuilder.DefineField(fieldName, type, attributes)); }
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 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); }
private void CreateProperty(TypeBuilder a_TypeBuilder, string a_PropertyName, Type a_PropertyType) { FieldBuilder fieldBuilder = a_TypeBuilder.DefineField("_" + a_PropertyName, a_PropertyType, FieldAttributes.Private); PropertyBuilder propertyBuilder = a_TypeBuilder.DefineProperty(a_PropertyName, PropertyAttributes.HasDefault, a_PropertyType, null); MethodBuilder getPropMthdBldr = a_TypeBuilder.DefineMethod("get_" + a_PropertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, a_PropertyType, Type.EmptyTypes); ILGenerator getIl = getPropMthdBldr.GetILGenerator(); // Load the current instance onto the stack getIl.Emit(OpCodes.Ldarg_0); // Loads the value of the field specified as parameter from the object on the stack getIl.Emit(OpCodes.Ldfld, fieldBuilder); // Returns the method and pushes the get value onto the caller's stack getIl.Emit(OpCodes.Ret); MethodBuilder setPropMthdBldr = a_TypeBuilder.DefineMethod("set_" + a_PropertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, null, new[] { a_PropertyType }); ILGenerator setIl = setPropMthdBldr.GetILGenerator(); // Load the current instance onto the stack setIl.Emit(OpCodes.Ldarg_0); // Load the first argument, which is the assignment value onto the stack setIl.Emit(OpCodes.Ldarg_1); // Store the value currently on the stack in the field specified as parameter in the object on the stack setIl.Emit(OpCodes.Stfld, fieldBuilder); // Returns the setter setIl.Emit(OpCodes.Ret); propertyBuilder.SetGetMethod(getPropMthdBldr); propertyBuilder.SetSetMethod(setPropMthdBldr); }
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 AbstractProxyBuilder(ModuleBuilder moduleBuilder, string className, Type interfaceType, Type innerType) { Verify.ArgumentNotNull(moduleBuilder, "moduleBuilder"); Verify.ArgumentNotNull(className, "className"); Verify.ArgumentNotNull(interfaceType, "interfaceType"); Verify.ArgumentNotNull(innerType, "innerType"); if (!interfaceType.IsInterface) { throw new ArgumentException("must be an interface type", "interfaceType"); } _errorMessages = new List<string>(); _moduleBuilder = moduleBuilder; _className = className; _interfaceType = interfaceType; _innerType = innerType; _typeBuilder = _moduleBuilder.DefineType( _className, TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit | TypeAttributes.AutoLayout, typeof(object), new Type[] {_interfaceType}); _innerFieldBuilder = _typeBuilder.DefineField("inner", _innerType, FieldAttributes.Private); }
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); }
/// <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; }
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; }
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 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 CreateProperty(TypeBuilder tb, string propertyName, Type propertyType) { FieldBuilder fieldBuilder = tb.DefineField("_" + propertyName, propertyType, FieldAttributes.Private); PropertyBuilder propertyBuilder = tb.DefineProperty( propertyName, System.Reflection.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 Type[] { propertyType }); ILGenerator setIL = setPropMthdBldr.GetILGenerator(); setIL.Emit(OpCodes.Ldarg_0); setIL.Emit(OpCodes.Ldarg_1); setIL.Emit(OpCodes.Stfld, fieldBuilder); setIL.Emit(OpCodes.Ret); propertyBuilder.SetGetMethod(getPropMthdBldr); propertyBuilder.SetSetMethod(setPropMthdBldr); }
private static void CreateProperty(TypeBuilder typeBuilder, string name, Type type) { var fieldBuilder = typeBuilder.DefineField("_" + name.ToLower(), type, FieldAttributes.Private); var propertyBuilder = typeBuilder.DefineProperty(name, PropertyAttributes.HasDefault, type, null); propertyBuilder.SetGetMethod(CreateGetMethod(typeBuilder, fieldBuilder, name, type)); propertyBuilder.SetSetMethod(CreateSetMethod(typeBuilder, fieldBuilder, name, type)); }
protected virtual unsafe FieldBuilder DefineField(TypeBuilder typeBuilder, BCSYM_Variable* pField) { string fieldName = new string(*((char**) (pField + 12))); BCSYM* pSymbol = BCSYM.DigThroughNamedType(*((BCSYM* modopt(IsConst) modopt(IsConst)*) (pField + 80))); Type type = this.GetType(typeBuilder, pSymbol); FieldAttributes fieldAttributes = GetFieldAttributes(pField); return typeBuilder.DefineField(fieldName, type, fieldAttributes); }
private void BuildFields(TypeBuilder typeBuilder) { foreach (string str in this._parser.SymbolTable.Variables.Keys) { FieldInfo info = typeBuilder.DefineField(str, typeof(Primitive), FieldAttributes.Static | FieldAttributes.Private); this._currentScope.Fields.Add(str, info); } }
private void CreateFields(Type sourceType, TypeBuilder typeBuilder) { var fieldMap = SnapshotableField.GetMap(sourceType); foreach (var pair in fieldMap) { typeBuilder.DefineField(pair.Key, pair.Value.FieldType, FieldAttributes.Public); } }
internal EnumBuilder (ModuleBuilder mb, string name, TypeAttributes visibility, Type underlyingType) { _tb = new TypeBuilder (mb, name, (visibility | TypeAttributes.Sealed), typeof(Enum), null, PackingSize.Unspecified, 0, null); _underlyingType = underlyingType; _underlyingField = _tb.DefineField ("value__", underlyingType, (FieldAttributes.SpecialName | FieldAttributes.Private | FieldAttributes.RTSpecialName)); setup_enum_type (_tb); }
private EnumeratorCompiler(Type t, ModuleBuilder module) { var et = typeof(IEnumerator<>).MakeGenericType(t); _tBuilder = module.DefineType("DbEnumerator_" + t.Name, TypeAttributes.Class | TypeAttributes.Public, null, new[] { et }); _fldCls = _tBuilder.DefineField("_cols", typeof(int[]), FieldAttributes.Private); _fldCur = _tBuilder.DefineField("_current", t, FieldAttributes.Private); _fldRdr = _tBuilder.DefineField("_rdr", t, FieldAttributes.Private); var fields = new List<PropertyInfo>(); foreach (var member in t.GetMembers()) { if (!(member is PropertyInfo)) continue; var property = (PropertyInfo) member; if (property.CanWrite && property.GetSetMethod().IsPublic) fields.Add(property); } _fields = fields.ToArray(); }
public InjectedTypeBuilder(TypeBuilder typeBuilder) { if (typeBuilder == null) throw new ArgumentNullException("typeBuilder"); _typeBuilder = typeBuilder; _injectionSetField = typeBuilder.DefineField("_injectionSet", typeof(InjectionSet), FieldAttributes.Private | FieldAttributes.InitOnly); }
private static FieldBuilder GenerateField(TypeBuilder typeBuilder, FieldMetadata fieldMetadata) { var field = typeBuilder.DefineField( fieldMetadata.Name, fieldMetadata.FieldType, fieldMetadata.FieldAttributes); return field; }
public virtual void Implement(TypeBuilder typeBuilder, Action<FieldBuilder, bool> registerField) { // Add instance field to store IEntityWrapper instance // The field is typed as object, for two reasons: // 1. The practical one, IEntityWrapper is internal and not accessible from the dynamic assembly. // 2. We purposely want the wrapper field to be opaque on the proxy type. var wrapperField = typeBuilder.DefineField(EntityProxyTypeInfo.EntityWrapperFieldName, typeof(object), FieldAttributes.Public); registerField(wrapperField, false); }
/// <summary> /// Adds a new field to this type. You should give an expression that access a local /// variable, as this will be marked as the local variable that represents the field /// in all other calls. /// </summary> public void AddField <T>(string fieldName, Expression <Func <T> > expression) { if (fieldName == null) { throw new ArgumentNullException("fieldName"); } if (expression == null) { throw new ArgumentNullException("expression"); } var body = expression.Body; if (body.NodeType != ExpressionType.MemberAccess) { throw new ArgumentException("A call to AddField must access a local variable of your code to work properly."); } _CheckUncompiled(); MemberExpression memberExpression = (MemberExpression)body; MemberInfo member = memberExpression.Member; if (member.MemberType != MemberTypes.Field) { throw new ArgumentException("A call to AddField must access a local variable of your code to work properly."); } object source = null; Expression untypedSource = memberExpression.Expression; if (untypedSource != null) { if (untypedSource.NodeType != ExpressionType.Constant) { throw new ArgumentException("A call to AddField must access a local variable of your code to work properly."); } var sourceExpression = (ConstantExpression)untypedSource; source = sourceExpression.Value; } var field = (FieldInfo)member; object fieldValue = field.GetValue(source); if (!EqualityComparer <T> .Default.Equals((T)fieldValue, default(T))) { throw new ArgumentException("The local variable used to declare a field must have its default value at this moment."); } var fieldBuilder = _type.DefineField(fieldName, field.FieldType, FieldAttributes.Private); _fields.Add(new KeyValuePair <FieldInfo, object>(field, source), new KeyValuePair <MemberExpression, string>(null, fieldName)); }
private static void CreateProperty(System.Reflection.Emit.TypeBuilder tb, string propertyName, Type propertyType, bool required) { if (propertyType.IsByRef) { //avoids an exception in code below when by ref parameters are used propertyType = propertyType.GetElementType(); } 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); }
/// <summary>把lcpi参数里的属性加入到myTypeBuilder中。注意:该操作会将其它成员清除掉,其功能有待完善。</summary> /// <param name="typeBuilder">类型构造器的实例。</param> /// <param name="cpis">里面包含属性列表的信息。</param> private static void AddPropertyToTypeBuilder(System.Reflection.Emit.TypeBuilder typeBuilder, List <CustPropertyInfo> cpis) { PropertyBuilder custNamePropBldr; MethodBuilder custNameGetPropMthdBldr; MethodBuilder custNameSetPropMthdBldr; MethodAttributes getSetAttr; ILGenerator custNameGetIL; ILGenerator custNameSetIL; // 属性Set和Get方法要一个专门的属性。这里设置为Public。 getSetAttr = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig; // 添加属性到myTypeBuilder。 foreach (CustPropertyInfo cpi in cpis) { // 定义字段。 FieldBuilder customerNameBldr = typeBuilder.DefineField(cpi.FieldName, Type.GetType(cpi.Type), FieldAttributes.Private); customerNameBldr.SetConstant("11111111"); // 定义属性。 最后一个参数为null,因为属性没有参数。 custNamePropBldr = typeBuilder.DefineProperty(cpi.PropertyName, PropertyAttributes.HasDefault, Type.GetType(cpi.Type), null); custNamePropBldr.SetConstant("111111111"); // 定义Get方法。 custNameGetPropMthdBldr = typeBuilder.DefineMethod(cpi.GetPropertyMethodName, getSetAttr, Type.GetType(cpi.Type), Type.EmptyTypes); custNameGetIL = custNameGetPropMthdBldr.GetILGenerator(); try { custNameGetIL.Emit(OpCodes.Ldarg_0); //custNameGetIL.Emit(OpCodes.Ldfld, customerNameBldr); custNameGetIL.Emit(OpCodes.Ldfld, customerNameBldr); custNameGetIL.Emit(OpCodes.Ret); } catch { } //定义Set方法。 custNameSetPropMthdBldr = typeBuilder.DefineMethod(cpi.SetPropertyMethodName, getSetAttr, null, new Type[] { Type.GetType(cpi.Type) }); custNameSetIL = custNameSetPropMthdBldr.GetILGenerator(); custNameSetIL.Emit(OpCodes.Ldarg_0); custNameSetIL.Emit(OpCodes.Ldarg_1); custNameSetIL.Emit(OpCodes.Stfld, customerNameBldr); custNameSetIL.Emit(OpCodes.Ret); //custNamePropBldr.SetConstant("ceshi"); //把创建的两个方法(Get,Set)加入到PropertyBuilder中。 custNamePropBldr.SetGetMethod(custNameGetPropMthdBldr); custNamePropBldr.SetSetMethod(custNameSetPropMthdBldr); } }
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); }
/// <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().Length == 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 override void CreateDeclarations(System.Reflection.Emit.TypeBuilder typeBuilder) { this.Field = typeBuilder.DefineField(this.MemberName, this.MemberType, FieldAttributes.Private); }
/// <summary> /// Creates a new fluent type builder using the given name, telling if the /// generated type will be collectible (if you use the other overloads, /// this value is true) and optionally telling which interfaces should be /// implemented. /// </summary> public FluentTypeBuilder(string name, bool isCollectible, params Type[] interfaceTypes) { _delegatesExpression = () => _delegates; _creatorThreadId = Thread.CurrentThread.ManagedThreadId; _isCollectible = isCollectible; Type baseType; HashSet <Type> allInterfaces = new HashSet <Type>(); if (typeof(TBase).IsInterface) { baseType = typeof(object); allInterfaces.Add(typeof(TBase)); } else { baseType = typeof(TBase); } foreach (var interfaceType in typeof(TBase).GetInterfaces()) { allInterfaces.Add(interfaceType); } if (interfaceTypes != null) { foreach (var interfaceType in interfaceTypes) { if (interfaceType == null) { throw new ArgumentException("interfaceTypes can't contain null values.", "interfaceTypes"); } if (!interfaceType.IsInterface) { throw new ArgumentException("interfaceTypes can't contain non-interface types.", "interfaceTypes"); } if (!interfaceType.IsVisible) { throw new ArgumentException("interfaceTypes must only contain visible interfaces (public interfaces declared directly in namespaces or inside other public types).", "interfaceTypes"); } allInterfaces.Add(interfaceType); foreach (var baseInterface in interfaceType.GetInterfaces()) { allInterfaces.Add(baseInterface); } } } AssemblyBuilderAccess access = AssemblyBuilderAccess.Run; if (isCollectible) { access = AssemblyBuilderAccess.RunAndCollect; } _interfaceTypes = allInterfaces.ToArray(); var assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(name), access); var module = assembly.DefineDynamicModule(name); _type = module.DefineType(name, TypeAttributes.NotPublic, baseType, _interfaceTypes); _type.DefineDefaultConstructor(MethodAttributes.Public); _delegatesField = _type.DefineField(".delegates", typeof(Delegate[]), FieldAttributes.Private | FieldAttributes.Static); }