TypeBuilder Kelas

Definisi

Ruang nama:

System.Reflection.Emit

Rakitan:

System.Reflection.Emit.dll

Sumber:

TypeBuilder.cs

Menentukan dan membuat instans kelas baru selama durasi.

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

Warisan

Object

MemberInfo

Type

TypeInfo

TypeBuilder

Contoh

Contoh kode berikut menunjukkan cara menentukan dan menggunakan rakitan dinamis. Contoh rakitan berisi satu jenis, MyDynamicType, yang memiliki bidang privat, properti yang mendapatkan dan mengatur bidang privat, konstruktor yang menginisialisasi bidang privat, dan metode yang mengalikan angka yang disediakan pengguna dengan nilai bidang privat dan mengembalikan hasilnya.

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

        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

Sampel kode berikut menunjukkan cara membangun jenis secara dinamis dengan menggunakan TypeBuilder.

using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
Type^ DynamicDotProductGen()
{
   Type^ ivType = nullptr;
   array<Type^>^temp0 = {int::typeid,int::typeid,int::typeid};
   array<Type^>^ctorParams = temp0;
   AppDomain^ myDomain = Thread::GetDomain();
   AssemblyName^ myAsmName = gcnew 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", int::typeid, FieldAttributes::Private );
   FieldBuilder^ yField = ivTypeBld->DefineField( "y", int::typeid, FieldAttributes::Private );
   FieldBuilder^ zField = ivTypeBld->DefineField( "z", int::typeid, FieldAttributes::Private );
   Type^ objType = Type::GetType( "System.Object" );
   ConstructorInfo^ objCtor = objType->GetConstructor( gcnew array<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.
   array<Type^>^temp1 = {ivTypeBld};
   array<Type^>^dpParams = temp1;
   
   // 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, int::typeid, 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;
}

int main()
{
   Type^ IVType = nullptr;
   Object^ aVector1 = nullptr;
   Object^ aVector2 = nullptr;
   array<Type^>^temp2 = {int::typeid,int::typeid,int::typeid};
   array<Type^>^aVtypes = temp2;
   array<Object^>^temp3 = {10,10,10};
   array<Object^>^aVargs1 = temp3;
   array<Object^>^temp4 = {20,20,20};
   array<Object^>^aVargs2 = temp4;
   
   // 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 );
   array<Object^>^passMe = gcnew array<Object^>(1);
   passMe[ 0 ] = dynamic_cast<Object^>(aVector2);
   Console::WriteLine( "(10, 10, 10) . (20, 20, 20) = {0}", IVType->InvokeMember( "DotProduct", BindingFlags::InvokeMethod, nullptr, aVector1, passMe ) );
}

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

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

Keterangan

Untuk informasi selengkapnya tentang API ini, lihat Keterangan API Tambahan untuk TypeBuilder.

Konstruktor

TypeBuilder()

Menginisialisasi instans baru kelas TypeBuilder.

Bidang

UnspecifiedTypeSize

Menunjukkan bahwa ukuran total untuk jenis tidak ditentukan.

Properti

Assembly	Mengambil rakitan dinamis yang berisi definisi jenis ini.
AssemblyQualifiedName	Mengembalikan nama lengkap tipe ini yang memenuhi syarat dengan nama tampilan rakitan.
Attributes	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
BaseType	Mengambil jenis dasar jenis ini.
ContainsGenericParameters	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
CustomAttributes	Mendapatkan koleksi yang berisi atribut kustom anggota ini. (Diperoleh dari MemberInfo)
DeclaredConstructors	Mendapatkan koleksi konstruktor yang dideklarasikan oleh jenis saat ini. (Diperoleh dari TypeInfo)
DeclaredEvents	Mendapatkan kumpulan peristiwa yang ditentukan oleh jenis saat ini. (Diperoleh dari TypeInfo)
DeclaredFields	Mendapatkan kumpulan bidang yang ditentukan oleh jenis saat ini. (Diperoleh dari TypeInfo)
DeclaredMembers	Mendapatkan kumpulan anggota yang ditentukan oleh jenis saat ini. (Diperoleh dari TypeInfo)
DeclaredMethods	Mendapatkan kumpulan metode yang ditentukan oleh jenis saat ini. (Diperoleh dari TypeInfo)
DeclaredNestedTypes	Mendapatkan kumpulan jenis berlapis yang ditentukan oleh jenis saat ini. (Diperoleh dari TypeInfo)
DeclaredProperties	Mendapatkan kumpulan properti yang ditentukan oleh jenis saat ini. (Diperoleh dari TypeInfo)
DeclaringMethod	Mendapatkan metode yang mendeklarasikan parameter jenis generik saat ini.
DeclaringType	Mengembalikan tipe yang mendeklarasikan tipe ini.
FullName	Mengambil jalur lengkap jenis ini.
GenericParameterAttributes	Mendapatkan nilai yang menunjukkan kovariansi dan batasan khusus dari parameter jenis generik saat ini.
GenericParameterPosition	Mendapatkan posisi parameter jenis dalam daftar parameter jenis jenis generik yang mendeklarasikan parameter.
GenericTypeArguments	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GenericTypeParameters	Mendapatkan array parameter jenis generik dari instans saat ini. (Diperoleh dari TypeInfo)
GUID	Mengambil GUID jenis ini.
HasElementType	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
ImplementedInterfaces	Mendapatkan koleksi antarmuka yang diimplementasikan oleh jenis saat ini. (Diperoleh dari TypeInfo)
IsAbstract	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsAnsiClass	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsArray	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsAutoClass	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsAutoLayout	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsByRef	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsByRefLike	Mendapatkan nilai yang menunjukkan apakah jenisnya adalah struktur seperti byref.
IsClass	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsCollectible	Mendapatkan nilai yang menunjukkan apakah objek ini MemberInfo adalah bagian dari perakitan yang dipegang dalam koleksi AssemblyLoadContext. (Diperoleh dari MemberInfo)
IsCOMObject	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsConstructedGenericType	Mendapatkan nilai yang menunjukkan apakah objek ini mewakili jenis generik yang dibangun.
IsContextful	Mendapatkan nilai yang menunjukkan apakah Type dapat dihosting dalam konteks. (Diperoleh dari Type)
IsEnum	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsExplicitLayout	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsFunctionPointer	Mendapatkan nilai yang menunjukkan apakah saat ini Type adalah penunjuk fungsi. (Diperoleh dari Type)
IsGenericMethodParameter	Mendapatkan nilai yang menunjukkan apakah saat ini Type mewakili parameter jenis dalam definisi metode generik. (Diperoleh dari Type)
IsGenericParameter	Mendapatkan nilai yang menunjukkan apakah jenis saat ini adalah parameter jenis generik.
IsGenericType	Mendapatkan nilai yang menunjukkan apakah jenis saat ini adalah jenis generik.
IsGenericTypeDefinition	Mendapatkan nilai yang menunjukkan apakah saat ini TypeBuilder mewakili definisi jenis generik tempat jenis generik lainnya dapat dibangun.
IsGenericTypeParameter	Mendapatkan nilai yang menunjukkan apakah saat ini Type mewakili parameter jenis dalam definisi jenis generik. (Diperoleh dari Type)
IsImport	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsInterface	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsLayoutSequential	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsMarshalByRef	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsNested	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsNestedAssembly	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsNestedFamANDAssem	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsNestedFamily	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsNestedFamORAssem	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsNestedPrivate	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsNestedPublic	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsNotPublic	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsPointer	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsPrimitive	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsPublic	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsSealed	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsSecurityCritical	Mendapatkan nilai yang menunjukkan apakah jenis saat ini penting bagi keamanan atau keamanan kritis, dan karenanya dapat melakukan operasi penting.
IsSecuritySafeCritical	Mendapatkan nilai yang menunjukkan apakah jenis saat ini penting untuk keamanan; yaitu, apakah dapat melakukan operasi penting dan dapat diakses dengan kode transparan.
IsSecurityTransparent	Mendapatkan nilai yang menunjukkan apakah jenis saat ini transparan, dan karenanya tidak dapat melakukan operasi penting.
IsSerializable	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsSignatureType	Mendapatkan nilai yang menunjukkan apakah jenisnya adalah jenis tanda tangan. (Diperoleh dari Type)
IsSpecialName	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsSZArray	Menentukan dan membuat instans kelas baru selama durasi.
IsTypeDefinition	Menentukan dan membuat instans kelas baru selama durasi.
IsUnicodeClass	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsUnmanagedFunctionPointer	Mendapatkan nilai yang menunjukkan apakah saat ini Type adalah penunjuk fungsi yang tidak dikelola. (Diperoleh dari Type)
IsValueType	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsVariableBoundArray	Mendapatkan nilai yang menunjukkan apakah jenisnya adalah jenis array yang dapat mewakili array multi-dimensi atau array dengan batas bawah arbitrer. (Diperoleh dari Type)
IsVisible	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
MemberType	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
MetadataToken	Mendapatkan token yang mengidentifikasi modul dinamis saat ini dalam metadata.
Module	Mengambil modul dinamis yang berisi definisi jenis ini.
Name	Mengambil nama jenis ini.
Namespace	Mengambil namespace tempat ini TypeBuilder ditentukan.
PackingSize	Mengambil ukuran pengemasan jenis ini.
PackingSizeCore	Ketika ditimpa di kelas turunan, mendapatkan ukuran pengemasan jenis ini.
ReflectedType	Mengembalikan tipe yang digunakan untuk mendapatkan tipe ini.
Size	Mengambil ukuran total jenis.
SizeCore	Ketika ditimpa di kelas turunan, mendapatkan ukuran total jenis.
StructLayoutAttribute	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
TypeHandle	Tidak didukung dalam modul dinamis.
TypeInitializer	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
UnderlyingSystemType	Mengembalikan jenis sistem yang mendasar untuk ini TypeBuilder.

Metode

AddInterfaceImplementation(Type)	Menambahkan antarmuka yang diterapkan jenis ini.
AddInterfaceImplementationCore(Type)	Saat ditimpa di kelas turunan, menambahkan antarmuka yang diterapkan jenis ini.
AsType()	Mengembalikan tipe saat ini sebagai Type objek. (Diperoleh dari TypeInfo)
CreateType()	Type Membuat objek untuk kelas . Setelah menentukan bidang dan metode pada kelas , CreateType dipanggil untuk memuat objeknya Type .
CreateTypeInfo()	TypeInfo Mendapatkan objek yang mewakili jenis ini.
CreateTypeInfoCore()	Ketika ditimpa dalam kelas turunan TypeInfo , mendapatkan objek yang mewakili jenis ini.
DefineConstructor(MethodAttributes, CallingConventions, Type[])	Menambahkan konstruktor baru ke jenis , dengan atribut dan tanda tangan yang diberikan.
DefineConstructor(MethodAttributes, CallingConventions, Type[], Type[][], Type[][])	Menambahkan konstruktor baru ke jenis , dengan atribut, tanda tangan, dan pengubah kustom yang diberikan.
DefineConstructorCore(MethodAttributes, CallingConventions, Type[], Type[][], Type[][])	Saat ditimpa di kelas turunan, menambahkan konstruktor baru ke jenis , dengan atribut, tanda tangan, dan pengubah kustom yang diberikan.
DefineDefaultConstructor(MethodAttributes)	Mendefinisikan konstruktor tanpa parameter. Konstruktor yang ditentukan di sini hanya akan memanggil konstruktor tanpa parameter induk.
DefineDefaultConstructorCore(MethodAttributes)	Saat ditimpa di kelas turunan, menentukan konstruktor tanpa parameter. Konstruktor yang ditentukan di sini memanggil konstruktor tanpa parameter induk.
DefineEvent(String, EventAttributes, Type)	Menambahkan peristiwa baru ke jenis , dengan nama, atribut, dan jenis peristiwa yang diberikan.
DefineEventCore(String, EventAttributes, Type)	Saat ditimpa di kelas turunan, menambahkan peristiwa baru ke jenis , dengan nama, atribut, dan jenis peristiwa yang diberikan.
DefineField(String, Type, FieldAttributes)	Menambahkan bidang baru ke jenis , dengan nama, atribut, dan jenis bidang yang diberikan.
DefineField(String, Type, Type[], Type[], FieldAttributes)	Menambahkan bidang baru ke jenis , dengan nama, atribut, jenis bidang, dan pengubah kustom yang diberikan.
DefineFieldCore(String, Type, Type[], Type[], FieldAttributes)	Saat ditimpa di kelas turunan, menambahkan bidang baru ke jenis , dengan nama, atribut, jenis bidang, dan pengubah kustom yang diberikan.
DefineGenericParameters(String[])	Menentukan parameter jenis generik untuk jenis saat ini, menentukan jumlah dan namanya, dan mengembalikan array GenericTypeParameterBuilder objek yang dapat digunakan untuk mengatur batasannya.
DefineGenericParametersCore(String[])	Saat ditimpa di kelas turunan, menentukan parameter jenis generik untuk jenis saat ini, menentukan jumlah dan namanya.
DefineInitializedData(String, Byte[], FieldAttributes)	Menentukan bidang data yang diinisialisasi di bagian .sdata dari file portable executable (PE).
DefineInitializedDataCore(String, Byte[], FieldAttributes)	Saat ditimpa di kelas turunan, menentukan bidang data yang diinisialisasi di bagian .sdata dari file portable executable (PE).
DefineMethod(String, MethodAttributes)	Menambahkan metode baru ke jenis , dengan atribut nama dan metode yang ditentukan.
DefineMethod(String, MethodAttributes, CallingConventions)	Menambahkan metode baru ke jenis , dengan nama, atribut metode, dan konvensi panggilan yang ditentukan.
DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[])	Menambahkan metode baru ke jenis , dengan nama, atribut metode, konvensi panggilan, dan tanda tangan metode yang ditentukan.
DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Menambahkan metode baru ke jenis , dengan nama, atribut metode, konvensi panggilan, tanda tangan metode, dan pengubah kustom yang ditentukan.
DefineMethod(String, MethodAttributes, Type, Type[])	Menambahkan metode baru ke jenis , dengan nama, atribut metode, dan tanda tangan metode yang ditentukan.
DefineMethodCore(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Saat ditimpa di kelas turunan, menambahkan metode baru ke jenis , dengan nama, atribut metode, konvensi panggilan, tanda tangan metode, dan pengubah kustom yang ditentukan.
DefineMethodOverride(MethodInfo, MethodInfo)	Menentukan isi metode tertentu yang mengimplementasikan deklarasi metode tertentu, berpotensi dengan nama yang berbeda.
DefineMethodOverrideCore(MethodInfo, MethodInfo)	Ketika ditimpa dalam kelas turunan, menentukan isi metode tertentu yang mengimplementasikan deklarasi metode tertentu, berpotensi dengan nama yang berbeda.
DefineNestedType(String)	Mendefinisikan jenis berlapis, mengingat namanya.
DefineNestedType(String, TypeAttributes)	Mendefinisikan jenis berlapis, mengingat nama dan atributnya.
DefineNestedType(String, TypeAttributes, Type)	Mendefinisikan jenis berlapis, mengingat nama, atribut, dan jenis yang diperluasnya.
DefineNestedType(String, TypeAttributes, Type, Int32)	Mendefinisikan jenis berlapis, mengingat nama, atribut, ukuran total jenis, dan jenis yang diperluasnya.
DefineNestedType(String, TypeAttributes, Type, PackingSize)	Mendefinisikan jenis berlapis, mengingat nama, atribut, jenis yang diperluas, dan ukuran pengemasannya.
DefineNestedType(String, TypeAttributes, Type, PackingSize, Int32)	Mendefinisikan jenis berlapis, mengingat nama, atribut, ukuran, dan jenis yang diperluasnya.
DefineNestedType(String, TypeAttributes, Type, Type[])	Mendefinisikan jenis berlapis, mengingat nama, atribut, jenis yang diperluas, dan antarmuka yang diterapkannya.
DefineNestedTypeCore(String, TypeAttributes, Type, Type[], PackingSize, Int32)	Saat ditimpa dalam kelas turunan, menentukan jenis berlapis, mengingat nama, atribut, ukuran, dan jenis yang diperluasnya.
DefinePInvokeMethod(String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Mendefinisikan metode yang PInvoke diberikan namanya, nama DLL tempat metode ditentukan, atribut metode, konvensi panggilan metode, jenis pengembalian metode, jenis parameter metode, dan PInvoke bendera.
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Mendefinisikan metode yang PInvoke diberikan namanya, nama DLL tempat metode ditentukan, nama titik masuk, atribut metode, konvensi panggilan metode, jenis pengembalian metode, jenis parameter metode, dan PInvoke bendera.
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][], CallingConvention, CharSet)	Mendefinisikan metode yang PInvoke diberikan namanya, nama DLL di mana metode ditentukan, nama titik masuk, atribut metode, konvensi panggilan metode, jenis pengembalian metode, jenis parameter metode, bendera bendera PInvoke , dan pengubah kustom untuk parameter dan jenis pengembalian.
DefinePInvokeMethodCore(String, String, String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][], CallingConvention, CharSet)	Saat ditimpa dalam kelas turunan, menentukan metode PInvoke dengan nama yang disediakan, nama DLL, nama titik entri, atribut, konvensi panggilan, jenis pengembalian, jenis parameter, bendera PInvoke, dan pengubah kustom untuk parameter dan jenis pengembalian.
DefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[])	Menambahkan properti baru ke jenis , dengan nama, atribut, konvensi panggilan, dan tanda tangan properti yang diberikan.
DefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Menambahkan properti baru ke jenis , dengan nama yang diberikan, konvensi panggilan, tanda tangan properti, dan pengubah kustom.
DefineProperty(String, PropertyAttributes, Type, Type[])	Menambahkan properti baru ke jenis , dengan nama dan tanda tangan properti yang diberikan.
DefineProperty(String, PropertyAttributes, Type, Type[], Type[], Type[], Type[][], Type[][])	Menambahkan properti baru ke jenis , dengan nama yang diberikan, tanda tangan properti, dan pengubah kustom.
DefinePropertyCore(String, PropertyAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Saat ditimpa di kelas turunan, menambahkan properti baru ke jenis , dengan nama yang diberikan, konvensi panggilan, tanda tangan properti, dan pengubah kustom.
DefineTypeInitializer()	Menentukan penginisialisasi untuk jenis ini.
DefineTypeInitializerCore()	Ketika ditimpa di kelas turunan, menentukan penginisialisasi untuk jenis ini.
DefineUninitializedData(String, Int32, FieldAttributes)	Menentukan bidang data yang tidak diinisialisasi di bagian .sdata file portable executable (PE).
DefineUninitializedDataCore(String, Int32, FieldAttributes)	Saat ditimpa dalam kelas turunan, menentukan bidang data yang tidak diinisialisasi di .sdata bagian file portable executable (PE).
Equals(Object)	Menentukan apakah jenis sistem yang mendasar dari objek saat ini Type sama dengan jenis sistem yang mendasar dari yang ditentukan Object. (Diperoleh dari Type)
Equals(Type)	Menentukan apakah jenis sistem yang mendasar dari saat ini Type sama dengan jenis sistem yang mendasar dari yang ditentukan Type. (Diperoleh dari Type)
FindInterfaces(TypeFilter, Object)	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetArrayRank()	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetAttributeFlagsImpl()	Ketika ditimpa di kelas turunan, mengimplementasikan Attributes properti dan mendapatkan kombinasi bitwise dari nilai enumerasi yang menunjukkan atribut yang terkait dengan Type.
GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Mencari konstruktor yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan konvensi panggilan yang ditentukan. (Diperoleh dari Type)
GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])	Mencari konstruktor yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan. (Diperoleh dari Type)
GetConstructor(BindingFlags, Type[])	Mencari konstruktor yang parameternya cocok dengan jenis argumen yang ditentukan, menggunakan batasan pengikatan yang ditentukan. (Diperoleh dari Type)
GetConstructor(Type, ConstructorInfo)	Mengembalikan konstruktor dari jenis generik yang dibuat yang ditentukan yang sesuai dengan konstruktor yang ditentukan dari definisi jenis generik.
GetConstructor(Type[])	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Saat ditimpa di kelas turunan, cari konstruktor yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan konvensi panggilan yang ditentukan.
GetConstructors()	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetConstructors(BindingFlags)	Mengembalikan array ConstructorInfo objek yang mewakili konstruktor publik dan non-publik yang ditentukan untuk kelas ini, seperti yang ditentukan.
GetCustomAttributes(Boolean)	Mengembalikan semua atribut kustom yang ditentukan untuk jenis ini.
GetCustomAttributes(Type, Boolean)	Mengembalikan semua atribut kustom dari jenis saat ini yang dapat ditetapkan ke jenis tertentu.
GetCustomAttributesData()	Mengembalikan daftar CustomAttributeData objek yang mewakili data tentang atribut yang telah diterapkan ke anggota target. (Diperoleh dari MemberInfo)
GetDeclaredEvent(String)	Mengembalikan objek yang mewakili peristiwa yang ditentukan yang dideklarasikan oleh jenis saat ini. (Diperoleh dari TypeInfo)
GetDeclaredField(String)	Mengembalikan objek yang mewakili bidang yang ditentukan yang dideklarasikan oleh jenis saat ini. (Diperoleh dari TypeInfo)
GetDeclaredMethod(String)	Mengembalikan objek yang mewakili metode yang ditentukan yang dideklarasikan oleh jenis saat ini. (Diperoleh dari TypeInfo)
GetDeclaredMethods(String)	Mengembalikan koleksi yang berisi semua metode yang dideklarasikan pada tipe saat ini yang cocok dengan nama yang ditentukan. (Diperoleh dari TypeInfo)
GetDeclaredNestedType(String)	Mengembalikan objek yang mewakili tipe berlapis yang ditentukan yang dideklarasikan oleh tipe saat ini. (Diperoleh dari TypeInfo)
GetDeclaredProperty(String)	Mengembalikan objek yang mewakili properti yang ditentukan yang dideklarasikan oleh tipe saat ini. (Diperoleh dari TypeInfo)
GetDefaultMembers()	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetElementType()	Memanggil metode ini selalu melempar NotSupportedException.
GetEnumName(Object)	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetEnumNames()	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetEnumUnderlyingType()	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetEnumValues()	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetEnumValuesAsUnderlyingType()	Mengambil array nilai dari konstanta jenis dasar dari jenis enumerasi ini. (Diperoleh dari Type)
GetEvent(String)	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetEvent(String, BindingFlags)	Mengembalikan peristiwa dengan nama yang ditentukan.
GetEvents()	Mengembalikan peristiwa publik yang dideklarasikan atau diwariskan oleh tipe ini.
GetEvents(BindingFlags)	Mengembalikan peristiwa publik dan non-publik yang dideklarasikan oleh jenis ini.
GetField(String)	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetField(String, BindingFlags)	Mengembalikan bidang yang ditentukan oleh nama yang diberikan.
GetField(Type, FieldInfo)	Mengembalikan bidang dari jenis generik yang dibuat yang ditentukan yang sesuai dengan bidang yang ditentukan dari definisi jenis generik.
GetFields()	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetFields(BindingFlags)	Mengembalikan bidang publik dan non-publik yang dideklarasikan oleh tipe ini.
GetFunctionPointerCallingConventions()	Saat ditimpa di kelas turunan, mengembalikan konvensi panggilan dari penunjuk Typefungsi saat ini . (Diperoleh dari Type)
GetFunctionPointerParameterTypes()	Saat ditimpa di kelas turunan, mengembalikan jenis parameter penunjuk Typefungsi saat ini . (Diperoleh dari Type)
GetFunctionPointerReturnType()	Saat ditimpa di kelas turunan, mengembalikan jenis pengembalian penunjuk Typefungsi saat ini . (Diperoleh dari Type)
GetGenericArguments()	Mengembalikan array Type objek yang mewakili argumen jenis dari jenis generik atau parameter jenis definisi jenis generik.
GetGenericParameterConstraints()	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetGenericTypeDefinition()	Type Mengembalikan objek yang mewakili definisi jenis generik dari mana jenis saat ini dapat diperoleh.
GetHashCode()	Mengembalikan kode hash untuk instans ini. (Diperoleh dari Type)
GetInterface(String)	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetInterface(String, Boolean)	Mengembalikan antarmuka yang diimplementasikan (secara langsung atau tidak langsung) oleh kelas ini dengan nama yang sepenuhnya memenuhi syarat yang cocok dengan nama antarmuka yang diberikan.
GetInterfaceMap(Type)	Mengembalikan pemetaan antarmuka untuk antarmuka yang diminta.
GetInterfaces()	Mengembalikan array dari semua antarmuka yang diimplementasikan pada jenis ini dan jenis dasarnya.
GetMember(String)	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetMember(String, BindingFlags)	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetMember(String, MemberTypes, BindingFlags)	Mengembalikan semua anggota publik dan non-publik yang dinyatakan atau diwarisi oleh jenis ini, seperti yang ditentukan.
GetMembers()	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetMembers(BindingFlags)	Mengembalikan anggota untuk anggota publik dan non-publik yang dinyatakan atau diwarisi oleh jenis ini.
GetMemberWithSameMetadataDefinitionAs(MemberInfo)	Mencari MemberInfo pada saat ini Type yang cocok dengan yang ditentukan MemberInfo. (Diperoleh dari Type)
GetMethod(String)	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetMethod(String, BindingFlags)	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Mencari metode yang ditentukan yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan konvensi panggilan yang ditentukan. (Diperoleh dari Type)
GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])	Mencari metode yang ditentukan yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan. (Diperoleh dari Type)
GetMethod(String, BindingFlags, Type[])	Mencari metode yang ditentukan yang parameternya cocok dengan jenis argumen yang ditentukan, menggunakan batasan pengikatan yang ditentukan. (Diperoleh dari Type)
GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Mencari metode yang ditentukan yang parameternya cocok dengan jumlah parameter generik, jenis argumen, dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan konvensi panggilan yang ditentukan. (Diperoleh dari Type)
GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[])	Mencari metode yang ditentukan yang parameternya cocok dengan jumlah parameter generik, jenis argumen, dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan. (Diperoleh dari Type)
GetMethod(String, Int32, BindingFlags, Type[])	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari Type)
GetMethod(String, Int32, Type[])	Mencari metode publik yang ditentukan yang parameternya cocok dengan jumlah parameter generik dan jenis argumen yang ditentukan. (Diperoleh dari Type)
GetMethod(String, Int32, Type[], ParameterModifier[])	Mencari metode publik yang ditentukan yang parameternya cocok dengan jumlah parameter generik, jenis argumen, dan pengubah yang ditentukan. (Diperoleh dari Type)
GetMethod(String, Type[])	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetMethod(String, Type[], ParameterModifier[])	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetMethod(Type, MethodInfo)	Mengembalikan metode dari jenis generik yang dibuat yang ditentukan yang sesuai dengan metode yang ditentukan dari definisi jenis generik.
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Saat ditimpa dalam kelas turunan, cari metode yang ditentukan yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan konvensi panggilan yang ditentukan.
GetMethodImpl(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Saat ditimpa di kelas turunan, cari metode yang ditentukan yang parameternya cocok dengan jumlah parameter generik, jenis argumen, dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan konvensi panggilan yang ditentukan. (Diperoleh dari Type)
GetMethods()	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetMethods(BindingFlags)	Mengembalikan semua metode publik dan non-publik yang dideklarasikan atau diwarisi oleh jenis ini, seperti yang ditentukan.
GetNestedType(String)	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetNestedType(String, BindingFlags)	Mengembalikan tipe berlapis publik dan non-publik yang dideklarasikan oleh jenis ini.
GetNestedTypes()	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetNestedTypes(BindingFlags)	Mengembalikan tipe berlapis publik dan non-publik yang dinyatakan atau diwarisi oleh jenis ini.
GetOptionalCustomModifiers()	Saat ditimpa di kelas turunan, mengembalikan pengubah kustom opsional dari saat ini Type. (Diperoleh dari Type)
GetProperties()	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetProperties(BindingFlags)	Mengembalikan semua properti publik dan non-publik yang dideklarasikan atau diwarisi oleh jenis ini, seperti yang ditentukan.
GetProperty(String)	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetProperty(String, BindingFlags)	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Mencari properti yang ditentukan yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan. (Diperoleh dari Type)
GetProperty(String, Type)	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetProperty(String, Type, Type[])	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetProperty(String, Type, Type[], ParameterModifier[])	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetProperty(String, Type[])	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Saat ditimpa di kelas turunan, cari properti yang ditentukan yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan.
GetRequiredCustomModifiers()	Saat ditimpa di kelas turunan, mengembalikan pengubah kustom yang Typediperlukan dari . (Diperoleh dari Type)
GetType()	TypeMendapatkan . (Diperoleh dari Type)
GetTypeCodeImpl()	Mengembalikan kode jenis yang mendasar dari instans ini Type . (Diperoleh dari Type)
HasElementTypeImpl()	Ketika ditimpa di kelas turunan, mengimplementasikan HasElementType properti dan menentukan apakah saat ini Type mencakup atau merujuk ke jenis lain; yaitu, apakah saat ini Type adalah array, pointer, atau diteruskan oleh referensi.
HasSameMetadataDefinitionAs(MemberInfo)	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari MemberInfo)
InvokeMember(String, BindingFlags, Binder, Object, Object[])	Memanggil anggota yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan mencocokkan daftar argumen yang ditentukan. (Diperoleh dari Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)	Memanggil anggota yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan mencocokkan daftar argumen dan budaya yang ditentukan. (Diperoleh dari Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])	Memanggil anggota yang ditentukan. Metode yang akan dipanggil harus dapat diakses dan memberikan kecocokan paling spesifik dengan daftar argumen yang ditentukan, di bawah batasan atribut binder dan pemanggilan yang ditentukan.
IsArrayImpl()	Saat ditimpa di kelas turunan, terapkan IsArray properti dan tentukan Type apakah itu array.
IsAssignableFrom(Type)	Mendapatkan nilai yang menunjukkan apakah yang ditentukan Type dapat ditetapkan ke objek ini.
IsAssignableFrom(TypeInfo)	Mendapatkan nilai yang menunjukkan apakah objek tertentu TypeInfo dapat ditetapkan ke objek ini.
IsAssignableTo(Type)	Menentukan apakah jenis saat ini dapat ditetapkan ke variabel dari yang ditentukan targetType. (Diperoleh dari Type)
IsByRefImpl()	Ketika ditimpa di kelas turunan, mengimplementasikan IsByRef properti dan menentukan apakah Type diteruskan oleh referensi.
IsCOMObjectImpl()	Ketika ditimpa di kelas turunan, mengimplementasikan IsCOMObject properti dan menentukan apakah Type itu objek COM.
IsContextfulImpl()	IsContextful Menerapkan properti dan menentukan apakah Type dapat dihosting dalam konteks. (Diperoleh dari Type)
IsCreated()	Mengembalikan nilai yang menunjukkan apakah jenis dinamis saat ini telah dibuat.
IsCreatedCore()	Saat ditimpa di kelas turunan, mengembalikan nilai yang menunjukkan apakah jenis dinamis saat ini telah dibuat.
IsDefined(Type, Boolean)	Menentukan apakah atribut kustom diterapkan ke jenis saat ini.
IsEnumDefined(Object)	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsEquivalentTo(Type)	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsInstanceOfType(Object)	Menentukan dan membuat instans kelas baru selama durasi. (Diperoleh dari TypeInfo)
IsMarshalByRefImpl()	IsMarshalByRef Mengimplementasikan properti dan menentukan apakah Type marshaled by reference. (Diperoleh dari Type)
IsPointerImpl()	Saat ditimpa di kelas turunan, terapkan IsPointer properti dan tentukan Type apakah itu pointer.
IsPrimitiveImpl()	Ketika ditimpa di kelas turunan, terapkan IsPrimitive properti dan tentukan apakah Type itu salah satu jenis primitif.
IsSubclassOf(Type)	Menentukan apakah jenis ini berasal dari tipe tertentu.
IsValueTypeImpl()	IsValueType Mengimplementasikan properti dan menentukan apakah Type adalah jenis nilai; yaitu, bukan kelas atau antarmuka. (Diperoleh dari Type)
MakeArrayType()	Mengembalikan Type objek yang mewakili array satu dimensi dari jenis saat ini, dengan batas nol yang lebih rendah.
MakeArrayType(Int32)	Mengembalikan Type objek yang mewakili array dari jenis saat ini, dengan jumlah dimensi yang ditentukan.
MakeByRefType()	Mengembalikan Type objek yang mewakili jenis saat ini saat diteruskan sebagai ref parameter (ByRef di Visual Basic).
MakeGenericType(Type[])	Mengganti elemen array jenis untuk parameter jenis definisi jenis generik saat ini, dan mengembalikan jenis konstruksi yang dihasilkan.
MakePointerType()	Mengembalikan Type objek yang menunjukkan tipe penunjuk yang tidak dikelola ke tipe saat ini.
MemberwiseClone()	Membuat salinan dangkal dari saat ini Object. (Diperoleh dari Object)
SetCustomAttribute(ConstructorInfo, Byte[])	Mengatur atribut kustom menggunakan blob atribut kustom tertentu.
SetCustomAttribute(CustomAttributeBuilder)	Atur atribut kustom menggunakan penyusun atribut kustom.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Saat ditimpa di kelas turunan, mengatur atribut kustom pada assembly ini.
SetParent(Type)	Mengatur jenis dasar jenis yang saat ini sedang dibangun.
SetParentCore(Type)	Ketika ditimpa dalam kelas turunan, mengatur jenis dasar jenis yang saat ini sedang dibangun.
ToString()	Mengembalikan nama jenis yang tidak termasuk namespace layanan.

Implementasi Antarmuka Eksplisit

IReflectableType.GetTypeInfo()

Mengembalikan representasi dari jenis saat ini sebagai TypeInfo objek. (Diperoleh dari TypeInfo)

Metode Ekstensi

GetCustomAttribute(MemberInfo, Type)	Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.
GetCustomAttribute(MemberInfo, Type, Boolean)	Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttribute<T>(MemberInfo)	Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.
GetCustomAttribute<T>(MemberInfo, Boolean)	Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttributes(MemberInfo)	Mengambil kumpulan atribut kustom yang diterapkan ke anggota tertentu.
GetCustomAttributes(MemberInfo, Boolean)	Mengambil kumpulan atribut kustom yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttributes(MemberInfo, Type)	Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.
GetCustomAttributes(MemberInfo, Type, Boolean)	Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttributes<T>(MemberInfo)	Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.
GetCustomAttributes<T>(MemberInfo, Boolean)	Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
IsDefined(MemberInfo, Type)	Menunjukkan apakah atribut kustom dari jenis tertentu diterapkan ke anggota tertentu.
IsDefined(MemberInfo, Type, Boolean)	Menunjukkan apakah atribut kustom dari jenis tertentu diterapkan ke anggota tertentu, dan, secara opsional, diterapkan ke leluhurnya.
GetTypeInfo(Type)	Mengembalikan TypeInfo representasi dari jenis yang ditentukan.
GetMetadataToken(MemberInfo)	Mendapatkan token metadata untuk anggota tertentu, jika tersedia.
HasMetadataToken(MemberInfo)	Mengembalikan nilai yang menunjukkan apakah token metadata tersedia untuk anggota yang ditentukan.
GetRuntimeEvent(Type, String)	Mengambil objek yang mewakili peristiwa yang ditentukan.
GetRuntimeEvents(Type)	Mengambil koleksi yang mewakili semua peristiwa yang ditentukan pada jenis tertentu.
GetRuntimeField(Type, String)	Mengambil objek yang mewakili bidang tertentu.
GetRuntimeFields(Type)	Mengambil koleksi yang mewakili semua bidang yang ditentukan pada jenis tertentu.
GetRuntimeInterfaceMap(TypeInfo, Type)	Mengembalikan pemetaan antarmuka untuk jenis yang ditentukan dan antarmuka yang ditentukan.
GetRuntimeMethod(Type, String, Type[])	Mengambil objek yang mewakili metode tertentu.
GetRuntimeMethods(Type)	Mengambil koleksi yang mewakili semua metode yang ditentukan pada jenis tertentu.
GetRuntimeProperties(Type)	Mengambil koleksi yang mewakili semua properti yang ditentukan pada jenis tertentu.
GetRuntimeProperty(Type, String)	Mengambil objek yang mewakili properti tertentu.
GetConstructor(Type, Type[])	Menentukan dan membuat instans kelas baru selama durasi.
GetConstructors(Type)	Menentukan dan membuat instans kelas baru selama durasi.
GetConstructors(Type, BindingFlags)	Menentukan dan membuat instans kelas baru selama durasi.
GetFields(Type, BindingFlags)	Menentukan dan membuat instans kelas baru selama durasi.
GetGenericArguments(Type)	Menentukan dan membuat instans kelas baru selama durasi.
GetInterfaces(Type)	Menentukan dan membuat instans kelas baru selama durasi.
GetMember(Type, String)	Menentukan dan membuat instans kelas baru selama durasi.
GetMember(Type, String, BindingFlags)	Menentukan dan membuat instans kelas baru selama durasi.
GetMembers(Type)	Menentukan dan membuat instans kelas baru selama durasi.
GetMethods(Type)	Menentukan dan membuat instans kelas baru selama durasi.
GetNestedType(Type, String, BindingFlags)	Menentukan dan membuat instans kelas baru selama durasi.
GetProperties(Type)	Menentukan dan membuat instans kelas baru selama durasi.
GetProperties(Type, BindingFlags)	Menentukan dan membuat instans kelas baru selama durasi.
GetProperty(Type, String, BindingFlags)	Menentukan dan membuat instans kelas baru selama durasi.
GetProperty(Type, String, Type)	Menentukan dan membuat instans kelas baru selama durasi.
GetProperty(Type, String, Type, Type[])	Menentukan dan membuat instans kelas baru selama durasi.
IsAssignableFrom(Type, Type)	Menentukan dan membuat instans kelas baru selama durasi.
IsInstanceOfType(Type, Object)	Menentukan dan membuat instans kelas baru selama durasi.

Lihat juga

• Petunjuk: Menentukan Jenis Generik dengan Pancaran Refleksi