// private ParameterInfo[] indexParameters; public PropertyEmitter(AbstractTypeEmitter parentTypeEmitter, String name, PropertyAttributes attributes, Type propertyType) { this.parentTypeEmitter = parentTypeEmitter; builder = parentTypeEmitter.TypeBuilder.DefineProperty(name, attributes, propertyType, new Type[0]); }
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); }
// private ParameterInfo[] indexParameters; public PropertyEmitter(AbstractTypeEmitter parentTypeEmitter, string name, PropertyAttributes attributes, Type propertyType, Type[] arguments) { this.parentTypeEmitter = parentTypeEmitter; // DYNPROXY-73 - AmbiguousMatchException for properties // This is a workaround for a framework limitation in CLR 2.0 // This limitation was removed in CLR 2.0 SP1, but we don't want to // tie ourselves to that version. This perform the lookup for the new overload // dynamically, so we have a nice fallback on vanilla CLR 2.0 if (TypeBuilderMethods.DefineProperty == null || true) // TODO { DefineProperty_Clr2_0 oldDefineProperty = parentTypeEmitter.TypeBuilder.DefineProperty; builder = oldDefineProperty(name, attributes, propertyType, arguments); } else { var newDefinedProperty = (DefineProperty_Clr_2_0_SP1) Delegate.CreateDelegate(typeof(DefineProperty_Clr_2_0_SP1), parentTypeEmitter.TypeBuilder, TypeBuilderMethods.DefineProperty); builder = newDefinedProperty( name, attributes, CallingConventions.HasThis, propertyType, null, null, arguments, null, null); } }
static MethodBuilder CreateNewInstanceGetter(TypeBuilder typeBuilder, PropertyBuilder property, ConstructorInfo constructor, MethodAttributes accessRights) { var getterMethod = CodeGenerationUtils.GetterMethodFor(typeBuilder, property, accessRights); CodeGenerationUtils.ReturnNewInstanceILInstructions(constructor, getterMethod); return getterMethod; }
internal static MethodBuilder GetterMethodFor(TypeBuilder typeBuilder, PropertyBuilder property, MethodAttributes access) { var getterMethod = typeBuilder.DefineMethod("get_" + property.Name, access, property.PropertyType, null); property.SetGetMethod(getterMethod); return getterMethod; }
public PropertyEmitter(AbstractTypeEmitter parentTypeEmitter, string name, PropertyAttributes attributes, Type propertyType, Type[] arguments) { this.parentTypeEmitter = parentTypeEmitter; builder = parentTypeEmitter.TypeBuilder.DefineProperty( name, attributes, CallingConventions.HasThis, propertyType, null, null, arguments, null, null); }
void LockSignature() { if (pb == null) { indexParameters.Lock(); pb = owner.TypeBuilder.DefineProperty(interfaceType == null ? name : interfaceType.FullName + "." + name, PropertyAttributes.None, type, indexParameters.TypeArray); owner.RegisterForCompletion(this); } }
private void BuildSetter(TypeBuilder typeBuilder, PropertyInfo contractProperty, PropertyBuilder builder) { var setMethod = contractProperty.GetSetMethod(); if (null != setMethod) { var setMethodBuilder = new ProxyMethodImplementationStrategy().BuildMethodProxy(typeBuilder, setMethod); builder.SetSetMethod(setMethodBuilder); } }
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); }
/// <summary> /// Creates the get method. /// </summary> /// <param name="typeBuilder">The type builder.</param> /// <param name="prop">The prop.</param> /// <param name="fieldBuilder">The field builder.</param> /// <param name="propBuilder">The prop builder.</param> private static void CreateGetMethod(TypeBuilder typeBuilder, PropertyInfo prop, FieldInfo fieldBuilder, PropertyBuilder propBuilder) { var getMethodBuilder = typeBuilder.DefineMethod( "get_" + prop.Name, GetSetAttributes, prop.PropertyType, Type.EmptyTypes); var getIl = getMethodBuilder.GetILGenerator(); getIl.Emit(OpCodes.Ldarg_0); getIl.Emit(OpCodes.Ldfld, fieldBuilder); getIl.Emit(OpCodes.Ret); propBuilder.SetGetMethod(getMethodBuilder); }
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); }
protected virtual void OnGeneratePropertyMethods( PropertyInfo targetProp, PropertyDefinition proxyProp, TypeReference proxyBaseType, TypeReference proxyTargetType, TypeReference rootProxyTargetType) { if (this.onGeneratePropertyMethodsFunc == null) { throw new InvalidOperationException( "Either onGenerateMethodsFunc must be provided in argument, or OnGenerateMethods must be overrided"); } this.onGeneratePropertyMethodsFunc(targetProp, proxyProp, proxyBaseType, proxyTargetType); }
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 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); }
/// <summary> /// Creates the set method. /// </summary> /// <param name="typeBuilder">The type builder.</param> /// <param name="prop">The prop.</param> /// <param name="fieldBuilder">The field builder.</param> /// <param name="propBuilder">The prop builder.</param> private static void CreateSetMethod(TypeBuilder typeBuilder, PropertyInfo prop, FieldInfo fieldBuilder, PropertyBuilder propBuilder) { var setMethodBuilder = typeBuilder.DefineMethod( "set_" + prop.Name, GetSetAttributes, null, new[] { prop.PropertyType }); var setIl = setMethodBuilder.GetILGenerator(); setIl.Emit(OpCodes.Ldarg_0); setIl.Emit(OpCodes.Ldarg_1); setIl.Emit(OpCodes.Stfld, fieldBuilder); setIl.Emit(OpCodes.Ret); propBuilder.SetSetMethod(setMethodBuilder); }
/// <summary> /// Creates the getter. /// </summary> /// <param name="typeBuilder">The type builder.</param> /// <param name="propertyBuilder">The property builder.</param> /// <param name="column">The column.</param> private static void CreateGetter(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, SLDataColumn column) { var getMethodBuilder = typeBuilder.DefineMethod( "get_" + column.ColumnName, MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName, CallingConventions.HasThis, column.DataType, Type.EmptyTypes); var getMethodIL = getMethodBuilder.GetILGenerator(); getMethodIL.Emit(OpCodes.Ldarg_0); getMethodIL.Emit(OpCodes.Ldstr, column.ColumnName); getMethodIL.Emit(OpCodes.Callvirt, GetValueMethod.MakeGenericMethod(column.DataType)); getMethodIL.Emit(OpCodes.Ret); propertyBuilder.SetGetMethod(getMethodBuilder); }
private static void CreateGetter(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, IPropertyInfo propertyInfo) { MethodBuilder getMethodBuilder = typeBuilder.DefineMethod( "get_" + propertyInfo.PropertyName, MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName, CallingConventions.HasThis, propertyInfo.PropertyType, Type.EmptyTypes); ILGenerator getMethodIL = getMethodBuilder.GetILGenerator(); getMethodIL.Emit(OpCodes.Ldarg_0); getMethodIL.Emit(OpCodes.Ldstr, propertyInfo.PropertyName); getMethodIL.Emit(OpCodes.Callvirt, GetValueMethod.MakeGenericMethod(propertyInfo.PropertyType)); getMethodIL.Emit(OpCodes.Ret); propertyBuilder.SetGetMethod(getMethodBuilder); }
private static void CreateSetter(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, DataColumn column) { var setMethodBuilder = typeBuilder.DefineMethod( "set_" + column.ColumnName, MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName, CallingConventions.HasThis, null, new[] { column.DataType }); var setMethodIL = setMethodBuilder.GetILGenerator(); setMethodIL.Emit(OpCodes.Ldarg_0); setMethodIL.Emit(OpCodes.Ldstr, column.ColumnName); setMethodIL.Emit(OpCodes.Ldarg_1); setMethodIL.Emit(OpCodes.Callvirt, SetValueMethod.MakeGenericMethod(column.DataType)); setMethodIL.Emit(OpCodes.Ret); propertyBuilder.SetSetMethod(setMethodBuilder); }
private static void CreateSetter(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, IPropertyInfo propertyInfo) { MethodBuilder setMethodBuilder = typeBuilder.DefineMethod( "set_" + propertyInfo.PropertyName, MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName, CallingConventions.HasThis, null, new[] { propertyInfo.PropertyType }); ILGenerator setMethodIL = setMethodBuilder.GetILGenerator(); setMethodIL.Emit(OpCodes.Ldarg_0); setMethodIL.Emit(OpCodes.Ldstr, propertyInfo.PropertyName); setMethodIL.Emit(OpCodes.Ldarg_1); setMethodIL.Emit(OpCodes.Callvirt, SetValueMethod.MakeGenericMethod(propertyInfo.PropertyType)); setMethodIL.Emit(OpCodes.Ret); propertyBuilder.SetSetMethod(setMethodBuilder); }
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); }
public static Type BuildDynamicTypeWithProperties(string classname, Dictionary <string, Type> properties) { AppDomain myDomain = Thread.GetDomain(); AssemblyName myAsmName = Assembly.GetExecutingAssembly().GetName(); AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.RunAndCollect); ModuleBuilder myModBuilder = myAsmBuilder.DefineDynamicModule(myAsmName.Name); MethodAttributes getSetAttr = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig; TypeBuilder typebuilder = myModBuilder.DefineType(classname, TypeAttributes.Public); foreach (var propertie in properties) { FieldBuilder fieldbuilder = typebuilder.DefineField(propertie.Key.ToLower(), propertie.Value, FieldAttributes.Private); System.Reflection.Emit.PropertyBuilder getsetbuilder = typebuilder.DefineProperty(propertie.Key, PropertyAttributes.HasDefault, propertie.Value, null); //Define the "get" accessor method MethodBuilder getmethodbuilder = typebuilder.DefineMethod(string.Format("get_{0}", propertie.Key), getSetAttr, propertie.Value, Type.EmptyTypes); ILGenerator getil = getmethodbuilder.GetILGenerator(); getil.Emit(OpCodes.Ldarg_0); getil.Emit(OpCodes.Ldfld, fieldbuilder); getil.Emit(OpCodes.Ret); //Define the "set" accessor method MethodBuilder setmethodbuilder = typebuilder.DefineMethod(string.Format("set_{0}", propertie.Key), getSetAttr, null, new Type[] { propertie.Value }); ILGenerator setil = setmethodbuilder.GetILGenerator(); setil.Emit(OpCodes.Ldarg_0); setil.Emit(OpCodes.Ldarg_1); setil.Emit(OpCodes.Stfld, fieldbuilder); setil.Emit(OpCodes.Ret); //Add get/set getsetbuilder.SetGetMethod(getmethodbuilder); getsetbuilder.SetSetMethod(setmethodbuilder); } return(typebuilder.CreateType()); }
// private ParameterInfo[] indexParameters; public PropertyEmitter(AbstractTypeEmitter parentTypeEmitter, string name, PropertyAttributes attributes, Type propertyType, Type[] arguments) { this.parentTypeEmitter = parentTypeEmitter; // DYNPROXY-73 - AmbiguousMatchException for properties // This is a workaround for a framework limitation in CLR 2.0 // This limitation was removed in CLR 2.0 SP1, but we don't want to // tie ourselves to that version. This perform the lookup for the new overload // dynamically, so we have a nice fallback on vanilla CLR 2.0 // @mbrit - 2012-05-30 - it appears in WinRT, the old version works OK... new version is baffling... #if !NETFX_CORE bool isWinRt = false; #else bool isWinRt = true; #endif if (TypeBuilderMethods.DefineProperty == null || isWinRt) { DefineProperty_Clr2_0 oldDefineProperty = parentTypeEmitter.TypeBuilder.DefineProperty; builder = oldDefineProperty(name, attributes, propertyType, arguments); } else { #if !NETFX_CORE var newDefinedProperty = (DefineProperty_Clr_2_0_SP1) Delegate.CreateDelegate(typeof(DefineProperty_Clr_2_0_SP1), parentTypeEmitter.TypeBuilder, TypeBuilderMethods.DefineProperty); builder = newDefinedProperty( name, attributes, CallingConventions.HasThis, propertyType, null, null, arguments, null, null); #endif } }
/// <summary> /// Given a custom attribute and property builder, adds an instance of custom attribute /// to the property builder /// </summary> void AddCustomAttributeToProperty(object customAttribute, PropertyBuilder propBuilder) { var customAttributeBuilder = BuildCustomAttribute(customAttribute); if (customAttributeBuilder != null) { propBuilder.SetCustomAttribute(customAttributeBuilder); } }
protected override void OnGeneratePropertyMethods(PropertyInfo targetProp, PropertyDefinition proxyProp, TypeReference proxyBaseType, TypeReference proxyTargetType, TypeReference rootProxyTargetType) { var propWrapperTypeRef = this.propertyWrapperType.MakeGenericType(proxyTargetType, proxyProp.PropertyType); var proxyType = (TypeDefinition)proxyProp.DeclaringType; if (proxyType == null) { throw new InvalidOperationException($"{proxyProp} has no declaring type."); } var propWrapperCtor = propWrapperTypeRef.GetConstructor(typeof(string)); var propertyWrapperField = proxyType.DefineField("_pwrap_" + targetProp.Name, propWrapperTypeRef, FieldAttributes.Private | FieldAttributes.Static); this.initPropertyWrapperIlAction.Add(il => { il.Emit(OpCodes.Ldstr, targetProp.Name); il.Emit(OpCodes.Newobj, propWrapperCtor); il.Emit(OpCodes.Stsfld, propertyWrapperField); }); /* * var initPropertyWrappersMethod = GetInitPropertyWrappersMethod(proxyProp); * * var initIl = initPropertyWrappersMethod.Body.GetILProcessor(); * var lastInstruction = initPropertyWrappersMethod.Body.Instructions.Last(); * if (lastInstruction.OpCode != OpCodes.Ret) * throw new InvalidOperationException("Expected to find ret instruction as last instruction"); * * initIl.InsertBefore(lastInstruction, Instruction.Create(OpCodes.Ldstr, targetProp.Name)); * initIl.InsertBefore(lastInstruction, Instruction.Create(OpCodes.Newobj, propWrapperCtor)); * initIl.InsertBefore(lastInstruction, Instruction.Create(OpCodes.Stsfld, propertyWrapperField)); */ var baseDef = proxyBaseType; var proxyOnGetMethod = baseDef.GetGenericInstanceMethod("OnGet", proxyTargetType, proxyProp.PropertyType); var proxyOnGetMethodInstance = proxyOnGetMethod.MakeGenericMethod(proxyTargetType, proxyProp.PropertyType); var proxyOnSetMethod = baseDef.GetGenericInstanceMethod("OnSet", proxyTargetType, proxyProp.PropertyType); var proxyOnSetMethodInstance = proxyOnSetMethod.MakeGenericMethod(proxyTargetType, proxyProp.PropertyType); var getMethod = (MethodDefinition)proxyProp.GetGetMethod(true); if (getMethod != null) { var getIl = getMethod.GetILGenerator(); getIl.Emit(OpCodes.Ldarg_0); getIl.Emit(OpCodes.Ldsfld, propertyWrapperField); getIl.Emit(OpCodes.Callvirt, proxyOnGetMethodInstance); getIl.Emit(OpCodes.Ret); } var setMethod = (MethodDefinition)proxyProp.GetSetMethod(true); if (setMethod != null) { var setIl = setMethod.GetILGenerator(); setIl.Emit(OpCodes.Ldarg_0); setIl.Emit(OpCodes.Ldsfld, propertyWrapperField); setIl.Emit(OpCodes.Ldarg_1); setIl.Emit(OpCodes.Callvirt, proxyOnSetMethodInstance); setIl.Emit(OpCodes.Ret); } }
private static void SetAttributes(PropertyBuilder propertyBuilder, MemberInfo memberInfo) { var customAttributeBuilders = PropertyAttributeBuilders .GetOrAdd( memberInfo, p => { var customAttributes = p.GetCustomAttributesData(); return CreateCustomAttributeBuilders(customAttributes).ToArray(); }); Contract.Assume(customAttributeBuilders != null); foreach (var attribute in customAttributeBuilders) { propertyBuilder.SetCustomAttribute(attribute); } }
private static void DefineSetMethod(TypeBuilder newType, PropertyBuilder propertyBuilder, FieldInfo fieldBuilder, PropertyInfo property) { var setMethod = property.GetSetMethod(); if (setMethod == null) return; var methodBuilder = newType.DefineMethod(setMethod.Name, MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.Virtual, null, new[] {property.PropertyType}); var ilg = methodBuilder.GetILGenerator(); ilg.Emit(OpCodes.Ldarg_0); ilg.Emit(OpCodes.Ldarg_1); ilg.Emit(OpCodes.Stfld, fieldBuilder); ilg.Emit(OpCodes.Ret); propertyBuilder.SetSetMethod(methodBuilder); var methodInfo = methodBuilder.GetBaseDefinition(); newType.DefineMethodOverride(methodInfo, setMethod); }
public PropertyLambda(ITypeLambda typeLambda, PropertyBuilder propertyBuilder) { this.TypeLambda = typeLambda; this.propertyBuilder = propertyBuilder; }
public bool EmitMember( TypeBuilder typeBuilder, EdmMember member, PropertyBuilder propertyBuilder, PropertyInfo baseProperty, BaseProxyImplementor baseImplementor) { if (_members.Contains(member)) { var baseGetter = baseProperty.GetGetMethod(true); const MethodAttributes getterAttributes = MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.Virtual; var getterAccess = baseGetter.Attributes & MethodAttributes.MemberAccessMask; // Define field to store interceptor Func // Signature of interceptor Func delegate is as follows: // // bool intercept(ProxyType proxy, PropertyType propertyValue) // // where // PropertyType is the type of the Property, such as ICollection<Customer>, // ProxyType is the type of the proxy object, // propertyValue is the value returned from the proxied type's property getter. var interceptorType = typeof(Func<,,>).MakeGenericType(typeBuilder, baseProperty.PropertyType, typeof(bool)); var interceptorInvoke = TypeBuilder.GetMethod(interceptorType, typeof(Func<,,>).GetMethod("Invoke")); var interceptorField = typeBuilder.DefineField( GetInterceptorFieldName(baseProperty.Name), interceptorType, FieldAttributes.Private | FieldAttributes.Static); // Define a property getter override in the proxy type var getterBuilder = typeBuilder.DefineMethod( "get_" + baseProperty.Name, getterAccess | getterAttributes, baseProperty.PropertyType, Type.EmptyTypes); var generator = getterBuilder.GetILGenerator(); // Emit instructions for the following call: // T value = base.SomeProperty; // if(this._interceptorForSomeProperty(this, value)) // { return value; } // return base.SomeProperty; // where _interceptorForSomeProperty represents the interceptor Func field. var lableTrue = generator.DefineLabel(); generator.DeclareLocal(baseProperty.PropertyType); // T value generator.Emit(OpCodes.Ldarg_0); // call base.SomeProperty generator.Emit(OpCodes.Call, baseGetter); // call to base property getter generator.Emit(OpCodes.Stloc_0); // value = result generator.Emit(OpCodes.Ldarg_0); // load this generator.Emit(OpCodes.Ldfld, interceptorField); // load this._interceptor generator.Emit(OpCodes.Ldarg_0); // load this generator.Emit(OpCodes.Ldloc_0); // load value generator.Emit(OpCodes.Callvirt, interceptorInvoke); // call to interceptor delegate with (this, value) generator.Emit(OpCodes.Brtrue_S, lableTrue); // if true, just return generator.Emit(OpCodes.Ldarg_0); // else, call the base propertty getter again generator.Emit(OpCodes.Call, baseGetter); // call to base property getter generator.Emit(OpCodes.Ret); generator.MarkLabel(lableTrue); generator.Emit(OpCodes.Ldloc_0); generator.Emit(OpCodes.Ret); propertyBuilder.SetGetMethod(getterBuilder); baseImplementor.AddBasePropertyGetter(baseProperty); return true; } return false; }
private static void DefineGetMethod(TypeBuilder newType, PropertyBuilder propertyBuilder, FieldInfo fieldBuilder, PropertyInfo property) { var getMethod = property.GetGetMethod(); var methodBuilder = newType.DefineMethod(getMethod.Name, MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.Virtual, property.PropertyType, Type.EmptyTypes); var ilg = methodBuilder.GetILGenerator(); ilg.Emit(OpCodes.Ldarg_0); ilg.Emit(OpCodes.Ldfld, fieldBuilder); ilg.Emit(OpCodes.Ret); propertyBuilder.SetGetMethod(methodBuilder); var methodInfo = methodBuilder.GetBaseDefinition(); newType.DefineMethodOverride(methodInfo, getMethod); }
protected void DefineBuilders (MemberKind kind, ParametersCompiled parameters) { PropertyBuilder = Parent.TypeBuilder.DefineProperty ( GetFullName (MemberName), PropertyAttributes.None, #if !BOOTSTRAP_BASIC // Requires trunk version mscorlib IsStatic ? 0 : CallingConventions.HasThis, #endif MemberType.GetMetaInfo (), null, null, parameters.GetMetaInfo (), null, null); PropertySpec spec; if (kind == MemberKind.Indexer) spec = new IndexerSpec (Parent.Definition, this, MemberType, parameters, PropertyBuilder, ModFlags); else spec = new PropertySpec (kind, Parent.Definition, this, MemberType, PropertyBuilder, ModFlags); if (Get != null) { spec.Get = Get.Spec; var method = Get.Spec.GetMetaInfo () as MethodBuilder; if (method != null) { PropertyBuilder.SetGetMethod (method); Parent.MemberCache.AddMember (this, method.Name, Get.Spec); } } else { CheckMissingAccessor (kind, parameters, true); } if (Set != null) { spec.Set = Set.Spec; var method = Set.Spec.GetMetaInfo () as MethodBuilder; if (method != null) { PropertyBuilder.SetSetMethod (method); Parent.MemberCache.AddMember (this, method.Name, Set.Spec); } } else { CheckMissingAccessor (kind, parameters, false); } Parent.MemberCache.AddMember (this, PropertyBuilder.Name, spec); }
public PropertyBuilder DefineProperty (string name, PropertyAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers) { check_name ("name", name); if (parameterTypes != null) foreach (Type param in parameterTypes) if (param == null) throw new ArgumentNullException ("parameterTypes"); check_not_created (); PropertyBuilder res = new PropertyBuilder (this, name, attributes, callingConvention, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers); if (properties != null) { Array.Resize (ref properties, properties.Length + 1); properties [properties.Length - 1] = res; } else { properties = new PropertyBuilder [1] { res }; } return res; }
public void EmitAttribute (PropertyBuilder builder) { if (ResolveBuilder ()) builder.SetCustomAttribute (cab); }
private static void EmitBaseSetter(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, PropertyInfo baseProperty) { if (CanProxySetter(baseProperty)) { var baseSetter = baseProperty.GetSetMethod(true); const MethodAttributes methodAttributes = MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.Virtual; var methodAccess = baseSetter.Attributes & MethodAttributes.MemberAccessMask; var setterBuilder = typeBuilder.DefineMethod( "set_" + baseProperty.Name, methodAccess | methodAttributes, null, new[] { baseProperty.PropertyType }); var generator = setterBuilder.GetILGenerator(); generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Ldarg_1); generator.Emit(OpCodes.Call, baseSetter); generator.Emit(OpCodes.Ret); propertyBuilder.SetSetMethod(setterBuilder); } }
private static void EmitBaseGetter(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, PropertyInfo baseProperty) { if (CanProxyGetter(baseProperty)) { var baseGetter = baseProperty.GetGetMethod(true); const MethodAttributes getterAttributes = MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.Virtual; var getterAccess = baseGetter.Attributes & MethodAttributes.MemberAccessMask; // Define a property getter override in the proxy type var getterBuilder = typeBuilder.DefineMethod( "get_" + baseProperty.Name, getterAccess | getterAttributes, baseProperty.PropertyType, Type.EmptyTypes); var gen = getterBuilder.GetILGenerator(); gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Call, baseGetter); gen.Emit(OpCodes.Ret); propertyBuilder.SetGetMethod(getterBuilder); } }