TypeBuilder 類別

定義

命名空間:

System.Reflection.Emit

組件:

netstandard.dll, System.Reflection.Emit.dll

來源:

TypeBuilder.cs

在執行期間定義並建立新的類別實例。

public ref class TypeBuilder abstract : System::Reflection::TypeInfo

public abstract class TypeBuilder : System.Reflection.TypeInfo

type TypeBuilder = class
    inherit TypeInfo

Public MustInherit Class TypeBuilder
Inherits TypeInfo

繼承

Object

MemberInfo

Type

TypeInfo

TypeBuilder

範例

以下程式碼範例說明如何定義並使用動態組合語言。 範例組合包含一個類型 ， MyDynamicType具有私有欄位、一個取得並設定私有欄位的屬性、初始化私有欄位的建構子，以及一個將使用者提供的數字乘以私有欄位值並回傳結果的方法。

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

        var 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 ?? "DynamicAssemblyExample");

        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);
        ConstructorInfo? ci = typeof(object).GetConstructor(Type.EmptyTypes);
        ctor1IL.Emit(OpCodes.Call, ci!);
        // 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 = null;
        if (t is not null)
            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 = null;
        if (t is not null)
            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
 */

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

以下範例示範如何利用 TypeBuilder動態建構型別。

using System;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;

class TestILGenerator
{
    public static Type DynamicDotProductGen()
    {
       Type ivType = null;
       Type[] ctorParams = new Type[] { typeof(int),
                                typeof(int),
                        typeof(int)};
    
       AppDomain myDomain = Thread.GetDomain();
       AssemblyName myAsmName = new AssemblyName();
       myAsmName.Name = "IntVectorAsm";
    
       AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
                      myAsmName,
                      AssemblyBuilderAccess.RunAndSave);

       ModuleBuilder IntVectorModule = myAsmBuilder.DefineDynamicModule("IntVectorModule",
                                        "Vector.dll");

       TypeBuilder ivTypeBld = IntVectorModule.DefineType("IntVector",
                                      TypeAttributes.Public);

       FieldBuilder xField = ivTypeBld.DefineField("x", typeof(int),
                                                       FieldAttributes.Private);
       FieldBuilder yField = ivTypeBld.DefineField("y", typeof(int),
                                                       FieldAttributes.Private);
       FieldBuilder zField = ivTypeBld.DefineField("z", typeof(int),
                                                       FieldAttributes.Private);

           Type objType = Type.GetType("System.Object");
           ConstructorInfo objCtor = objType.GetConstructor(new Type[0]);

       ConstructorBuilder ivCtor = ivTypeBld.DefineConstructor(
                      MethodAttributes.Public,
                      CallingConventions.Standard,
                      ctorParams);
       ILGenerator ctorIL = ivCtor.GetILGenerator();
           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Call, objCtor);
           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Ldarg_1);
           ctorIL.Emit(OpCodes.Stfld, xField);
           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Ldarg_2);
           ctorIL.Emit(OpCodes.Stfld, yField);
           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Ldarg_3);
           ctorIL.Emit(OpCodes.Stfld, zField);
       ctorIL.Emit(OpCodes.Ret);

       // This method will find the dot product of the stored vector
       // with another.

       Type[] dpParams = new Type[] { ivTypeBld };

           // Here, you create a MethodBuilder containing the
       // name, the attributes (public, static, private, and so on),
       // the return type (int, in this case), and a array of Type
       // indicating the type of each parameter. Since the sole parameter
       // is a IntVector, the very class you're creating, you will
       // pass in the TypeBuilder (which is derived from Type) instead of
       // a Type object for IntVector, avoiding an exception.

       // -- This method would be declared in C# as:
       //    public int DotProduct(IntVector aVector)

           MethodBuilder dotProductMthd = ivTypeBld.DefineMethod(
                                  "DotProduct",
                          MethodAttributes.Public,
                                          typeof(int),
                                          dpParams);

       // A ILGenerator can now be spawned, attached to the MethodBuilder.

       ILGenerator mthdIL = dotProductMthd.GetILGenerator();
    
       // Here's the body of our function, in MSIL form. We're going to find the
       // "dot product" of the current vector instance with the passed vector
       // instance. For reference purposes, the equation is:
       // (x1 * x2) + (y1 * y2) + (z1 * z2) = the dot product

       // First, you'll load the reference to the current instance "this"
       // stored in argument 0 (ldarg.0) onto the stack. Ldfld, the subsequent
       // instruction, will pop the reference off the stack and look up the
       // field "x", specified by the FieldInfo token "xField".

       mthdIL.Emit(OpCodes.Ldarg_0);
       mthdIL.Emit(OpCodes.Ldfld, xField);

       // That completed, the value stored at field "x" is now atop the stack.
       // Now, you'll do the same for the object reference we passed as a
       // parameter, stored in argument 1 (ldarg.1). After Ldfld executed,
       // you'll have the value stored in field "x" for the passed instance
       // atop the stack.

       mthdIL.Emit(OpCodes.Ldarg_1);
       mthdIL.Emit(OpCodes.Ldfld, xField);

           // There will now be two values atop the stack - the "x" value for the
       // current vector instance, and the "x" value for the passed instance.
       // You'll now multiply them, and push the result onto the evaluation stack.

       mthdIL.Emit(OpCodes.Mul_Ovf_Un);

       // Now, repeat this for the "y" fields of both vectors.

       mthdIL.Emit(OpCodes.Ldarg_0);
       mthdIL.Emit(OpCodes.Ldfld, yField);
       mthdIL.Emit(OpCodes.Ldarg_1);
       mthdIL.Emit(OpCodes.Ldfld, yField);
       mthdIL.Emit(OpCodes.Mul_Ovf_Un);

       // At this time, the results of both multiplications should be atop
       // the stack. You'll now add them and push the result onto the stack.

       mthdIL.Emit(OpCodes.Add_Ovf_Un);

       // Multiply both "z" field and push the result onto the stack.
       mthdIL.Emit(OpCodes.Ldarg_0);
       mthdIL.Emit(OpCodes.Ldfld, zField);
       mthdIL.Emit(OpCodes.Ldarg_1);
       mthdIL.Emit(OpCodes.Ldfld, zField);
       mthdIL.Emit(OpCodes.Mul_Ovf_Un);

       // Finally, add the result of multiplying the "z" fields with the
       // result of the earlier addition, and push the result - the dot product -
       // onto the stack.
       mthdIL.Emit(OpCodes.Add_Ovf_Un);

       // The "ret" opcode will pop the last value from the stack and return it
       // to the calling method. You're all done!

       mthdIL.Emit(OpCodes.Ret);

       ivType = ivTypeBld.CreateType();

       return ivType;
    }

    public static void Main() {
    
       Type IVType = null;
           object aVector1 = null;
           object aVector2 = null;
       Type[] aVtypes = new Type[] {typeof(int), typeof(int), typeof(int)};
           object[] aVargs1 = new object[] {10, 10, 10};
           object[] aVargs2 = new object[] {20, 20, 20};
    
       // Call the  method to build our dynamic class.

       IVType = DynamicDotProductGen();

           Console.WriteLine("---");

       ConstructorInfo myDTctor = IVType.GetConstructor(aVtypes);
       aVector1 = myDTctor.Invoke(aVargs1);
       aVector2 = myDTctor.Invoke(aVargs2);

       object[] passMe = new object[1];
           passMe[0] = (object)aVector2;

       Console.WriteLine("(10, 10, 10) . (20, 20, 20) = {0}",
                 IVType.InvokeMember("DotProduct",
                          BindingFlags.InvokeMethod,
                          null,
                          aVector1,
                          passMe));

       // +++ OUTPUT +++
       // ---
       // (10, 10, 10) . (20, 20, 20) = 600
    }
}

Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit

 _


Class TestILGenerator
   
   
   Public Shared Function DynamicDotProductGen() As Type
      
      Dim ivType As Type = Nothing
      Dim ctorParams() As Type = {GetType(Integer), GetType(Integer), GetType(Integer)}
      
      Dim myDomain As AppDomain = Thread.GetDomain()
      Dim myAsmName As New AssemblyName()
      myAsmName.Name = "IntVectorAsm"
      
      Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly( _
                        myAsmName, _
                        AssemblyBuilderAccess.RunAndSave)
      
      Dim IntVectorModule As ModuleBuilder = myAsmBuilder.DefineDynamicModule( _
                         "IntVectorModule", _
                         "Vector.dll")
      
      Dim ivTypeBld As TypeBuilder = IntVectorModule.DefineType("IntVector", TypeAttributes.Public)
      
      Dim xField As FieldBuilder = ivTypeBld.DefineField("x", _
                                 GetType(Integer), _
                                 FieldAttributes.Private)
      Dim yField As FieldBuilder = ivTypeBld.DefineField("y", _ 
                                 GetType(Integer), _
                                 FieldAttributes.Private)
      Dim zField As FieldBuilder = ivTypeBld.DefineField("z", _
                                 GetType(Integer), _
                                 FieldAttributes.Private)
      
      
      Dim objType As Type = Type.GetType("System.Object")
      Dim objCtor As ConstructorInfo = objType.GetConstructor(New Type() {})
      
      Dim ivCtor As ConstructorBuilder = ivTypeBld.DefineConstructor( _
                     MethodAttributes.Public, _
                     CallingConventions.Standard, _
                     ctorParams)
      Dim ctorIL As ILGenerator = ivCtor.GetILGenerator()
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Call, objCtor)
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_1)
      ctorIL.Emit(OpCodes.Stfld, xField)
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_2)
      ctorIL.Emit(OpCodes.Stfld, yField)
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_3)
      ctorIL.Emit(OpCodes.Stfld, zField)
      ctorIL.Emit(OpCodes.Ret)
     

      ' Now, you'll construct the method find the dot product of two vectors. First,
      ' let's define the parameters that will be accepted by the method. In this case,
      ' it's an IntVector itself!

      Dim dpParams() As Type = {ivTypeBld}
      
      ' Here, you create a MethodBuilder containing the
      ' name, the attributes (public, static, private, and so on),
      ' the return type (int, in this case), and a array of Type
      ' indicating the type of each parameter. Since the sole parameter
      ' is a IntVector, the very class you're creating, you will
      ' pass in the TypeBuilder (which is derived from Type) instead of 
      ' a Type object for IntVector, avoiding an exception. 
      ' -- This method would be declared in VB.NET as:
      '    Public Function DotProduct(IntVector aVector) As Integer

      Dim dotProductMthd As MethodBuilder = ivTypeBld.DefineMethod("DotProduct", _
                        MethodAttributes.Public, GetType(Integer), _
                                            dpParams)
      
      ' A ILGenerator can now be spawned, attached to the MethodBuilder.
      Dim mthdIL As ILGenerator = dotProductMthd.GetILGenerator()
      
      ' Here's the body of our function, in MSIL form. We're going to find the
      ' "dot product" of the current vector instance with the passed vector 
      ' instance. For reference purposes, the equation is:
      ' (x1 * x2) + (y1 * y2) + (z1 * z2) = the dot product
      ' First, you'll load the reference to the current instance "this"
      ' stored in argument 0 (ldarg.0) onto the stack. Ldfld, the subsequent
      ' instruction, will pop the reference off the stack and look up the
      ' field "x", specified by the FieldInfo token "xField".
      mthdIL.Emit(OpCodes.Ldarg_0)
      mthdIL.Emit(OpCodes.Ldfld, xField)
      
      ' That completed, the value stored at field "x" is now atop the stack.
      ' Now, you'll do the same for the object reference we passed as a
      ' parameter, stored in argument 1 (ldarg.1). After Ldfld executed,
      ' you'll have the value stored in field "x" for the passed instance
      ' atop the stack.
      mthdIL.Emit(OpCodes.Ldarg_1)
      mthdIL.Emit(OpCodes.Ldfld, xField)
      
      ' There will now be two values atop the stack - the "x" value for the
      ' current vector instance, and the "x" value for the passed instance.
      ' You'll now multiply them, and push the result onto the evaluation stack.
      mthdIL.Emit(OpCodes.Mul_Ovf_Un)
      
      ' Now, repeat this for the "y" fields of both vectors.
      mthdIL.Emit(OpCodes.Ldarg_0)
      mthdIL.Emit(OpCodes.Ldfld, yField)
      mthdIL.Emit(OpCodes.Ldarg_1)
      mthdIL.Emit(OpCodes.Ldfld, yField)
      mthdIL.Emit(OpCodes.Mul_Ovf_Un)
      
      ' At this time, the results of both multiplications should be atop
      ' the stack. You'll now add them and push the result onto the stack.
      mthdIL.Emit(OpCodes.Add_Ovf_Un)
      
      ' Multiply both "z" field and push the result onto the stack.
      mthdIL.Emit(OpCodes.Ldarg_0)
      mthdIL.Emit(OpCodes.Ldfld, zField)
      mthdIL.Emit(OpCodes.Ldarg_1)
      mthdIL.Emit(OpCodes.Ldfld, zField)
      mthdIL.Emit(OpCodes.Mul_Ovf_Un)
      
      ' Finally, add the result of multiplying the "z" fields with the
      ' result of the earlier addition, and push the result - the dot product -
      ' onto the stack.
      mthdIL.Emit(OpCodes.Add_Ovf_Un)
      
      ' The "ret" opcode will pop the last value from the stack and return it
      ' to the calling method. You're all done!
      mthdIL.Emit(OpCodes.Ret)
      
      
      ivType = ivTypeBld.CreateType()
      
      Return ivType
   End Function 'DynamicDotProductGen
    
   
   Public Shared Sub Main()
      
      Dim IVType As Type = Nothing
      Dim aVector1 As Object = Nothing
      Dim aVector2 As Object = Nothing
      Dim aVtypes() As Type = {GetType(Integer), GetType(Integer), GetType(Integer)}
      Dim aVargs1() As Object = {10, 10, 10}
      Dim aVargs2() As Object = {20, 20, 20}
      
      ' Call the  method to build our dynamic class.
      IVType = DynamicDotProductGen()
      
      
      Dim myDTctor As ConstructorInfo = IVType.GetConstructor(aVtypes)
      aVector1 = myDTctor.Invoke(aVargs1)
      aVector2 = myDTctor.Invoke(aVargs2)
      
      Console.WriteLine("---")
      Dim passMe(0) As Object
      passMe(0) = CType(aVector2, Object)
      
      Console.WriteLine("(10, 10, 10) . (20, 20, 20) = {0}", _
                        IVType.InvokeMember("DotProduct", BindingFlags.InvokeMethod, _
                        Nothing, aVector1, passMe))
   End Sub
End Class



' +++ OUTPUT +++
' ---
' (10, 10, 10) . (20, 20, 20) = 600

備註

TypeBuilder 是用來控制運行時間中動態類別建立的根類別。 它提供一組例程，用來定義類別、新增方法和字段，並在模組內建立類別。 您可以從動態模組呼叫 TypeBuilder 方法來建立新的 ModuleBuilder.DefineType，該方法會傳回 TypeBuilder 物件。

反射功能提供以下選項來定義類型：

• 使用指定的名稱定義類別或介面。
• 使用指定的名稱和屬性定義類別或介面。
• 使用指定的名稱、屬性和基類來定義類別。
• 使用指定的名稱、屬性、基類和類別實作的介面集來定義類別。
• 使用指定的名稱、屬性、基類和封裝大小來定義類別。
• 使用指定的名稱、屬性、基類和整個類別大小來定義類別。
• 使用指定的名稱、屬性、基類、封裝大小和整體類別大小來定義類別。

若要為由物件 TypeBuilder 表示的不完整類型建立陣列類型、指標類型或 byref 類型，請分別使用 MakeArrayType 方法、MakePointerType 方法或 MakeByRefType 方法。

在使用類別之前，必須先呼叫TypeBuilder.CreateType 方法。 CreateType 會完成類型的建立。 在呼叫 CreateType 之後，呼叫端可以使用 方法具現化類型 Activator.CreateInstance ，並使用 方法叫用 Type.InvokeMember 型別的成員。 在呼叫 CreateType 之後，嘗試執行更改類型的實作的任何方法，都是錯誤的。 例如，如果呼叫端嘗試將新成員新增至類型，Common Language Runtime 會擲回例外狀況。

類別初始化運算式是使用 TypeBuilder.DefineTypeInitializer 方法建立的。 DefineTypeInitializer 會 ConstructorBuilder 傳回 物件。

巢狀類型是藉由呼叫其中 TypeBuilder.DefineNestedType 一種方法來定義。

屬性

類別 TypeBuilder 使用列舉 TypeAttributes，以進一步指定要建立的類型特性：

• 介面是使用 TypeAttributes.Interface 和 TypeAttributes.Abstract 屬性來指定。
• 具體類別（無法擴充的類別）是使用 TypeAttributes.Sealed 屬性來指定。
• 數個屬性會決定類型可見性。 請參閱 TypeAttributes 列舉項的描述。
• 如果 TypeAttributes.SequentialLayout 指定了 ，類別載入器會依從元數據讀取的順序配置欄位。 類別載入器會考慮指定的封裝大小，但會忽略任何指定的欄位偏移量。 元數據會保留發出欄位定義的順序。 即使在合併中，元數據也不會重新排序欄位定義。 只有在 TypeAttributes.ExplicitLayout 已指定的情況下，載入器才會遵循指定的欄位偏移。

已知的問題

• 反射不會驗證實作介面的非抽象類別是否已實作介面中宣告的所有方法。 不過，如果類別未實作介面中宣告的所有方法，運行時間就不會載入 類別。
• 雖然 TypeBuilder 衍生自 Type，但 類別中 Type 定義的一些抽象方法並未完全實作於 TypeBuilder 類別中。 呼叫這些 TypeBuilder 方法會擲回 NotSupportedException 例外狀況。 您可以使用Type.GetType或Assembly.GetType來擷取所建立的類型，並反映所擷取的類型，以取得所需的功能。

建構函式

名稱	Description
TypeBuilder()	初始化 TypeBuilder 類別的新執行個體。

欄位

名稱	Description
UnspecifiedTypeSize	代表該類型的總大小未被指定。

屬性

名稱	Description
Assembly	擷取包含此型別定義的動態組裝。
AssemblyQualifiedName	回傳此類型的全名，並以組件的顯示名稱作為限定。
BaseType	擷取此類型的基底型態。
CustomAttributes	會獲得包含該成員自訂屬性的集合。 (繼承來源 MemberInfo)
DeclaredConstructors	取得由當前類型宣告的建構子集合。 (繼承來源 TypeInfo)
DeclaredEvents	取得由當前型別定義的事件集合。 (繼承來源 TypeInfo)
DeclaredFields	會得到一組由目前型別定義的欄位。 (繼承來源 TypeInfo)
DeclaredMembers	取得由目前型別定義的成員集合。 (繼承來源 TypeInfo)
DeclaredMethods	取得由目前型別定義的方法集合。 (繼承來源 TypeInfo)
DeclaredNestedTypes	會得到由目前型別定義的巢狀型別集合。 (繼承來源 TypeInfo)
DeclaredProperties	取得由目前類型定義的屬性集合。 (繼承來源 TypeInfo)
DeclaringMethod	取得宣告當前泛型參數的方法。
DeclaringType	回傳宣告此型態的類型。
FullName	可取得此類型的完整路徑。
GenericParameterAttributes	會得到一個值，表示當前通用型別參數的協變數與特殊約束。
GenericParameterPosition	取得宣告該參數的泛型型態參數列表中型別參數的位置。
GenericTypeParameters	取得目前實例的通用參數陣列。 (繼承來源 TypeInfo)
GUID	取得此類 GUID。
ImplementedInterfaces	取得目前型別實作的介面集合。 (繼承來源 TypeInfo)
IsByRefLike	會得到一個值，表示該型別是否為類似 byref 結構。
IsCollectible	獲得一個值，表示該 MemberInfo 物件是否參考收藏品 AssemblyLoadContext中一個或多個組件。 (繼承來源 MemberInfo)
IsConstructedGenericType	會得到一個值，表示此物件是否代表建構的泛型型別。
IsContextful	會獲得一個值，表示是否 Type 可以在某個情境中被託管。 (繼承來源 Type)
IsFunctionPointer	會得到一個值，表示電流 Type 是否為函數指標。 (繼承來源 Type)
IsGenericMethodParameter	會得到一個值，表示電流 Type 是否代表一般方法定義中的型別參數。 (繼承來源 Type)
IsGenericParameter	會取得一個值，表示目前型別是否為一般型別參數。
IsGenericType	會取得一個值，表示目前型別是否為通用型別。
IsGenericTypeDefinition	獲得一個值，表示電流 TypeBuilder 是否代表一個通用型別定義，從而可構造其他泛型。
IsGenericTypeParameter	會得到一個值，表示電流 Type 是否代表一般型別定義中的型別參數。 (繼承來源 Type)
IsSecurityCritical	會獲得一個值，表示目前類型是安全關鍵還是安全關鍵，因此可以執行關鍵操作。
IsSecuritySafeCritical	會得到一個值，表示目前類型是安全-安全-關鍵;也就是說，它是否能執行關鍵操作，且是否能被透明程式碼存取。
IsSecurityTransparent	會得到一個值，表示目前型別是否透明，因此無法執行關鍵操作。
IsSignatureType	會得到一個值，表示該型別是否為簽章型別。 (繼承來源 Type)
IsSZArray	在執行期間定義並建立新的類別實例。
IsTypeDefinition	在執行期間定義並建立新的類別實例。
IsUnmanagedFunctionPointer	會得到一個值，表示該電流 Type 是否為未管理函數指標。 (繼承來源 Type)
IsVariableBoundArray	會得到一個值，表示該型別是可以表示多維陣列的陣列型態，還是具有任意下界的陣列型態。 (繼承來源 Type)
MetadataToken	會取得一個標記，用來識別當前動態模組的元資料。
Module	取得包含此型別定義的動態模組。
Name	取得此類型名稱。
Namespace	取回定義此詞 TypeBuilder 的命名空間。
PackingSize	可取得此類的包裝尺寸。
PackingSizeCore	當在導出類別中被覆寫時，會得到該類型的包裝大小。
ReflectedType	回傳用於取得此類型所使用的類型。
Size	取回型態的總大小。
SizeCore	當在衍生類別中覆寫時，會得到該型別的總大小。
TypeHandle	動態模組不支援此功能。
UnderlyingSystemType	回傳此底 TypeBuilder層系統類型。

方法

名稱	Description
AddInterfaceImplementation(Type)	新增一個介面，該類型實作了它。
AddInterfaceImplementationCore(Type)	當在衍生類別中覆寫時，會新增一個介面，該類型實作該類型。
AsType()	會將目前的型態作為 Type 物件回傳。 (繼承來源 TypeInfo)
CreateType()	為類別建立一個 Type 物件。 在定義類別的欄位與方法後， CreateType 會被呼叫以載入其 Type 物件。
CreateTypeInfo()	會得到 TypeInfo 一個代表此類型物件的物件。
CreateTypeInfoCore()	當在衍生類別中被覆寫時，會得到 TypeInfo 一個代表此類型的物件。
DefineConstructor(MethodAttributes, CallingConventions, Type[], Type[][], Type[][])	新增一個建構子到該類型，包含給定的屬性、簽名和自訂修飾符。
DefineConstructor(MethodAttributes, CallingConventions, Type[])	新增一個新的建構子到型別中，並帶有給定的屬性與簽名。
DefineConstructorCore(MethodAttributes, CallingConventions, Type[], Type[][], Type[][])	當在衍生類別中覆寫時，會為該類型新增一個建構子，包含給定的屬性、簽名和自訂修飾符。
DefineDefaultConstructor(MethodAttributes)	定義了無參數建構子。 此處定義的建構子將直接呼叫父建構子的無參數建構子。
DefineDefaultConstructorCore(MethodAttributes)	當在派生類別中覆寫時，定義了無參數建構子。 此處定義的建構子稱為父建構子的無參數建構子。
DefineEvent(String, EventAttributes, Type)	新增一個事件，包含名稱、屬性和事件類型。
DefineEventCore(String, EventAttributes, Type)	當在衍生類別中覆寫時，會新增一個事件，包含名稱、屬性和事件類型。
DefineField(String, Type, FieldAttributes)	新增一個欄位，包含名稱、屬性和欄位類型。
DefineField(String, Type, Type[], Type[], FieldAttributes)	新增一個欄位，包含名稱、屬性、欄位類型及自訂修飾符。
DefineFieldCore(String, Type, Type[], Type[], FieldAttributes)	當在衍生類別中覆寫時，會在該類型中新增一個欄位，包含名稱、屬性、欄位類型及自訂修飾符。
DefineGenericParameters(String[])	定義當前型別的通用型別參數，指定其數量與名稱，並回傳一個可用於設定限制的物件陣列 GenericTypeParameterBuilder 。
DefineGenericParametersCore(String[])	當在衍生類別中被覆寫時，定義了當前型態的通用型態參數，並指定其數量與名稱。
DefineInitializedData(String, Byte[], FieldAttributes)	在可攜式可執行檔（PE）檔案的 .sdata 區段定義初始化資料欄位。
DefineInitializedDataCore(String, Byte[], FieldAttributes)	當在派生類別中覆寫時，會在可攜式可執行檔（PE）檔案的 .sdata 區段定義初始化資料欄位。
DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	新增一個新方法，包含指定的名稱、方法屬性、呼叫慣例、方法簽章及自訂修飾符。
DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[])	為該型別新增一個方法，並具備指定的名稱、方法屬性、呼叫慣例及方法簽章。
DefineMethod(String, MethodAttributes, CallingConventions)	新增一個新方法，包含指定的名稱、方法屬性及呼叫慣例。
DefineMethod(String, MethodAttributes, Type, Type[])	新增一個新方法到該型別，並擁有指定的名稱、方法屬性和方法簽章。
DefineMethod(String, MethodAttributes)	新增一個方法到型別，並帶有指定的名稱和方法屬性。
DefineMethodCore(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	當在衍生類別中覆寫時，會新增一個新方法，並包含指定的名稱、方法屬性、呼叫慣例、方法簽章及自訂修飾符。
DefineMethodOverride(MethodInfo, MethodInfo)	指定一個方法體，實作特定方法宣告，可能名稱不同。
DefineMethodOverrideCore(MethodInfo, MethodInfo)	當在衍生類別中覆寫時，指定一個實作特定方法宣告的方法主體，可能名稱不同。
DefineNestedType(String, TypeAttributes, Type, Int32)	定義巢狀型別，根據其名稱、屬性、型別的總大小以及它所延伸的型別。
DefineNestedType(String, TypeAttributes, Type, PackingSize, Int32)	定義巢狀型別，根據其名稱、屬性、大小及延伸型別。
DefineNestedType(String, TypeAttributes, Type, PackingSize)	定義巢狀型別，根據其名稱、屬性、所延伸的型別及包裝大小。
DefineNestedType(String, TypeAttributes, Type, Type[])	定義巢狀型別，名稱、屬性、所擴展的型態以及實作的介面。
DefineNestedType(String, TypeAttributes, Type)	定義巢狀型別，名稱、屬性及其延伸型別。
DefineNestedType(String, TypeAttributes)	定義巢狀型別，根據其名稱與屬性。
DefineNestedType(String)	定義了巢狀型態，因其名稱而定。
DefineNestedTypeCore(String, TypeAttributes, Type, Type[], PackingSize, Int32)	當在衍生類別中覆寫時，定義了一個巢狀型別，名稱、屬性、大小以及它所延伸的型別。
DefinePInvokeMethod(String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	定義 PInvoke 方法名稱、定義該方法的 DLL 名稱、方法的屬性、方法的呼叫慣例、方法的回傳類型、參數的類型，以及 PInvoke 旗標。
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	定義 PInvoke 方法名稱、定義該方法的 DLL 名稱、入口點名稱、方法屬性、方法的呼叫慣例、方法的回傳類型、參數類型及 PInvoke 標誌。
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][], CallingConvention, CharSet)	定義 PInvoke 方法名稱、定義該方法的 DLL 名稱、入口點名稱、方法屬性、方法的呼叫慣例、方法的回傳類型、參數的類型、 PInvoke 參數的標誌，以及參數與返回類型的自訂修飾符。
DefinePInvokeMethodCore(String, String, String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][], CallingConvention, CharSet)	當在衍生類別中覆寫時，會定義一個 PInvoke 方法，包含提供的名稱、DLL 名稱、入口點名稱、屬性、呼叫慣例、回傳類型、參數類型、PInvoke 標誌，以及參數和返回類型的自訂修飾符。
DefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	在型別中新增一個屬性，包含名稱、呼叫慣例、屬性簽名和自訂修飾符。
DefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[])	為型別新增一個屬性，包含名稱、屬性、呼叫慣例及屬性簽名。
DefineProperty(String, PropertyAttributes, Type, Type[], Type[], Type[], Type[][], Type[][])	為型別新增一個屬性，包含名稱、屬性簽名和自訂修飾符。
DefineProperty(String, PropertyAttributes, Type, Type[])	為型別新增一個屬性，包含名稱與屬性簽名。
DefinePropertyCore(String, PropertyAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	當在衍生類別中覆寫時，會在型別中新增一個屬性，包含名稱、呼叫慣例、屬性簽名及自訂修飾符。
DefineTypeInitializer()	定義了此類型的初始化器。
DefineTypeInitializerCore()	當在衍生類別中覆寫時，定義了此類型的初始化器。
DefineUninitializedData(String, Int32, FieldAttributes)	在可攜式可執行檔（PE）的區段中定義一個未初始化的資料欄位 .sdata 。
DefineUninitializedDataCore(String, Int32, FieldAttributes)	當在派生類別中覆寫時，會在可攜式可執行檔（PE）的區段中定義一個未初始化的資料欄位 .sdata 。
Equals(Object)	判斷當前 Type 物件的底層系統類型是否與指定 Object物件的底層系統類型相同。 (繼承來源 Type)
Equals(Type)	判斷電流的底層系統類型 Type 是否與指定 Type電流的底層系統類型相同。 (繼承來源 Type)
GetAttributeFlagsImpl()	當在派生類別中覆寫時，實作了該 Attributes 性質，並獲得一個位元組合的列舉值，表示與 Type相關聯的屬性。
GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	利用指定的綁定約束與呼叫慣例，搜尋參數與指定參數類型與修飾符相符的建構子。 (繼承來源 Type)
GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])	搜尋參數與指定參數類型及修飾符相符的建構子，並使用指定的綁定約束。 (繼承來源 Type)
GetConstructor(BindingFlags, Type[])	利用指定的綁定約束，搜尋參數與指定參數類型相符的建構子。 (繼承來源 Type)
GetConstructor(Type, ConstructorInfo)	回傳對應於該定義中指定建構型別的建構子。
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	當在衍生類別中被覆寫時，會搜尋參數與指定參數類型與修飾符相符的建構子，使用指定的綁定約束與指定的呼叫慣例。
GetConstructors(BindingFlags)	回傳一個代表該類別定義的公開與非公開建構子的物件陣列 ConstructorInfo ，依照指定方式。
GetCustomAttributes(Boolean)	會回傳所有為此類型定義的自訂屬性。
GetCustomAttributes(Type, Boolean)	回傳目前類型中所有可指派給指定類型的自訂屬性。
GetCustomAttributesData()	回傳一份物件清單 CustomAttributeData ，代表已套用於目標成員的屬性資料。 (繼承來源 MemberInfo)
GetDeclaredEvent(String)	回傳一個代表當前類型所宣告指定事件的物件。 (繼承來源 TypeInfo)
GetDeclaredField(String)	回傳一個物件，代表由當前類型宣告的指定欄位。 (繼承來源 TypeInfo)
GetDeclaredMethod(String)	回傳一個物件，代表目前類型所宣告的指定方法。 (繼承來源 TypeInfo)
GetDeclaredMethods(String)	回傳一個集合，包含所有在當前型別上宣告且符合指定名稱的方法。 (繼承來源 TypeInfo)
GetDeclaredNestedType(String)	回傳一個物件，代表由目前類型宣告的指定巢狀型別。 (繼承來源 TypeInfo)
GetDeclaredProperty(String)	回傳一個物件，代表目前類型所宣告的指定屬性。 (繼承來源 TypeInfo)
GetElementType()	呼叫此方法總是拋 NotSupportedException出 。
GetEnumValuesAsUnderlyingType()	取得此枚舉類型底層類型常數值的陣列。 (繼承來源 Type)
GetEvent(String, BindingFlags)	回傳指定名稱的事件。
GetEvents()	回傳由此類型宣告或繼承的公共事件。
GetEvents(BindingFlags)	回傳由此類型宣告的公開與非公開事件。
GetField(String, BindingFlags)	回傳由名字指定的欄位。
GetField(Type, FieldInfo)	回傳對應於該定義中指定欄位的指定構造型態欄位。
GetFields(BindingFlags)	回傳由此類型宣告的公用與非公有欄位。
GetFunctionPointerCallingConventions()	當在導出類別中覆寫時，會回傳當前函數指標 Type的呼叫慣例。 (繼承來源 Type)
GetFunctionPointerParameterTypes()	當在導出類別中覆寫時，會回傳目前函數指標 Type的參數類型。 (繼承來源 Type)
GetFunctionPointerReturnType()	當在導出類別中覆寫時，會回傳目前函式指標 Type的回傳型別。 (繼承來源 Type)
GetGenericArguments()	回傳一個物件陣列 Type ，代表泛型型別的型別參數或泛型型定義的型別參數。
GetGenericTypeDefinition()	回傳一個 Type 物件，代表一個通用型別定義，可從中取得目前型別。
GetHashCode()	傳回這個實例的哈希碼。 (繼承來源 Type)
GetInterface(String, Boolean)	回傳由此類別（直接或間接）實作的介面，且名稱完全符合指定介面名稱。
GetInterfaceMap(Type)	回傳所請求介面的介面映射。
GetInterfaces()	回傳此類型及其基底類型所實作的所有介面陣列。
GetMember(String, MemberTypes, BindingFlags)	回傳所有由此類型宣告或繼承的公開及非公開成員，依規定而定。
GetMembers(BindingFlags)	申報此類型所宣告或繼承的公開及非公開會員的成員。
GetMemberWithSameMetadataDefinitionAs(MemberInfo)	搜尋與指定MemberInfo電流Type相符的 。MemberInfo (繼承來源 Type)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	使用指定的系結條件約束和指定的呼叫慣例，搜尋指定的方法，其參數符合指定的自變數類型和修飾詞。 (繼承來源 Type)
GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])	使用指定的系結條件約束，搜尋指定的方法，其參數符合指定的自變數類型和修飾詞。 (繼承來源 Type)
GetMethod(String, BindingFlags, Type[])	使用指定的系結條件約束，搜尋指定的方法，其參數符合指定的自變數類型。 (繼承來源 Type)
GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	使用指定的系結條件約束和指定的呼叫慣例，搜尋指定的方法，其參數符合指定的泛型參數計數、自變數類型和修飾詞。 (繼承來源 Type)
GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[])	使用指定的系結條件約束，搜尋指定的方法，其參數符合指定的泛型參數計數、自變數類型和修飾詞。 (繼承來源 Type)
GetMethod(String, Int32, BindingFlags, Type[])	使用指定的系結條件約束，搜尋指定的方法，其參數符合指定的泛型參數計數和自變數類型。 (繼承來源 Type)
GetMethod(String, Int32, Type[], ParameterModifier[])	搜尋指定的公用方法，其參數符合指定的泛型參數計數、自變數類型和修飾詞。 (繼承來源 Type)
GetMethod(String, Int32, Type[])	搜尋指定的公用方法，其參數符合指定的泛型參數計數和自變數類型。 (繼承來源 Type)
GetMethod(Type, MethodInfo)	回傳對應於該定義中指定方法的指定構造通用型別的方法。
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	當導出類別被覆寫時，會搜尋指定方法，其參數與指定的參數類型與修飾符相符，並使用指定的綁定約束與呼叫慣例。
GetMethodImpl(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	當在派生類別中覆寫時，會搜尋指定方法，其參數與指定的參數數量、參數類型及修飾符相符，並使用指定的綁定約束與呼叫慣例。 (繼承來源 Type)
GetMethods(BindingFlags)	回傳所有由此類型宣告或繼承的公開及非公開方法，依規定而定。
GetNestedType(String, BindingFlags)	回傳由此類型宣告的公開與非公開巢狀類型。
GetNestedTypes(BindingFlags)	回傳由此類型宣告或繼承的公有與非公有巢狀型別。
GetOptionalCustomModifiers()	當在衍生類別中覆寫時，會回傳當前 Type的可選自訂修飾符。 (繼承來源 Type)
GetProperties(BindingFlags)	回傳所有由此類型宣告或繼承的公共及非公共財產，依規定而定。
GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	搜尋參數與指定參數類型與修飾符相符的指定屬性，並使用指定的綁定約束。 (繼承來源 Type)
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	當在衍生類別中覆寫時，會搜尋該屬性的參數與指定的參數類型與修飾符相符，並使用指定的綁定約束。
GetRequiredCustomModifiers()	當在衍生類別中被覆寫時，會回傳當前 Type的自訂修飾符。 (繼承來源 Type)
GetType()	取得電流 Type。 (繼承來源 Type)
GetTypeCodeImpl()	回傳此 Type 實例的底層型別代碼。 (繼承來源 Type)
HasElementTypeImpl()	當在派生類別中覆寫時，實作了該 HasElementType 特性，並判斷當前 Type 電流是否包含或指向其他類型;也就是說，當前電流 Type 是陣列、指標，還是透過參考傳遞。
HasSameMetadataDefinitionAs(MemberInfo)	在執行期間定義並建立新的類別實例。 (繼承來源 MemberInfo)
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)	呼叫指定的成員，使用指定的綁定約束，並匹配指定的參數清單與文化。 (繼承來源 Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])	呼叫指定的成員。 要調用的方法必須是可存取的，並且在指定的綁定器和調用屬性限制下，提供與指定參數列表最具體的匹配。
InvokeMember(String, BindingFlags, Binder, Object, Object[])	呼叫指定的成員，使用指定的綁定約束並匹配指定的參數清單。 (繼承來源 Type)
IsArrayImpl()	當在派生類別中覆寫時，實作了該 IsArray 性質，並判斷是否 Type 為陣列。
IsAssignableFrom(Type)	會得到一個值，表示是否可以將指定 Type 物品指派給該物件。
IsAssignableFrom(TypeInfo)	會得到一個值，指示是否可以將指定 TypeInfo 物件指派到該物件上。
IsAssignableTo(Type)	判斷當前型別是否能指派給指定 targetType變數。 (繼承來源 Type)
IsByRefImpl()	當在派生類別中覆寫時，實作了該IsByRef屬性，並判斷是否通過引用傳遞。Type
IsCOMObjectImpl()	當在衍生類別中覆寫時，實作了該 IsCOMObject 屬性並判斷是否 Type 為 COM 物件。
IsContextfulImpl()	實作該 IsContextful 屬性並判斷是否 Type 能在上下文中託管。 (繼承來源 Type)
IsCreated()	回傳一個值，表示目前動態型別是否已被建立。
IsCreatedCore()	當在衍生類別中覆寫時，會回傳一個值，表示目前動態型別是否已被建立。
IsDefined(Type, Boolean)	判斷是否套用自訂屬性於目前型別。
IsMarshalByRefImpl()	實作屬性 IsMarshalByRef 並判斷是否 Type 以引用為編組。 (繼承來源 Type)
IsPointerImpl()	當在派生類別中覆寫時，實作了該 IsPointer 屬性，並判定是否 Type 為指標。
IsPrimitiveImpl()	當在導出類別中覆寫時，實作了該 IsPrimitive 性質，並判斷是否 Type 為原始型態之一。
IsSubclassOf(Type)	判斷此型別是否源自特定型別。
IsValueTypeImpl()	實作屬性 IsValueType 並判斷 是 Type 值型別;也就是說，不是類別或介面。 (繼承來源 Type)
MakeArrayType()	回傳一個 Type 代表當前類型一維陣列的物件，下界為零。
MakeArrayType(Int32)	回傳 Type 一個代表當前類型陣列的物件，且具有指定維度數。
MakeByRefType()	回傳一個 Type 物件，當以 ref 參數（ByRef Visual Basic 中）傳遞時，代表當前類型。
MakeGenericType(Type[])	將一個型別陣列的元素替換為目前通用型別定義的型別參數，並回傳所產生的建構型別。
MakePointerType()	回傳 Type 一個物件，代表指向當前型別的未管理指標的型別。
MemberwiseClone()	建立目前 Object的淺層複本。 (繼承來源 Object)
SetCustomAttribute(ConstructorInfo, Byte[])	使用指定的自訂屬性 blob 設定自訂屬性。
SetCustomAttribute(CustomAttributeBuilder)	用自訂屬性建構器設定自訂屬性。
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	當在衍生類別中覆寫時，會在該組合語言上設定自訂屬性。
SetParent(Type)	設定目前正在建造的機型的基礎型態。
SetParentCore(Type)	當在衍生類別中覆寫時，會設定目前建構中的類型的基底型態。
ToString()	回傳不包含命名空間的類型名稱。

明確介面實作

名稱	Description
IReflectableType.GetTypeInfo()	回傳當前型態的表示，作為物件 TypeInfo 。 (繼承來源 TypeInfo)

擴充方法

名稱	Description
GetConstructor(Type, Type[])	在執行期間定義並建立新的類別實例。
GetConstructors(Type, BindingFlags)	在執行期間定義並建立新的類別實例。
GetConstructors(Type)	在執行期間定義並建立新的類別實例。
GetCustomAttribute(MemberInfo, Type, Boolean)	擷取指定類型的自訂屬性，套用於指定成員，並可選擇性地檢查該成員的祖先。
GetCustomAttribute(MemberInfo, Type)	擷取指定型別的自訂屬性，套用到指定成員。
GetCustomAttribute<T>(MemberInfo, Boolean)	擷取指定類型的自訂屬性，套用於指定成員，並可選擇性地檢查該成員的祖先。
GetCustomAttribute<T>(MemberInfo)	擷取指定型別的自訂屬性，套用到指定成員。
GetCustomAttributes(MemberInfo, Boolean)	擷取一套套用於指定成員的自訂屬性，並可選擇性地檢查該成員的祖先。
GetCustomAttributes(MemberInfo, Type, Boolean)	擷取一組指定類型的自訂屬性，套用於指定成員，並可選擇性檢查該成員的祖先。
GetCustomAttributes(MemberInfo, Type)	擷取一組指定類型的自訂屬性，套用到指定成員。
GetCustomAttributes(MemberInfo)	擷取一套套用於指定成員的自訂屬性集合。
GetCustomAttributes<T>(MemberInfo, Boolean)	擷取一組指定類型的自訂屬性，套用於指定成員，並可選擇性檢查該成員的祖先。
GetCustomAttributes<T>(MemberInfo)	擷取一組指定類型的自訂屬性，套用到指定成員。
GetDefaultMembers(Type)	在執行期間定義並建立新的類別實例。
GetEvent(Type, String, BindingFlags)	在執行期間定義並建立新的類別實例。
GetEvent(Type, String)	在執行期間定義並建立新的類別實例。
GetEvents(Type, BindingFlags)	在執行期間定義並建立新的類別實例。
GetEvents(Type)	在執行期間定義並建立新的類別實例。
GetField(Type, String, BindingFlags)	在執行期間定義並建立新的類別實例。
GetField(Type, String)	在執行期間定義並建立新的類別實例。
GetFields(Type, BindingFlags)	在執行期間定義並建立新的類別實例。
GetFields(Type)	在執行期間定義並建立新的類別實例。
GetGenericArguments(Type)	在執行期間定義並建立新的類別實例。
GetInterfaces(Type)	在執行期間定義並建立新的類別實例。
GetMember(Type, String, BindingFlags)	在執行期間定義並建立新的類別實例。
GetMember(Type, String)	在執行期間定義並建立新的類別實例。
GetMembers(Type, BindingFlags)	在執行期間定義並建立新的類別實例。
GetMembers(Type)	在執行期間定義並建立新的類別實例。
GetMetadataToken(MemberInfo)	如果有的話，會獲得該成員的元資料標記。
GetMethod(Type, String, BindingFlags)	在執行期間定義並建立新的類別實例。
GetMethod(Type, String, Type[])	在執行期間定義並建立新的類別實例。
GetMethods(Type, BindingFlags)	在執行期間定義並建立新的類別實例。
GetMethods(Type)	在執行期間定義並建立新的類別實例。
GetNestedTypes(Type, BindingFlags)	在執行期間定義並建立新的類別實例。
GetProperties(Type, BindingFlags)	在執行期間定義並建立新的類別實例。
GetProperties(Type)	在執行期間定義並建立新的類別實例。
GetProperty(Type, String, Type, Type[])	在執行期間定義並建立新的類別實例。
GetProperty(Type, String, Type)	在執行期間定義並建立新的類別實例。
GetProperty(Type, String)	在執行期間定義並建立新的類別實例。
GetRuntimeEvent(Type, String)	擷取代表指定事件的物件。
GetRuntimeEvents(Type)	擷取一個集合，代表指定型別上定義的所有事件。
GetRuntimeField(Type, String)	擷取代表指定欄位的物件。
GetRuntimeFields(Type)	檢索一個集合，代表指定型別上定義的所有欄位。
GetRuntimeInterfaceMap(TypeInfo, Type)	回傳指定類型與介面的介面映射。
GetRuntimeMethod(Type, String, Type[])	擷取代表指定方法的物件。
GetRuntimeMethods(Type)	檢索一個集合，代表指定型別上定義的所有方法。
GetRuntimeProperties(Type)	擷取一個集合，代表指定型別上定義的所有屬性。
GetRuntimeProperty(Type, String)	擷取代表指定屬性的物件。
GetTypeInfo(Type)	回傳 TypeInfo 指定型別的表示。
HasMetadataToken(MemberInfo)	回傳一個值，表示指定成員是否有可用的元資料標記。
IsAssignableFrom(Type, Type)	在執行期間定義並建立新的類別實例。
IsDefined(MemberInfo, Type, Boolean)	表示是否將特定類型的自訂屬性套用於指定成員，並可選擇套用於其祖先。
IsDefined(MemberInfo, Type)	表示是否套用特定類型的自訂屬性給指定成員。
IsInstanceOfType(Type, Object)	在執行期間定義並建立新的類別實例。

另請參閱

• 如何：使用 Reflection Emit 定義泛型類型