TypeBuilder Třída

Definice

Obor názvů:

System.Reflection.Emit

Sestavení:

System.Reflection.Emit.dll

Zdroj:

TypeBuilder.cs

Definuje a vytváří nové instance tříd během běhu.

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

public abstract class TypeBuilder : System.Reflection.TypeInfo

type TypeBuilder = class
    inherit TypeInfo

Public MustInherit Class TypeBuilder
Inherits TypeInfo

Dědičnost

Object

MemberInfo

Type

TypeInfo

TypeBuilder

Příklady

Následující příklad kódu ukazuje, jak definovat a používat dynamické sestavení. Příklad sestavení obsahuje jeden typ, MyDynamicType, který má soukromé pole, vlastnost, která získá a nastaví privátní pole, konstruktory, které inicializují privátní pole, a metodu, která vynásobí uživatelem zadané číslo hodnotou soukromého pole a vrátí výsledek.

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

Následující ukázka kódu ukazuje, jak dynamicky sestavit typ pomocí 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

Poznámky

Další informace o tomto rozhraní API naleznete v tématu Doplňkové poznámky k rozhraní API pro TypeBuilder.

Konstruktory

TypeBuilder()

Inicializuje novou instanci TypeBuilder třídy.

Pole

UnspecifiedTypeSize

Představuje celkovou velikost pro typ není zadána.

Vlastnosti

Assembly	Načte dynamické sestavení, které obsahuje tuto definici typu.
AssemblyQualifiedName	Vrátí úplný název tohoto typu kvalifikovaný zobrazovaný název sestavení.
Attributes	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
BaseType	Načte základní typ tohoto typu.
ContainsGenericParameters	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
CustomAttributes	Získá kolekci, která obsahuje vlastní atributy tohoto člena. (Zděděno od MemberInfo)
DeclaredConstructors	Získá kolekci konstruktorů deklarovaných aktuálním typem. (Zděděno od TypeInfo)
DeclaredEvents	Získá kolekci událostí definovaných aktuálním typem. (Zděděno od TypeInfo)
DeclaredFields	Získá kolekci polí definovaných aktuálním typem. (Zděděno od TypeInfo)
DeclaredMembers	Získá kolekci členů definovaných aktuálním typem. (Zděděno od TypeInfo)
DeclaredMethods	Získá kolekci metod definovaných aktuálním typem. (Zděděno od TypeInfo)
DeclaredNestedTypes	Získá kolekci vnořených typů definovaných aktuálním typem. (Zděděno od TypeInfo)
DeclaredProperties	Získá kolekci vlastností definovaných aktuálním typem. (Zděděno od TypeInfo)
DeclaringMethod	Získá metodu, která deklarovala aktuální parametr obecného typu.
DeclaringType	Vrátí typ, který deklaroval tento typ.
FullName	Načte úplnou cestu tohoto typu.
GenericParameterAttributes	Získá hodnotu, která označuje kovarianci a zvláštní omezení aktuálního parametru obecného typu.
GenericParameterPosition	Získá pozici parametru typu v seznamu parametrů typu obecného typu, který deklaroval parametr.
GenericTypeArguments	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GenericTypeParameters	Získá pole parametrů obecného typu aktuální instance. (Zděděno od TypeInfo)
GUID	Načte identifikátor GUID tohoto typu.
HasElementType	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
ImplementedInterfaces	Získá kolekci rozhraní implementovaných aktuálním typem. (Zděděno od TypeInfo)
IsAbstract	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsAnsiClass	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsArray	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsAutoClass	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsAutoLayout	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsByRef	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsByRefLike	Získá hodnotu, která označuje, zda typ je byref-like struktura.
IsClass	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsCollectible	Získá hodnotu, která označuje, zda je tento MemberInfo objekt součástí sestavení uchovávané v shromažďovatelné AssemblyLoadContext. (Zděděno od MemberInfo)
IsCOMObject	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsConstructedGenericType	Získá hodnotu, která označuje, zda tento objekt představuje vytvořený obecný typ.
IsContextful	Získá hodnotu označující, zda Type lze hostovat v kontextu. (Zděděno od Type)
IsEnum	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsExplicitLayout	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsFunctionPointer	Získá hodnotu, která určuje, zda aktuální Type je ukazatel funkce. (Zděděno od Type)
IsGenericMethodParameter	Získá hodnotu, která určuje, zda aktuální Type představuje typ parametr v definici obecné metody. (Zděděno od Type)
IsGenericParameter	Získá hodnotu určující, zda aktuální typ je obecný typ parametr.
IsGenericType	Získá hodnotu určující, zda aktuální typ je obecný typ.
IsGenericTypeDefinition	Získá hodnotu určující, zda aktuální TypeBuilder představuje obecnou definici typu, ze které lze vytvořit jiné obecné typy.
IsGenericTypeParameter	Získá hodnotu, která určuje, zda aktuální Type představuje typ parametr v definici obecného typu. (Zděděno od Type)
IsImport	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsInterface	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsLayoutSequential	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsMarshalByRef	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsNested	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsNestedAssembly	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsNestedFamANDAssem	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsNestedFamily	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsNestedFamORAssem	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsNestedPrivate	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsNestedPublic	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsNotPublic	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsPointer	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsPrimitive	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsPublic	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsSealed	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsSecurityCritical	Získá hodnotu, která označuje, zda aktuální typ je kritický pro zabezpečení nebo zabezpečení-bezpečné-kritické, a proto může provádět kritické operace.
IsSecuritySafeCritical	Získá hodnotu, která označuje, zda aktuální typ je zabezpečení-bezpečné-kritické; to znamená, jestli může provádět kritické operace a může k němu přistupovat transparentní kód.
IsSecurityTransparent	Získá hodnotu, která určuje, zda je aktuální typ transparentní, a proto nemůže provádět kritické operace.
IsSerializable	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsSignatureType	Získá hodnotu, která označuje, zda typ je typ podpisu. (Zděděno od Type)
IsSpecialName	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsSZArray	Definuje a vytváří nové instance tříd během běhu.
IsTypeDefinition	Definuje a vytváří nové instance tříd během běhu.
IsUnicodeClass	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsUnmanagedFunctionPointer	Získá hodnotu, která určuje, zda aktuální Type je nespravovaný ukazatel funkce. (Zděděno od Type)
IsValueType	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsVariableBoundArray	Získá hodnotu, která určuje, zda typ je typ pole, který může představovat vícerozměrné pole nebo pole s libovolnou dolní mez. (Zděděno od Type)
IsVisible	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
MemberType	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
MetadataToken	Získá token, který identifikuje aktuální dynamický modul v metadatech.
Module	Načte dynamický modul, který obsahuje tuto definici typu.
Name	Načte název tohoto typu.
Namespace	Načte obor názvů, ve kterém je definován tento TypeBuilder.
PackingSize	Načte velikost balení tohoto typu.
PackingSizeCore	Při přepsání v odvozené třídě získá velikost balení tohoto typu.
ReflectedType	Vrátí typ, který byl použit k získání tohoto typu.
Size	Načte celkovou velikost typu.
SizeCore	Při přepsání v odvozené třídě získá celkovou velikost typu.
StructLayoutAttribute	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
TypeHandle	Nepodporuje se v dynamických modulech.
TypeInitializer	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
UnderlyingSystemType	Vrátí typ základního systému pro tento TypeBuilder.

Metody

AddInterfaceImplementation(Type)	Přidá rozhraní, které tento typ implementuje.
AddInterfaceImplementationCore(Type)	Při přepsání v odvozené třídě přidá rozhraní, které tento typ implementuje.
AsType()	Vrátí aktuální typ jako objekt Type. (Zděděno od TypeInfo)
CreateType()	Vytvoří objekt Type pro třídu. Po definování polí a metod třídy je volána CreateType, aby se načetla jeho Type objektu.
CreateTypeInfo()	Získá TypeInfo objekt, který představuje tento typ.
CreateTypeInfoCore()	Při přepsání v odvozené třídě získá TypeInfo objekt, který představuje tento typ.
DefineConstructor(MethodAttributes, CallingConventions, Type[], Type[][], Type[][])	Přidá do typu nový konstruktor s danými atributy, podpisem a vlastními modifikátory.
DefineConstructor(MethodAttributes, CallingConventions, Type[])	Přidá do typu nový konstruktor s danými atributy a podpisem.
DefineConstructorCore(MethodAttributes, CallingConventions, Type[], Type[][], Type[][])	Při přepsání v odvozené třídě přidá nový konstruktor do typu s danými atributy, podpis a vlastní modifikátory.
DefineDefaultConstructor(MethodAttributes)	Definuje konstruktor bez parametrů. Zde definovaný konstruktor jednoduše zavolá konstruktor bez parametrů nadřazeného objektu.
DefineDefaultConstructorCore(MethodAttributes)	Při přepsání v odvozené třídě definuje konstruktor bez parametrů. Konstruktor definovaný zde volá konstruktor bez parametrů nadřazeného objektu.
DefineEvent(String, EventAttributes, Type)	Přidá do typu novou událost s daným názvem, atributy a typem události.
DefineEventCore(String, EventAttributes, Type)	Při přepsání v odvozené třídě přidá do typu novou událost s daným názvem, atributy a typem události.
DefineField(String, Type, FieldAttributes)	Přidá do typu nové pole s daným názvem, atributy a typem pole.
DefineField(String, Type, Type[], Type[], FieldAttributes)	Přidá do typu nové pole s daným názvem, atributy, typem pole a vlastními modifikátory.
DefineFieldCore(String, Type, Type[], Type[], FieldAttributes)	Při přepsání v odvozené třídě přidá do typu nové pole s daným názvem, atributy, typem pole a vlastními modifikátory.
DefineGenericParameters(String[])	Definuje parametry obecného typu pro aktuální typ, určuje jejich počet a jejich názvy a vrátí pole GenericTypeParameterBuilder objektů, které lze použít k nastavení jejich omezení.
DefineGenericParametersCore(String[])	Při přepsání v odvozené třídě definuje obecné parametry typu pro aktuální typ, určení jejich čísla a jejich názvů.
DefineInitializedData(String, Byte[], FieldAttributes)	Definuje inicializované datové pole v oddílu .sdata přenosného spustitelného souboru (PE).
DefineInitializedDataCore(String, Byte[], FieldAttributes)	Při přepsání v odvozené třídě definuje inicializované datové pole v oddílu .sdata přenosného spustitelného souboru (PE).
DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Přidá do typu novou metodu se zadaným názvem, atributy metody, konvencí volání, podpisem metody a vlastními modifikátory.
DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[])	Přidá do typu novou metodu se zadaným názvem, atributy metody, konvencí volání a podpisem metody.
DefineMethod(String, MethodAttributes, CallingConventions)	Přidá do typu novou metodu se zadaným názvem, atributy metody a konvencí volání.
DefineMethod(String, MethodAttributes, Type, Type[])	Přidá do typu novou metodu se zadaným názvem, atributy metody a podpisem metody.
DefineMethod(String, MethodAttributes)	Přidá do typu novou metodu se zadaným názvem a atributy metody.
DefineMethodCore(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Při přepsání v odvozené třídě přidá novou metodu do typu se zadaným názvem, atributy metody, volání konvence, podpis metody a vlastní modifikátory.
DefineMethodOverride(MethodInfo, MethodInfo)	Určuje daný text metody, který implementuje danou deklaraci metody, potenciálně s jiným názvem.
DefineMethodOverrideCore(MethodInfo, MethodInfo)	Při přepsání v odvozené třídě určuje daný text metody, který implementuje danou deklaraci metody, potenciálně s jiným názvem.
DefineNestedType(String, TypeAttributes, Type, Int32)	Definuje vnořený typ s ohledem na jeho název, atributy, celkovou velikost typu a typ, který rozšiřuje.
DefineNestedType(String, TypeAttributes, Type, PackingSize, Int32)	Definuje vnořený typ s názvem, atributy, velikostí a typem, který rozšiřuje.
DefineNestedType(String, TypeAttributes, Type, PackingSize)	Definuje vnořený typ s ohledem na jeho název, atributy, typ, který rozšiřuje, a velikost balení.
DefineNestedType(String, TypeAttributes, Type, Type[])	Definuje vnořený typ s ohledem na jeho název, atributy, typ, který rozšiřuje, a rozhraní, která implementuje.
DefineNestedType(String, TypeAttributes, Type)	Definuje vnořený typ s ohledem na jeho název, atributy a typ, který rozšiřuje.
DefineNestedType(String, TypeAttributes)	Definuje vnořený typ vzhledem k jeho názvu a atributům.
DefineNestedType(String)	Definuje vnořený typ s daným názvem.
DefineNestedTypeCore(String, TypeAttributes, Type, Type[], PackingSize, Int32)	Při přepsání v odvozené třídě definuje vnořený typ s ohledem na jeho název, atributy, velikost a typ, který rozšiřuje.
DefinePInvokeMethod(String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Definuje PInvoke metodu s názvem, název knihovny DLL, ve které je metoda definována, atributy metody, volání konvence metody, návratový typ metody, typy parametrů metody a PInvoke příznaky.
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Definuje PInvoke metodu s názvem, název knihovny DLL, ve které je metoda definována, název vstupního bodu, atributy metody, konvence volání metody, návratový typ metody, typy parametrů metody a PInvoke příznaky.
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][], CallingConvention, CharSet)	Definuje PInvoke metodu s názvem, název knihovny DLL, ve které je metoda definována, název vstupního bodu, atributy metody, konvence volání metody, návratový typ metody, typy parametrů metody, PInvoke příznaky a vlastní modifikátory parametrů a návratový typ.
DefinePInvokeMethodCore(String, String, String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][], CallingConvention, CharSet)	Při přepsání v odvozené třídě definuje PInvoke metoda s zadaným názvem, název knihovny DLL, název vstupního bodu, atributy, volání konvence, návratový typ, typy parametrů, příznaky PInvoke a vlastní modifikátory parametrů a návratový typ.
DefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Přidá do typu novou vlastnost s daným názvem, konvencí volání, podpisem vlastnosti a vlastními modifikátory.
DefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[])	Přidá do typu novou vlastnost s daným názvem, atributy, konvencí volání a podpisem vlastnosti.
DefineProperty(String, PropertyAttributes, Type, Type[], Type[], Type[], Type[][], Type[][])	Přidá do typu novou vlastnost s daným názvem, podpisem vlastnosti a vlastními modifikátory.
DefineProperty(String, PropertyAttributes, Type, Type[])	Přidá do typu novou vlastnost s daným názvem a podpisem vlastnosti.
DefinePropertyCore(String, PropertyAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Při přepsání v odvozené třídě přidá novou vlastnost do typu s daným názvem, volání konvence, podpis vlastnosti a vlastní modifikátory.
DefineTypeInitializer()	Definuje inicializátor pro tento typ.
DefineTypeInitializerCore()	Při přepsání v odvozené třídě definuje inicializátor pro tento typ.
DefineUninitializedData(String, Int32, FieldAttributes)	Definuje neinicializované datové pole v .sdata části přenosného spustitelného souboru (PE).
DefineUninitializedDataCore(String, Int32, FieldAttributes)	Při přepsání v odvozené třídě definuje neinicializované datové pole v .sdata části přenosného spustitelného souboru (PE).
Equals(Object)	Určuje, zda typ základního systému aktuálního Type objektu je stejný jako typ základního systému zadaného Object. (Zděděno od Type)
Equals(Type)	Určuje, zda typ základního systému aktuálního Type je stejný jako typ základního systému zadaného Type. (Zděděno od Type)
FindInterfaces(TypeFilter, Object)	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetArrayRank()	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetAttributeFlagsImpl()	Při přepsání v odvozené třídě implementuje Attributes vlastnost a bitové kombinace hodnot výčtu, které označují atributy přidružené k Type.
GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Vyhledá konstruktor, jehož parametry odpovídají zadaným typům argumentů a modifikátorům, pomocí zadaných omezení vazby a zadané konvence volání. (Zděděno od Type)
GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])	Vyhledá konstruktor, jehož parametry odpovídají zadaným typům argumentů a modifikátorům, pomocí zadaných omezení vazby. (Zděděno od Type)
GetConstructor(BindingFlags, Type[])	Vyhledá konstruktor, jehož parametry odpovídají zadaným typům argumentů pomocí zadaných omezení vazby. (Zděděno od Type)
GetConstructor(Type, ConstructorInfo)	Vrátí konstruktor zadaného obecného typu, který odpovídá zadanému konstruktoru definice obecného typu.
GetConstructor(Type[])	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Při přepsání v odvozené třídě hledá konstruktor, jehož parametry odpovídají zadaným typům argumentů a modifikátorům, pomocí zadaných omezení vazby a zadané konvence volání.
GetConstructors()	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetConstructors(BindingFlags)	Vrátí pole ConstructorInfo objektů představujících veřejné a neveřejné konstruktory definované pro tuto třídu, jak je uvedeno.
GetCustomAttributes(Boolean)	Vrátí všechny vlastní atributy definované pro tento typ.
GetCustomAttributes(Type, Boolean)	Vrátí všechny vlastní atributy aktuálního typu, které lze přiřadit zadanému typu.
GetCustomAttributesData()	Vrátí seznam CustomAttributeData objektů představujících data o atributech použitých na cílového člena. (Zděděno od MemberInfo)
GetDeclaredEvent(String)	Vrátí objekt, který představuje zadanou událost deklarovanou aktuálním typem. (Zděděno od TypeInfo)
GetDeclaredField(String)	Vrátí objekt, který představuje zadané pole deklarované aktuálním typem. (Zděděno od TypeInfo)
GetDeclaredMethod(String)	Vrátí objekt, který představuje zadanou metodu deklarovanou aktuálním typem. (Zděděno od TypeInfo)
GetDeclaredMethods(String)	Vrátí kolekci, která obsahuje všechny metody deklarované v aktuálním typu, které odpovídají zadanému názvu. (Zděděno od TypeInfo)
GetDeclaredNestedType(String)	Vrátí objekt, který představuje zadaný vnořený typ deklarovaný aktuálním typem. (Zděděno od TypeInfo)
GetDeclaredProperty(String)	Vrátí objekt, který představuje zadanou vlastnost deklarovanou aktuálním typem. (Zděděno od TypeInfo)
GetDefaultMembers()	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetElementType()	Volání této metody vždy vyvolá NotSupportedException.
GetEnumName(Object)	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetEnumNames()	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetEnumUnderlyingType()	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetEnumValues()	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetEnumValuesAsUnderlyingType()	Načte pole hodnot základních konstant typu tohoto typu výčtu. (Zděděno od Type)
GetEvent(String, BindingFlags)	Vrátí událost se zadaným názvem.
GetEvent(String)	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetEvents()	Vrátí veřejné události deklarované nebo zděděné tímto typem.
GetEvents(BindingFlags)	Vrátí veřejné a neveřejné události, které jsou deklarovány tímto typem.
GetField(String, BindingFlags)	Vrátí pole určené daným názvem.
GetField(String)	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetField(Type, FieldInfo)	Vrátí pole zadaného vytvořeného obecného typu, které odpovídá zadanému poli definice obecného typu.
GetFields()	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetFields(BindingFlags)	Vrátí veřejná a neveřejná pole, která jsou deklarována tímto typem.
GetFunctionPointerCallingConventions()	Při přepsání v odvozené třídě vrátí volající konvence aktuálního ukazatele funkce Type. (Zděděno od Type)
GetFunctionPointerParameterTypes()	Při přepsání v odvozené třídě vrátí typy parametrů aktuálního ukazatele funkce Type. (Zděděno od Type)
GetFunctionPointerReturnType()	Při přepsání v odvozené třídě vrátí návratový typ aktuálního ukazatele funkce Type. (Zděděno od Type)
GetGenericArguments()	Vrátí pole Type objektů představujících argumenty typu obecného typu nebo parametry typu definice obecného typu.
GetGenericParameterConstraints()	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetGenericTypeDefinition()	Vrátí Type objekt, který představuje definici obecného typu, ze které lze získat aktuální typ.
GetHashCode()	Vrátí kód hash pro tuto instanci. (Zděděno od Type)
GetInterface(String, Boolean)	Vrátí implementované rozhraní (přímo nebo nepřímo) touto třídou s plně kvalifikovaným názvem, který odpovídá danému názvu rozhraní.
GetInterface(String)	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetInterfaceMap(Type)	Vrátí mapování rozhraní požadovaného rozhraní.
GetInterfaces()	Vrátí pole všech rozhraní implementovaných pro tento typ a jeho základní typy.
GetMember(String, BindingFlags)	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetMember(String, MemberTypes, BindingFlags)	Vrátí všechny veřejné a neveřejné členy deklarované nebo zděděné tímto typem, jak je uvedeno.
GetMember(String)	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetMembers()	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetMembers(BindingFlags)	Vrátí členy pro veřejné a neveřejné členy deklarované nebo zděděné tímto typem.
GetMemberWithSameMetadataDefinitionAs(MemberInfo)	Vyhledá MemberInfo v aktuálním Type, který odpovídá zadanému MemberInfo. (Zděděno od Type)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Vyhledá zadanou metodu, jejíž parametry odpovídají zadaným typům argumentů a modifikátorům, pomocí zadaných omezení vazby a zadané konvence volání. (Zděděno od Type)
GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])	Vyhledá zadanou metodu, jejíž parametry odpovídají zadaným typům argumentů a modifikátorům, pomocí zadaných omezení vazby. (Zděděno od Type)
GetMethod(String, BindingFlags, Type[])	Vyhledá zadanou metodu, jejíž parametry odpovídají zadaným typům argumentů, pomocí zadaných omezení vazby. (Zděděno od Type)
GetMethod(String, BindingFlags)	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Vyhledá zadanou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů, typů argumentů a modifikátorům, pomocí zadaných omezení vazby a zadané konvence volání. (Zděděno od Type)
GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[])	Vyhledá zadanou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů, typům argumentů a modifikátorům, pomocí zadaných omezení vazby. (Zděděno od Type)
GetMethod(String, Int32, BindingFlags, Type[])	Vyhledá zadanou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů a typům argumentů, pomocí zadaných omezení vazby. (Zděděno od Type)
GetMethod(String, Int32, Type[], ParameterModifier[])	Vyhledá zadanou veřejnou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů, typům argumentů a modifikátorům. (Zděděno od Type)
GetMethod(String, Int32, Type[])	Vyhledá zadanou veřejnou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů a typům argumentů. (Zděděno od Type)
GetMethod(String, Type[], ParameterModifier[])	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetMethod(String, Type[])	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetMethod(String)	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetMethod(Type, MethodInfo)	Vrátí metodu zadaného vytvořeného obecného typu, který odpovídá zadané metodě definice obecného typu.
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Při přepsání v odvozené třídě vyhledá zadanou metodu, jejíž parametry odpovídají zadaným typům argumentů a modifikátorům, pomocí zadaných omezení vazby a zadané konvence volání.
GetMethodImpl(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Při přepsání v odvozené třídě vyhledá zadanou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů, typů argumentů a modifikátorům, pomocí zadaných omezení vazby a zadané konvence volání. (Zděděno od Type)
GetMethods()	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetMethods(BindingFlags)	Vrátí všechny veřejné a neveřejné metody deklarované nebo zděděné tímto typem, jak je uvedeno.
GetNestedType(String, BindingFlags)	Vrátí veřejné a neveřejné vnořené typy, které jsou deklarovány tímto typem.
GetNestedType(String)	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetNestedTypes()	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetNestedTypes(BindingFlags)	Vrátí veřejné a nevnořené typy, které jsou deklarovány nebo zděděné tímto typem.
GetOptionalCustomModifiers()	Při přepsání v odvozené třídě vrátí volitelné vlastní modifikátory aktuální Type. (Zděděno od Type)
GetProperties()	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetProperties(BindingFlags)	Vrátí všechny veřejné a neveřejné vlastnosti deklarované nebo zděděné tímto typem, jak je uvedeno.
GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Vyhledá zadanou vlastnost, jejíž parametry odpovídají zadaným typům argumentů a modifikátorům, pomocí zadaných omezení vazby. (Zděděno od Type)
GetProperty(String, BindingFlags)	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetProperty(String, Type, Type[], ParameterModifier[])	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetProperty(String, Type, Type[])	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetProperty(String, Type)	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetProperty(String, Type[])	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetProperty(String)	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Při přepsání v odvozené třídě vyhledá zadanou vlastnost, jejíž parametry odpovídají zadaným typům argumentů a modifikátorům, pomocí zadaných omezení vazby.
GetRequiredCustomModifiers()	Při přepsání v odvozené třídě vrátí požadované vlastní modifikátory aktuální Type. (Zděděno od Type)
GetType()	Získá aktuální Type. (Zděděno od Type)
GetTypeCodeImpl()	Vrátí kód základního typu této instance Type. (Zděděno od Type)
HasElementTypeImpl()	Při přepsání v odvozené třídě implementuje HasElementType vlastnost a určuje, zda aktuální Type zahrnuje nebo odkazuje na jiný typ; to znamená, zda aktuální Type je matice, ukazatel nebo je předána odkazem.
HasSameMetadataDefinitionAs(MemberInfo)	Definuje a vytváří nové instance tříd během běhu. (Zděděno od MemberInfo)
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)	Vyvolá zadaný člen pomocí zadaných omezení vazby a porovnává zadaný seznam argumentů a jazykovou verzi. (Zděděno od Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])	Vyvolá zadaný člen. Metoda, která má být vyvolána, musí být přístupná a poskytovat nejpřesnější shodu se zadaným seznamem argumentů v rámci omezení zadaných vazeb a vyvolání atributů.
InvokeMember(String, BindingFlags, Binder, Object, Object[])	Vyvolá zadaný člen pomocí zadaných omezení vazby a porovnává zadaný seznam argumentů. (Zděděno od Type)
IsArrayImpl()	Při přepsání v odvozené třídě implementuje IsArray vlastnost a určuje, zda Type je pole.
IsAssignableFrom(Type)	Získá hodnotu, která určuje, zda zadaný Type lze přiřadit k tomuto objektu.
IsAssignableFrom(TypeInfo)	Získá hodnotu, která určuje, zda zadaný TypeInfo objekt lze přiřadit k tomuto objektu.
IsAssignableTo(Type)	Určuje, zda lze aktuální typ přiřadit proměnné zadané targetType. (Zděděno od Type)
IsByRefImpl()	Při přepsání v odvozené třídě implementuje IsByRef vlastnost a určuje, zda je Type předán odkazem.
IsCOMObjectImpl()	Při přepsání v odvozené třídě implementuje IsCOMObject vlastnost a určuje, zda Type je objekt COM.
IsContextfulImpl()	Implementuje vlastnost IsContextful a určuje, zda lze Type hostovat v kontextu. (Zděděno od Type)
IsCreated()	Vrátí hodnotu, která určuje, zda byl vytvořen aktuální dynamický typ.
IsCreatedCore()	Při přepsání v odvozené třídě vrátí hodnotu, která označuje, zda byl vytvořen aktuální dynamický typ.
IsDefined(Type, Boolean)	Určuje, zda se na aktuální typ použije vlastní atribut.
IsEnumDefined(Object)	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsEquivalentTo(Type)	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsInstanceOfType(Object)	Definuje a vytváří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsMarshalByRefImpl()	Implementuje vlastnost IsMarshalByRef a určuje, zda je Type zařazován odkazem. (Zděděno od Type)
IsPointerImpl()	Při přepsání v odvozené třídě implementuje IsPointer vlastnost a určuje, zda Type je ukazatel.
IsPrimitiveImpl()	Při přepsání v odvozené třídě implementuje IsPrimitive vlastnost a určuje, zda Type je jedním z primitivních typů.
IsSubclassOf(Type)	Určuje, zda je tento typ odvozen ze zadaného typu.
IsValueTypeImpl()	Implementuje vlastnost IsValueType a určuje, zda Type je typ hodnoty; to znamená, že nikoli třída nebo rozhraní. (Zděděno od Type)
MakeArrayType()	Vrátí objekt Type, který představuje jednorozměrné pole aktuálního typu s dolní hranici nuly.
MakeArrayType(Int32)	Vrátí Type objekt, který představuje pole aktuálního typu se zadaným počtem dimenzí.
MakeByRefType()	Vrátí objekt Type, který představuje aktuální typ při předání jako parametr ref (ByRef v jazyce Visual Basic).
MakeGenericType(Type[])	Nahradí prvky pole typů parametry typu aktuální definice obecného typu a vrátí výsledný konstruovaný typ.
MakePointerType()	Vrátí Type objekt, který představuje typ nespravovaného ukazatele na aktuální typ.
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
SetCustomAttribute(ConstructorInfo, Byte[])	Nastaví vlastní atribut pomocí zadaného objektu blob vlastního atributu.
SetCustomAttribute(CustomAttributeBuilder)	Nastavte vlastní atribut pomocí tvůrce vlastních atributů.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Při přepsání v odvozené třídě nastaví vlastní atribut pro toto sestavení.
SetParent(Type)	Nastaví základní typ typu, který je aktuálně ve konstrukci.
SetParentCore(Type)	Při přepsání v odvozené třídě nastaví základní typ typu aktuálně v rámci konstrukce.
ToString()	Vrátí název typu s výjimkou oboru názvů.

Explicitní implementace rozhraní

IReflectableType.GetTypeInfo()

Vrátí reprezentaci aktuálního typu jako objekt TypeInfo. (Zděděno od TypeInfo)

Metody rozšíření

GetCustomAttribute(MemberInfo, Type, Boolean)	Načte vlastní atribut zadaného typu, který se použije u zadaného členu, a volitelně zkontroluje předky daného člena.
GetCustomAttribute(MemberInfo, Type)	Načte vlastní atribut zadaného typu, který se použije na zadaný člen.
GetCustomAttribute<T>(MemberInfo, Boolean)	Načte vlastní atribut zadaného typu, který se použije u zadaného členu, a volitelně zkontroluje předky daného člena.
GetCustomAttribute<T>(MemberInfo)	Načte vlastní atribut zadaného typu, který se použije na zadaný člen.
GetCustomAttributes(MemberInfo, Boolean)	Načte kolekci vlastních atributů, které se použijí na zadaného člena, a volitelně zkontroluje předky daného člena.
GetCustomAttributes(MemberInfo, Type, Boolean)	Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaný člen, a volitelně zkontroluje nadřazené objekty daného člena.
GetCustomAttributes(MemberInfo, Type)	Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaný člen.
GetCustomAttributes(MemberInfo)	Načte kolekci vlastních atributů, které se použijí na zadaný člen.
GetCustomAttributes<T>(MemberInfo, Boolean)	Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaný člen, a volitelně zkontroluje nadřazené objekty daného člena.
GetCustomAttributes<T>(MemberInfo)	Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaný člen.
IsDefined(MemberInfo, Type, Boolean)	Určuje, zda se vlastní atributy zadaného typu použijí na zadaný člen a volitelně se použijí na jeho nadřazené objekty.
IsDefined(MemberInfo, Type)	Určuje, zda jsou u zadaného člena použity vlastní atributy zadaného typu.
GetTypeInfo(Type)	Vrátí TypeInfo reprezentaci zadaného typu.
GetMetadataToken(MemberInfo)	Získá token metadat pro daného člena, pokud je k dispozici.
HasMetadataToken(MemberInfo)	Vrátí hodnotu, která určuje, zda je token metadat k dispozici pro zadaného člena.
GetRuntimeEvent(Type, String)	Načte objekt, který představuje zadanou událost.
GetRuntimeEvents(Type)	Načte kolekci, která představuje všechny události definované v zadaném typu.
GetRuntimeField(Type, String)	Načte objekt, který představuje zadané pole.
GetRuntimeFields(Type)	Načte kolekci, která představuje všechna pole definovaná pro zadaný typ.
GetRuntimeInterfaceMap(TypeInfo, Type)	Vrátí mapování rozhraní pro zadaný typ a zadané rozhraní.
GetRuntimeMethod(Type, String, Type[])	Načte objekt, který představuje zadanou metodu.
GetRuntimeMethods(Type)	Načte kolekci, která představuje všechny metody definované pro zadaný typ.
GetRuntimeProperties(Type)	Načte kolekci, která představuje všechny vlastnosti definované pro zadaný typ.
GetRuntimeProperty(Type, String)	Načte objekt, který představuje zadanou vlastnost.
GetConstructor(Type, Type[])	Definuje a vytváří nové instance tříd během běhu.
GetConstructors(Type, BindingFlags)	Definuje a vytváří nové instance tříd během běhu.
GetConstructors(Type)	Definuje a vytváří nové instance tříd během běhu.
GetDefaultMembers(Type)	Definuje a vytváří nové instance tříd během běhu.
GetEvent(Type, String, BindingFlags)	Definuje a vytváří nové instance tříd během běhu.
GetEvent(Type, String)	Definuje a vytváří nové instance tříd během běhu.
GetEvents(Type, BindingFlags)	Definuje a vytváří nové instance tříd během běhu.
GetField(Type, String, BindingFlags)	Definuje a vytváří nové instance tříd během běhu.
GetField(Type, String)	Definuje a vytváří nové instance tříd během běhu.
GetFields(Type, BindingFlags)	Definuje a vytváří nové instance tříd během běhu.
GetFields(Type)	Definuje a vytváří nové instance tříd během běhu.
GetGenericArguments(Type)	Definuje a vytváří nové instance tříd během běhu.
GetMember(Type, String, BindingFlags)	Definuje a vytváří nové instance tříd během běhu.
GetMethod(Type, String, BindingFlags)	Definuje a vytváří nové instance tříd během běhu.
GetMethod(Type, String, Type[])	Definuje a vytváří nové instance tříd během běhu.
GetMethods(Type)	Definuje a vytváří nové instance tříd během běhu.
GetNestedType(Type, String, BindingFlags)	Definuje a vytváří nové instance tříd během běhu.
GetProperties(Type)	Definuje a vytváří nové instance tříd během běhu.
GetProperty(Type, String, Type, Type[])	Definuje a vytváří nové instance tříd během běhu.
GetProperty(Type, String, Type)	Definuje a vytváří nové instance tříd během běhu.
IsInstanceOfType(Type, Object)	Definuje a vytváří nové instance tříd během běhu.

Viz také

• Postupy: Definování obecného typu pomocí generování reflexe