Sdílet prostřednictvím


TypeBuilder Třída

Definice

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

public ref class TypeBuilder sealed : Type
public ref class TypeBuilder sealed : System::Reflection::TypeInfo
public ref class TypeBuilder abstract : System::Reflection::TypeInfo
public ref class TypeBuilder sealed : Type, System::Runtime::InteropServices::_TypeBuilder
public ref class TypeBuilder sealed : System::Reflection::TypeInfo, System::Runtime::InteropServices::_TypeBuilder
public sealed class TypeBuilder : Type
public sealed class TypeBuilder : System.Reflection.TypeInfo
public abstract class TypeBuilder : System.Reflection.TypeInfo
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public sealed class TypeBuilder : Type, System.Runtime.InteropServices._TypeBuilder
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class TypeBuilder : Type, System.Runtime.InteropServices._TypeBuilder
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class TypeBuilder : System.Reflection.TypeInfo, System.Runtime.InteropServices._TypeBuilder
type TypeBuilder = class
    inherit Type
type TypeBuilder = class
    inherit TypeInfo
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type TypeBuilder = class
    inherit Type
    interface _TypeBuilder
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type TypeBuilder = class
    inherit Type
    interface _TypeBuilder
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type TypeBuilder = class
    inherit TypeInfo
    interface _TypeBuilder
Public NotInheritable Class TypeBuilder
Inherits Type
Public NotInheritable Class TypeBuilder
Inherits TypeInfo
Public MustInherit Class TypeBuilder
Inherits TypeInfo
Public NotInheritable Class TypeBuilder
Inherits Type
Implements _TypeBuilder
Public NotInheritable Class TypeBuilder
Inherits TypeInfo
Implements _TypeBuilder
Dědičnost
TypeBuilder
Dědičnost
TypeBuilder
Dědičnost
Atributy
Implementuje

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.

Attributes

Získá atributy přidružené k Type.

(Zděděno od Type)
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.

ContainsGenericParameters

Získá hodnotu označující, zda aktuální Type objekt má parametry typu, které nebyly nahrazeny konkrétními typy.

(Zděděno od Type)
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.

DeclaringMethod

Získá, MethodBase který představuje deklarující metodu, pokud aktuální Type představuje parametr typu obecné metody.

(Zděděno od Type)
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.

GenericParameterAttributes

Získá kombinaci GenericParameterAttributes příznaků, které popisují kovarianci a speciální omezení aktuálního obecného typu parametru.

(Zděděno od Type)
GenericParameterPosition

Získá pozici parametru typu v seznamu parametrů typu obecného typu, který deklaroval parametr.

GenericParameterPosition

Získá pozici parametru typu v seznamu parametrů typu obecného typu nebo metody, která deklarovala parametr, když Type objekt představuje parametr typu obecného typu nebo obecné metody.

(Zděděno od Type)
GenericTypeArguments

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

GenericTypeArguments

Získá pole argumentů obecného typu pro tento typ.

(Zděděno od Type)
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

Získá hodnotu označující, zda aktuální Type zahrnuje nebo odkazuje na jiný typ; to znamená, zda je aktuální Type pole, ukazatel, nebo je předán pomocí odkazu.

(Zděděno od Type)
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

Získá hodnotu označující, zda Type je abstraktní a musí být přepsána.

(Zděděno od Type)
IsAbstract

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

(Zděděno od TypeInfo)
IsAnsiClass

Získá hodnotu označující, zda je atribut formátu AnsiClass řetězce vybrán pro Type.

(Zděděno od Type)
IsAnsiClass

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

(Zděděno od TypeInfo)
IsArray

Získá hodnotu, která označuje, zda je typ pole.

(Zděděno od Type)
IsArray

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

(Zděděno od TypeInfo)
IsAutoClass

Získá hodnotu označující, zda je atribut formátu AutoClass řetězce vybrán pro Type.

(Zděděno od Type)
IsAutoClass

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

(Zděděno od TypeInfo)
IsAutoLayout

Získá hodnotu označující, zda pole aktuálního typu jsou automaticky rozloženy modulem CLR (Common Language Runtime).

(Zděděno od Type)
IsAutoLayout

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

(Zděděno od TypeInfo)
IsByRef

Získá hodnotu označující, zda Type je předán odkaz.

(Zděděno od Type)
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.

IsByRefLike

Získá hodnotu, která označuje, zda je typ byref-like struktury.

(Zděděno od Type)
IsClass

Získá hodnotu označující, zda Type je třída nebo delegát; to znamená, že ne typ hodnoty nebo rozhraní.

(Zděděno od Type)
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

Získá hodnotu označující, zda Type je objekt COM.

(Zděděno od Type)
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.

IsConstructedGenericType

Získá hodnotu, která označuje, zda tento objekt představuje vytvořený obecný typ. Můžete vytvořit instance vytvořeného obecného typu.

(Zděděno od Type)
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.

IsEnum

Získá hodnotu označující, zda aktuální Type představuje výčet.

(Zděděno od Type)
IsEnum

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

(Zděděno od TypeInfo)
IsExplicitLayout

Získá hodnotu označující, zda pole aktuálního typu jsou rozloženy na explicitně zadané posuny.

(Zděděno od Type)
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.

IsGenericParameter

Získá hodnotu označující, zda aktuální Type představuje parametr typu v definici obecného typu nebo metody.

(Zděděno od Type)
IsGenericType

Získá hodnotu označující, zda aktuální typ je obecný typ.

IsGenericType

Získá hodnotu označující, zda aktuální typ je obecný typ.

(Zděděno od Type)
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.

IsGenericTypeDefinition

Získá hodnotu označující, zda aktuální Type představuje definici obecného typu, ze které mohou být vytvořeny další obecné typy.

(Zděděno od Type)
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

Získá hodnotu označující, zda TypeComImportAttribute atribut použitý, což označuje, že byl importován z knihovny typů modelu COM.

(Zděděno od Type)
IsImport

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

(Zděděno od TypeInfo)
IsInterface

Získá hodnotu označující, zda Type je rozhraní; to znamená, že třída nebo typ hodnoty.

(Zděděno od Type)
IsInterface

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

(Zděděno od TypeInfo)
IsLayoutSequential

Získá hodnotu označující, zda pole aktuálního typu jsou rozloženy postupně v pořadí, v jakém byly definovány nebo generovány do metadat.

(Zděděno od Type)
IsLayoutSequential

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

(Zděděno od TypeInfo)
IsMarshalByRef

Získá hodnotu označující, zda Type je zařazován odkazem.

(Zděděno od Type)
IsMarshalByRef

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

(Zděděno od TypeInfo)
IsNested

Získá hodnotu označující, zda aktuální Type objekt představuje typ, jehož definice je vnořena uvnitř definice jiného typu.

(Zděděno od Type)
IsNested

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

(Zděděno od TypeInfo)
IsNestedAssembly

Získá hodnotu označující, zda Type je vnořený a viditelný pouze v rámci vlastní sestavení.

(Zděděno od Type)
IsNestedAssembly

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

(Zděděno od TypeInfo)
IsNestedFamANDAssem

Získá hodnotu označující, zda Type je vnořený a viditelný pouze třídy, které patří do jeho vlastní rodiny i vlastní sestavení.

(Zděděno od Type)
IsNestedFamANDAssem

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

(Zděděno od TypeInfo)
IsNestedFamily

Získá hodnotu označující, zda Type je vnořený a viditelný pouze v rámci své vlastní rodiny.

(Zděděno od Type)
IsNestedFamily

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

(Zděděno od TypeInfo)
IsNestedFamORAssem

Získá hodnotu označující, zda Type je vnořený a viditelný pouze třídy, které patří buď do vlastní rodiny, nebo do vlastního sestavení.

(Zděděno od Type)
IsNestedFamORAssem

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

(Zděděno od TypeInfo)
IsNestedPrivate

Získá hodnotu označující, zda je vnořený Type a deklarován privátní.

(Zděděno od Type)
IsNestedPrivate

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

(Zděděno od TypeInfo)
IsNestedPublic

Získá hodnotu označující, zda je třída vnořená a deklarována veřejná.

(Zděděno od Type)
IsNestedPublic

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

(Zděděno od TypeInfo)
IsNotPublic

Získá hodnotu označující, zda Type není deklarován veřejný.

(Zděděno od Type)
IsNotPublic

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

(Zděděno od TypeInfo)
IsPointer

Získá hodnotu označující, zda Type je ukazatel.

(Zděděno od Type)
IsPointer

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

(Zděděno od TypeInfo)
IsPrimitive

Získá hodnotu označující, zda Type je jedním z primitivních typů.

(Zděděno od Type)
IsPrimitive

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

(Zděděno od TypeInfo)
IsPublic

Získá hodnotu označující, zda Type je deklarován veřejný.

(Zděděno od Type)
IsPublic

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

(Zděděno od TypeInfo)
IsSealed

Získá hodnotu označující, zda Type je deklarován zapečetěný.

(Zděděno od Type)
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.

IsSecurityCritical

Získá hodnotu, která označuje, zda aktuální typ je kritický zabezpečení nebo zabezpečení-bezpečné-kritické na aktuální úrovni důvěryhodnosti, a proto může provádět kritické operace.

(Zděděno od Type)
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.

IsSecuritySafeCritical

Získá hodnotu, která označuje, zda aktuální typ je zabezpečení-kritický na aktuální úroveň důvěryhodnosti; to znamená, zda může provádět kritické operace a může být přístupný transparentním kódem.

(Zděděno od Type)
IsSecurityTransparent

Získá hodnotu, která označuje, zda aktuální typ je transparentní, a proto nemůže provádět kritické operace.

IsSecurityTransparent

Získá hodnotu, která označuje, zda aktuální typ je transparentní na aktuální úrovni důvěryhodnosti, a proto nelze provádět kritické operace.

(Zděděno od Type)
IsSerializable

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

IsSerializable
Zastaralé.

Získá hodnotu označující, zda Type je binární serializovatelný.

(Zděděno od Type)
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

Získá hodnotu označující, zda typ má název, který vyžaduje speciální zpracování.

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

IsSZArray

Získá hodnotu, která označuje, zda typ je typ pole, který může představovat pouze jednorozměrné pole s nulovou dolní mez.

(Zděděno od Type)
IsTypeDefinition

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

IsTypeDefinition

Získá hodnotu, která označuje, zda typ je definice typu.

(Zděděno od Type)
IsUnicodeClass

Získá hodnotu označující, zda je atribut formátu UnicodeClass řetězce vybrán pro Type.

(Zděděno od Type)
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

Získá hodnotu označující, zda Type je typ hodnoty.

(Zděděno od Type)
IsValueType

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

(Zděděno od TypeInfo)
IsVariableBoundArray

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

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

Získá hodnotu označující, zda Type lze přistupovat kódem mimo sestavení.

(Zděděno od Type)
IsVisible

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

(Zděděno od TypeInfo)
MemberType

MemberTypes Získá hodnotu označující, že tento člen je typ nebo vnořený typ.

(Zděděno od Type)
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.

MetadataToken

Získá hodnotu, která identifikuje metadata element.

(Zděděno od MemberInfo)
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.

ReflectedType

Získá objekt třídy, který byl použit k získání této instance .MemberInfo

(Zděděno od MemberInfo)
Size

Načte celkovou velikost typu.

SizeCore

Při přepsání v odvozené třídě získá celkovou velikost typu.

StructLayoutAttribute

Získá, StructLayoutAttribute který popisuje rozložení aktuálního typu.

(Zděděno od Type)
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

Získá inicializátor pro typ.

(Zděděno od Type)
TypeInitializer

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

(Zděděno od TypeInfo)
TypeToken

Vrátí token typu tohoto typu.

UnderlyingSystemType

Vrátí základní typ systému pro tento TypeBuilderobjekt .

UnderlyingSystemType

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

(Zděděno od TypeInfo)

Metody

AddDeclarativeSecurity(SecurityAction, PermissionSet)

Přidá k tomuto typu deklarativní zabezpečení.

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

Vrací hodnotu, která určuje, zda je tato instance rovna zadanému objektu.

(Zděděno od MemberInfo)
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)

Vrátí pole Type objektů představující filtrovaný seznam rozhraní implementovaných nebo zděděných aktuálním Typeobjektem .

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

Vrátí filtrované pole MemberInfo objektů zadaného typu členu.

(Zděděno od Type)
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.

GetArrayRank()

Získá počet dimenzí v poli.

(Zděděno od Type)
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.

GetAttributeFlagsImpl()

Při přepsání v odvozené třídě implementuje Attributes vlastnost a získá bitovou kombinaci hodnot výčtu, která označuje atributy přidružené k Type.

(Zděděno od 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[])

Vyhledá konstruktor veřejné instance, jehož parametry odpovídají typům v zadaném poli.

(Zděděno od Type)
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í.

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 vazeb omezení a zadané konvence volání.

(Zděděno od Type)
GetConstructors()

Vrátí všechny veřejné konstruktory definované pro aktuální Type.

(Zděděno od Type)
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.

GetConstructors(BindingFlags)

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

(Zděděno od TypeInfo)
GetCustomAttributes(Boolean)

Vrátí všechny vlastní atributy definované pro tento typ.

GetCustomAttributes(Boolean)

Při přepsání v odvozené třídě vrátí pole všech vlastních atributů použitých pro tento člen.

(Zděděno od MemberInfo)
GetCustomAttributes(Type, Boolean)

Vrátí všechny vlastní atributy aktuálního typu, které lze přiřadit k zadanému typu.

GetCustomAttributes(Type, Boolean)

Při přepsání v odvozené třídě vrátí pole vlastních atributů použitých na tohoto člena a identifikovaných pomocí Type.

(Zděděno od MemberInfo)
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()

Vyhledá členy definované pro aktuální Type , jehož DefaultMemberAttribute hodnota je nastavena.

(Zděděno od Type)
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)

Vrátí název konstanty, která má zadanou hodnotu pro aktuální typ výčtu.

(Zděděno od Type)
GetEnumName(Object)

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

(Zděděno od TypeInfo)
GetEnumNames()

Vrátí názvy členů aktuálního typu výčtu.

(Zděděno od Type)
GetEnumNames()

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

(Zděděno od TypeInfo)
GetEnumUnderlyingType()

Vrátí podkladový typ aktuálního typu výčtu.

(Zděděno od Type)
GetEnumUnderlyingType()

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

(Zděděno od TypeInfo)
GetEnumValues()

Vrátí matici hodnot konstant v aktuálním typu výčtu.

(Zděděno od Type)
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)

EventInfo Vrátí objekt představující zadanou veřejnou událost.

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

GetEvent(String, BindingFlags)

Definuje a vytvoří 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()

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

(Zděděno od TypeInfo)
GetEvents(BindingFlags)

Vrátí veřejné a neveřejné události, které jsou deklarovány tímto typem.

GetEvents(BindingFlags)

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

(Zděděno od TypeInfo)
GetField(String)

Vyhledá veřejné pole se zadaným názvem.

(Zděděno od Type)
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(String, BindingFlags)

Definuje a vytvoří 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()

Vrátí všechna veřejná pole aktuálního Typepole .

(Zděděno od Type)
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.

GetFields(BindingFlags)

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

(Zděděno od TypeInfo)
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.

GetGenericArguments()

Vrátí pole Type objektů, které představují argumenty typu uzavřeného obecného typu nebo parametry typu definice obecného typu.

(Zděděno od Type)
GetGenericArguments()

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

(Zděděno od TypeInfo)
GetGenericParameterConstraints()

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

GetGenericParameterConstraints()

Vrátí pole Type objektů, které představují omezení aktuálního parametru obecného typu.

(Zděděno od Type)
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.

GetGenericTypeDefinition()

Type Vrátí objekt, který představuje definici obecného typu, ze které lze vytvořit aktuální obecný typ.

(Zděděno od Type)
GetHashCode()

Vrátí hodnotu hash pro tuto instanci.

(Zděděno od Type)
GetHashCode()

Vrátí hodnotu hash pro tuto instanci.

(Zděděno od MemberInfo)
GetInterface(String)

Vyhledá rozhraní se zadaným názvem.

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

GetInterface(String, Boolean)

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

(Zděděno od TypeInfo)
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ů.

GetInterfaces()

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

(Zděděno od TypeInfo)
GetMember(String)

Vyhledá veřejné členy se zadaným názvem.

(Zděděno od Type)
GetMember(String)

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

(Zděděno od TypeInfo)
GetMember(String, BindingFlags)

Vyhledá zadané členy pomocí zadaných omezení vazby.

(Zděděno od Type)
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.

GetMember(String, MemberTypes, BindingFlags)

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

(Zděděno od TypeInfo)
GetMembers()

Vrátí všechny veřejné členy aktuálního Type.

(Zděděno od Type)
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.

GetMembers(BindingFlags)

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

(Zděděno od TypeInfo)
GetMemberWithSameMetadataDefinitionAs(MemberInfo)

Vyhledá u MemberInfo aktuálního Type , který odpovídá zadané MemberInfohodnotě .

(Zděděno od Type)
GetMethod(String)

Vyhledá veřejnou metodu se zadaným názvem.

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

Vyhledá zadanou metodu pomocí zadaných omezení vazby.

(Zděděno od Type)
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[])

Vyhledá zadanou veřejnou metodu, jejíž parametry odpovídají zadaným typům argumentů.

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

Vyhledá zadanou veřejnou metodu, jejíž parametry odpovídají zadaným typům argumentů a modifikátorům.

(Zděděno od Type)
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, 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í.

(Zděděno od Type)
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()

Vrátí všechny veřejné metody aktuálního Typeobjektu .

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

GetMethods(BindingFlags)

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

(Zděděno od TypeInfo)
GetNestedType(String)

Vyhledá veřejný vnořený typ se zadaným názvem.

(Zděděno od Type)
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.

GetNestedType(String, BindingFlags)

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

(Zděděno od TypeInfo)
GetNestedTypes()

Vrátí veřejné typy vnořené do aktuálního Type.

(Zděděno od Type)
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.

GetNestedTypes(BindingFlags)

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

(Zděděno od TypeInfo)
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()

Vrátí všechny veřejné vlastnosti aktuálního Typeobjektu .

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

GetProperties(BindingFlags)

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

(Zděděno od TypeInfo)
GetProperty(String)

Vyhledá veřejnou vlastnost se zadaným názvem.

(Zděděno od Type)
GetProperty(String)

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

(Zděděno od TypeInfo)
GetProperty(String, BindingFlags)

Vyhledá zadanou vlastnost pomocí zadaných omezení vazby.

(Zděděno od Type)
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)

Vyhledá veřejnou vlastnost se zadaným názvem a návratovým typem.

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

Vyhledá zadanou veřejnou vlastnost, jejíž parametry odpovídají zadaným typům argumentů.

(Zděděno od Type)
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[])

Vyhledá zadanou veřejnou vlastnost, jejíž parametry odpovídají zadaným typům argumentů a modifikátorům.

(Zděděno od Type)
GetProperty(String, Type, Type[], ParameterModifier[])

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

(Zděděno od TypeInfo)
GetProperty(String, Type[])

Vyhledá zadanou veřejnou vlastnost, jejíž parametry odpovídají zadaným typům argumentů.

(Zděděno od Type)
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í.

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

(Zděděno od Type)
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)
GetType()

Zjistí atributy člena a poskytuje přístup k metadatům člena.

(Zděděno od MemberInfo)
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.

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 je proud Type pole, ukazatel, nebo je předán odkazem.

(Zděděno od Type)
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.

IsArrayImpl()

Při přepsání v odvozené třídě implementuje IsArray vlastnost a určuje, zda Type je pole.

(Zděděno od Type)
IsAssignableFrom(Type)

Získá hodnotu, která označuje, zda zadané Type lze přiřadit k tomuto objektu.

IsAssignableFrom(Type)

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

(Zděděno od TypeInfo)
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.

IsByRefImpl()

Při přepsání v odvozené třídě implementuje IsByRef vlastnost a určuje, zda Type je předán odkaz.

(Zděděno od Type)
IsCOMObjectImpl()

Při přepsání v odvozené třídě implementuje IsCOMObject vlastnost a určuje, zda Type je objekt com.

IsCOMObjectImpl()

Při přepsání v odvozené třídě implementuje IsCOMObject vlastnost a určuje, zda Type je objekt com.

(Zděděno od Type)
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.

IsDefined(Type, Boolean)

Při přepsání v odvozené třídě označuje, zda jeden nebo více atributů zadaného typu nebo jeho odvozených typů je použit na tohoto člena.

(Zděděno od MemberInfo)
IsEnumDefined(Object)

Vrátí hodnotu, která označuje, zda zadaná hodnota existuje v aktuálním typu výčtu.

(Zděděno od Type)
IsEnumDefined(Object)

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

(Zděděno od TypeInfo)
IsEquivalentTo(Type)

Určuje, zda dva typy modelu COM mají stejnou identitu a jsou způsobilé pro ekvivalenci typů.

(Zděděno od Type)
IsEquivalentTo(Type)

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

(Zděděno od TypeInfo)
IsInstanceOfType(Object)

Určuje, zda je zadaný objekt instancí aktuálního Typeobjektu .

(Zděděno od Type)
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.

IsPointerImpl()

Při přepsání v odvozené třídě implementuje IsPointer vlastnost a určuje, zda Type je ukazatel.

(Zděděno od Type)
IsPrimitiveImpl()

Při přepsání v odvozené třídě implementuje IsPrimitive vlastnost a určuje, zda Type je jeden z primitivních typů.

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

(Zděděno od Type)
IsSubclassOf(Type)

Určuje, zda je tento typ odvozen od zadaného typu.

IsSubclassOf(Type)

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

(Zděděno od TypeInfo)
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()

Type Vrátí objekt představující jednorozměrné pole aktuálního typu s dolní nulou.

(Zděděno od Type)
MakeArrayType(Int32)

Type Vrátí objekt, který představuje pole aktuálního typu se zadaným počtem dimenzí.

MakeArrayType(Int32)

Type Vrátí objekt představující pole aktuálního typu se zadaným počtem dimenzí.

(Zděděno od Type)
MakeByRefType()

Type Vrátí objekt, který představuje aktuální typ při předání jako ref parametr (ByRef v jazyce Visual Basic).

MakeByRefType()

Type Vrátí objekt, který představuje aktuální typ, pokud je ref předán jako parametr (ByRef parametr v jazyce Visual Basic).

(Zděděno od Type)
MakeGenericType(Type[])

Nahradí prvky pole typů parametry typu aktuální definice obecného typu a vrátí výsledný vytvořený typ.

MakeGenericType(Type[])

Nahradí prvky pole typů parametry typu aktuální definice obecného typu a vrátí Type objekt představující výsledný vytvořený typ.

(Zděděno od Type)
MakePointerType()

Type Vrátí objekt, který představuje typ nespravovaného ukazatele na aktuální typ.

MakePointerType()

Type Vrátí objekt, který představuje ukazatel na aktuální typ.

(Zděděno od Type)
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í

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

Mapuje sadu názvů na odpovídající sadu identifikátorů pro rozesílání.

(Zděděno od MemberInfo)
_MemberInfo.GetType()

Type Získá objekt představující MemberInfo třídu.

(Zděděno od MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Načte informace o typu objektu, který lze použít k získání informací o typu pro rozhraní.

(Zděděno od MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 1).

(Zděděno od MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Poskytuje přístup k vlastnostem a metodám vystaveným objektem.

(Zděděno od MemberInfo)
_Type.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mapuje sadu názvů na odpovídající sadu identifikátorů pro rozesílání.

(Zděděno od Type)
_Type.GetTypeInfo(UInt32, UInt32, IntPtr)

Načte informace o typu objektu, který lze použít k získání informací o typu pro rozhraní.

(Zděděno od Type)
_Type.GetTypeInfoCount(UInt32)

Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 1).

(Zděděno od Type)
_Type.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Poskytuje přístup k vlastnostem a metodám vystaveným objektem.

(Zděděno od Type)
_TypeBuilder.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mapuje sadu názvů na odpovídající sadu identifikátorů pro rozesílání.

_TypeBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)

Načte informace o typu objektu, který lze použít k získání informací o typu pro rozhraní.

_TypeBuilder.GetTypeInfoCount(UInt32)

Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 1).

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

Poskytuje přístup k vlastnostem a metodám vystaveným objektem.

ICustomAttributeProvider.GetCustomAttributes(Boolean)

Vrátí pole všech vlastních atributů definovaných v tomto členu, s výjimkou pojmenovaných atributů, nebo prázdné pole, pokud neexistují žádné vlastní atributy.

(Zděděno od MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)

Vrátí pole vlastních atributů definovaných na tomto členu, které jsou identifikovány typem, nebo prázdné pole, pokud neexistují žádné vlastní atributy tohoto typu.

(Zděděno od MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean)

Určuje, zda je u tohoto člena attributeType definována jedna nebo více instancí.

(Zděděno od MemberInfo)
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.

Platí pro

Viz také