AssemblyBuilder 類別

定義

定義及表示動態組件。

public ref class AssemblyBuilder sealed : System::Reflection::Assembly
public ref class AssemblyBuilder sealed : System::Reflection::Assembly, System::Runtime::InteropServices::_AssemblyBuilder
public ref class AssemblyBuilder : System::Reflection::Assembly
public sealed class AssemblyBuilder : System.Reflection.Assembly
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public sealed class AssemblyBuilder : System.Reflection.Assembly, System.Runtime.InteropServices._AssemblyBuilder
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class AssemblyBuilder : System.Reflection.Assembly, System.Runtime.InteropServices._AssemblyBuilder
public class AssemblyBuilder : System.Reflection.Assembly
type AssemblyBuilder = class
    inherit Assembly
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type AssemblyBuilder = class
    inherit Assembly
    interface _AssemblyBuilder
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type AssemblyBuilder = class
    inherit Assembly
    interface _AssemblyBuilder
Public NotInheritable Class AssemblyBuilder
Inherits Assembly
Public NotInheritable Class AssemblyBuilder
Inherits Assembly
Implements _AssemblyBuilder
Public Class AssemblyBuilder
Inherits Assembly
繼承
AssemblyBuilder
屬性
實作

範例

下列程式碼範例示範如何定義和使用動態元件。 此範例元件包含一種類型 , MyDynamicType 其具有私用欄位、取得和設定私用欄位的屬性、初始化私用欄位的建構函式,以及乘以私用域值乘以使用者提供數位的方法,並傳回結果。

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;

void main()
{
    // This code creates an assembly that contains one type,
    // named "MyDynamicType", that has a private field, a property
    // that gets and sets the private field, constructors that
    // initialize the private field, and a method that multiplies
    // a user-supplied number by the private field value and returns
    // the result. In Visual C++ the type might look like this:
    /*
      public ref class MyDynamicType
      {
      private:
          int m_number;

      public:
          MyDynamicType() : m_number(42) {};
          MyDynamicType(int initNumber) : m_number(initNumber) {};
      
          property int Number
          {
              int get() { return m_number; }
              void set(int value) { m_number = value; }
          }

          int MyMethod(int multiplier)
          {
              return m_number * multiplier;
          }
      };
    */
      
    AssemblyName^ aName = gcnew AssemblyName("DynamicAssemblyExample");
    AssemblyBuilder^ ab = 
        AssemblyBuilder::DefineDynamicAssembly(
            aName, 
            AssemblyBuilderAccess::Run);

    // The module name is usually the same as the assembly name
    ModuleBuilder^ mb = 
        ab->DefineDynamicModule(aName->Name);
      
    TypeBuilder^ tb = mb->DefineType(
        "MyDynamicType", 
         TypeAttributes::Public);

    // Add a private field of type int (Int32).
    FieldBuilder^ fbNumber = tb->DefineField(
        "m_number", 
        int::typeid, 
        FieldAttributes::Private);

    // Define a constructor that takes an integer argument and 
    // stores it in the private field. 
    array<Type^>^ parameterTypes = { int::typeid };
    ConstructorBuilder^ ctor1 = tb->DefineConstructor(
        MethodAttributes::Public, 
        CallingConventions::Standard, 
        parameterTypes);

    ILGenerator^ ctor1IL = ctor1->GetILGenerator();
    // For a constructor, argument zero is a reference to the new
    // instance. Push it on the stack before calling the base
    // class constructor. Specify the default constructor of the 
    // base class (System::Object) by passing an empty array of 
    // types (Type::EmptyTypes) to GetConstructor.
    ctor1IL->Emit(OpCodes::Ldarg_0);
    ctor1IL->Emit(OpCodes::Call, 
        Object::typeid->GetConstructor(Type::EmptyTypes));
    // Push the instance on the stack before pushing the argument
    // that is to be assigned to the private field m_number.
    ctor1IL->Emit(OpCodes::Ldarg_0);
    ctor1IL->Emit(OpCodes::Ldarg_1);
    ctor1IL->Emit(OpCodes::Stfld, fbNumber);
    ctor1IL->Emit(OpCodes::Ret);

    // Define a default constructor that supplies a default value
    // for the private field. For parameter types, pass the empty
    // array of types or pass nullptr.
    ConstructorBuilder^ ctor0 = tb->DefineConstructor(
        MethodAttributes::Public, 
        CallingConventions::Standard, 
        Type::EmptyTypes);

    ILGenerator^ ctor0IL = ctor0->GetILGenerator();
    ctor0IL->Emit(OpCodes::Ldarg_0);
    ctor0IL->Emit(OpCodes::Call, 
        Object::typeid->GetConstructor(Type::EmptyTypes));
    // For a constructor, argument zero is a reference to the new
    // instance. Push it on the stack before pushing the default
    // value on the stack.
    ctor0IL->Emit(OpCodes::Ldarg_0);
    ctor0IL->Emit(OpCodes::Ldc_I4_S, 42);
    ctor0IL->Emit(OpCodes::Stfld, fbNumber);
    ctor0IL->Emit(OpCodes::Ret);

    // Define a property named Number that gets and sets the private 
    // field.
    //
    // The last argument of DefineProperty is nullptr, because the
    // property has no parameters. (If you don't specify nullptr, you must
    // specify an array of Type objects. For a parameterless property,
    // use the built-in array with no elements: Type::EmptyTypes)
    PropertyBuilder^ pbNumber = tb->DefineProperty(
        "Number", 
        PropertyAttributes::HasDefault, 
        int::typeid, 
        nullptr);
      
    // The property "set" and property "get" methods require a special
    // set of attributes.
    MethodAttributes getSetAttr = MethodAttributes::Public | 
        MethodAttributes::SpecialName | MethodAttributes::HideBySig;

    // Define the "get" accessor method for Number. The method returns
    // an integer and has no arguments. (Note that nullptr could be 
    // used instead of Types::EmptyTypes)
    MethodBuilder^ mbNumberGetAccessor = tb->DefineMethod(
        "get_Number", 
        getSetAttr, 
        int::typeid, 
        Type::EmptyTypes);
      
    ILGenerator^ numberGetIL = mbNumberGetAccessor->GetILGenerator();
    // For an instance property, argument zero is the instance. Load the 
    // instance, then load the private field and return, leaving the
    // field value on the stack.
    numberGetIL->Emit(OpCodes::Ldarg_0);
    numberGetIL->Emit(OpCodes::Ldfld, fbNumber);
    numberGetIL->Emit(OpCodes::Ret);
    
    // Define the "set" accessor method for Number, which has no return
    // type and takes one argument of type int (Int32).
    MethodBuilder^ mbNumberSetAccessor = tb->DefineMethod(
        "set_Number", 
        getSetAttr, 
        nullptr, 
        gcnew array<Type^> { int::typeid });
      
    ILGenerator^ numberSetIL = mbNumberSetAccessor->GetILGenerator();
    // Load the instance and then the numeric argument, then store the
    // argument in the field.
    numberSetIL->Emit(OpCodes::Ldarg_0);
    numberSetIL->Emit(OpCodes::Ldarg_1);
    numberSetIL->Emit(OpCodes::Stfld, fbNumber);
    numberSetIL->Emit(OpCodes::Ret);
      
    // Last, map the "get" and "set" accessor methods to the 
    // PropertyBuilder. The property is now complete. 
    pbNumber->SetGetMethod(mbNumberGetAccessor);
    pbNumber->SetSetMethod(mbNumberSetAccessor);

    // Define a method that accepts an integer argument and returns
    // the product of that integer and the private field m_number. This
    // time, the array of parameter types is created on the fly.
    MethodBuilder^ meth = tb->DefineMethod(
        "MyMethod", 
        MethodAttributes::Public, 
        int::typeid, 
        gcnew array<Type^> { int::typeid });

    ILGenerator^ methIL = meth->GetILGenerator();
    // To retrieve the private instance field, load the instance it
    // belongs to (argument zero). After loading the field, load the 
    // argument one and then multiply. Return from the method with 
    // the return value (the product of the two numbers) on the 
    // execution stack.
    methIL->Emit(OpCodes::Ldarg_0);
    methIL->Emit(OpCodes::Ldfld, fbNumber);
    methIL->Emit(OpCodes::Ldarg_1);
    methIL->Emit(OpCodes::Mul);
    methIL->Emit(OpCodes::Ret);

    // Finish the type->
    Type^ t = tb->CreateType();

    // Because AssemblyBuilderAccess includes Run, the code can be
    // executed immediately. Start by getting reflection objects for
    // the method and the property.
    MethodInfo^ mi = t->GetMethod("MyMethod");
    PropertyInfo^ pi = t->GetProperty("Number");
  
    // Create an instance of MyDynamicType using the default 
    // constructor. 
    Object^ o1 = Activator::CreateInstance(t);

    // Display the value of the property, then change it to 127 and 
    // display it again. Use nullptr to indicate that the property
    // has no index.
    Console::WriteLine("o1->Number: {0}", pi->GetValue(o1, nullptr));
    pi->SetValue(o1, 127, nullptr);
    Console::WriteLine("o1->Number: {0}", pi->GetValue(o1, nullptr));

    // Call MyMethod, passing 22, and display the return value, 22
    // times 127. Arguments must be passed as an array, even when
    // there is only one.
    array<Object^>^ arguments = { 22 };
    Console::WriteLine("o1->MyMethod(22): {0}", 
        mi->Invoke(o1, arguments));

    // Create an instance of MyDynamicType using the constructor
    // that specifies m_Number. The constructor is identified by
    // matching the types in the argument array. In this case, 
    // the argument array is created on the fly. Display the 
    // property value.
    Object^ o2 = Activator::CreateInstance(t, 
        gcnew array<Object^> { 5280 });
    Console::WriteLine("o2->Number: {0}", pi->GetValue(o2, nullptr));
};

/* This code produces the following output:

o1->Number: 42
o1->Number: 127
o1->MyMethod(22): 2794
o2->Number: 5280
 */
using System;
using System.Reflection;
using System.Reflection.Emit;

class DemoAssemblyBuilder
{
    public static void Main()
    {
        // This code creates an assembly that contains one type,
        // named "MyDynamicType", that has a private field, a property
        // that gets and sets the private field, constructors that
        // initialize the private field, and a method that multiplies
        // a user-supplied number by the private field value and returns
        // the result. In C# the type might look like this:
        /*
        public class MyDynamicType
        {
            private int m_number;

            public MyDynamicType() : this(42) {}
            public MyDynamicType(int initNumber)
            {
                m_number = initNumber;
            }

            public int Number
            {
                get { return m_number; }
                set { m_number = value; }
            }

            public int MyMethod(int multiplier)
            {
                return m_number * multiplier;
            }
        }
        */

        AssemblyName aName = new AssemblyName("DynamicAssemblyExample");
        AssemblyBuilder ab =
            AssemblyBuilder.DefineDynamicAssembly(
                aName,
                AssemblyBuilderAccess.Run);

        // The module name is usually the same as the assembly name.
        ModuleBuilder mb =
            ab.DefineDynamicModule(aName.Name);

        TypeBuilder tb = mb.DefineType(
            "MyDynamicType",
             TypeAttributes.Public);

        // Add a private field of type int (Int32).
        FieldBuilder fbNumber = tb.DefineField(
            "m_number",
            typeof(int),
            FieldAttributes.Private);

        // Define a constructor that takes an integer argument and
        // stores it in the private field.
        Type[] parameterTypes = { typeof(int) };
        ConstructorBuilder ctor1 = tb.DefineConstructor(
            MethodAttributes.Public,
            CallingConventions.Standard,
            parameterTypes);

        ILGenerator ctor1IL = ctor1.GetILGenerator();
        // For a constructor, argument zero is a reference to the new
        // instance. Push it on the stack before calling the base
        // class constructor. Specify the default constructor of the
        // base class (System.Object) by passing an empty array of
        // types (Type.EmptyTypes) to GetConstructor.
        ctor1IL.Emit(OpCodes.Ldarg_0);
        ctor1IL.Emit(OpCodes.Call,
            typeof(object).GetConstructor(Type.EmptyTypes));
        // Push the instance on the stack before pushing the argument
        // that is to be assigned to the private field m_number.
        ctor1IL.Emit(OpCodes.Ldarg_0);
        ctor1IL.Emit(OpCodes.Ldarg_1);
        ctor1IL.Emit(OpCodes.Stfld, fbNumber);
        ctor1IL.Emit(OpCodes.Ret);

        // Define a default constructor that supplies a default value
        // for the private field. For parameter types, pass the empty
        // array of types or pass null.
        ConstructorBuilder ctor0 = tb.DefineConstructor(
            MethodAttributes.Public,
            CallingConventions.Standard,
            Type.EmptyTypes);

        ILGenerator ctor0IL = ctor0.GetILGenerator();
        // For a constructor, argument zero is a reference to the new
        // instance. Push it on the stack before pushing the default
        // value on the stack, then call constructor ctor1.
        ctor0IL.Emit(OpCodes.Ldarg_0);
        ctor0IL.Emit(OpCodes.Ldc_I4_S, 42);
        ctor0IL.Emit(OpCodes.Call, ctor1);
        ctor0IL.Emit(OpCodes.Ret);

        // Define a property named Number that gets and sets the private
        // field.
        //
        // The last argument of DefineProperty is null, because the
        // property has no parameters. (If you don't specify null, you must
        // specify an array of Type objects. For a parameterless property,
        // use the built-in array with no elements: Type.EmptyTypes)
        PropertyBuilder pbNumber = tb.DefineProperty(
            "Number",
            PropertyAttributes.HasDefault,
            typeof(int),
            null);

        // The property "set" and property "get" methods require a special
        // set of attributes.
        MethodAttributes getSetAttr = MethodAttributes.Public |
            MethodAttributes.SpecialName | MethodAttributes.HideBySig;

        // Define the "get" accessor method for Number. The method returns
        // an integer and has no arguments. (Note that null could be
        // used instead of Types.EmptyTypes)
        MethodBuilder mbNumberGetAccessor = tb.DefineMethod(
            "get_Number",
            getSetAttr,
            typeof(int),
            Type.EmptyTypes);

        ILGenerator numberGetIL = mbNumberGetAccessor.GetILGenerator();
        // For an instance property, argument zero is the instance. Load the
        // instance, then load the private field and return, leaving the
        // field value on the stack.
        numberGetIL.Emit(OpCodes.Ldarg_0);
        numberGetIL.Emit(OpCodes.Ldfld, fbNumber);
        numberGetIL.Emit(OpCodes.Ret);

        // Define the "set" accessor method for Number, which has no return
        // type and takes one argument of type int (Int32).
        MethodBuilder mbNumberSetAccessor = tb.DefineMethod(
            "set_Number",
            getSetAttr,
            null,
            new Type[] { typeof(int) });

        ILGenerator numberSetIL = mbNumberSetAccessor.GetILGenerator();
        // Load the instance and then the numeric argument, then store the
        // argument in the field.
        numberSetIL.Emit(OpCodes.Ldarg_0);
        numberSetIL.Emit(OpCodes.Ldarg_1);
        numberSetIL.Emit(OpCodes.Stfld, fbNumber);
        numberSetIL.Emit(OpCodes.Ret);

        // Last, map the "get" and "set" accessor methods to the
        // PropertyBuilder. The property is now complete.
        pbNumber.SetGetMethod(mbNumberGetAccessor);
        pbNumber.SetSetMethod(mbNumberSetAccessor);

        // Define a method that accepts an integer argument and returns
        // the product of that integer and the private field m_number. This
        // time, the array of parameter types is created on the fly.
        MethodBuilder meth = tb.DefineMethod(
            "MyMethod",
            MethodAttributes.Public,
            typeof(int),
            new Type[] { typeof(int) });

        ILGenerator methIL = meth.GetILGenerator();
        // To retrieve the private instance field, load the instance it
        // belongs to (argument zero). After loading the field, load the
        // argument one and then multiply. Return from the method with
        // the return value (the product of the two numbers) on the
        // execution stack.
        methIL.Emit(OpCodes.Ldarg_0);
        methIL.Emit(OpCodes.Ldfld, fbNumber);
        methIL.Emit(OpCodes.Ldarg_1);
        methIL.Emit(OpCodes.Mul);
        methIL.Emit(OpCodes.Ret);

        // Finish the type.
        Type t = tb.CreateType();                

        // Because AssemblyBuilderAccess includes Run, the code can be
        // executed immediately. Start by getting reflection objects for
        // the method and the property.
        MethodInfo mi = t.GetMethod("MyMethod");
        PropertyInfo pi = t.GetProperty("Number");

        // Create an instance of MyDynamicType using the default
        // constructor.
        object o1 = Activator.CreateInstance(t);

        // Display the value of the property, then change it to 127 and
        // display it again. Use null to indicate that the property
        // has no index.
        Console.WriteLine("o1.Number: {0}", pi.GetValue(o1, null));
        pi.SetValue(o1, 127, null);
        Console.WriteLine("o1.Number: {0}", pi.GetValue(o1, null));

        // Call MyMethod, passing 22, and display the return value, 22
        // times 127. Arguments must be passed as an array, even when
        // there is only one.
        object[] arguments = { 22 };
        Console.WriteLine("o1.MyMethod(22): {0}",
            mi.Invoke(o1, arguments));

        // Create an instance of MyDynamicType using the constructor
        // that specifies m_Number. The constructor is identified by
        // matching the types in the argument array. In this case,
        // the argument array is created on the fly. Display the
        // property value.
        object o2 = Activator.CreateInstance(t,
            new object[] { 5280 });
        Console.WriteLine("o2.Number: {0}", pi.GetValue(o2, null));
    }
}

/* This code produces the following output:

o1.Number: 42
o1.Number: 127
o1.MyMethod(22): 2794
o2.Number: 5280
 */
open System
open System.Threading
open System.Reflection
open System.Reflection.Emit

// This code creates an assembly that contains one type,
// named "MyDynamicType", that has a private field, a property
// that gets and sets the private field, constructors that
// initialize the private field, and a method that multiplies
// a user-supplied number by the private field value and returns
// the result. In C# the type might look like this:
(*
public class MyDynamicType
{
    private int m_number;

    public MyDynamicType() : this(42) {}
    public MyDynamicType(int initNumber)
    {
        m_number = initNumber;
    }

    public int Number
    {
        get { return m_number; }
        set { m_number = value; }
    }

    public int MyMethod(int multiplier)
    {
        return m_number * multiplier;
    }
}
*)

let assemblyName = new AssemblyName("DynamicAssemblyExample")
let assemblyBuilder =
    AssemblyBuilder.DefineDynamicAssembly(
        assemblyName,
        AssemblyBuilderAccess.Run)

// The module name is usually the same as the assembly name.
let moduleBuilder =
    assemblyBuilder.DefineDynamicModule(assemblyName.Name)

let typeBuilder =
    moduleBuilder.DefineType(
        "MyDynamicType",
        TypeAttributes.Public)

// Add a private field of type int (Int32)
let fieldBuilderNumber =
    typeBuilder.DefineField(
        "m_number",
        typeof<int>,
        FieldAttributes.Private)

// Define a constructor1 that takes an integer argument and
// stores it in the private field.
let parameterTypes = [| typeof<int> |]
let ctor1 =
    typeBuilder.DefineConstructor(
        MethodAttributes.Public,
        CallingConventions.Standard,
        parameterTypes)

let ctor1IL = ctor1.GetILGenerator()

// For a constructor, argument zero is a reference to the new
// instance. Push it on the stack before calling the base
// class constructor. Specify the default constructor of the
// base class (System.Object) by passing an empty array of
// types (Type.EmptyTypes) to GetConstructor.
ctor1IL.Emit(OpCodes.Ldarg_0)
ctor1IL.Emit(OpCodes.Call,
                 typeof<obj>.GetConstructor(Type.EmptyTypes))

// Push the instance on the stack before pushing the argument
// that is to be assigned to the private field m_number.
ctor1IL.Emit(OpCodes.Ldarg_0)
ctor1IL.Emit(OpCodes.Ldarg_1)
ctor1IL.Emit(OpCodes.Stfld, fieldBuilderNumber)
ctor1IL.Emit(OpCodes.Ret)

// Define a default constructor1 that supplies a default value
// for the private field. For parameter types, pass the empty
// array of types or pass null.
let ctor0 =
    typeBuilder.DefineConstructor(
        MethodAttributes.Public,
        CallingConventions.Standard,
        Type.EmptyTypes)

let ctor0IL = ctor0.GetILGenerator()
// For a constructor, argument zero is a reference to the new
// instance. Push it on the stack before pushing the default
// value on the stack, then call constructor ctor1.
ctor0IL.Emit(OpCodes.Ldarg_0)
ctor0IL.Emit(OpCodes.Ldc_I4_S, 42)
ctor0IL.Emit(OpCodes.Call, ctor1)
ctor0IL.Emit(OpCodes.Ret)

// Define a property named Number that gets and sets the private
// field.
//
// The last argument of DefineProperty is null, because the
// property has no parameters. (If you don't specify null, you must
// specify an array of Type objects. For a parameterless property,
// use the built-in array with no elements: Type.EmptyTypes)
let propertyBuilderNumber =
    typeBuilder.DefineProperty(
        "Number",
        PropertyAttributes.HasDefault,
        typeof<int>,
        null)

// The property "set" and property "get" methods require a special
// set of attributes.
let getSetAttr = MethodAttributes.Public ||| MethodAttributes.SpecialName ||| MethodAttributes.HideBySig

// Define the "get" accessor method for Number. The method returns
// an integer and has no arguments. (Note that null could be
// used instead of Types.EmptyTypes)
let methodBuilderNumberGetAccessor =
    typeBuilder.DefineMethod(
        "get_number",
        getSetAttr,
        typeof<int>,
        Type.EmptyTypes)

let numberGetIL =
    methodBuilderNumberGetAccessor.GetILGenerator()

// For an instance property, argument zero ir the instance. Load the
// instance, then load the private field and return, leaving the
// field value on the stack.
numberGetIL.Emit(OpCodes.Ldarg_0)
numberGetIL.Emit(OpCodes.Ldfld, fieldBuilderNumber)
numberGetIL.Emit(OpCodes.Ret)

// Define the "set" accessor method for Number, which has no return
// type and takes one argument of type int (Int32).
let methodBuilderNumberSetAccessor =
    typeBuilder.DefineMethod(
        "set_number",
        getSetAttr,
        null,
        [| typeof<int> |])

let numberSetIL =
    methodBuilderNumberSetAccessor.GetILGenerator()
// Load the instance and then the numeric argument, then store the
// argument in the field
numberSetIL.Emit(OpCodes.Ldarg_0)
numberSetIL.Emit(OpCodes.Ldarg_1)
numberSetIL.Emit(OpCodes.Stfld, fieldBuilderNumber)
numberSetIL.Emit(OpCodes.Ret)

// Last, map the "get" and "set" accessor methods to the
// PropertyBuilder. The property is now complete.
propertyBuilderNumber.SetGetMethod(methodBuilderNumberGetAccessor)
propertyBuilderNumber.SetSetMethod(methodBuilderNumberSetAccessor)

// Define a method that accepts an integer argument and returns
// the product of that integer and the private field m_number. This
// time, the array of parameter types is created on the fly.
let methodBuilder =
    typeBuilder.DefineMethod(
        "MyMethod",
        MethodAttributes.Public,
        typeof<int>,
        [| typeof<int> |])

let methodIL = methodBuilder.GetILGenerator()
// To retrieve the private instance field, load the instance it
// belongs to (argument zero). After loading the field, load the
// argument one and then multiply. Return from the method with
// the return value (the product of the two numbers) on the
// execution stack.
methodIL.Emit(OpCodes.Ldarg_0)
methodIL.Emit(OpCodes.Ldfld, fieldBuilderNumber)
methodIL.Emit(OpCodes.Ldarg_1)
methodIL.Emit(OpCodes.Mul)
methodIL.Emit(OpCodes.Ret)

// Finish the type
let typ = typeBuilder.CreateType()

// Because AssemblyBuilderAccess includes Run, the code can be
// executed immediately. Start by getting reflection objects for
// the method and the property.
let methodInfo = typ.GetMethod("MyMethod")
let propertyInfo = typ.GetProperty("Number")

// Create an instance of MyDynamicType using the default
// constructor.
let obj1 = Activator.CreateInstance(typ)

// Display the value of the property, then change it to 127 and
// display it again. Use null to indicate that the property
// has no index.
printfn "obj1.Number: %A" (propertyInfo.GetValue(obj1, null))
propertyInfo.SetValue(obj1, 127, null)
printfn "obj1.Number: %A" (propertyInfo.GetValue(obj1, null))

// Call MyMethod, pasing 22, and display the return value, 22
// times 127. Arguments must be passed as an array, even when
// there is only one.
let arguments: obj array = [| 22 |]
printfn "obj1.MyMethod(22): %A" (methodInfo.Invoke(obj1, arguments))

// Create an instance of MyDynamicType using the constructor
// that specifies m_Number. The constructor is identified by
// matching the types in the argument array. In this case,
// the argument array is created on the fly. Display the
// property value.
let constructorArguments: obj array = [| 5280 |]
let obj2 = Activator.CreateInstance(typ, constructorArguments)
printfn "obj2.Number: %A" (propertyInfo.GetValue(obj2, null))

(* This code produces the following output:

obj1.Number: 42
obj1.Number: 127
obj1.MyMethod(22): 2794
obj1.Number: 5280
*)
Imports System.Reflection
Imports System.Reflection.Emit

Class DemoAssemblyBuilder

    Public Shared Sub Main()

        ' This code creates an assembly that contains one type,
        ' named "MyDynamicType", that has a private field, a property
        ' that gets and sets the private field, constructors that
        ' initialize the private field, and a method that multiplies
        ' a user-supplied number by the private field value and returns
        ' the result. The code might look like this in Visual Basic:
        '
        'Public Class MyDynamicType
        '    Private m_number As Integer
        '
        '    Public Sub New()
        '        Me.New(42)
        '    End Sub
        '
        '    Public Sub New(ByVal initNumber As Integer)
        '        m_number = initNumber
        '    End Sub
        '
        '    Public Property Number As Integer
        '        Get
        '            Return m_number
        '        End Get
        '        Set
        '            m_Number = Value
        '        End Set
        '    End Property
        '
        '    Public Function MyMethod(ByVal multiplier As Integer) As Integer
        '        Return m_Number * multiplier
        '    End Function
        'End Class
      
        Dim aName As New AssemblyName("DynamicAssemblyExample")
        Dim ab As AssemblyBuilder = _
            AssemblyBuilder.DefineDynamicAssembly( _
                aName, _
                AssemblyBuilderAccess.Run)

        ' The module name is usually the same as the assembly name.
        Dim mb As ModuleBuilder = ab.DefineDynamicModule( _
            aName.Name)
      
        Dim tb As TypeBuilder = _
            mb.DefineType("MyDynamicType", TypeAttributes.Public)

        ' Add a private field of type Integer (Int32).
        Dim fbNumber As FieldBuilder = tb.DefineField( _
            "m_number", _
            GetType(Integer), _
            FieldAttributes.Private)

        ' Define a constructor that takes an integer argument and 
        ' stores it in the private field. 
        Dim parameterTypes() As Type = { GetType(Integer) }
        Dim ctor1 As ConstructorBuilder = _
            tb.DefineConstructor( _
                MethodAttributes.Public, _
                CallingConventions.Standard, _
                parameterTypes)

        Dim ctor1IL As ILGenerator = ctor1.GetILGenerator()
        ' For a constructor, argument zero is a reference to the new
        ' instance. Push it on the stack before calling the base
        ' class constructor. Specify the default constructor of the 
        ' base class (System.Object) by passing an empty array of 
        ' types (Type.EmptyTypes) to GetConstructor.
        ctor1IL.Emit(OpCodes.Ldarg_0)
        ctor1IL.Emit(OpCodes.Call, _
            GetType(Object).GetConstructor(Type.EmptyTypes))
        ' Push the instance on the stack before pushing the argument
        ' that is to be assigned to the private field m_number.
        ctor1IL.Emit(OpCodes.Ldarg_0)
        ctor1IL.Emit(OpCodes.Ldarg_1)
        ctor1IL.Emit(OpCodes.Stfld, fbNumber)
        ctor1IL.Emit(OpCodes.Ret)

        ' Define a default constructor that supplies a default value
        ' for the private field. For parameter types, pass the empty
        ' array of types or pass Nothing.
        Dim ctor0 As ConstructorBuilder = tb.DefineConstructor( _
            MethodAttributes.Public, _
            CallingConventions.Standard, _
            Type.EmptyTypes)

        Dim ctor0IL As ILGenerator = ctor0.GetILGenerator()
        ' For a constructor, argument zero is a reference to the new
        ' instance. Push it on the stack before pushing the default
        ' value on the stack, then call constructor ctor1.
        ctor0IL.Emit(OpCodes.Ldarg_0)
        ctor0IL.Emit(OpCodes.Ldc_I4_S, 42)
        ctor0IL.Emit(OpCodes.Call, ctor1)
        ctor0IL.Emit(OpCodes.Ret)

        ' Define a property named Number that gets and sets the private 
        ' field.
        '
        ' The last argument of DefineProperty is Nothing, because the
        ' property has no parameters. (If you don't specify Nothing, you must
        ' specify an array of Type objects. For a parameterless property,
        ' use the built-in array with no elements: Type.EmptyTypes)
        Dim pbNumber As PropertyBuilder = tb.DefineProperty( _
            "Number", _
            PropertyAttributes.HasDefault, _
            GetType(Integer), _
            Nothing)
      
        ' The property Set and property Get methods require a special
        ' set of attributes.
        Dim getSetAttr As MethodAttributes = _
            MethodAttributes.Public Or MethodAttributes.SpecialName _
                Or MethodAttributes.HideBySig

        ' Define the "get" accessor method for Number. The method returns
        ' an integer and has no arguments. (Note that Nothing could be 
        ' used instead of Types.EmptyTypes)
        Dim mbNumberGetAccessor As MethodBuilder = tb.DefineMethod( _
            "get_Number", _
            getSetAttr, _
            GetType(Integer), _
            Type.EmptyTypes)
      
        Dim numberGetIL As ILGenerator = mbNumberGetAccessor.GetILGenerator()
        ' For an instance property, argument zero is the instance. Load the 
        ' instance, then load the private field and return, leaving the
        ' field value on the stack.
        numberGetIL.Emit(OpCodes.Ldarg_0)
        numberGetIL.Emit(OpCodes.Ldfld, fbNumber)
        numberGetIL.Emit(OpCodes.Ret)
        
        ' Define the "set" accessor method for Number, which has no return
        ' type and takes one argument of type Integer (Int32).
        Dim mbNumberSetAccessor As MethodBuilder = _
            tb.DefineMethod( _
                "set_Number", _
                getSetAttr, _
                Nothing, _
                New Type() { GetType(Integer) })
      
        Dim numberSetIL As ILGenerator = mbNumberSetAccessor.GetILGenerator()
        ' Load the instance and then the numeric argument, then store the
        ' argument in the field.
        numberSetIL.Emit(OpCodes.Ldarg_0)
        numberSetIL.Emit(OpCodes.Ldarg_1)
        numberSetIL.Emit(OpCodes.Stfld, fbNumber)
        numberSetIL.Emit(OpCodes.Ret)
      
        ' Last, map the "get" and "set" accessor methods to the 
        ' PropertyBuilder. The property is now complete. 
        pbNumber.SetGetMethod(mbNumberGetAccessor)
        pbNumber.SetSetMethod(mbNumberSetAccessor)

        ' Define a method that accepts an integer argument and returns
        ' the product of that integer and the private field m_number. This
        ' time, the array of parameter types is created on the fly.
        Dim meth As MethodBuilder = tb.DefineMethod( _
            "MyMethod", _
            MethodAttributes.Public, _
            GetType(Integer), _
            New Type() { GetType(Integer) })

        Dim methIL As ILGenerator = meth.GetILGenerator()
        ' To retrieve the private instance field, load the instance it
        ' belongs to (argument zero). After loading the field, load the 
        ' argument one and then multiply. Return from the method with 
        ' the return value (the product of the two numbers) on the 
        ' execution stack.
        methIL.Emit(OpCodes.Ldarg_0)
        methIL.Emit(OpCodes.Ldfld, fbNumber)
        methIL.Emit(OpCodes.Ldarg_1)
        methIL.Emit(OpCodes.Mul)
        methIL.Emit(OpCodes.Ret)

        ' Finish the type.
        Dim t As Type = tb.CreateType()

        ' Because AssemblyBuilderAccess includes Run, the code can be
        ' executed immediately. Start by getting reflection objects for
        ' the method and the property.
        Dim mi As MethodInfo = t.GetMethod("MyMethod")
        Dim pi As PropertyInfo = t.GetProperty("Number")
  
        ' Create an instance of MyDynamicType using the default 
        ' constructor. 
        Dim o1 As Object = Activator.CreateInstance(t)

        ' Display the value of the property, then change it to 127 and 
        ' display it again. Use Nothing to indicate that the property
        ' has no index.
        Console.WriteLine("o1.Number: {0}", pi.GetValue(o1, Nothing))
        pi.SetValue(o1, 127, Nothing)
        Console.WriteLine("o1.Number: {0}", pi.GetValue(o1, Nothing))

        ' Call MyMethod, passing 22, and display the return value, 22
        ' times 127. Arguments must be passed as an array, even when
        ' there is only one.
        Dim arguments() As Object = { 22 }
        Console.WriteLine("o1.MyMethod(22): {0}", _
            mi.Invoke(o1, arguments))

        ' Create an instance of MyDynamicType using the constructor
        ' that specifies m_Number. The constructor is identified by
        ' matching the types in the argument array. In this case, 
        ' the argument array is created on the fly. Display the 
        ' property value.
        Dim o2 As Object = Activator.CreateInstance(t, _
            New Object() { 5280 })
        Console.WriteLine("o2.Number: {0}", pi.GetValue(o2, Nothing))
      
    End Sub  
End Class

' This code produces the following output:
'
'o1.Number: 42
'o1.Number: 127
'o1.MyMethod(22): 2794
'o2.Number: 5280

備註

動態元件是使用反映發出 API 建立的元件。 您可以使用 AssemblyBuilder 在記憶體中產生動態元件,並在相同的應用程式執行期間執行其程式碼。 動態元件可以參考另一個動態或靜態元件中定義的類型。

若要取得 AssemblyBuilder 物件,請使用 AssemblyBuilder.DefineDynamicAssembly 方法。

動態元件可以使用下列其中一種存取模式來建立:

定義動態元件且稍後無法變更時,必須在呼叫 AssemblyBuilder.DefineDynamicAssembly 方法時提供適當的 AssemblyBuilderAccess 值來指定存取模式。 執行時間會使用動態元件的存取模式,將元件的內部表示優化。

在.NET Framework中,您可以將動態元件儲存至檔案。 此功能不適用於 .NET Core 和 .NET 5 和更新版本。 如需產生元件檔案的替代方式,請參閱 MetadataBuilder

在.NET Framework中,動態元件可以包含一或多個動態模組。 如果動態元件包含一個以上的動態模組,元件的資訊清單檔案名應該符合指定為方法第一個引數 DefineDynamicModule 的模組名稱。 在 .NET Core 和 .NET 5+ 中,動態元件只能包含一個動態模組。

.NET Framework中可保存的動態元件

在.NET Framework中,動態元件和模組可以儲存至檔案。 為了支援這項功能, AssemblyBuilderAccess 列舉會宣告兩個額外的欄位: SaveRunAndSave 。 使用其中一種存取模式建立的動態元件稱為 可保存 元件,而一般記憶體專用元件稱為 暫時性 元件。

使用 方法儲存 Save 動態元件時,會儲存可保存動態元件中的動態模組。 若要產生可執行檔, SetEntryPoint 必須呼叫 方法,以識別元件進入點的方法。 除非方法要求產生主控台應用程式或以 Windows 為基礎的應用程式,否則 SetEntryPoint 元件預設會儲存為 DLL。

從 物件呼叫 AssemblyBuilder 時,基 Assembly 類上的某些方法,例如 GetModulesGetLoadedModules ,將無法正常運作。 您可以載入定義的動態元件,並在載入的元件上呼叫 方法。 例如,若要確保傳回的模組清單中包含資源模組,請在載入 Assembly 的物件上呼叫 GetModules

在將元件儲存到磁片之前,使用 KeyPair 的動態元件簽署無效。 因此,強式名稱不適用於暫時性動態元件。

動態元件可以參考另一個元件中定義的類型。 暫時性動態元件可以安全地參考另一個暫時性動態元件、可保存動態元件或靜態元件中定義的類型。 不過,Common Language Runtime 不允許保存的動態模組參考暫時性動態模組中定義的類型。 這是因為在儲存至磁片之後載入保存的動態模組時,執行時間無法解析暫時性動態模組中所定義類型的參考。

在 .NET Framework 中發出遠端應用程式域的限制

有些案例需要在遠端應用程式域中建立和執行動態元件。 反映發出不允許將動態元件直接發出至遠端應用程式域。 解決方案是在目前應用程式域中發出動態元件、將發出的動態元件儲存至磁片,然後將動態元件載入遠端應用程式域。 遠端和應用程式域僅支援.NET Framework。

建構函式

AssemblyBuilder()

屬性

CodeBase
已過時。

取得原先指定的組件位置 (例如在 AssemblyName 物件中指定的位置)。

CodeBase
已過時。
已過時。

取得組件位置,例如原先在 AssemblyName 物件中指定的。

(繼承來源 Assembly)
CustomAttributes

取得包含此組件之自訂屬性的集合。

(繼承來源 Assembly)
DefinedTypes
DefinedTypes

取得這個組件中定義之類型的集合。

(繼承來源 Assembly)
EntryPoint

傳回這個組件的進入點。

EntryPoint

取得這個組件的進入點。

(繼承來源 Assembly)
EscapedCodeBase
已過時。
已過時。

取得代表基礎碼的 URI,包括逸出字元。

(繼承來源 Assembly)
Evidence

取得這個組件的辨識碼。

Evidence

取得這個組件的辨識碼。

(繼承來源 Assembly)
ExportedTypes

取得在這個組件中定義的公用類型集合,而這些類型在組件外部是可見的。

(繼承來源 Assembly)
FullName

取得目前動態組件的顯示名稱。

FullName

取得組件的顯示名稱。

(繼承來源 Assembly)
GlobalAssemblyCache
已過時。

取得值,這個值表示組件是否從全域組件快取載入。

GlobalAssemblyCache
已過時。

取得值,這個值表示元件是否從全域組件快取載入 (只 .NET Framework) 。

(繼承來源 Assembly)
HostContext

取得建立動態組件所在的主機內容。

HostContext

取得用來載入組件的主應用程式內容。

(繼承來源 Assembly)
ImageRuntimeVersion

取得將要儲存在含有資訊清單之檔案中的 Common Language Runtime 版本。

ImageRuntimeVersion

取得字串,表示儲存在含有資訊清單之檔案中的 Common Language Runtime (CLR) 版本。

(繼承來源 Assembly)
IsCollectible

取得值,這個值表示這個動態元件是否保留在可 AssemblyLoadContext 收集的 中。

IsCollectible

取得指出此組件是否在可回收 AssemblyLoadContext 中保存的值。

(繼承來源 Assembly)
IsDynamic

取得值,表示目前的組件是動態組件。

IsDynamic

取得值,這個值表示目前組件是否使用反映發出在目前處理序中動態產生。

(繼承來源 Assembly)
IsFullyTrusted

取得值,這個值表示目前組件是否以完全信任來載入。

(繼承來源 Assembly)
Location

如果不是陰影複製,則取得包含資訊清單之已載入檔案的位置 (程式碼基底格式)。

Location

取得包含資訊清單之載入檔的完整路徑或 UNC 位置。

(繼承來源 Assembly)
ManifestModule

在目前的 AssemblyBuilder 中取得模組,其中包含組件資訊清單。

ManifestModule

取得包含目前組件之資訊清單的模組。

(繼承來源 Assembly)
Modules
Modules

取得包含這個組件中模組的集合。

(繼承來源 Assembly)
PermissionSet

取得目前動態組件的授權集。

PermissionSet

取得目前組件的授權集。

(繼承來源 Assembly)
ReflectionOnly

取得值,其會表示此動態組件是否位於僅限反射內容中。

ReflectionOnly

取得 Boolean 值,指出這個組件是否已載入僅限反映的內容中。

(繼承來源 Assembly)
SecurityRuleSet

取得值,這個值指出應針對此組件強制執行的 Common Language Runtime (CLR) 安全性規則組合。

SecurityRuleSet

取得值,這個值指出應針對此組件強制執行的 Common Language Runtime (CLR) 安全性規則組合。

(繼承來源 Assembly)

方法

AddResourceFile(String, String)

將現有的資源檔加入這個組件。

AddResourceFile(String, String, ResourceAttributes)

將現有的資源檔加入這個組件。

CreateInstance(String)

從這個組件找出指定類型,並使用系統啟動項,利用區分大小寫的搜尋,建立它的執行個體。

(繼承來源 Assembly)
CreateInstance(String, Boolean)

從這個組件找出指定類型,並使用系統啟動項,利用選擇性區分大小寫的搜尋,建立它的執行個體。

(繼承來源 Assembly)
CreateInstance(String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])

從這個組件找出指定類型,並使用系統啟動項,利用選擇性區分大小寫的搜尋,以及取得指定文化特性 (Culture)、引數和繫結和啟動屬性,建立它的執行個體。

(繼承來源 Assembly)
DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess)

定義具有指定名稱和存取模式的動態組件。

DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, IEnumerable<CustomAttributeBuilder>)

定義具有指定名稱、存取權和屬性的新組件。

DefineDynamicModule(String)

在此組件中定義具名的暫時性動態模組。

DefineDynamicModule(String, Boolean)

定義這個組件中的具名暫時性動態模組,並指定是否應該發出符號資訊。

DefineDynamicModule(String, String)

以會儲存在指定檔案的指定名稱定義永久性動態模組。 沒有發出任何符號資訊。

DefineDynamicModule(String, String, Boolean)

定義永久性動態模組,指定模組名稱、要儲存該模組的檔案名稱,以及是否應使用預設符號寫入器發出符號資訊。

DefineResource(String, String, String)

使用預設公用資源屬性定義這個組件的獨立受管理資源。

DefineResource(String, String, String, ResourceAttributes)

定義這個組件的獨立受管理資源。 Managed 資源可指定屬性。

DefineUnmanagedResource(Byte[])

將這個組件的 Unmanaged 資源定義為不透明的 Blob (位元組)。

DefineUnmanagedResource(String)

定義指定資源檔名稱的這個組件之 Unmanaged 資源檔。

DefineVersionInfoResource()

使用組件 AssemblyName 物件和組件自訂屬性中指定的資訊,定義 Unmanaged Version 資訊資源。

DefineVersionInfoResource(String, String, String, String, String)

請使用指定的規格定義這個組件的 Unmanaged Version 資訊資源。

Equals(Object)

傳回值,指出此執行個體是否等於指定的物件。

Equals(Object)

判斷這個組件和指定的物件是否相等。

(繼承來源 Assembly)
GetCustomAttributes(Boolean)

傳回已套用至目前 AssemblyBuilder 的所有自訂屬性。

GetCustomAttributes(Boolean)

取得這個組件的所有自訂屬性。

(繼承來源 Assembly)
GetCustomAttributes(Type, Boolean)

傳回已套用至目前 AssemblyBuilder 的所有自訂屬性,以及衍生自指定屬性類型的所有自訂屬性。

GetCustomAttributes(Type, Boolean)

取得這個組件由類型所指定的自訂屬性。

(繼承來源 Assembly)
GetCustomAttributesData()

傳回 CustomAttributeData 物件,其中包含已套用至目前 AssemblyBuilder 的屬性之相關資訊。

GetCustomAttributesData()

傳回已套用至目前 Assembly 之屬性的相關資訊,表示為 CustomAttributeData 物件。

(繼承來源 Assembly)
GetDynamicModule(String)

傳回具有指定名稱的動態模組。

GetExportedTypes()

取得這個組件中定義的匯出類型。

GetExportedTypes()

取得在這個組件中定義的公用類型,而這些類型在組件外部是可見的。

(繼承來源 Assembly)
GetFile(String)

取得指定之檔案的 FileStream,這個指定之檔案位於這個組件的資訊清單檔案表中。

GetFile(String)

取得指定之檔案的 FileStream,這個指定之檔案位於這個組件的資訊清單檔案表中。

(繼承來源 Assembly)
GetFiles()

取得組件資訊清單檔案表中的檔案。

(繼承來源 Assembly)
GetFiles(Boolean)

取得組件資訊清單檔案表中的檔案,指定是否要包含資源模組。

GetFiles(Boolean)

取得組件資訊清單檔案表中的檔案,指定是否要包含資源模組。

(繼承來源 Assembly)
GetForwardedTypes() (繼承來源 Assembly)
GetHashCode()

傳回這個執行個體的雜湊碼。

GetHashCode()

傳回這個執行個體的雜湊碼。

(繼承來源 Assembly)
GetLoadedModules()

取得做為這個組件部分的所有載入模組。

(繼承來源 Assembly)
GetLoadedModules(Boolean)

傳回所有屬於這個組件的載入模組,並選擇性地包含資源模組。

GetLoadedModules(Boolean)

取得做為這個組件部分的所有載入模組,指定是否要包含資源模組。

(繼承來源 Assembly)
GetManifestResourceInfo(String)

傳回指定資源已保存方式的資訊。

GetManifestResourceInfo(String)

傳回指定資源已保存方式的資訊。

(繼承來源 Assembly)
GetManifestResourceNames()

載入來自這個組件的指定資訊清單資源。

GetManifestResourceNames()

傳回這個組件中的所有資源名稱。

(繼承來源 Assembly)
GetManifestResourceStream(String)

載入來自這個組件的指定資訊清單資源。

GetManifestResourceStream(String)

載入來自這個組件的指定資訊清單資源。

(繼承來源 Assembly)
GetManifestResourceStream(Type, String)

從這個組件載入指定資訊清單資源,由指定類型的命名空間限定範圍。

GetManifestResourceStream(Type, String)

從這個組件載入指定資訊清單資源,由指定類型的命名空間限定範圍。

(繼承來源 Assembly)
GetModule(String)

取得這個組件中的指定模組。

GetModule(String)

取得這個組件中的指定模組。

(繼承來源 Assembly)
GetModules()

取得所有屬於這個組件的模組。

(繼承來源 Assembly)
GetModules(Boolean)

取得所有屬於這個組件的模組,並選擇性地包含資源模組。

GetModules(Boolean)

取得所有屬於這個組件的模組,指定是否要包含資源模組。

(繼承來源 Assembly)
GetName()

取得這個組件的 AssemblyName

(繼承來源 Assembly)
GetName(Boolean)

取得目前動態組件建立時指定的 AssemblyName,且依指定方式設定程式碼基底。

GetName(Boolean)

取得這個組件的 AssemblyName,設定按照 copiedName 指定的基礎碼。

(繼承來源 Assembly)
GetObjectData(SerializationInfo, StreamingContext)

使用要重新執行個體化這個組件所需的所有資料,取得序列化 (Serialization) 資訊。

(繼承來源 Assembly)
GetReferencedAssemblies()

取得這個 AssemblyBuilder 所參考組件之 AssemblyName 物件的不完整清單。

GetReferencedAssemblies()

取得這個組件參考之所有組件的 AssemblyName 物件。

(繼承來源 Assembly)
GetSatelliteAssembly(CultureInfo)

取得指定文化特性的附屬組件。

GetSatelliteAssembly(CultureInfo)

取得指定文化特性的附屬組件。

(繼承來源 Assembly)
GetSatelliteAssembly(CultureInfo, Version)

取得指定文化特性的附屬組件指定版本。

GetSatelliteAssembly(CultureInfo, Version)

取得指定文化特性的附屬組件指定版本。

(繼承來源 Assembly)
GetType() (繼承來源 Assembly)
GetType(String)

取得具有組件執行個體中指定名稱的 Type 物件。

(繼承來源 Assembly)
GetType(String, Boolean)

取得具有組件執行個體中指定之名稱的 Type 物件,並在找不到類型時選擇性地擲回例外狀況。

(繼承來源 Assembly)
GetType(String, Boolean, Boolean)

由在目前 AssemblyBuilder 中定義和建立的類型取得指定的類型。

GetType(String, Boolean, Boolean)

使用忽略大小寫和找不到類型時擲回例外狀況的選項,取得具有組件執行個體中指定之名稱的 Type 物件。

(繼承來源 Assembly)
GetTypes()

取得定義於這個組件中的類型。

(繼承來源 Assembly)
IsDefined(Type, Boolean)

傳回值,這個值表示指定屬性類型的一或多個執行個體是否套用至這個成員。

IsDefined(Type, Boolean)

指出是否已將指定的屬性套用至組件。

(繼承來源 Assembly)
LoadModule(String, Byte[])

使用通用物件檔案格式 (COFF) 為基礎的映像 (包含發出的模組) 或是資源檔,載入組件的內部模組。

(繼承來源 Assembly)
LoadModule(String, Byte[], Byte[])

使用通用物件檔案格式 (COFF) 為基礎的映像 (包含發出的模組) 或是資源檔,載入組件的內部模組。 表示模組符號的未經處理位元組也載入。

(繼承來源 Assembly)
MemberwiseClone()

建立目前 Object 的淺層複製。

(繼承來源 Object)
Save(String)

將此動態組件儲存到磁碟。

Save(String, PortableExecutableKinds, ImageFileMachine)

將這個動態組件儲存至磁碟,指定在組件的可執行檔和目標平台的程式碼本質。

SetCustomAttribute(ConstructorInfo, Byte[])

使用指定的自訂屬性 Blob 來設定這個組件上的自訂屬性。

SetCustomAttribute(CustomAttributeBuilder)

使用自訂屬性產生器來設定這個組件上的自訂屬性。

SetEntryPoint(MethodInfo)

設定這個動態組件的進入點,並假設正在建立主控台應用程式。

SetEntryPoint(MethodInfo, PEFileKinds)

設定這個組件的進入點和定義正在建置之可攜式執行檔 (PE 檔) 的類型。

ToString()

傳回組件的完整名稱,也稱為顯示名稱。

(繼承來源 Assembly)

事件

ModuleResolve

發生於 Common Language Runtime 類別載入器無法經由一般方法解析對組件內部模組的參考時。

(繼承來源 Assembly)

明確介面實作

_Assembly.GetType()

傳回目前執行個體的類型。

(繼承來源 Assembly)
_AssemblyBuilder.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

將一組名稱對應至一組對應的分派識別項 (Dispatch Identifier)。

_AssemblyBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)

擷取物件的類型資訊,可以用來取得介面的類型資訊。

_AssemblyBuilder.GetTypeInfoCount(UInt32)

擷取物件提供的類型資訊介面數目 (0 或 1)。

_AssemblyBuilder.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

提供物件所公開的屬性和方法的存取權。

ICustomAttributeProvider.GetCustomAttributes(Boolean)

傳回這個成員中定義的所有自訂屬性的陣列 (但具名屬性除外),如果沒有自訂屬性,則傳回空陣列。

(繼承來源 Assembly)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)

傳回這個成員中定義的自訂屬性陣列 (依類型識別),如果沒有該類型的自訂屬性,則傳回空陣列。

(繼承來源 Assembly)
ICustomAttributeProvider.IsDefined(Type, Boolean)

指出此成員上是否有定義一個或多個 attributeType 執行個體。

(繼承來源 Assembly)

擴充方法

GetExportedTypes(Assembly)
GetModules(Assembly)
GetTypes(Assembly)
GetCustomAttribute(Assembly, Type)

擷取指定型別的自訂屬性,此屬性套用至指定組件。

GetCustomAttribute<T>(Assembly)

擷取指定型別的自訂屬性,此屬性套用至指定組件。

GetCustomAttributes(Assembly)

擷取套用至指定組件的自訂屬性集合。

GetCustomAttributes(Assembly, Type)

擷取指定型別的自訂屬性集合,此集合套用至指定組件。

GetCustomAttributes<T>(Assembly)

擷取指定型別的自訂屬性集合,此集合套用至指定組件。

IsDefined(Assembly, Type)

指出是否將所指定型別的自訂屬性套用至指定的組件。

TryGetRawMetadata(Assembly, Byte*, Int32)

擷取元件的中繼資料區段,以搭配 使用 MetadataReader

適用於

另請參閱