C# TypeBuilder.DefineConstructor方法代码示例

        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);
        }

 /// <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 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 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);
 }

        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);
        }

        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);
        }

        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);
 }