TypeBuilder Třída

Definice

Obor názvů:

System.Reflection.Emit

Sestavení:

System.Reflection.Emit.dll

Zdroj:

TypeBuilder.cs

Definuje a vytvoří 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á privátní pole, vlastnost, která získá a nastaví privátní pole, konstruktory inicializují privátní pole a metodu, která vynásobí uživatelem zadané číslo hodnotou privátní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 najdete v tématu Doplňkové poznámky k rozhraní API pro TypeBuilder.

Konstruktory

TypeBuilder()

Inicializuje novou instanci TypeBuilder třídy.

Pole

UnspecifiedTypeSize

Představuje, že celková velikost pro typ není zadána.

Vlastnosti

Assembly	Načte dynamické sestavení, které obsahuje definici tohoto typu.
AssemblyQualifiedName	Vrátí úplný název tohoto typu kvalifikovaný zobrazovaný název sestavení.
Attributes	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
BaseType	Načte základní typ tohoto typu.
ContainsGenericParameters	Definuje a vytvoří 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ý tento typ deklaroval.
FullName	Načte úplnou cestu tohoto typu.
GenericParameterAttributes	Získá hodnotu, která označuje kovarianci a speciální omezení aktuálního obecného typu parametru.
GenericParameterPosition	Získá pozici parametru typu v seznamu parametrů typu obecného typu, který deklaroval parametr.
GenericTypeArguments	Definuje a vytvoří 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 vytvoří 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 vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsAnsiClass	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsArray	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsAutoClass	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsAutoLayout	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsByRef	Definuje a vytvoří 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 struktury.
IsClass	Definuje a vytvoří 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ého v collectible AssemblyLoadContext. (Zděděno od MemberInfo)
IsCOMObject	Definuje a vytvoří 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 vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsExplicitLayout	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsFunctionPointer	Získá hodnotu, která označuje, zda Type aktuální je ukazatel funkce. (Zděděno od Type)
IsGenericMethodParameter	Získá hodnotu, která označuje, zda aktuální Type představuje parametr typu v definici obecné metody. (Zděděno od Type)
IsGenericParameter	Získá hodnotu označující, zda aktuální typ je obecný typ parametru.
IsGenericType	Získá hodnotu označující, zda aktuální typ je obecný typ.
IsGenericTypeDefinition	Získá hodnotu označující, zda aktuální TypeBuilder představuje definici obecného typu, ze které lze vytvořit další obecné typy.
IsGenericTypeParameter	Získá hodnotu, která označuje, zda aktuální Type představuje parametr typu v definici obecného typu. (Zděděno od Type)
IsImport	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsInterface	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsLayoutSequential	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsMarshalByRef	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsNested	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsNestedAssembly	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsNestedFamANDAssem	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsNestedFamily	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsNestedFamORAssem	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsNestedPrivate	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsNestedPublic	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsNotPublic	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsPointer	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsPrimitive	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsPublic	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsSealed	Definuje a vytvoří 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 zabezpečení-kritický nebo zabezpečení-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 být přístupný transparentním kódem.
IsSecurityTransparent	Získá hodnotu, která označuje, zda aktuální typ je transparentní, a proto nemůže provádět kritické operace.
IsSerializable	Definuje a vytvoří 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 vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsSZArray	Definuje a vytvoří nové instance tříd během běhu.
IsTypeDefinition	Definuje a vytvoří nové instance tříd během běhu.
IsUnicodeClass	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsUnmanagedFunctionPointer	Získá hodnotu, která označuje, zda Type aktuální je nespravovaný ukazatel funkce. (Zděděno od Type)
IsValueType	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsVariableBoundArray	Získá hodnotu, která označ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 vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
MemberType	Definuje a vytvoří 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 definici tohoto typu.
Name	Načte název tohoto typu.
Namespace	Načte obor názvů, ve kterém TypeBuilder je definován.
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 vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
TypeHandle	Není podporováno v dynamických modulech.
TypeInitializer	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
UnderlyingSystemType	Vrátí základní typ systému pro tento TypeBuilderobjekt .

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 Type objekt. (Zděděno od TypeInfo)
CreateType()	Vytvoří Type objekt pro třídu. Po definování polí a metod ve třídě se CreateType volá, aby se načetl jeho Type objekt.
CreateTypeInfo()	TypeInfo Získá objekt, který představuje tento typ.
CreateTypeInfoCore()	Při přepsání v odvozené třídě získá objekt, TypeInfo který představuje tento typ.
DefineConstructor(MethodAttributes, CallingConventions, Type[])	Přidá do typu nový konstruktor s danými atributy a podpisem.
DefineConstructor(MethodAttributes, CallingConventions, Type[], Type[][], Type[][])	Přidá do typu nový konstruktor s danými atributy, podpisem a vlastními modifikátory.
DefineConstructorCore(MethodAttributes, CallingConventions, Type[], Type[][], Type[][])	Při přepsání v odvozené třídě přidá do typu nový konstruktor s danými atributy, podpisem a vlastními modifikátory.
DefineDefaultConstructor(MethodAttributes)	Definuje konstruktor bez parametrů. Zde definovaný konstruktor jednoduše zavolá konstruktor nadřazeného objektu bez parametrů.
DefineDefaultConstructorCore(MethodAttributes)	Při přepsání v odvozené třídě definuje konstruktor bez parametrů. Zde definovaný konstruktor volá konstruktor nadřazeného objektu bez parametrů.
DefineEvent(String, EventAttributes, Type)	Přidá k 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á k 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 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 parametry obecného typu pro aktuální typ a určuje jejich číslo a jejich názvy.
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)	Přidá novou metodu k typu se zadaným názvem a atributy 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, CallingConventions, Type, Type[])	Přidá novou metodu k typu se zadaným názvem, atributy metody, konvencí volání a podpisem metody.
DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Přidá novou metodu k typu se zadaným názvem, atributy metody, konvencí volání, podpisem metody a vlastními modifikátory.
DefineMethod(String, MethodAttributes, Type, Type[])	Přidá novou metodu k typu se zadaným názvem, atributy metody a podpisem 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, konvencí volání, podpisem metody a vlastními modifikátory.
DefineMethodOverride(MethodInfo, MethodInfo)	Určuje daný text metody, který implementuje deklaraci dané metody, potenciálně s jiným názvem.
DefineMethodOverrideCore(MethodInfo, MethodInfo)	Při přepsání v odvozené třídě určuje dané tělo metody, která implementuje danou deklaraci metody, potenciálně s jiným názvem.
DefineNestedType(String)	Definuje vnořený typ vzhledem k jeho názvu.
DefineNestedType(String, TypeAttributes)	Definuje vnořený typ vzhledem k jeho názvu a atributům.
DefineNestedType(String, TypeAttributes, Type)	Definuje vnořený typ vzhledem k jeho názvu, atributům a typu, který rozšiřuje.
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)	Definuje vnořený typ s ohledem na jeho název, atributy, typ, který rozšiřuje, a velikost balení.
DefineNestedType(String, TypeAttributes, Type, PackingSize, Int32)	Definuje vnořený typ s ohledem na jeho název, atributy, velikost a typ, který rozšiřuje.
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.
DefineNestedTypeCore(String, TypeAttributes, Type, Type[], PackingSize, Int32)	Při přepsání v odvozené třídě definuje vnořený typ vzhledem k jeho názvu, atributům, velikosti a typu, který rozšiřuje.
DefinePInvokeMethod(String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Definuje metodu PInvoke vzhledem k jejímu názvu, název knihovny DLL, ve které je definována metoda, 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[], CallingConvention, CharSet)	Definuje metodu PInvoke vzhledem k jejímu názvu, název knihovny DLL, ve které je definována metoda, 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 metodu PInvoke s názvem, názvem knihovny DLL, ve které je metoda definována, názvem vstupního bodu, atributy metody, konvencí volání metody, návratovým typem metody, typy parametrů metody, PInvoke příznaky a vlastní modifikátory pro parametry 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 metodu se zadaným názvem, názvem knihovny DLL, názvem vstupního bodu, atributy, konvencí volání, návratovým typem, typy parametrů, příznaky PInvoke a vlastními modifikátory pro parametry a návratový typ.
DefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[])	Přidá k typu novou vlastnost s daným názvem, atributy, konvencí volání a podpisem vlastnosti.
DefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Přidá k typu novou vlastnost se zadaným názvem, konvencí volání, podpisem vlastnosti a vlastními modifikátory.
DefineProperty(String, PropertyAttributes, Type, Type[])	Přidá do typu novou vlastnost se zadaným názvem 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.
DefinePropertyCore(String, PropertyAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Při přepsání v odvozené třídě přidá do typu novou vlastnost s daným názvem, konvencí volání, podpisem vlastnosti a vlastními 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 je typ základního systému aktuálního Type objektu stejný jako typ základního systému zadaného Objectobjektu . (Zděděno od Type)
Equals(Type)	Určuje, zda je typ základního systému aktuálního Type systému stejný jako typ základního systému zadaného Type. (Zděděno od Type)
FindInterfaces(TypeFilter, Object)	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetArrayRank()	Definuje a vytvoří 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 získá 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 vazeb omezení 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 vazeb omezení. (Zděděno od Type)
GetConstructor(BindingFlags, Type[])	Vyhledá konstruktor, jehož parametry odpovídají zadaným typům argumentů pomocí zadaných vazeb omezení. (Zděděno od Type)
GetConstructor(Type, ConstructorInfo)	Vrátí konstruktor zadaného vytvořeného obecného typu, který odpovídá zadanému konstruktoru definice obecného typu.
GetConstructor(Type[])	Definuje a vytvoří 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ě 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í.
GetConstructors()	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetConstructors(BindingFlags)	Vrátí pole ConstructorInfo objektů představující 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 k zadanému typu.
GetCustomAttributesData()	Vrátí seznam CustomAttributeData objektů představujících data o atributech, které byly použity 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é u aktuálního 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 vytvoří 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 vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetEnumNames()	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetEnumUnderlyingType()	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetEnumValues()	Definuje a vytvoří 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)	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetEvent(String, BindingFlags)	Vrátí událost se zadaným názvem.
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)	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetField(String, BindingFlags)	Vrátí pole určené daným názvem.
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 vytvoří 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í konvence volání aktuálního ukazatele Typena funkci . (Zděděno od Type)
GetFunctionPointerParameterTypes()	Při přepsání v odvozené třídě vrátí typy parametrů aktuálního ukazatele Typena funkci . (Zděděno od Type)
GetFunctionPointerReturnType()	Při přepsání v odvozené třídě vrátí návratový typ aktuálního ukazatele Typena funkci . (Zděděno od Type)
GetGenericArguments()	Vrátí pole Type objektů představující argumenty typu obecného typu nebo parametry typu definice obecného typu.
GetGenericParameterConstraints()	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetGenericTypeDefinition()	Type Vrátí objekt, který představuje definici obecného typu, ze které lze získat aktuální typ.
GetHashCode()	Vrátí hodnotu hash pro tuto instanci. (Zděděno od Type)
GetInterface(String)	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetInterface(String, Boolean)	Vrátí rozhraní implementované (přímo nebo nepřímo) touto třídou s plně kvalifikovaným názvem, který odpovídá danému názvu rozhraní.
GetInterfaceMap(Type)	Vrátí mapování rozhraní pro požadované rozhraní.
GetInterfaces()	Vrátí pole všech rozhraní implementovaných u tohoto typu a jeho základních typů.
GetMember(String)	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetMember(String, BindingFlags)	Definuje a vytvoří 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.
GetMembers()	Definuje a vytvoří 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á u MemberInfo aktuálního Type , který odpovídá zadané MemberInfohodnotě . (Zděděno od Type)
GetMethod(String)	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetMethod(String, BindingFlags)	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
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 vazeb omezení 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 vazeb omezení. (Zděděno od Type)
GetMethod(String, BindingFlags, Type[])	Vyhledá zadanou metodu, jejíž parametry odpovídají zadaným typům argumentů, pomocí zadaných vazeb omezení. (Zděděno od Type)
GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, 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 vazeb omezení 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 vazebních omezení. (Zděděno od Type)
GetMethod(String, Int32, BindingFlags, Type[])	Definuje a vytvoří nové instance tříd během běhu. (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, 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, Type[])	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetMethod(String, Type[], ParameterModifier[])	Definuje a vytvoří 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 vazeb omezení 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ům argumentů a modifikátorům, pomocí zadaných vazeb omezení a zadané konvence volání. (Zděděno od Type)
GetMethods()	Definuje a vytvoří 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)	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetNestedType(String, BindingFlags)	Vrátí veřejné a neveřejné vnořené typy, které jsou deklarovány tímto typem.
GetNestedTypes()	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetNestedTypes(BindingFlags)	Vrátí veřejné a neveřejné vnořené typy, které jsou deklarovány nebo zděděny tímto typem.
GetOptionalCustomModifiers()	Při přepsání v odvozené třídě vrátí volitelné vlastní modifikátory aktuálního Type. (Zděděno od Type)
GetProperties()	Definuje a vytvoří 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)	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetProperty(String, BindingFlags)	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
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 vazeb omezení. (Zděděno od Type)
GetProperty(String, Type)	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetProperty(String, Type, Type[])	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetProperty(String, Type, Type[], ParameterModifier[])	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
GetProperty(String, Type[])	Definuje a vytvoří 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 vazeb omezení.
GetRequiredCustomModifiers()	Při přepsání v odvozené třídě vrátí požadované vlastní modifikátory aktuálního 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 Type instance. (Zděděno od Type)
HasElementTypeImpl()	Při přepsání v odvozené třídě implementuje HasElementType vlastnost a určuje, zda proud Type zahrnuje nebo odkazuje na jiný typ; to znamená, zda je proud Type pole, ukazatel, nebo je předán odkazem.
HasSameMetadataDefinitionAs(MemberInfo)	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od MemberInfo)
InvokeMember(String, BindingFlags, Binder, Object, Object[])	Vyvolá zadaný člen pomocí omezení zadané vazby a odpovídající seznamu zadaných argumentů. (Zděděno od Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)	Vyvolá zadaný člen pomocí zadaných vazeb omezení a odpovídající zadanému seznamu argumentů a jazykové verzi. (Zděděno od Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])	Vyvolá zadaného člena. Metoda, která má být vyvolána, musí být přístupná a musí poskytovat nejkonvlastnější shodu se zadaným seznamem argumentů pod omezeními zadaného pořadače a vyvolání atributů.
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á označuje, zda zadané Type lze přiřadit k tomuto objektu.
IsAssignableFrom(TypeInfo)	Získá hodnotu, která označ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ého targetTypetypu . (Zděděno od Type)
IsByRefImpl()	Při přepsání v odvozené třídě implementuje IsByRef vlastnost a určuje, zda Type je předán odkaz.
IsCOMObjectImpl()	Při přepsání v odvozené třídě implementuje IsCOMObject vlastnost a určuje, zda Type je objekt com.
IsContextfulImpl()	Implementuje IsContextful vlastnost a určuje, zda Type lze hostovat v kontextu. (Zděděno od Type)
IsCreated()	Vrátí hodnotu, která označ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 je na aktuální typ použit vlastní atribut.
IsEnumDefined(Object)	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsEquivalentTo(Type)	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsInstanceOfType(Object)	Definuje a vytvoří nové instance tříd během běhu. (Zděděno od TypeInfo)
IsMarshalByRefImpl()	Implementuje IsMarshalByRef vlastnost a určuje, zda Type je 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 jeden z primitivních typů.
IsSubclassOf(Type)	Určuje, zda je tento typ odvozen od zadaného typu.
IsValueTypeImpl()	Implementuje IsValueType vlastnost a určuje, zda Type je typ hodnoty, tj. nikoli třída nebo rozhraní. (Zděděno od Type)
MakeArrayType()	Type Vrátí objekt, který představuje jednorozměrnou matici aktuálního typu s dolní nulou.
MakeArrayType(Int32)	Type Vrátí objekt, který představuje pole aktuálního typu se zadaným počtem dimenzí.
MakeByRefType()	Type Vrátí objekt, který představuje aktuální typ při předání jako ref parametr (ByRef v jazyce Visual Basic).
MakeGenericType(Type[])	Nahradí prvky pole typů parametry typu aktuální definice obecného typu a vrátí výsledný vytvořený typ.
MakePointerType()	Type Vrátí objekt, který představuje typ nespravovaného ukazatele na aktuální typ.
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Objectsouboru . (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í vlastního tvůrce atributů.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Při přepsání v odvozené třídě nastaví vlastní atribut v tomto sestavení.
SetParent(Type)	Nastaví základní typ aktuálně sestrojeného typu.
SetParentCore(Type)	Při přepsání v odvozené třídě nastaví základní typ typu, který se právě připravuje.
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 objektu TypeInfo . (Zděděno od TypeInfo)

Metody rozšíření

GetCustomAttribute(MemberInfo, Type)	Načte vlastní atribut zadaného typu, který je použit na zadaného člena.
GetCustomAttribute(MemberInfo, Type, Boolean)	Načte vlastní atribut zadaného typu, který je použit na zadaného člena, a volitelně zkontroluje předchůdce tohoto člena.
GetCustomAttribute<T>(MemberInfo)	Načte vlastní atribut zadaného typu, který je použit na zadaného člena.
GetCustomAttribute<T>(MemberInfo, Boolean)	Načte vlastní atribut zadaného typu, který je použit na zadaného člena, a volitelně zkontroluje předchůdce tohoto člena.
GetCustomAttributes(MemberInfo)	Načte kolekci vlastních atributů, které jsou použity na zadaného člena.
GetCustomAttributes(MemberInfo, Boolean)	Načte kolekci vlastních atributů, které jsou použity na zadaného člena, a volitelně zkontroluje předky tohoto člena.
GetCustomAttributes(MemberInfo, Type)	Načte kolekci vlastních atributů zadaného typu, které jsou použity na zadaného člena.
GetCustomAttributes(MemberInfo, Type, Boolean)	Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaného člena, a volitelně zkontroluje předky tohoto člena.
GetCustomAttributes<T>(MemberInfo)	Načte kolekci vlastních atributů zadaného typu, které jsou použity na zadaného člena.
GetCustomAttributes<T>(MemberInfo, Boolean)	Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaného člena, a volitelně zkontroluje předky tohoto člena.
IsDefined(MemberInfo, Type)	Určuje, zda jsou na zadaného člena použity vlastní atributy zadaného typu.
IsDefined(MemberInfo, Type, Boolean)	Určuje, zda se vlastní atributy zadaného typu použijí na zadaného člena a volitelně se použijí na jeho předky.
GetTypeInfo(Type)	Vrátí reprezentaci TypeInfo zadaného typu.
GetMetadataToken(MemberInfo)	Získá token metadat pro daného člena, pokud je k dispozici.
HasMetadataToken(MemberInfo)	Vrátí hodnotu, která označ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é na 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á na zadaném typu.
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é na zadaném typu.
GetRuntimeProperties(Type)	Načte kolekci, která představuje všechny vlastnosti definované na zadaném typu.
GetRuntimeProperty(Type, String)	Načte objekt, který představuje zadanou vlastnost.
GetConstructor(Type, Type[])	Definuje a vytvoří nové instance tříd během běhu.
GetConstructors(Type)	Definuje a vytvoří nové instance tříd během běhu.
GetConstructors(Type, BindingFlags)	Definuje a vytvoří nové instance tříd během běhu.
GetFields(Type, BindingFlags)	Definuje a vytvoří nové instance tříd během běhu.
GetGenericArguments(Type)	Definuje a vytvoří nové instance tříd během běhu.
GetInterfaces(Type)	Definuje a vytvoří nové instance tříd během běhu.
GetMember(Type, String)	Definuje a vytvoří nové instance tříd během běhu.
GetMember(Type, String, BindingFlags)	Definuje a vytvoří nové instance tříd během běhu.
GetMembers(Type)	Definuje a vytvoří nové instance tříd během běhu.
GetMethods(Type)	Definuje a vytvoří nové instance tříd během běhu.
GetNestedType(Type, String, BindingFlags)	Definuje a vytvoří nové instance tříd během běhu.
GetProperties(Type)	Definuje a vytvoří nové instance tříd během běhu.
GetProperties(Type, BindingFlags)	Definuje a vytvoří nové instance tříd během běhu.
GetProperty(Type, String, BindingFlags)	Definuje a vytvoří nové instance tříd během běhu.
GetProperty(Type, String, Type)	Definuje a vytvoří nové instance tříd během běhu.
GetProperty(Type, String, Type, Type[])	Definuje a vytvoří nové instance tříd během běhu.
IsAssignableFrom(Type, Type)	Definuje a vytvoří nové instance tříd během běhu.
IsInstanceOfType(Type, Object)	Definuje a vytvoří nové instance tříd během běhu.

Viz také

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