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 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 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 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()); }
/// <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); }
private void EmitCollectionProperty(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, PropertyInfo baseProperty, NavigationProperty navProperty) { const MethodAttributes methodAttributes = MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.Virtual; MethodInfo baseSetter = baseProperty.GetSetMethod(true); ; MethodAttributes methodAccess = baseSetter.Attributes & MethodAttributes.MemberAccessMask; string cannotSetException = System.Data.Entity.Strings.EntityProxyTypeInfo_CannotSetEntityCollectionProperty(propertyBuilder.Name, typeBuilder.Name); MethodBuilder setterBuilder = typeBuilder.DefineMethod("set_" + baseProperty.Name, methodAccess | methodAttributes, null, new Type[] { baseProperty.PropertyType }); ILGenerator generator = setterBuilder.GetILGenerator(); Label instanceEqual = generator.DefineLabel(); generator.Emit(OpCodes.Ldarg_1); generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Call, _getRelationshipManager); generator.Emit(OpCodes.Ldstr, navProperty.RelationshipType.FullName); generator.Emit(OpCodes.Ldstr, navProperty.ToEndMember.Name); generator.Emit(OpCodes.Callvirt, s_GetRelatedEnd); generator.Emit(OpCodes.Beq_S, instanceEqual); generator.Emit(OpCodes.Ldstr, cannotSetException); generator.Emit(OpCodes.Newobj, s_InvalidOperationConstructor); generator.Emit(OpCodes.Throw); generator.MarkLabel(instanceEqual); generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Ldarg_1); generator.Emit(OpCodes.Call, baseProperty.GetSetMethod(true)); generator.Emit(OpCodes.Ret); propertyBuilder.SetSetMethod(setterBuilder); _collectionProperties.Add(new KeyValuePair<NavigationProperty, PropertyInfo>(navProperty, baseProperty)); }
private void EmitReferenceProperty(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, PropertyInfo baseProperty, NavigationProperty navProperty) { const MethodAttributes methodAttributes = MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.Virtual; MethodInfo baseSetter = baseProperty.GetSetMethod(true); ; MethodAttributes methodAccess = baseSetter.Attributes & MethodAttributes.MemberAccessMask; MethodInfo specificGetRelatedReference = s_GetRelatedReference.MakeGenericMethod(baseProperty.PropertyType); MethodInfo specificEntityReferenceSetValue = typeof(EntityReference<>).MakeGenericType(baseProperty.PropertyType).GetMethod("set_Value"); ; MethodBuilder setterBuilder = typeBuilder.DefineMethod("set_" + baseProperty.Name, methodAccess | methodAttributes, null, new Type[] { baseProperty.PropertyType }); ILGenerator generator = setterBuilder.GetILGenerator(); generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Callvirt, _getRelationshipManager); generator.Emit(OpCodes.Ldstr, navProperty.RelationshipType.FullName); generator.Emit(OpCodes.Ldstr, navProperty.ToEndMember.Name); generator.Emit(OpCodes.Callvirt, specificGetRelatedReference); generator.Emit(OpCodes.Ldarg_1); generator.Emit(OpCodes.Callvirt, specificEntityReferenceSetValue); generator.Emit(OpCodes.Ret); propertyBuilder.SetSetMethod(setterBuilder); _referenceProperties.Add(new KeyValuePair<NavigationProperty,PropertyInfo>(navProperty, baseProperty)); }
private void EmitScalarSetter(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, PropertyInfo baseProperty, bool isKeyMember) { MethodInfo baseSetter = baseProperty.GetSetMethod(true); const MethodAttributes methodAttributes = MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.Virtual; MethodAttributes methodAccess = baseSetter.Attributes & MethodAttributes.MemberAccessMask; MethodBuilder setterBuilder = typeBuilder.DefineMethod("set_" + baseProperty.Name, methodAccess | methodAttributes, null, new Type[] { baseProperty.PropertyType }); ILGenerator generator = setterBuilder.GetILGenerator(); Label endOfMethod = generator.DefineLabel(); // If the CLR property represents a key member of the Entity Type, // ignore attempts to set the key value to the same value. if (isKeyMember) { MethodInfo baseGetter = baseProperty.GetGetMethod(true); if (baseGetter != null) { // if (base.[Property] != value) // { // // perform set operation // } Type propertyType = baseProperty.PropertyType; if (propertyType == typeof(int) || // signed integer types propertyType == typeof(short) || propertyType == typeof(Int64) || propertyType == typeof(bool) || // boolean propertyType == typeof(byte) || propertyType == typeof(UInt32) || propertyType == typeof(UInt64)|| propertyType == typeof(float) || propertyType == typeof(double) || propertyType.IsEnum) { generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Call, baseGetter); generator.Emit(OpCodes.Ldarg_1); generator.Emit(OpCodes.Beq_S, endOfMethod); } else if (propertyType == typeof(byte[])) { // Byte arrays must be compared by value generator.Emit(OpCodes.Ldsfld, _compareByteArraysField); generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Call, baseGetter); generator.Emit(OpCodes.Ldarg_1); generator.Emit(OpCodes.Callvirt, s_Func_object_object_bool_Invoke); generator.Emit(OpCodes.Brtrue_S, endOfMethod); } else { // Get the specific type's inequality method if it exists MethodInfo op_inequality = propertyType.GetMethod("op_Inequality", new Type[] { propertyType, propertyType }); if (op_inequality != null) { generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Call, baseGetter); generator.Emit(OpCodes.Ldarg_1); generator.Emit(OpCodes.Call, op_inequality); generator.Emit(OpCodes.Brfalse_S, endOfMethod); } else { // Use object inequality generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Call, baseGetter); if (propertyType.IsValueType) { generator.Emit(OpCodes.Box, propertyType); } generator.Emit(OpCodes.Ldarg_1); if (propertyType.IsValueType) { generator.Emit(OpCodes.Box, propertyType); } generator.Emit(OpCodes.Call, s_ObjectEquals); generator.Emit(OpCodes.Brtrue_S, endOfMethod); } } } } // Creates code like this: // // try // { // MemberChanging(propertyName); // base.Property_set(value); // MemberChanged(propertyName); // } // finally // { // _resetFKSetterFlagField(this); // } // // Note that the try/finally ensures that even if an exception causes // the setting of the property to be aborted, we still clear the flag that // indicates that we are in a property setter. generator.BeginExceptionBlock(); generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Ldstr, baseProperty.Name); generator.Emit(OpCodes.Call, _entityMemberChanging); generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Ldarg_1); generator.Emit(OpCodes.Call, baseSetter); generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Ldstr, baseProperty.Name); generator.Emit(OpCodes.Call, _entityMemberChanged); generator.BeginFinallyBlock(); generator.Emit(OpCodes.Ldsfld, _resetFKSetterFlagField); generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Callvirt, s_Action_Invoke); generator.EndExceptionBlock(); generator.MarkLabel(endOfMethod); generator.Emit(OpCodes.Ret); propertyBuilder.SetSetMethod(setterBuilder); }
/* Setter IL IL_0000: ldarg.0 IL_0001: ldfld Ns.EntityBase::Record IL_0006: ldc.i4.1 IL_0007: ldarg.1 IL_0008: callvirt instance void Ns.EntityRecord::SetValue(int32, object) IL_000d: ret */ private MethodBuilder CreateSetter(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, int memberIndex, string name = null, bool asPublic = true) { var setterName = name ?? "set_" + propertyBuilder.Name; var attrs = MethodAttributes.SpecialName | MethodAttributes.Virtual | MethodAttributes.HideBySig; if (asPublic) attrs |= MethodAttributes.Public; else attrs |= MethodAttributes.Private; var propType = propertyBuilder.PropertyType; var setter = typeBuilder.DefineMethod(setterName, attrs, null, new Type[] { propType }); var ilGen = setter.GetILGenerator(); ilGen.Emit(OpCodes.Ldarg_0); ilGen.Emit(OpCodes.Ldfld, _entityBase_Record); ilGen.Emit(OpCodes.Ldc_I4, memberIndex); ilGen.Emit(OpCodes.Ldarg_1); if (propType.IsValueType || propType.IsEnum) ilGen.Emit(OpCodes.Box, propType); ilGen.Emit(OpCodes.Call, _entityRecord_SetValue); ilGen.Emit(OpCodes.Ret); propertyBuilder.SetSetMethod(setter); return setter; }
private static void SetAccessors(PropertyBuilder property, IEnumerable<RppMethodInfo> methods) { string propertyName = property.Name; foreach (RppMethodInfo method in methods) { if (method.Name == RppMethodInfo.GetGetterAccessorName(propertyName)) { property.SetGetMethod((MethodBuilder) method.Native); } else if (method.Name == RppMethodInfo.GetSetterAccessorName(propertyName)) { property.SetSetMethod((MethodBuilder) method.Native); } } }
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 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); }
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 void DefinePropertySetter(Entity c, Entity p, TypeBuilder t, bool forward, string propname, Type rettype, Type retelemtype, bool functional, PropertyBuilder property) { if (!functional) return; MethodBuilder method = t.DefineMethod("set_" + propname, MethodAttributes.Public | MethodAttributes.SpecialName, CallingConventions.HasThis, null, new Type[] { rettype } ); property.SetSetMethod(method); ILGenerator il = method.GetILGenerator(); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldstr, p.Uri); il.Emit(OpCodes.Newobj, newentity); il.Emit(OpCodes.Ldarg_1); if (forward) il.Emit(OpCodes.Ldc_I4_1); else il.Emit(OpCodes.Ldc_I4_0); il.Emit(OpCodes.Call, anysetfuncvalue); il.Emit(OpCodes.Ret); }
/// <summary> /// Creates the body of a property setter /// </summary> /// <param name="generatedTypeBuilder"></param> /// <param name="p"></param> /// <param name="property"></param> /// <param name="setDecl"></param> /// <param name="logicField"></param> private void CreatePropertySetMethod(TypeBuilderHelper generatedTypeBuilder, PropertyInfo p, PropertyBuilder property, MethodInfo setDecl, FieldInfo logicField) { //set getter name and parameter types var name = setDecl == null ? "set_" + p.Name : setDecl.Name; var parameterTypes = setDecl == null ? new[] { p.PropertyType } : setDecl.GetParameters().Select(x => x.ParameterType).ToArray(); //set attributes on setter var methodAttributes = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Virtual; //build setter method var setBuilder = generatedTypeBuilder.DefineMethod(name, methodAttributes, null, parameterTypes); //spit out IL setBuilder .Emitter .ldarg_0 .ldfld(logicField) .ldstr(p.Name) .ldarg_1 .callvirt(Reflect<LogicBase>.GetMethod(x=> x.SetProperty(string.Empty, string.Empty)).MakeGenericMethod(p.PropertyType)) .nop .ret(); //apply setter method to the property property.SetSetMethod(setBuilder); }
protected void DefineBuilders(MemberKind kind, ParametersCompiled parameters) { // FIXME - PropertyAttributes.HasDefault ? PropertyBuilder = Parent.TypeBuilder.DefineProperty ( GetFullName (MemberName), PropertyAttributes.None, MemberType.GetMetaInfo (), parameters.GetMetaInfo ()); 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); spec.Get = Get.Spec; spec.Set = Set.Spec; if (!Get.IsDummy) { PropertyBuilder.SetGetMethod (GetBuilder); } if (!Set.IsDummy) { PropertyBuilder.SetSetMethod (SetBuilder); } Parent.MemberCache.AddMember (this, Get.IsDummy ? Get.Name : GetBuilder.Name, Get.Spec); Parent.MemberCache.AddMember (this, Set.IsDummy ? Set.Name : SetBuilder.Name, Set.Spec); Parent.MemberCache.AddMember (this, PropertyBuilder.Name, spec); }
public MethodBuilder CreateSetMethod(TypeBuilder Class, PropertyBuilder Property, FieldBuilder Field, Boolean Public, System.Type ReturnType) { String methodName = "set_" + Property.Name; MethodBuilder setMethod = Class.DefineMethod(methodName, BasePropertyMethodAttr, null, new Type[] { ReturnType }); ILGenerator setIL = setMethod.GetILGenerator(); setIL.Emit(OpCodes.Ldarg_0); setIL.Emit(OpCodes.Ldarg_1); setIL.Emit(OpCodes.Stfld, Field); setIL.Emit(OpCodes.Ret); Property.SetSetMethod(setMethod); return setMethod; }
private static void EmitProperty( PropertyInfo info, string name, string convertGet, Type tGetReturnType, string invokeGet, Type[] indexParamTypes, MethodInfo setMethod, string invokeSet, Type[] setParamTypes, TypeBuilder typeBuilder, MethodBuilder getMethodBuilder, Type callSite, Type contextType, Type tConvertFuncType, Type invokeGetFuncType, PropertyBuilder tMp, Type invokeSetFuncType, bool defaultImp) { if (indexParamTypes == null) { throw new ArgumentNullException("indexParamTypes"); } var tIlGen = getMethodBuilder.GetILGenerator(); var tConvertCallsiteField = callSite.GetFieldEvenIfGeneric(convertGet); var tReturnLocal = tIlGen.DeclareLocal(tGetReturnType); using (tIlGen.EmitBranchTrue(gen => gen.Emit(OpCodes.Ldsfld, tConvertCallsiteField))) { tIlGen.EmitDynamicConvertBinder(CSharpBinderFlags.None, tGetReturnType, contextType); tIlGen.EmitCallsiteCreate(tConvertFuncType); tIlGen.Emit(OpCodes.Stsfld, tConvertCallsiteField); } var tInvokeGetCallsiteField = callSite.GetFieldEvenIfGeneric(invokeGet); using (tIlGen.EmitBranchTrue(gen => gen.Emit(OpCodes.Ldsfld, tInvokeGetCallsiteField))) { tIlGen.EmitDynamicGetBinder(CSharpBinderFlags.None, name, contextType, indexParamTypes); tIlGen.EmitCallsiteCreate(invokeGetFuncType); tIlGen.Emit(OpCodes.Stsfld, tInvokeGetCallsiteField); } tIlGen.Emit(OpCodes.Ldsfld, tConvertCallsiteField); tIlGen.Emit(OpCodes.Ldfld, tConvertCallsiteField.FieldType.GetFieldEvenIfGeneric("Target")); tIlGen.Emit(OpCodes.Ldsfld, tConvertCallsiteField); tIlGen.Emit(OpCodes.Ldsfld, tInvokeGetCallsiteField); tIlGen.Emit(OpCodes.Ldfld, tInvokeGetCallsiteField.FieldType.GetFieldEvenIfGeneric("Target")); tIlGen.Emit(OpCodes.Ldsfld, tInvokeGetCallsiteField); tIlGen.Emit(OpCodes.Ldarg_0); tIlGen.Emit(OpCodes.Call, typeof (ActLikeProxy).GetProperty("Original").GetGetMethod()); for (var i = 1; i <= indexParamTypes.Length; i++) { tIlGen.EmitLoadArgument(i); } tIlGen.EmitCallInvokeFunc(invokeGetFuncType); tIlGen.EmitCallInvokeFunc(tConvertFuncType); tIlGen.EmitStoreLocation(tReturnLocal.LocalIndex); var tReturnLabel = tIlGen.DefineLabel(); tIlGen.Emit(OpCodes.Br_S, tReturnLabel); tIlGen.MarkLabel(tReturnLabel); tIlGen.EmitLoadLocation(tReturnLocal.LocalIndex); tIlGen.Emit(OpCodes.Ret); tMp.SetGetMethod(getMethodBuilder); if (setMethod != null) { MethodAttributes tPublicPrivate = MethodAttributes.Public; var tPrefixedSet = setMethod.Name; if (!defaultImp) { tPublicPrivate = MethodAttributes.Private; tPrefixedSet = String.Format("{0}.{1}", info.DeclaringType.FullName, tPrefixedSet); } var tSetMethodBuilder = typeBuilder.DefineMethod(tPrefixedSet, tPublicPrivate | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.Final | MethodAttributes.NewSlot, null, setParamTypes); if (!defaultImp) { typeBuilder.DefineMethodOverride(tSetMethodBuilder, info.GetSetMethod()); } foreach (var tParam in info.GetSetMethod().GetParameters()) { tSetMethodBuilder.DefineParameter(tParam.Position + 1, AttributesForParam(tParam), tParam.Name); } tIlGen = tSetMethodBuilder.GetILGenerator(); var tSetCallsiteField = callSite.GetFieldEvenIfGeneric(invokeSet); using (tIlGen.EmitBranchTrue(gen => gen.Emit(OpCodes.Ldsfld, tSetCallsiteField))) { tIlGen.EmitDynamicSetBinder(CSharpBinderFlags.None, name, contextType, setParamTypes); tIlGen.EmitCallsiteCreate(invokeSetFuncType); tIlGen.Emit(OpCodes.Stsfld, tSetCallsiteField); } tIlGen.Emit(OpCodes.Ldsfld, tSetCallsiteField); tIlGen.Emit(OpCodes.Ldfld, tSetCallsiteField.FieldType.GetFieldEvenIfGeneric("Target")); tIlGen.Emit(OpCodes.Ldsfld, tSetCallsiteField); tIlGen.Emit(OpCodes.Ldarg_0); tIlGen.Emit(OpCodes.Call, typeof (ActLikeProxy).GetProperty("Original").GetGetMethod()); for (var i = 1; i <= setParamTypes.Length; i++) { tIlGen.EmitLoadArgument(i); } tIlGen.EmitCallInvokeFunc(invokeSetFuncType); tIlGen.Emit(OpCodes.Pop); tIlGen.Emit(OpCodes.Ret); tMp.SetSetMethod(tSetMethodBuilder); } }
private void createHashMethod(PropertyBuilder propBuild,TypeBuilder typeBuild,FieldBuilder hash) { // First, we'll define the behavior of the "get" property for Hash as a method. MethodBuilder typeHashGet = typeBuild.DefineMethod("GetHash", MethodAttributes.Public, typeof(Hashtable), new Type[] { }); ILGenerator ilg = typeHashGet.GetILGenerator(); ilg.Emit(OpCodes.Ldarg_0); ilg.Emit(OpCodes.Ldfld, hash); ilg.Emit(OpCodes.Ret); // Now, we'll define the behavior of the "set" property for Hash. MethodBuilder typeHashSet = typeBuild.DefineMethod("SetHash", MethodAttributes.Public, null, new Type[] { typeof(Hashtable) }); ilg = typeHashSet.GetILGenerator(); ilg.Emit(OpCodes.Ldarg_0); ilg.Emit(OpCodes.Ldarg_1); ilg.Emit(OpCodes.Stfld, hash); ilg.Emit(OpCodes.Ret); // map the two methods created above to their property propBuild.SetGetMethod(typeHashGet); propBuild.SetSetMethod(typeHashSet); //add the [Browsable(false)] property to the Hash property so it doesnt show up on the property list ConstructorInfo ci = typeof(BrowsableAttribute).GetConstructor(new Type[]{typeof(bool)}); CustomAttributeBuilder cab = new CustomAttributeBuilder(ci,new object[]{false}); propBuild.SetCustomAttribute(cab); }
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); }
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); }
/// <summary> /// Creates the setter. /// </summary> /// <param name="typeBuilder">The type builder.</param> /// <param name="propertyBuilder">The property builder.</param> /// <param name="column">The column.</param> private static void CreateSetter(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, SLDataColumn 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 EmitSetter(TypeBuilder proxyTypeBuilder, PropertyBuilder propertyBuilder, FieldBuilder self, PropertyInfo declaration, PropertyInfo delegatedProperty, Type propertyType, Type[] indexTypes) { var setter = declaration.GetSetMethod(); if (setter != null) { indexTypes = indexTypes.Concat(propertyType.AsSingleEnumerable()).ToArray(); var setterBuilder = proxyTypeBuilder.DefineMethod("set_" + declaration.Name, PropertyAttribute, null, indexTypes); var generator = setterBuilder.GetILGenerator(); if (delegatedProperty == null) { generator.ThrowException(typeof(NotSupportedException)); } else { var delegatedSetter = delegatedProperty.GetSetMethod(); EmitImplementation(generator, self, delegatedSetter, indexTypes); propertyBuilder.SetSetMethod(setterBuilder); } } }