public DefineConstructor ( System attributes, System callingConvention, System parameterTypes ) : System.Reflection.Emit.ConstructorBuilder | ||
attributes | System | |
callingConvention | System | |
parameterTypes | System | |
return | System.Reflection.Emit.ConstructorBuilder |
/// <summary> /// Adds a new public constructor to the class, with the given parameters. /// </summary> /// <param name="parameterTypes">The types of the parameters of the method.</param> /// <returns>The defined constructor.</returns> public ConstructorBuilderHelper DefinePublicConstructor(params Type[] parameterTypes) { return(new ConstructorBuilderHelper( this, _typeBuilder.DefineConstructor( MethodAttributes.Public, CallingConventions.Standard, parameterTypes))); }
public ClassBuilder(TypeBuilder tb) { this.tb = tb; System.Type[] param = {}; ConstructorBuilder ctor = tb.DefineConstructor( MethodAttributes.Public, CallingConventions.Standard, param ); cil = ctor.GetILGenerator(); ctor = tb.DefineConstructor(MethodAttributes.Public | MethodAttributes.Static, CallingConventions.Standard, param); ccil = ctor.GetILGenerator(); }
private static void BuildConstructor(TypeBuilder proxyBuilder, Type proxyType, FieldBuilder wrappedType, FieldBuilder invokeHandlers, TypeDebugging debug) { var arguments = new Type[] { proxyType, typeof(IInvocationHandler[]) }; var constructor = proxyBuilder.DefineConstructor( MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName | MethodAttributes.HideBySig, CallingConventions.Standard, arguments); using (var generator = debug.GetMethodDebugging(constructor)) { // Call the base constructor. generator.Emit(OpCodes.Ldarg_0); var objectCtor = proxyType.GetConstructor(Type.EmptyTypes); generator.Emit(OpCodes.Call, objectCtor); // Store the target object. generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Ldarg_1); generator.Emit(OpCodes.Stfld, wrappedType); // Store the handlers. generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Ldarg_2); generator.Emit(OpCodes.Stfld, invokeHandlers); generator.Emit(OpCodes.Ret); } }
protected ConstructorInfo GrabConstructor(ConstructorInfo Original, TypeBuilder On) { if(Original == null) return null; if(ConstructorsDone.ContainsKey(Original)) return ConstructorsDone[Original]; if(!Sources.Contains(Original.Module)) return ConstructorReplaceGenerics(Original); if(On == null) On = GrabType(Original.DeclaringType) as TypeBuilder; ConstructorBuilder Builder = On.DefineConstructor(Original.Attributes, Original.CallingConvention, ParameterTypes(Original)); Builder.SetImplementationFlags(Original.GetMethodImplementationFlags()); if(ConstructorsDone.ContainsKey(Original)) return ConstructorsDone[Original]; ConstructorsDone.Add(Original, Builder); CopyMethodBody(Original, Builder); return Builder; }
private static void CreateConstructor(TypeBuilder tb, IList<IInjectableConstructorArg> properties) { var constructor = tb.DefineConstructor( MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, CallingConventions.Standard, properties.Select(p => p.PropertyType).ToArray()); var conObj = typeof(object).GetConstructor(new Type[0]); ILGenerator il = constructor.GetILGenerator(); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Call, conObj); il.Emit(OpCodes.Nop); il.Emit(OpCodes.Nop); for (var i = 0; i < properties.Count; i++) { var property = properties[i]; il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldarg, i + 1); il.Emit(OpCodes.Call, property.Setter); il.Emit(OpCodes.Nop); } il.Emit(OpCodes.Nop); il.Emit(OpCodes.Ret); }
/// <summary> /// Uses reflection to emit the given <see cref="ConstructorInfo"/> body for the given type. /// </summary> /// <param name="typeBuilder"> /// The <see cref="TypeBuilder"/>. /// </param> /// <param name="constructorInfo"> /// The <see cref="ConstructorInfo"/>. /// </param> public static void Emit(TypeBuilder typeBuilder, ConstructorInfo constructorInfo) { // Define the default constructor attributes. const MethodAttributes ConstructorAttributes = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName; // Get the parameters. Type[] parameterTypes = constructorInfo.GetParameters().Select(p => p.ParameterType).ToArray(); // Define the constructor. ConstructorBuilder constructor = typeBuilder.DefineConstructor( ConstructorAttributes, CallingConventions.Standard, parameterTypes); ILGenerator il = constructor.GetILGenerator(); // ReSharper disable once BitwiseOperatorOnEnumWithoutFlags constructor.SetImplementationFlags(MethodImplAttributes.IL | MethodImplAttributes.Managed); // Load all constructor arguments. Note argument 0 is 'this' pointer, so you must emit one more. for (int i = 0; i <= parameterTypes.Length; i++) { il.Emit(OpCodes.Ldarg_S, i); } // Call the base constructor and return. il.Emit(OpCodes.Call, constructorInfo); il.Emit(OpCodes.Ret); }
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()); }
/// <summary> /// Defines the constructor used. /// </summary> /// <param name="owner"></param> /// <param name="interfaceType"></param> /// <returns></returns> protected override ConstructorBuilder DefineConstructor(TypeBuilder owner, Type interfaceType) { var probeType = typeof(IMethodCallProbe<>).MakeGenericType(interfaceType); return owner.DefineConstructor( MethodAttributes.Public, CallingConventions.Standard, new[] { typeof(ILibrary), probeType }); }
public ConstructorBuilder GenerateConstructor(TypeBuilder builder, Type[] parameters) { return builder.DefineConstructor( MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, CallingConventions.Standard, parameters); }
CodeMethod (CodeClass cls, MethodAttributes attributes, Type[] parameterTypes) { this.cls = cls; this.typeBuilder = cls.TypeBuilder; this.attributes = attributes; this.parameterTypes = parameterTypes; this.name = typeBuilder.Name; methodBase = typeBuilder.DefineConstructor (attributes, CallingConventions.Standard, parameterTypes); builder = new CodeBuilder (cls); }
private static ConstructorInfo BuildConstructor(TypeBuilder type, FieldInfo helperClassFieldInfo) { // Declaring method builder // Method attributes ConstructorBuilder method = type.DefineConstructor(MethodAttributes.Public, 0, new[] { typeof(IDbConnection) }); // Preparing Reflection instances ConstructorInfo ctor1 = typeof(DebuggerNonUserCodeAttribute).GetConstructor( BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[]{ }, null ); ConstructorInfo ctor2 = typeof(DataContextBase).GetConstructor( BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[]{ typeof(IDbConnection) }, null ); ConstructorInfo ctor3 = typeof(SqlDataContextHelperClass).GetConstructor( BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[]{ typeof(DataContext) }, null ); FieldInfo field4 = helperClassFieldInfo; // Adding custom attributes to method // [DebuggerNonUserCodeAttribute] method.SetCustomAttribute( new CustomAttributeBuilder( ctor1, new Type[] { } ) ); // Parameter connection //ParameterBuilder connection = method.DefineParameter(0, ParameterAttributes.None, "connection"); ILGenerator gen = method.GetILGenerator(); // Writing body gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Ldarg_1); gen.Emit(OpCodes.Call, ctor2); gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Newobj, ctor3); gen.Emit(OpCodes.Stfld, field4); gen.Emit(OpCodes.Ret); // finished return method; }
private void Constructor(TypeBuilder typeBuilder) { var constructor = typeBuilder.DefineConstructor(MethodAttributes.Public | MethodAttributes.RTSpecialName, CallingConventions.Standard, new[] { typeof(IDynamicImplementation) }); var constructorILGenerator = constructor.GetILGenerator(); constructorILGenerator.Emit(OpCodes.Ldarg_0); var originalConstructor = typeof(Object).GetConstructor(BindingFlags.Instance | BindingFlags.Public, null, new Type[0], null); constructorILGenerator.Emit(OpCodes.Call, originalConstructor); constructorILGenerator.Emit(OpCodes.Ldarg_0); constructorILGenerator.Emit(OpCodes.Ldarg_1); constructorILGenerator.Emit(OpCodes.Stfld, __interceptionService); constructorILGenerator.Emit(OpCodes.Ret); }
/// <summary> /// AddConstructor /// </summary> /// <param name="typeBuilder"></param> /// <param name="backingFields"></param> private static void CreateConstructor(System.Reflection.Emit.TypeBuilder typeBuilder, IReadOnlyList <dynamic> backingFields) { #region Constructor //-------------------------------------------------------------------- // Constructor: (Default) // <code> // .custom instance void [Newtonsoft.Json]Newtonsoft.Json.JsonConverterAttribute::.ctor(class [mscorlib]System.Type) = { type(<NameSpace>.PayloadComplexTypeConverter) } // .method public hidebysig specialname rtspecialname instance void .ctor() cil managed // { // } // </code> // Attribute: // [JsonConverter(typeof(PayloadComplexTypeConverter))] // Ctor attributes /* Uncomment if needing similar functionality for nested duck types */ // Attribute: // [JsonConverterAttribute()] //var jsonConverterAttr = typeof(JsonConverterAttribute).GetConstructor(new [] { typeof(Type) }); //if (jsonConverterAttr != null) { // // ReSharper disable once InconsistentNaming // var jsonConverterCABuilder = new CustomAttributeBuilder( // jsonConverterAttr, // new object[] { typeof(PayloadComplexTypeConverter) } // ); // typeBuilder.SetCustomAttribute(jsonConverterCABuilder); //} var constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, CallingConventions.Standard, new[] { typeof(string), typeof(string), typeof(Dictionary <string, Type>) }); var ctorIl = constructorBuilder.GetILGenerator(); // Now, we'll load the current instance ref in arg 0, along // with the value of parameter "x" stored in arg X, into stfld. for (var x = 0; x < backingFields.Count; x++) { ctorIl.Emit(OpCodes.Ldarg_0); ctorIl.Emit(OpCodes.Ldarg_S, x + 1); ctorIl.Emit(OpCodes.Stfld, backingFields[x]); } // Our work complete, we return. ctorIl.Emit(OpCodes.Ret); //-------------------------------------------------------------------- #endregion Constructor }
private static void GenerateConstructor(TypeBuilder typeBuilder) { var constructor = typeBuilder.DefineConstructor( MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, CallingConventions.Standard, Type.EmptyTypes); var constructorMethod = typeof(object).GetConstructor(Type.EmptyTypes); var constructorGenerator = constructor.GetILGenerator(); constructorGenerator.Emit(OpCodes.Ldarg_0); constructorGenerator.Emit(OpCodes.Call, constructorMethod); constructorGenerator.Emit(OpCodes.Ret); }
private void WeaveConstructor(TypeBuilder typeBuilder, EventBrokerResolvedType eventBrokerResolvedType) { ConstructorBuilder ctor = null; ILGenerator ilGenerator = null; var ctorArgs = new[] { eventBrokerResolvedType.DecalringType, typeof(EventInfo), eventBrokerResolvedType.EventBrokerInvokeDelegateType }; var baseCtor = eventBrokerResolvedType.EventBrokerBaseClassType.GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, Type.DefaultBinder, ctorArgs, null); ctor = typeBuilder.DefineConstructor(ctorAttrs, CallingConventions.Standard | CallingConventions.HasThis, ctorArgs); ilGenerator = ctor.GetILGenerator(); ilGenerator.EmitLoadArg(0); ctorArgs.ForEach(1, (arg, i) => ilGenerator.EmitLoadArg(i)); ilGenerator.Emit(OpCodes.Call, baseCtor); ilGenerator.Emit(OpCodes.Ret); }
public void Build(TypeBuilder typeBuilder, Type contractType) { ConstructorBuilder constructor = typeBuilder.DefineConstructor( MethodAttributes.Public, CallingConventions.HasThis, new[] { contractType, typeof(IPointcut[]) }); ILGenerator il = constructor.GetILGenerator(); // call base constructor passing second parameter of this constructor as argument il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldarg_1); il.Emit(OpCodes.Ldarg_2); il.Emit(OpCodes.Call, typeof(InvocationProxy).GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance).First()); il.Emit(OpCodes.Ret); }
private static void DefineForwardingConstructor(TypeBuilder definingType, Type baseType, Type[] parameters, Type[] baseParams, string[] paramNames, Action<ILGenerator> paramIL) { ConstructorBuilder builder = definingType.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, parameters); int num = 0; foreach (string str in paramNames) { builder.DefineParameter(++num, ParameterAttributes.None, str); } ILGenerator iLGenerator = builder.GetILGenerator(); iLGenerator.Emit(OpCodes.Ldarg_0); paramIL(iLGenerator); ConstructorInfo constructor = baseType.GetConstructor(baseParams); iLGenerator.Emit(OpCodes.Call, constructor); iLGenerator.Emit(OpCodes.Ret); }
private static void BuildParameterlessConstructor(TypeBuilder proxyBuilder, Type proxyType, TypeDebugging debug) { var constructor = proxyBuilder.DefineConstructor( MethodAttributes.Private | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName | MethodAttributes.HideBySig, CallingConventions.Standard, Type.EmptyTypes); using (var generator = debug.GetMethodDebugging(constructor)) { generator.Emit(OpCodes.Ldarg_0); var objectCtor = proxyType.GetConstructor(Type.EmptyTypes); generator.Emit(OpCodes.Call, objectCtor); generator.Emit(OpCodes.Ret); } }
public static void DefineCtor(TypeBuilder typeBuilder, FieldBuilder fieldBuilder) { var parameterTypes = new Type[] { fieldBuilder.FieldType }; ConstructorBuilder ctorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, parameterTypes); ILGenerator il = ctorBuilder.GetILGenerator(); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldarg_1); il.Emit(OpCodes.Stfld, fieldBuilder); il.Emit(OpCodes.Ret); MethodBuilder createBuider = typeBuilder.DefineMethod("<Create>", MethodAttributes.Static | MethodAttributes.Public, typeBuilder, parameterTypes); il = createBuider.GetILGenerator(); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Newobj, ctorBuilder); il.Emit(OpCodes.Ret); }
private static ILGenerator Generate_Constructor(TypeBuilder tb, FieldSet fields) { var cb = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] { typeof(string) }); var ilgen = cb.GetILGenerator(); ilgen.PushContext(new ILContext(fields)); // --- DECLARE PARAMETERS --- ilgen.DeclareParameter("filename"); // --- DECLARE LOCALS --- ilgen.DeclareLocal<TextReader>("tr"); ilgen.DeclareLocal<string>("quote"); ilgen.EmitCallToBaseConstructor(); // base(); ilgen.ConstructVariable<ArrayList>("_quotes"); // _quotes = new ArrayList(); ilgen.ConstructVariable<Random>("_random"); // _random = new Random(); ilgen.EmitLoadVariable("filename"); // "filename" - first constructor parameter ilgen.EmitCall(typeof(File), "OpenText"); // invoke File.OpenText with "filename" parameter ilgen.EmitStoreVariable("tr"); // Mark the loop label ilgen.EmitLoop((gen, exit) => { gen.EmitLoadVariable("tr"); // load local "tr" gen.EmitCallvirt<TextReader>("ReadLine"); // call tr.ReadLine() (virtual) gen.EmitStoreVariable("quote"); // store the result in the local "quote" gen.EmitLoadVariable("quote"); // load the local "quote" gen.Emit(OpCodes.Brfalse_S, exit); // branch to the exit label if "quote" is null gen.EmitLoadVariable("_quotes"); // load "_quotes" field gen.EmitLoadVariable("quote"); // load local "quote" gen.EmitCallvirt<ArrayList, object>("Add"); // call _quotes.Add(object) (virtual) gen.Emit(OpCodes.Pop); // pop the result of _quotes.Add(object) (unused) }); ilgen.EmitLoadVariable("tr"); // load local "tr" ilgen.EmitCallvirt<TextReader>("Close"); // call tr.Close() (virtual) ilgen.Emit(OpCodes.Ret); // emit return opcode ilgen.PopContext(); return ilgen; }
private void CreateConstructor(TypeBuilder typeBuilder) { var ctor = SnapshotBaseType.GetConstructors(BindingFlags.Public | BindingFlags.Instance).First(); var ctorSignature = ctor.GetParameters().Select(p => p.ParameterType); var ctorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, ctorSignature.ToArray()); var il = ctorBuilder.GetILGenerator(); il.Emit(OpCodes.Ldarg_0); // push this int paramIndex = 1; foreach (var param in ctorSignature) // push all constructor parameters onto the stack { il.Emit(OpCodes.Ldarg, paramIndex++); } il.Emit(OpCodes.Call, ctor); // call DynamicSnapshotBase constructor il.Emit(OpCodes.Ret); // return }
private void BuildConstructor(ConstructorInfo constructor, TypeBuilder typeBuilder) { ParameterInfo[] parameterInfos = constructor.GetParameters(); Type[] parameterTypes = new Type[parameterInfos.Length ]; //copy super ctor param types for (int i = 0; i < parameterInfos.Length; i++) { parameterTypes[i] = parameterInfos[i].ParameterType; } ConstructorBuilder proxyConstructor = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, parameterTypes); ILGenerator il = proxyConstructor.GetILGenerator(); for (int i = 0; i < parameterTypes.Length + 1 /* also load "this" */; i++) { il.Emit(OpCodes.Ldarg, i); } il.Emit(OpCodes.Callvirt, constructor); il.Emit(OpCodes.Ret); }
// generates this constructor: // public NewType(param0, param1, ...) : base(param0, param1, ...) { } private static void ImplementConstructor(TypeBuilder newType, ConstructorInfo baseCtor) { ParameterInfo[] parameters = baseCtor.GetParameters(); Type[] parameterTypes = (from p in parameters select p.ParameterType).ToArray(); ConstructorBuilder newCtor = newType.DefineConstructor( (baseCtor.Attributes & ~MethodAttributes.MemberAccessMask) | MethodAttributes.Public /* force public constructor */, baseCtor.CallingConvention, parameterTypes); // parameter 0 is 'this', so we start at index 1 for (int i = 0; i < parameters.Length; i++) { newCtor.DefineParameter(i + 1, parameters[i].Attributes, parameters[i].Name); } // load all arguments (including 'this') in proper order, then call and return ILGenerator ilGen = newCtor.GetILGenerator(); for (int i = 0; i <= parameterTypes.Length; i++) { ilGen.Emit(OpCodes.Ldarg_S, (byte)i); } ilGen.Emit(OpCodes.Call, baseCtor); ilGen.Emit(OpCodes.Ret); }
private static void ImplementConstructor(TypeBuilder newType, ConstructorInfo baseConstructor) { var parameters = baseConstructor.GetParameters(); var parameterTypes = parameters.Select(p => p.ParameterType).ToArray(); var constructor = newType.DefineConstructor(MethodAttributes.Public, baseConstructor.CallingConvention, parameterTypes); // parameter 0 is 'this', so we start at index 1 for (int i = 0; i < parameters.Length; i++) { constructor.DefineParameter(i + 1, parameters[i].Attributes, parameters[i].Name); } var ilGenerator = constructor.GetILGenerator(); for (int i = 0; i <= parameterTypes.Length; i++) { ilGenerator.Emit(OpCodes.Ldarg_S, (byte)i); } ilGenerator.Emit(OpCodes.Call, baseConstructor); ilGenerator.Emit(OpCodes.Ret); }
private static void ImplementConstructor(TypeBuilder newType, ConstructorInfo baseCtor) { ParameterInfo[] parameters = baseCtor.GetParameters(); Type[] parameterTypes = new Type[parameters.Length]; for (int idx = 0; idx < parameters.Length; idx++) parameterTypes[idx] = parameters[idx].ParameterType; ConstructorBuilder newCtor = newType.DefineConstructor( (baseCtor.Attributes & ~MethodAttributes.MemberAccessMask) | MethodAttributes.Public /* force public constructor */, baseCtor.CallingConvention, parameterTypes); for (int i = 0; i < parameters.Length; i++) newCtor.DefineParameter(i + 1, parameters[i].Attributes, parameters[i].Name); ILGenerator ilGen = newCtor.GetILGenerator(); for (int i = 0; i <= parameterTypes.Length; i++) ilGen.Emit(OpCodes.Ldarg_S, (byte)i); ilGen.Emit(OpCodes.Call, baseCtor); ilGen.Emit(OpCodes.Ret); }
public void DefineContextType() { linqContextBuilder = cg.IL.TypeBuilder.DefineNestedType(ContextTypeName + cg.IL.GetNextUniqueIndex(), TypeAttributes.Class | TypeAttributes.NestedPrivate | TypeAttributes.Sealed, typeof(PHP.Core.LinqContext), null); // .ctor: ConstructorBuilder ctor = linqContextBuilder.DefineConstructor(MethodAttributes.Assembly, CallingConventions.HasThis, Types.LinqContextArgs); ILEmitter il = new ILEmitter(ctor); il.Ldarg(0); il.Ldarg(1); il.Ldarg(2); il.Ldarg(3); il.Ldarg(4); il.Emit(OpCodes.Call, Constructors.LinqContext); il.Emit(OpCodes.Ret); linqContextCtor = ctor; }
public DataServiceContextGenerator(Uri serviceRoot) { AssemblyName myAsmName = new AssemblyName("DynamicAssembly" + Guid.NewGuid().ToString()); AssemblyBuilder myAsmBuilder = Thread.GetDomain().DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run); // Generate a single-module assembly. _moduleBuilder = myAsmBuilder.DefineDynamicModule(myAsmName.Name); _contextTypeBuilder = _moduleBuilder.DefineType("MyDataContext", TypeAttributes.Public, typeof(MyDataServiceContext)); ConstructorBuilder ctorBuilder = _contextTypeBuilder.DefineConstructor( MethodAttributes.Public, CallingConventions.Standard, null); ILGenerator ctorIL = ctorBuilder.GetILGenerator(); ctorIL.Emit(OpCodes.Ldarg_0); ctorIL.Emit(OpCodes.Ldstr, serviceRoot.AbsoluteUri); ctorIL.Emit(OpCodes.Newobj, typeof(Uri).GetConstructor(new[] { typeof(string) })); ctorIL.Emit(OpCodes.Call, typeof(MyDataServiceContext).GetConstructors().First()); ctorIL.Emit(OpCodes.Ret); }
private static void AddParentConstructor(TypeBuilder typeBuilder, Type parentType) { var parentConstructor = parentType.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.CreateInstance | BindingFlags.Instance).First(); var parentParameters = parentConstructor.GetParameters(); var parameterTypes = parentParameters.Select(x => x.ParameterType).ToArray(); var constructorBuilder = typeBuilder.DefineConstructor(parentConstructor.Attributes | MethodAttributes.Public, parentConstructor.CallingConvention, parameterTypes); var generator = constructorBuilder.GetILGenerator(); // load 'this' pointer generator.Emit(OpCodes.Ldarg_0); for (var i = 1; i <= parentParameters.Length; i++) { var parentParameter = parentParameters[i - 1]; constructorBuilder.DefineParameter(i, parentParameter.Attributes, parentParameter.Name); generator.Emit(OpCodes.Ldarg_S, i); } generator.Emit(OpCodes.Call, parentConstructor); generator.Emit(OpCodes.Ret); }
void SetUp (AssemblyBuilderAccess access) { AssemblyName assemblyName = new AssemblyName (); assemblyName.Name = ASSEMBLY_NAME; assembly = AppDomain.CurrentDomain.DefineDynamicAssembly ( assemblyName, access, Path.GetTempPath ()); module = assembly.DefineDynamicModule ("module1"); tb = module.DefineType ("Bar"); GenericTypeParameterBuilder [] typeParams = tb.DefineGenericParameters ("T"); cb = tb.DefineConstructor (MethodAttributes.Public, CallingConventions.Standard, new Type [] { typeof (string), typeof (int) }); ILGenerator ig = cb.GetILGenerator (); ig.Emit (OpCodes.Ret); typeBarOfInt32 = tb.MakeGenericType (typeof (int)); ci = TypeBuilder.GetConstructor (typeBarOfInt32, cb); }
public static void ImplementIn(this ConstructorInfo constructorInfo, TypeBuilder proxy) { var arguments = constructorInfo.GetParameters(); var types = arguments.Select(arg => arg.GetType()).ToArray(); var constructor = proxy.DefineConstructor(MethodAttributes.Public, constructorInfo.CallingConvention, types); for (var index = 0; index < arguments.Length; index++) { var argument = arguments[index]; constructor.DefineParameter(index, argument.Attributes, argument.Name); } var generator = constructor.GetILGenerator(); for (var index = 0; index <= types.Length; index++) { // generator.Emit(OpCodes.Ldarg_S, (byte)index); generator.Emit(OpCodes.Ldarg_S, index); } generator.Emit(OpCodes.Call, constructorInfo); generator.Emit(OpCodes.Ret); }
private static void AddConstructor(TypeBuilder typeBuilder, Type serviceInterface, FieldInfo proxyField, Type baseType) { var constructorBuilder = typeBuilder.DefineConstructor( MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, CallingConventions.HasThis, new[] { serviceInterface }); // Generate the constructor IL. var gen = constructorBuilder.GetILGenerator(); // The constructor calls the base constructor with the string[] parameter. gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Call, baseType.GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, Type.DefaultBinder, Type.EmptyTypes, null)); gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Ldarg_1); gen.Emit(OpCodes.Stfld, proxyField); gen.Emit(OpCodes.Ret); }
private static void GenerateConstructor( TypeBuilder typeBuilder, TypeMetadata typeMetadata, ConstructorMetadata constructorMetadata, FieldMetadataFieldBuilderMap fieldBuilders) { var constructor = typeBuilder.DefineConstructor( constructorMetadata.MethodAttributes, CallingConventions.Standard, constructorMetadata.ParameterTypes); DefineParameterNames(constructor, constructorMetadata); var il = constructor.GetILGenerator(); InitializeInstanceFields(il, typeMetadata, constructorMetadata, fieldBuilders); if (constructorMetadata.CallBaseConstructor) { GenerateBaseConstructorCall(il, constructorMetadata); } il.Emit(OpCodes.Ret); }
public static ConstructorBuilder DefineConstructor(this TypeBuilder tb, MethodAttributes attributes, CallingConventions callingConventions, GenericTypeParameterBuilder[] parameterTypes) { return(tb.DefineConstructor(attributes, callingConventions, parameterTypes.Select(g => g.AsType()).ToArray())); }
/// <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()); }