Bagikan melalui


TypeBuilder Kelas

Definisi

Menentukan dan membuat instans kelas baru selama durasi.

public ref class TypeBuilder sealed : Type
public ref class TypeBuilder sealed : System::Reflection::TypeInfo
public ref class TypeBuilder abstract : System::Reflection::TypeInfo
public ref class TypeBuilder sealed : Type, System::Runtime::InteropServices::_TypeBuilder
public ref class TypeBuilder sealed : System::Reflection::TypeInfo, System::Runtime::InteropServices::_TypeBuilder
public sealed class TypeBuilder : Type
public sealed class TypeBuilder : System.Reflection.TypeInfo
public abstract class TypeBuilder : System.Reflection.TypeInfo
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public sealed class TypeBuilder : Type, System.Runtime.InteropServices._TypeBuilder
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class TypeBuilder : Type, System.Runtime.InteropServices._TypeBuilder
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class TypeBuilder : System.Reflection.TypeInfo, System.Runtime.InteropServices._TypeBuilder
type TypeBuilder = class
    inherit Type
type TypeBuilder = class
    inherit TypeInfo
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type TypeBuilder = class
    inherit Type
    interface _TypeBuilder
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type TypeBuilder = class
    inherit Type
    interface _TypeBuilder
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type TypeBuilder = class
    inherit TypeInfo
    interface _TypeBuilder
Public NotInheritable Class TypeBuilder
Inherits Type
Public NotInheritable Class TypeBuilder
Inherits TypeInfo
Public MustInherit Class TypeBuilder
Inherits TypeInfo
Public NotInheritable Class TypeBuilder
Inherits Type
Implements _TypeBuilder
Public NotInheritable Class TypeBuilder
Inherits TypeInfo
Implements _TypeBuilder
Warisan
TypeBuilder
Warisan
TypeBuilder
Warisan
Atribut
Penerapan

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.

Attributes

Mendapatkan atribut yang terkait dengan Type.

(Diperoleh dari Type)
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.

ContainsGenericParameters

Mendapatkan nilai yang menunjukkan apakah objek saat ini Type memiliki parameter jenis yang belum digantikan oleh jenis tertentu.

(Diperoleh dari Type)
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.

DeclaringMethod

MethodBase Mendapatkan yang mewakili metode deklarasi, jika saat ini Type mewakili parameter jenis metode generik.

(Diperoleh dari Type)
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.

GenericParameterAttributes

Mendapatkan kombinasi GenericParameterAttributes bendera yang menjelaskan kovariansi dan batasan khusus dari parameter jenis generik saat ini.

(Diperoleh dari Type)
GenericParameterPosition

Mendapatkan posisi parameter jenis dalam daftar parameter jenis jenis generik yang mendeklarasikan parameter.

GenericParameterPosition

Mendapatkan posisi parameter jenis dalam daftar parameter jenis jenis atau metode generik yang mendeklarasikan parameter, ketika Type objek mewakili parameter jenis jenis generik atau metode generik.

(Diperoleh dari Type)
GenericTypeArguments

Menentukan dan membuat instans kelas baru selama durasi.

GenericTypeArguments

Mendapatkan array argumen jenis generik untuk jenis ini.

(Diperoleh dari Type)
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

Mendapatkan nilai yang menunjukkan apakah saat ini Type mencakup atau merujuk ke jenis lain; yaitu, apakah saat ini Type adalah array, penunjuk, atau diteruskan oleh referensi.

(Diperoleh dari Type)
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

Mendapatkan nilai yang menunjukkan apakah Type abstrak dan harus ditimpa.

(Diperoleh dari Type)
IsAbstract

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsAnsiClass

Mendapatkan nilai yang menunjukkan apakah atribut AnsiClass format string dipilih untuk Type.

(Diperoleh dari Type)
IsAnsiClass

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsArray

Mendapatkan nilai yang menunjukkan apakah jenisnya adalah array.

(Diperoleh dari Type)
IsArray

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsAutoClass

Mendapatkan nilai yang menunjukkan apakah atribut AutoClass format string dipilih untuk Type.

(Diperoleh dari Type)
IsAutoClass

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsAutoLayout

Mendapatkan nilai yang menunjukkan apakah bidang jenis saat ini ditata secara otomatis oleh runtime bahasa umum.

(Diperoleh dari Type)
IsAutoLayout

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsByRef

Mendapatkan nilai yang menunjukkan apakah Type diteruskan oleh referensi.

(Diperoleh dari Type)
IsByRef

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsByRefLike

Mendapatkan nilai yang menunjukkan apakah jenisnya adalah struktur seperti byref.

IsByRefLike

Mendapatkan nilai yang menunjukkan apakah jenisnya adalah struktur seperti byref.

(Diperoleh dari Type)
IsClass

Mendapatkan nilai yang menunjukkan apakah Type adalah kelas atau delegasi; yaitu, bukan jenis nilai atau antarmuka.

(Diperoleh dari Type)
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

Mendapatkan nilai yang menunjukkan apakah Type adalah objek COM.

(Diperoleh dari Type)
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.

IsConstructedGenericType

Mendapatkan nilai yang menunjukkan apakah objek ini mewakili jenis generik yang dibangun. Anda dapat membuat instans jenis generik yang dibangun.

(Diperoleh dari Type)
IsContextful

Mendapatkan nilai yang menunjukkan apakah Type dapat dihosting dalam konteks.

(Diperoleh dari Type)
IsEnum

Menentukan dan membuat instans kelas baru selama durasi.

IsEnum

Mendapatkan nilai yang menunjukkan apakah saat ini Type mewakili enumerasi.

(Diperoleh dari Type)
IsEnum

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsExplicitLayout

Mendapatkan nilai yang menunjukkan apakah bidang jenis saat ini ditata pada offset yang ditentukan secara eksplisit.

(Diperoleh dari Type)
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.

IsGenericParameter

Mendapatkan nilai yang menunjukkan apakah saat ini Type mewakili parameter jenis dalam definisi jenis atau metode generik.

(Diperoleh dari Type)
IsGenericType

Mendapatkan nilai yang menunjukkan apakah jenis saat ini adalah jenis generik.

IsGenericType

Mendapatkan nilai yang menunjukkan apakah jenis saat ini adalah jenis generik.

(Diperoleh dari Type)
IsGenericTypeDefinition

Mendapatkan nilai yang menunjukkan apakah saat ini TypeBuilder mewakili definisi jenis generik tempat jenis generik lainnya dapat dibangun.

IsGenericTypeDefinition

Mendapatkan nilai yang menunjukkan apakah saat ini Type mewakili definisi jenis generik, dari mana jenis generik lainnya dapat dibangun.

(Diperoleh dari Type)
IsGenericTypeParameter

Mendapatkan nilai yang menunjukkan apakah saat ini Type mewakili parameter jenis dalam definisi jenis generik.

(Diperoleh dari Type)
IsImport

Mendapatkan nilai yang menunjukkan apakah Type memiliki atribut yang ComImportAttribute diterapkan, menunjukkan bahwa atribut tersebut diimpor dari pustaka jenis COM.

(Diperoleh dari Type)
IsImport

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsInterface

Mendapatkan nilai yang menunjukkan apakah Type itu antarmuka; yaitu, bukan kelas atau jenis nilai.

(Diperoleh dari Type)
IsInterface

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsLayoutSequential

Mendapatkan nilai yang menunjukkan apakah bidang jenis saat ini ditata secara berurutan, dalam urutan yang ditentukan atau dipancarkan ke metadata.

(Diperoleh dari Type)
IsLayoutSequential

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsMarshalByRef

Mendapatkan nilai yang menunjukkan apakah Type marshaled by reference.

(Diperoleh dari Type)
IsMarshalByRef

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsNested

Mendapatkan nilai yang menunjukkan apakah objek saat ini Type mewakili jenis yang definisinya ditumpuk di dalam definisi jenis lain.

(Diperoleh dari Type)
IsNested

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsNestedAssembly

Mendapatkan nilai yang menunjukkan apakah Type berlapis dan hanya terlihat dalam perakitannya sendiri.

(Diperoleh dari Type)
IsNestedAssembly

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsNestedFamANDAssem

Mendapatkan nilai yang menunjukkan apakah Type berlapis dan hanya terlihat oleh kelas yang termasuk dalam keluarganya sendiri dan perakitannya sendiri.

(Diperoleh dari Type)
IsNestedFamANDAssem

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsNestedFamily

Mendapatkan nilai yang menunjukkan apakah Type berlapis dan hanya terlihat dalam keluarganya sendiri.

(Diperoleh dari Type)
IsNestedFamily

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsNestedFamORAssem

Mendapatkan nilai yang menunjukkan apakah Type berlapis dan hanya terlihat oleh kelas yang termasuk dalam keluarganya sendiri atau perakitannya sendiri.

(Diperoleh dari Type)
IsNestedFamORAssem

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsNestedPrivate

Mendapatkan nilai yang menunjukkan apakah Type berlapis dan dinyatakan privat.

(Diperoleh dari Type)
IsNestedPrivate

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsNestedPublic

Mendapatkan nilai yang menunjukkan apakah kelas ditumpuk dan dinyatakan publik.

(Diperoleh dari Type)
IsNestedPublic

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsNotPublic

Mendapatkan nilai yang menunjukkan apakah Type tidak dinyatakan publik.

(Diperoleh dari Type)
IsNotPublic

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsPointer

Mendapatkan nilai yang menunjukkan apakah Type adalah penunjuk.

(Diperoleh dari Type)
IsPointer

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsPrimitive

Mendapatkan nilai yang menunjukkan apakah Type adalah salah satu jenis primitif.

(Diperoleh dari Type)
IsPrimitive

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsPublic

Mendapatkan nilai yang menunjukkan apakah Type dinyatakan publik.

(Diperoleh dari Type)
IsPublic

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsSealed

Mendapatkan nilai yang menunjukkan apakah Type dinyatakan disegel.

(Diperoleh dari Type)
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.

IsSecurityCritical

Mendapatkan nilai yang menunjukkan apakah jenis saat ini kritis terhadap keamanan atau keamanan-aman-kritis pada tingkat kepercayaan saat ini, dan karenanya dapat melakukan operasi penting.

(Diperoleh dari Type)
IsSecuritySafeCritical

Mendapatkan nilai yang menunjukkan apakah jenis saat ini penting untuk keamanan; yaitu, apakah dapat melakukan operasi penting dan dapat diakses dengan kode transparan.

IsSecuritySafeCritical

Mendapatkan nilai yang menunjukkan apakah jenis saat ini adalah keamanan-aman-kritis pada tingkat kepercayaan saat ini; yaitu, apakah dapat melakukan operasi penting dan dapat diakses dengan kode transparan.

(Diperoleh dari Type)
IsSecurityTransparent

Mendapatkan nilai yang menunjukkan apakah jenis saat ini transparan, dan karenanya tidak dapat melakukan operasi penting.

IsSecurityTransparent

Mendapatkan nilai yang menunjukkan apakah jenis saat ini transparan pada tingkat kepercayaan saat ini, dan karenanya tidak dapat melakukan operasi penting.

(Diperoleh dari Type)
IsSerializable

Menentukan dan membuat instans kelas baru selama durasi.

IsSerializable
Kedaluwarsa.

Mendapatkan nilai yang menunjukkan apakah biner dapat diserialisasikan Type .

(Diperoleh dari Type)
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

Mendapatkan nilai yang menunjukkan apakah jenis memiliki nama yang memerlukan penanganan khusus.

(Diperoleh dari Type)
IsSpecialName

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsSZArray

Menentukan dan membuat instans kelas baru selama durasi.

IsSZArray

Mendapatkan nilai yang menunjukkan apakah jenisnya adalah jenis array yang hanya dapat mewakili array dimensi tunggal dengan batas nol yang lebih rendah.

(Diperoleh dari Type)
IsTypeDefinition

Menentukan dan membuat instans kelas baru selama durasi.

IsTypeDefinition

Mendapatkan nilai yang menunjukkan apakah jenisnya adalah definisi jenis.

(Diperoleh dari Type)
IsUnicodeClass

Mendapatkan nilai yang menunjukkan apakah atribut UnicodeClass format string dipilih untuk Type.

(Diperoleh dari Type)
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

Mendapatkan nilai yang menunjukkan apakah Type adalah jenis nilai.

(Diperoleh dari Type)
IsValueType

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsVariableBoundArray

Menentukan dan membuat instans kelas baru selama durasi.

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

Mendapatkan nilai yang menunjukkan apakah Type dapat diakses oleh kode di luar perakitan.

(Diperoleh dari Type)
IsVisible

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
MemberType

Mendapatkan nilai yang MemberTypes menunjukkan bahwa anggota ini adalah jenis atau jenis berlapis.

(Diperoleh dari Type)
MemberType

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
MetadataToken

Mendapatkan token yang mengidentifikasi modul dinamis saat ini dalam metadata.

MetadataToken

Mendapatkan nilai yang mengidentifikasi elemen metadata.

(Diperoleh dari MemberInfo)
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.

ReflectedType

Mendapatkan objek kelas yang digunakan untuk mendapatkan instans ini dari MemberInfo.

(Diperoleh dari MemberInfo)
Size

Mengambil ukuran total jenis.

SizeCore

Ketika ditimpa di kelas turunan, mendapatkan ukuran total jenis.

StructLayoutAttribute

Mendapatkan yang StructLayoutAttribute menjelaskan tata letak jenis saat ini.

(Diperoleh dari Type)
StructLayoutAttribute

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
TypeHandle

Tidak didukung dalam modul dinamis.

TypeInitializer

Mendapatkan penginisialisasi untuk jenis tersebut.

(Diperoleh dari Type)
TypeInitializer

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
TypeToken

Mengembalikan token jenis jenis ini.

UnderlyingSystemType

Mengembalikan jenis sistem yang mendasar untuk ini TypeBuilder.

UnderlyingSystemType

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)

Metode

AddDeclarativeSecurity(SecurityAction, PermissionSet)

Menambahkan keamanan deklaratif ke tipe ini.

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(Object)

Mengembalikan nilai yang menunjukkan apakah instans ini sama dengan objek tertentu.

(Diperoleh dari MemberInfo)
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)

Mengembalikan array Type objek yang mewakili daftar antarmuka yang difilter yang diimplementasikan atau diwarisi oleh saat ini Type.

(Diperoleh dari Type)
FindInterfaces(TypeFilter, Object)

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)

Mengembalikan array objek yang MemberInfo difilter dari jenis anggota yang ditentukan.

(Diperoleh dari Type)
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.

GetArrayRank()

Mendapatkan jumlah dimensi dalam array.

(Diperoleh dari Type)
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.

GetAttributeFlagsImpl()

Ketika ditimpa di kelas turunan, terapkan Attributes properti dan dapatkan kombinasi bitwise dari nilai enumerasi yang menunjukkan atribut yang terkait dengan Type.

(Diperoleh dari 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[])

Mencari konstruktor instans publik yang parameternya cocok dengan jenis dalam array yang ditentukan.

(Diperoleh dari Type)
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.

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.

(Diperoleh dari Type)
GetConstructors()

Mengembalikan semua konstruktor publik yang ditentukan untuk saat ini Type.

(Diperoleh dari Type)
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.

GetConstructors(BindingFlags)

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetCustomAttributes(Boolean)

Mengembalikan semua atribut kustom yang ditentukan untuk jenis ini.

GetCustomAttributes(Boolean)

Saat ditimpa di kelas turunan, mengembalikan array semua atribut kustom yang diterapkan ke anggota ini.

(Diperoleh dari MemberInfo)
GetCustomAttributes(Type, Boolean)

Mengembalikan semua atribut kustom dari jenis saat ini yang dapat ditetapkan ke jenis tertentu.

GetCustomAttributes(Type, Boolean)

Saat ditimpa di kelas turunan, mengembalikan array atribut kustom yang diterapkan ke anggota ini dan diidentifikasi oleh Type.

(Diperoleh dari MemberInfo)
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()

Mencari anggota yang ditentukan untuk saat ini Type yang DefaultMemberAttribute ditetapkan.

(Diperoleh dari Type)
GetDefaultMembers()

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetElementType()

Memanggil metode ini selalu melempar NotSupportedException.

GetEnumName(Object)

Mengembalikan nama konstanta yang memiliki nilai yang ditentukan, untuk jenis enumerasi saat ini.

(Diperoleh dari Type)
GetEnumName(Object)

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetEnumNames()

Mengembalikan nama anggota jenis enumerasi saat ini.

(Diperoleh dari Type)
GetEnumNames()

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetEnumUnderlyingType()

Mengembalikan jenis yang mendasar dari jenis enumerasi saat ini.

(Diperoleh dari Type)
GetEnumUnderlyingType()

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetEnumValues()

Mengembalikan array nilai konstanta dalam jenis enumerasi saat ini.

(Diperoleh dari Type)
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)

Mengembalikan objek yang EventInfo mewakili peristiwa publik yang ditentukan.

(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.

GetEvent(String, BindingFlags)

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetEvents()

Mengembalikan peristiwa publik yang dideklarasikan atau diwariskan oleh tipe ini.

GetEvents()

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetEvents(BindingFlags)

Mengembalikan peristiwa publik dan non-publik yang dideklarasikan oleh jenis ini.

GetEvents(BindingFlags)

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetField(String)

Mencari bidang publik dengan nama yang ditentukan.

(Diperoleh dari Type)
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(String, BindingFlags)

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetField(Type, FieldInfo)

Mengembalikan bidang dari jenis generik yang dibuat yang ditentukan yang sesuai dengan bidang yang ditentukan dari definisi jenis generik.

GetFields()

Mengembalikan semua bidang publik dari saat ini Type.

(Diperoleh dari Type)
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.

GetFields(BindingFlags)

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
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.

GetGenericArguments()

Mengembalikan array Type objek yang mewakili argumen jenis dari jenis generik tertutup atau parameter jenis definisi jenis generik.

(Diperoleh dari Type)
GetGenericArguments()

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetGenericParameterConstraints()

Menentukan dan membuat instans kelas baru selama durasi.

GetGenericParameterConstraints()

Menghasilkan larik objek Type yang mewakili batasan pada parameter jenis generik saat ini.

(Diperoleh dari Type)
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.

GetGenericTypeDefinition()

Mengembalikan Type objek yang mewakili definisi jenis generik dari mana jenis generik saat ini dapat dibangun.

(Diperoleh dari Type)
GetHashCode()

Mengembalikan kode hash untuk instans ini.

(Diperoleh dari Type)
GetHashCode()

Mengembalikan kode hash untuk instans ini.

(Diperoleh dari MemberInfo)
GetInterface(String)

Mencari antarmuka dengan nama yang ditentukan.

(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.

GetInterface(String, Boolean)

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetInterfaceMap(Type)

Mengembalikan pemetaan antarmuka untuk antarmuka yang diminta.

GetInterfaces()

Mengembalikan array dari semua antarmuka yang diimplementasikan pada jenis ini dan jenis dasarnya.

GetInterfaces()

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetMember(String)

Mencari anggota publik dengan nama yang ditentukan.

(Diperoleh dari Type)
GetMember(String)

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetMember(String, BindingFlags)

Mencari anggota yang ditentukan, menggunakan batasan pengikatan yang ditentukan.

(Diperoleh dari Type)
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.

GetMember(String, MemberTypes, BindingFlags)

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetMembers()

Mengembalikan semua anggota publik dari saat ini Type.

(Diperoleh dari Type)
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.

GetMembers(BindingFlags)

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetMemberWithSameMetadataDefinitionAs(MemberInfo)

Mencari MemberInfo pada saat ini Type yang cocok dengan yang ditentukan MemberInfo.

(Diperoleh dari Type)
GetMethod(String)

Mencari metode publik dengan nama yang ditentukan.

(Diperoleh dari Type)
GetMethod(String)

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetMethod(String, BindingFlags)

Mencari metode yang ditentukan, menggunakan batasan pengikatan yang ditentukan.

(Diperoleh dari Type)
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[])

Mencari metode publik yang ditentukan yang parameternya cocok dengan jenis argumen yang ditentukan.

(Diperoleh dari Type)
GetMethod(String, Type[])

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetMethod(String, Type[], ParameterModifier[])

Mencari metode publik yang ditentukan yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan.

(Diperoleh dari Type)
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, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Saat ditimpa di 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.

(Diperoleh dari Type)
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()

Mengembalikan semua metode publik dari saat ini Type.

(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.

GetMethods(BindingFlags)

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetNestedType(String)

Mencari jenis berlapis publik dengan nama yang ditentukan.

(Diperoleh dari Type)
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.

GetNestedType(String, BindingFlags)

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetNestedTypes()

Mengembalikan jenis publik yang ditumpuk di saat ini Type.

(Diperoleh dari Type)
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.

GetNestedTypes(BindingFlags)

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetOptionalCustomModifiers()

Saat ditimpa di kelas turunan, mengembalikan pengubah kustom opsional dari saat ini Type.

(Diperoleh dari Type)
GetProperties()

Mengembalikan semua properti publik 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.

GetProperties(BindingFlags)

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetProperty(String)

Mencari properti publik dengan nama yang ditentukan.

(Diperoleh dari Type)
GetProperty(String)

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetProperty(String, BindingFlags)

Mencari properti yang ditentukan, menggunakan batasan pengikatan yang ditentukan.

(Diperoleh dari Type)
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)

Mencari properti publik dengan nama dan jenis pengembalian yang ditentukan.

(Diperoleh dari Type)
GetProperty(String, Type)

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetProperty(String, Type, Type[])

Mencari properti publik yang ditentukan yang parameternya cocok dengan jenis argumen yang ditentukan.

(Diperoleh dari Type)
GetProperty(String, Type, Type[])

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetProperty(String, Type, Type[], ParameterModifier[])

Mencari properti publik yang ditentukan yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan.

(Diperoleh dari Type)
GetProperty(String, Type, Type[], ParameterModifier[])

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
GetProperty(String, Type[])

Mencari properti publik yang ditentukan yang parameternya cocok dengan jenis argumen yang ditentukan.

(Diperoleh dari Type)
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.

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.

(Diperoleh dari Type)
GetRequiredCustomModifiers()

Saat ditimpa di kelas turunan, mengembalikan pengubah kustom yang Typediperlukan dari .

(Diperoleh dari Type)
GetType()

TypeMendapatkan .

(Diperoleh dari Type)
GetType()

Menemukan atribut anggota dan menyediakan akses ke metadata anggota.

(Diperoleh dari MemberInfo)
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.

HasElementTypeImpl()

Ketika ditimpa di kelas turunan, terapkan HasElementType properti dan tentukan apakah saat ini Type mencakup atau mengacu pada jenis lain; yaitu, apakah saat ini Type adalah array, penunjuk, atau diteruskan oleh referensi.

(Diperoleh dari Type)
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.

IsArrayImpl()

Saat ditimpa di kelas turunan, terapkan IsArray properti dan tentukan Type apakah itu array.

(Diperoleh dari Type)
IsAssignableFrom(Type)

Mendapatkan nilai yang menunjukkan apakah yang ditentukan Type dapat ditetapkan ke objek ini.

IsAssignableFrom(Type)

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
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.

IsByRefImpl()

Ketika ditimpa di kelas turunan, terapkan IsByRef properti dan tentukan apakah Type diteruskan oleh referensi.

(Diperoleh dari Type)
IsCOMObjectImpl()

Ketika ditimpa di kelas turunan, mengimplementasikan IsCOMObject properti dan menentukan apakah Type itu objek COM.

IsCOMObjectImpl()

Ketika ditimpa di kelas turunan, terapkan IsCOMObject properti dan tentukan Type apakah itu objek COM.

(Diperoleh dari Type)
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.

IsDefined(Type, Boolean)

Ketika ditimpa di kelas turunan, menunjukkan apakah satu atau beberapa atribut dari jenis yang ditentukan atau jenis turunannya diterapkan kepada anggota ini.

(Diperoleh dari MemberInfo)
IsEnumDefined(Object)

Mengembalikan nilai yang menunjukkan apakah nilai yang ditentukan ada dalam jenis enumerasi saat ini.

(Diperoleh dari Type)
IsEnumDefined(Object)

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsEquivalentTo(Type)

Menentukan apakah dua jenis COM memiliki identitas yang sama dan memenuhi syarat untuk kesetaraan jenis.

(Diperoleh dari Type)
IsEquivalentTo(Type)

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
IsInstanceOfType(Object)

Menentukan apakah objek yang ditentukan adalah instans dari saat ini Type.

(Diperoleh dari Type)
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.

IsPointerImpl()

Saat ditimpa di kelas turunan, terapkan IsPointer properti dan tentukan Type apakah itu pointer.

(Diperoleh dari Type)
IsPrimitiveImpl()

Ketika ditimpa di kelas turunan, terapkan IsPrimitive properti dan tentukan apakah Type itu salah satu jenis primitif.

IsPrimitiveImpl()

Ketika ditimpa di kelas turunan, terapkan IsPrimitive properti dan tentukan apakah Type itu salah satu jenis primitif.

(Diperoleh dari Type)
IsSubclassOf(Type)

Menentukan apakah jenis ini berasal dari tipe tertentu.

IsSubclassOf(Type)

Menentukan dan membuat instans kelas baru selama durasi.

(Diperoleh dari TypeInfo)
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()

Mengembalikan objek yang Type mewakili array satu dimensi dari jenis saat ini, dengan batas nol yang lebih rendah.

(Diperoleh dari Type)
MakeArrayType(Int32)

Mengembalikan Type objek yang mewakili array dari jenis saat ini, dengan jumlah dimensi yang ditentukan.

MakeArrayType(Int32)

Mengembalikan objek yang Type mewakili array dari jenis saat ini, dengan jumlah dimensi yang ditentukan.

(Diperoleh dari Type)
MakeByRefType()

Mengembalikan Type objek yang mewakili jenis saat ini saat diteruskan sebagai ref parameter (ByRef di Visual Basic).

MakeByRefType()

Mengembalikan Type objek yang mewakili jenis saat ini saat diteruskan sebagai ref parameter (ByRef parameter di Visual Basic).

(Diperoleh dari Type)
MakeGenericType(Type[])

Mengganti elemen array jenis untuk parameter jenis definisi jenis generik saat ini, dan mengembalikan jenis konstruksi yang dihasilkan.

MakeGenericType(Type[])

Mengganti elemen array jenis untuk parameter jenis definisi jenis generik saat ini dan mengembalikan objek yang Type mewakili jenis konstruksi yang dihasilkan.

(Diperoleh dari Type)
MakePointerType()

Mengembalikan Type objek yang menunjukkan tipe penunjuk yang tidak dikelola ke tipe saat ini.

MakePointerType()

Mengembalikan Type objek yang mewakili penunjuk ke jenis saat ini.

(Diperoleh dari Type)
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

_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Memetakan sekumpulan nama ke sekumpulan pengidentifikasi pengiriman yang sesuai.

(Diperoleh dari MemberInfo)
_MemberInfo.GetType()

Mendapatkan objek yang Type mewakili MemberInfo kelas .

(Diperoleh dari MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Mengambil informasi jenis untuk objek, yang kemudian dapat digunakan untuk mendapatkan informasi jenis untuk antarmuka.

(Diperoleh dari MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

Mengambil jumlah antarmuka informasi jenis yang disediakan objek (baik 0 atau 1).

(Diperoleh dari MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Menyediakan akses ke properti dan metode yang diekspos oleh objek.

(Diperoleh dari MemberInfo)
_Type.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Memetakan sekumpulan nama ke sekumpulan pengidentifikasi pengiriman yang sesuai.

(Diperoleh dari Type)
_Type.GetTypeInfo(UInt32, UInt32, IntPtr)

Mengambil informasi jenis untuk objek, yang kemudian dapat digunakan untuk mendapatkan informasi jenis untuk antarmuka.

(Diperoleh dari Type)
_Type.GetTypeInfoCount(UInt32)

Mengambil jumlah antarmuka informasi jenis yang disediakan objek (baik 0 atau 1).

(Diperoleh dari Type)
_Type.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Menyediakan akses ke properti dan metode yang diekspos oleh objek.

(Diperoleh dari Type)
_TypeBuilder.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Memetakan sekumpulan nama ke sekumpulan pengidentifikasi pengiriman yang sesuai.

_TypeBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)

Mengambil informasi jenis untuk objek, yang kemudian dapat digunakan untuk mendapatkan informasi jenis untuk antarmuka.

_TypeBuilder.GetTypeInfoCount(UInt32)

Mengambil jumlah antarmuka informasi jenis yang disediakan objek (baik 0 atau 1).

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

Menyediakan akses ke properti dan metode yang diekspos oleh objek.

ICustomAttributeProvider.GetCustomAttributes(Boolean)

Mengembalikan array dari semua atribut kustom yang ditentukan pada anggota ini, tidak termasuk atribut bernama, atau array kosong jika tidak ada atribut kustom.

(Diperoleh dari MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)

Mengembalikan array atribut kustom yang ditentukan pada anggota ini, diidentifikasi berdasarkan jenis, atau array kosong jika tidak ada atribut kustom dari jenis tersebut.

(Diperoleh dari MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean)

Menunjukkan apakah satu atau beberapa attributeType instans ditentukan pada anggota ini.

(Diperoleh dari MemberInfo)
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.

Berlaku untuk

Lihat juga