TypeBuilder Clase

Definición

Espacio de nombres:

System.Reflection.Emit

Ensamblado:

System.Reflection.Emit.dll

Source:

TypeBuilder.cs

Define y crea nuevas instancias de clases en tiempo de ejecución.

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

public abstract class TypeBuilder : System.Reflection.TypeInfo

type TypeBuilder = class
    inherit TypeInfo

Public MustInherit Class TypeBuilder
Inherits TypeInfo

Herencia

Object

MemberInfo

Type

TypeInfo

TypeBuilder

Ejemplos

En el ejemplo de código siguiente se muestra cómo definir y usar un ensamblado dinámico. El ensamblado de ejemplo contiene un tipo, MyDynamicType, que tiene un campo privado, una propiedad que obtiene y establece el campo privado, constructores que inicializan el campo privado y un método que multiplica un número proporcionado por el usuario por el valor del campo privado y devuelve el resultado.

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

En el ejemplo de código siguiente se muestra cómo crear un tipo dinámicamente mediante 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

Comentarios

Para obtener más información sobre esta API, consulte Comentarios complementarios de api para TypeBuilder.

Constructores

TypeBuilder()

Inicializa una nueva instancia de la clase TypeBuilder.

Campos

UnspecifiedTypeSize

Representa que no se especifica el tamaño total del tipo.

Propiedades

Assembly	Recupera el ensamblado dinámico que contiene esta definición de tipo.
AssemblyQualifiedName	Devuelve el nombre completo del tipo calificado por el nombre para mostrar del ensamblado.
Attributes	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
BaseType	Recupera el tipo base de este tipo.
ContainsGenericParameters	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
CustomAttributes	Obtiene una colección que contiene los atributos personalizados de este miembro. (Heredado de MemberInfo)
DeclaredConstructors	Obtiene una colección de los constructores declarados por el tipo actual. (Heredado de TypeInfo)
DeclaredEvents	Obtiene una colección de los eventos definidos por el tipo actual. (Heredado de TypeInfo)
DeclaredFields	Obtiene una colección de los campos definidos por el tipo actual. (Heredado de TypeInfo)
DeclaredMembers	Obtiene una colección de los miembros definidos por el tipo actual. (Heredado de TypeInfo)
DeclaredMethods	Obtiene una colección de los métodos definidos por el tipo actual. (Heredado de TypeInfo)
DeclaredNestedTypes	Obtiene una colección de los tipos anidados definidos por el tipo actual. (Heredado de TypeInfo)
DeclaredProperties	Obtiene una colección de las propiedades definidas por el tipo actual. (Heredado de TypeInfo)
DeclaringMethod	Obtiene el método que declaró el parámetro de tipo genérico actual.
DeclaringType	Devuelve el tipo que declaró este tipo.
FullName	Recupera la ruta de acceso completa de este tipo.
GenericParameterAttributes	Obtiene un valor que indica la covarianza y las restricciones especiales del parámetro de tipo genérico actual.
GenericParameterPosition	Obtiene la posición de un parámetro de tipo en la lista de parámetros de tipo del tipo genérico que declaró el parámetro.
GenericTypeArguments	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GenericTypeParameters	Obtiene una matriz de los parámetros de tipo genérico de la instancia actual. (Heredado de TypeInfo)
GUID	Recupera el GUID de este tipo.
HasElementType	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
ImplementedInterfaces	Obtiene una colección de las interfaces implementadas por el tipo actual. (Heredado de TypeInfo)
IsAbstract	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsAnsiClass	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsArray	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsAutoClass	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsAutoLayout	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsByRef	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsByRefLike	Obtiene un valor que indica si el tipo es una estructura de tipo ByRef.
IsClass	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsCollectible	Obtiene un valor que indica si este objeto MemberInfo forma parte de un ensamblado contenido en un AssemblyLoadContext recopilable. (Heredado de MemberInfo)
IsCOMObject	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsConstructedGenericType	Obtiene un valor que indica si este objeto representa un tipo genérico construido.
IsContextful	Obtiene un valor que indica si Type puede estar hospedado en un contexto. (Heredado de Type)
IsEnum	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsExplicitLayout	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsFunctionPointer	Obtiene un valor que indica si el objeto actual Type es un puntero de función. (Heredado de Type)
IsGenericMethodParameter	Obtiene un valor que indica si el objeto Type actual representa un parámetro de tipo en la definición de un método genérico. (Heredado de Type)
IsGenericParameter	Obtiene un valor que indica si el tipo actual es un parámetro de tipo genérico.
IsGenericType	Obtiene un valor que indica si el tipo actual es genérico.
IsGenericTypeDefinition	Obtiene un valor que indica si el objeto TypeBuilder actual representa una definición de tipo genérico a partir de la cual se pueden construir otros tipos genéricos.
IsGenericTypeParameter	Obtiene un valor que indica si el objeto Type actual representa un parámetro de tipo en la definición de un tipo genérico. (Heredado de Type)
IsImport	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsInterface	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsLayoutSequential	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsMarshalByRef	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsNested	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsNestedAssembly	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsNestedFamANDAssem	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsNestedFamily	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsNestedFamORAssem	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsNestedPrivate	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsNestedPublic	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsNotPublic	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsPointer	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsPrimitive	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsPublic	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsSealed	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsSecurityCritical	Obtiene un valor que indica si el tipo actual es crítico para la seguridad o crítico para la seguridad y disponible desde código transparente y, por tanto, puede realizar operaciones críticas.
IsSecuritySafeCritical	Obtiene un valor que indica si el tipo actual es crítico para la seguridad y disponible desde código transparente; es decir, si puede realizar operaciones críticas y está disponible desde código transparente.
IsSecurityTransparent	Obtiene un valor que indica si el tipo actual es transparente y, por tanto, no puede realizar operaciones críticas.
IsSerializable	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsSignatureType	Obtiene un valor que indica si el tipo es una tipo de firma. (Heredado de Type)
IsSpecialName	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsSZArray	Define y crea nuevas instancias de clases en tiempo de ejecución.
IsTypeDefinition	Define y crea nuevas instancias de clases en tiempo de ejecución.
IsUnicodeClass	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsUnmanagedFunctionPointer	Obtiene un valor que indica si el objeto actual Type es un puntero de función no administrado. (Heredado de Type)
IsValueType	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsVariableBoundArray	Obtiene un valor que indica si el tipo es un tipo de matriz que puede representar una matriz multidimensional o una matriz con un límite inferior arbitrario. (Heredado de Type)
IsVisible	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
MemberType	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
MetadataToken	Obtiene un token que identifica el módulo dinámico actual en los metadatos.
Module	Recupera el módulo dinámico que contiene esta definición de tipo.
Name	Recupera el nombre de este tipo.
Namespace	Recupera el espacio de nombres donde se define este TypeBuilder.
PackingSize	Recupera el tamaño del empaquetado de este tipo.
PackingSizeCore	Cuando se reemplaza en una clase derivada, obtiene el tamaño de empaquetado de este tipo.
ReflectedType	Devuelve el tipo que se utilizó para obtener este tipo.
Size	Recupera el tamaño total de un tipo.
SizeCore	Cuando se reemplaza en una clase derivada, obtiene el tamaño total de un tipo.
StructLayoutAttribute	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
TypeHandle	No se admite en módulos dinámicos.
TypeInitializer	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
UnderlyingSystemType	Devuelve el tipo de sistema subyacente para esta TypeBuilder.

Métodos

AddInterfaceImplementation(Type)	Agrega una interfaz que implementa este tipo.
AddInterfaceImplementationCore(Type)	Cuando se reemplaza en una clase derivada, agrega una interfaz que este tipo implementa.
AsType()	Devuelve el tipo actual como un objeto Type. (Heredado de TypeInfo)
CreateType()	Crea un objeto Type para esta clase. Después de definir los campos y métodos en la clase, se llama a CreateType para cargar su objeto Type.
CreateTypeInfo()	Obtiene un objeto TypeInfo que representa este tipo.
CreateTypeInfoCore()	Cuando se reemplaza en una clase derivada, obtiene un TypeInfo objeto que representa este tipo.
DefineConstructor(MethodAttributes, CallingConventions, Type[])	Agrega un nuevo constructor al tipo, con los atributos y firma especificados.
DefineConstructor(MethodAttributes, CallingConventions, Type[], Type[][], Type[][])	Agrega un nuevo constructor al tipo, con los atributos, la firma y los modificadores personalizados especificados.
DefineConstructorCore(MethodAttributes, CallingConventions, Type[], Type[][], Type[][])	Cuando se reemplaza en una clase derivada, agrega un nuevo constructor al tipo , con los atributos, la firma y los modificadores personalizados especificados.
DefineDefaultConstructor(MethodAttributes)	Define el constructor sin parámetros. El constructor que se define aquí simplemente llamará al constructor sin parámetros del elemento primario.
DefineDefaultConstructorCore(MethodAttributes)	Cuando se reemplaza en una clase derivada, define el constructor sin parámetros. El constructor definido aquí llama al constructor sin parámetros del elemento primario.
DefineEvent(String, EventAttributes, Type)	Agrega un nuevo evento al tipo, con el nombre, los atributos y el tipo de evento especificados.
DefineEventCore(String, EventAttributes, Type)	Cuando se reemplaza en una clase derivada, agrega un nuevo evento al tipo , con el nombre, los atributos y el tipo de evento especificados.
DefineField(String, Type, FieldAttributes)	Agrega un nuevo campo al tipo, con el nombre, los atributos y el tipo de campo especificados.
DefineField(String, Type, Type[], Type[], FieldAttributes)	Agrega un nuevo campo al tipo, con el nombre, los atributos, el tipo de campo y os modificadores personalizados especificados.
DefineFieldCore(String, Type, Type[], Type[], FieldAttributes)	Cuando se reemplaza en una clase derivada, agrega un nuevo campo al tipo, con el nombre, los atributos, el tipo de campo y los modificadores personalizados especificados.
DefineGenericParameters(String[])	Define los parámetros de tipo genérico para el tipo actual, especificando su número y sus nombres y devuelve una matriz de GenericTypeParameterBuilder objetos que pueden usarse para establecer sus restricciones.
DefineGenericParametersCore(String[])	Cuando se invalida en una clase derivada, define los parámetros de tipo genérico para el tipo actual, especificando su número y sus nombres.
DefineInitializedData(String, Byte[], FieldAttributes)	Define el campo de datos inicializado en la sección .sdata del archivo ejecutable portable (PE).
DefineInitializedDataCore(String, Byte[], FieldAttributes)	Cuando se reemplaza en una clase derivada, define el campo de datos inicializado en la sección .sdata del archivo ejecutable portátil (PE).
DefineMethod(String, MethodAttributes)	Agrega un nuevo método al tipo, con el nombre especificado y los atributos de método.
DefineMethod(String, MethodAttributes, CallingConventions)	Agrega un nuevo método al tipo, con el nombre especificado, los atributos de método y la convención de llamada.
DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[])	Agrega un nuevo método al tipo, con el nombre especificado, los atributos de método, la convención de llamada y la firma del método.
DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Agrega un nuevo método al tipo, con el nombre especificado, los atributos de método, la convención de llamada, la firma del método y los modificadores personalizados.
DefineMethod(String, MethodAttributes, Type, Type[])	Agrega un nuevo método al tipo, con el nombre especificado, los atributos de método y la firma del método.
DefineMethodCore(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Cuando se reemplaza en una clase derivada, agrega un nuevo método al tipo, con el nombre, los atributos de método, la convención de llamada, la firma de método y los modificadores personalizados especificados.
DefineMethodOverride(MethodInfo, MethodInfo)	Especifica un cuerpo de método determinado que implementa una declaración de método concreta, posiblemente con otro nombre.
DefineMethodOverrideCore(MethodInfo, MethodInfo)	Cuando se reemplaza en una clase derivada, especifica un cuerpo de método determinado que implementa una declaración de método determinada, potencialmente con un nombre diferente.
DefineNestedType(String)	Define un tipo anidado, dado su nombre.
DefineNestedType(String, TypeAttributes)	Define un tipo anidado, dado su nombre y atributos.
DefineNestedType(String, TypeAttributes, Type)	Define un tipo anidado, dado su nombre, sus atributos y el tipo que extiende.
DefineNestedType(String, TypeAttributes, Type, Int32)	Define un tipo anidado, dados su nombre, sus atributos, el tamaño total del tipo y el tipo que extiende.
DefineNestedType(String, TypeAttributes, Type, PackingSize)	Define un tipo anidado, dado su nombre, sus atributos, el tipo que extiende y el tamaño de empaquetado.
DefineNestedType(String, TypeAttributes, Type, PackingSize, Int32)	Define un tipo anidado, dado su nombre, atributos, tamaño y el tipo que extiende.
DefineNestedType(String, TypeAttributes, Type, Type[])	Define un tipo anidado, dados su nombre, sus atributos, el tipo que extiende y las interfaces que implementa.
DefineNestedTypeCore(String, TypeAttributes, Type, Type[], PackingSize, Int32)	Cuando se reemplaza en una clase derivada, define un tipo anidado, dado su nombre, atributos, tamaño y el tipo que extiende.
DefinePInvokeMethod(String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Define un método PInvoke dado su nombre, el nombre de la DLL en la que se define el método, los atributos del método, la convención de llamada del método, el tipo devuelto del método, los tipos de parámetros del método y las marcas PInvoke.
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Define un método PInvoke dado su nombre, el nombre de la DLL en la que se define el método, el nombre del punto de entrada, los atributos del método, la convención de llamada del método, el tipo devuelto del método, los tipos de parámetros del método y las marcas PInvoke.
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][], CallingConvention, CharSet)	Define un método PInvoke dado su nombre, el nombre de la DLL en la que se define el método, el nombre del punto de entrada, los atributos del método, la convención de llamada del método, el tipo devuelto del método, los tipos de parámetros del método, las marcas PInvoke y los modificadores personalizados para los parámetros y el tipo de valor devuelto.
DefinePInvokeMethodCore(String, String, String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][], CallingConvention, CharSet)	Cuando se reemplaza en una clase derivada, define un método PInvoke con el nombre proporcionado, el nombre dll, el nombre del punto de entrada, los atributos, la convención de llamada, el tipo de valor devuelto, los tipos de parámetros, las marcas PInvoke y los modificadores personalizados para los parámetros y el tipo de valor devuelto.
DefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[])	Agrega una nueva propiedad al tipo, con el nombre, atributos, convención de llamada y firma de la propiedad especificados.
DefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Agrega una nueva propiedad al tipo, con el nombre proporcionado, la convención de llamada, la firma de la propiedad y los modificadores personalizados.
DefineProperty(String, PropertyAttributes, Type, Type[])	Agrega una nueva propiedad al tipo, con el nombre proporcionado y la firma de la propiedad.
DefineProperty(String, PropertyAttributes, Type, Type[], Type[], Type[], Type[][], Type[][])	Agrega una nueva propiedad al tipo, con el nombre proporcionado, la firma de la propiedad y los modificadores especificados.
DefinePropertyCore(String, PropertyAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Cuando se invalida en una clase derivada, agrega una nueva propiedad al tipo, con el nombre especificado, la convención de llamada, la firma de propiedad y los modificadores personalizados.
DefineTypeInitializer()	Define el inicializador para este tipo.
DefineTypeInitializerCore()	Cuando se invalida en una clase derivada, define el inicializador para este tipo.
DefineUninitializedData(String, Int32, FieldAttributes)	Define un campo de datos inicializado en la sección .sdata del archivo portable ejecutable (PE).
DefineUninitializedDataCore(String, Int32, FieldAttributes)	Cuando se reemplaza en una clase derivada, define un campo de datos no inicializado en la .sdata sección del archivo ejecutable portátil (PE).
Equals(Object)	Determina si el tipo del sistema subyacente del objeto Type actual es el mismo que el tipo del sistema subyacente del objeto Object especificado. (Heredado de Type)
Equals(Type)	Determina si el tipo de sistema subyacente del objeto Type actual es igual que el tipo de sistema subyacente del objeto Type especificado. (Heredado de Type)
FindInterfaces(TypeFilter, Object)	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetArrayRank()	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetAttributeFlagsImpl()	Cuando se invalida en una clase derivada, implementa la propiedad Attributes y obtiene una combinación bit a bit de valores de enumeración que indican los atributos asociados a Type.
GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Busca un constructor cuyos parámetros coincidan con los modificadores y tipos de argumento especificados, mediante las restricciones de enlace indicadas y la convención de llamadas también especificada. (Heredado de Type)
GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])	Busca un constructor cuyos parámetros coincidan con los tipos y modificadores de argumento especificados, mediante las restricciones de enlace también especificadas. (Heredado de Type)
GetConstructor(BindingFlags, Type[])	Busca un constructor cuyos parámetros coincidan con los tipos de argumento especificados, utilizando las restricciones de enlace especificadas. (Heredado de Type)
GetConstructor(Type, ConstructorInfo)	Devuelve el constructor del tipo genérico construido especificado que corresponde al constructor especificado de la definición de tipo genérico.
GetConstructor(Type[])	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Cuando se invalida en una clase derivada, busca un constructor cuyos parámetros coincidan con los tipos y modificadores de argumento especificados, y aplica las restricciones de enlace especificadas y la convención de llamadas especificada.
GetConstructors()	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetConstructors(BindingFlags)	Devuelve una matriz de ConstructorInfo objetos que representan los constructores públicos y no públicos definidos para esta clase, tal como se especifica.
GetCustomAttributes(Boolean)	Devuelve todos los atributos personalizados definidos para este tipo.
GetCustomAttributes(Type, Boolean)	Devuelve todos los atributos personalizados del tipo actual que se pueden asignar a un tipo especificado.
GetCustomAttributesData()	Devuelve una lista de objetos CustomAttributeData que representan datos sobre los atributos que se aplicaron al miembro de destino. (Heredado de MemberInfo)
GetDeclaredEvent(String)	Devuelve un objeto que representa el evento especificado declarado por el tipo actual. (Heredado de TypeInfo)
GetDeclaredField(String)	Devuelve un objeto que representa el campo especificado declarado por el tipo actual. (Heredado de TypeInfo)
GetDeclaredMethod(String)	Devuelve un objeto que representa el método especificado declarado por el tipo actual. (Heredado de TypeInfo)
GetDeclaredMethods(String)	Devuelve una colección que contiene todos los métodos declarados en el tipo actual que coinciden con el nombre especificado. (Heredado de TypeInfo)
GetDeclaredNestedType(String)	Devuelve un objeto que representa el tipo anidado especificado declarado por el tipo actual. (Heredado de TypeInfo)
GetDeclaredProperty(String)	Devuelve un objeto que representa la propiedad especificada declarada por el tipo actual. (Heredado de TypeInfo)
GetDefaultMembers()	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetElementType()	Cuando se llama a este método, siempre se produce NotSupportedException.
GetEnumName(Object)	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetEnumNames()	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetEnumUnderlyingType()	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetEnumValues()	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetEnumValuesAsUnderlyingType()	Recupera una matriz de los valores de las constantes de tipo subyacentes de este tipo de enumeración. (Heredado de Type)
GetEvent(String)	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetEvent(String, BindingFlags)	Devuelve el evento con el nombre especificado.
GetEvents()	Devuelve los eventos públicos declarados o heredados por este tipo.
GetEvents(BindingFlags)	Devuelve los eventos públicos y no públicos declarados por este tipo.
GetField(String)	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetField(String, BindingFlags)	Devuelve el campo especificado por el nombre facilitado.
GetField(Type, FieldInfo)	Devuelve el campo del tipo genérico construido especificado que corresponde al campo especificado de la definición de tipo genérico.
GetFields()	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetFields(BindingFlags)	Devuelve los campos públicos y no públicos declarados por este tipo.
GetFunctionPointerCallingConventions()	Cuando se reemplaza en una clase derivada, devuelve las convenciones de llamada del puntero Typede función actual . (Heredado de Type)
GetFunctionPointerParameterTypes()	Cuando se reemplaza en una clase derivada, devuelve los tipos de parámetro del puntero Typede función actual . (Heredado de Type)
GetFunctionPointerReturnType()	Cuando se reemplaza en una clase derivada, devuelve el tipo de valor devuelto del puntero Typede función actual. (Heredado de Type)
GetGenericArguments()	Devuelve una matriz de objetos Type que representan los argumentos de tipo de un tipo genérico o los parámetros de tipo de una definición de tipo genérico.
GetGenericParameterConstraints()	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetGenericTypeDefinition()	Devuelve un objeto Type que representa una definición de tipo genérico a partir de la cual se puede obtener el tipo actual.
GetHashCode()	Devuelve el código hash de esta instancia. (Heredado de Type)
GetInterface(String)	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetInterface(String, Boolean)	Devuelve la interfaz implementada por esta clase (directa o indirectamente) con el nombre completo que coincide con el nombre de la interfaz dada.
GetInterfaceMap(Type)	Devuelve una asignación de interfaz para la interfaz solicitada.
GetInterfaces()	Devuelve una matriz de todas las interfaces implementadas en este tipo y sus tipos base.
GetMember(String)	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetMember(String, BindingFlags)	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetMember(String, MemberTypes, BindingFlags)	Devuelve todos los miembros públicos y no públicos declarados o heredados por este tipo, tal como se especifica.
GetMembers()	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetMembers(BindingFlags)	Devuelve los miembros para los miembros públicos y no públicos declarados o heredados por este tipo.
GetMemberWithSameMetadataDefinitionAs(MemberInfo)	Busca en MemberInfo el objeto actual Type que coincida con el especificado MemberInfo. (Heredado de Type)
GetMethod(String)	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetMethod(String, BindingFlags)	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Busca el método especificado cuyos parámetros coincidan con los tipos y modificadores de argumentos especificados, usando las restricciones de enlace indicadas y la convención de llamada especificada. (Heredado de Type)
GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])	Busca el método especificado cuyos parámetros coincidan con los tipos y modificadores de argumentos especificados, mediante las restricciones de enlace indicadas. (Heredado de Type)
GetMethod(String, BindingFlags, Type[])	Busca el método especificado cuyos parámetros coinciden con los tipos de argumento especificados, utilizando las restricciones de enlace especificadas. (Heredado de Type)
GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Busca el método especificado cuyos parámetros coincidan con el número de parámetros genéricos, los tipos de argumento y los modificadores especificados, mediante las restricciones de enlace y la convención de llamada especificadas. (Heredado de Type)
GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[])	Busca el método especificado cuyos parámetros coincidan con el número de parámetros genéricos, los tipos de argumento y los modificadores especificados, mediante las restricciones de enlace especificadas. (Heredado de Type)
GetMethod(String, Int32, BindingFlags, Type[])	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de Type)
GetMethod(String, Int32, Type[])	Busca el método público especificado cuyos parámetros coincidan con el número de parámetros genéricos y los tipos de argumento especificados. (Heredado de Type)
GetMethod(String, Int32, Type[], ParameterModifier[])	Busca el método público especificado cuyos parámetros coincidan con el número de parámetros genéricos, los tipos de argumento y los modificadores especificados. (Heredado de Type)
GetMethod(String, Type[])	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetMethod(String, Type[], ParameterModifier[])	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetMethod(Type, MethodInfo)	Devuelve el método del tipo genérico construido especificado que corresponde al método especificado de la definición de tipo genérico.
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Cuando se invalida en una clase derivada, busca el método especificado cuyos parámetros coincidan con los tipos y modificadores de argumentos especificados y aplica las restricciones de enlace especificadas y la convención de llamada especificada.
GetMethodImpl(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Cuando se invalida en una clase derivada, busca el método especificado cuyos parámetros coincidan con el número de parámetros genéricos, tipos de argumento y modificadores especificados, mediante las restricciones de enlace y la convención de llamada especificadas. (Heredado de Type)
GetMethods()	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetMethods(BindingFlags)	Devuelve todos los métodos públicos y no públicos declarados o heredados por este tipo, tal como se especifica.
GetNestedType(String)	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetNestedType(String, BindingFlags)	Devuelve los tipos anidados públicos y no públicos declarados por este tipo.
GetNestedTypes()	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetNestedTypes(BindingFlags)	Devuelve los tipos anidados públicos y no públicos declarados o heredados por este tipo.
GetOptionalCustomModifiers()	Cuando se reemplaza en una clase derivada, devuelve los modificadores personalizados opcionales del objeto actual Type. (Heredado de Type)
GetProperties()	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetProperties(BindingFlags)	Devuelve todas las propiedades públicas y no públicas declaradas o heredadas por este tipo, como se especifica.
GetProperty(String)	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetProperty(String, BindingFlags)	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Busca la propiedad especificada cuyos parámetros coincidan con los tipos y modificadores de argumentos especificados, mediante las restricciones de enlace indicadas. (Heredado de Type)
GetProperty(String, Type)	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetProperty(String, Type, Type[])	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetProperty(String, Type, Type[], ParameterModifier[])	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetProperty(String, Type[])	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Cuando se invalida en una clase derivada, busca la propiedad especificada cuyos parámetros coincidan con los tipos y modificadores de argumentos especificados, usando las restricciones de enlace especificadas.
GetRequiredCustomModifiers()	Cuando se reemplaza en una clase derivada, devuelve los modificadores personalizados necesarios del objeto actual Type. (Heredado de Type)
GetType()	Obtiene la estructura Type actual. (Heredado de Type)
GetTypeCodeImpl()	Devuelve el código de tipo subyacente de esta instancia de Type. (Heredado de Type)
HasElementTypeImpl()	Cuando se invalida en una clase derivada, implementa la propiedad HasElementType y determina si el objeto Type actual engloba a otro tipo o hace referencia a él; es decir, si el objeto Type actual es una matriz o un puntero, o se pasa por referencia.
HasSameMetadataDefinitionAs(MemberInfo)	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de MemberInfo)
InvokeMember(String, BindingFlags, Binder, Object, Object[])	Invoca al miembro especificado, aplica las restricciones de enlace igualmente especificadas y compara la lista de argumentos indicada. (Heredado de Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)	Invoca al miembro especificado, aplica las restricciones de enlace especificadas y compara la lista de argumentos y la referencia cultural igualmente especificadas. (Heredado de Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])	Invoca el miembro especificado. El método que se va a invocar debe ser accesible y proporcionar la coincidencia más específica con la lista de argumentos dada, bajo las restricciones del enlazador y los atributos de invocación indicados.
IsArrayImpl()	Cuando se invalida en una clase derivada, implementa la propiedad IsArray y determina si Type es una matriz.
IsAssignableFrom(Type)	Obtiene un valor que indica si se puede asignar a este objeto un Type especificado a este objeto.
IsAssignableFrom(TypeInfo)	Obtiene un valor que indica si se puede asignar a este objeto un objeto TypeInfo especificado.
IsAssignableTo(Type)	Determina si el tipo actual se puede asignar a una variable del targetType especificado. (Heredado de Type)
IsByRefImpl()	Cuando se invalida en una clase derivada, implementa la propiedad IsByRef y determina si Type se pasa por referencia.
IsCOMObjectImpl()	Cuando se invalida en una clase derivada, implementa la propiedad IsCOMObject y determina si Type es un objeto COM.
IsContextfulImpl()	Implementa la propiedad IsContextful y determina si la clase Type puede hospedarse en un contexto. (Heredado de Type)
IsCreated()	Devuelve un valor que indica si se ha creado el tipo dinámico actual.
IsCreatedCore()	Cuando se invalida en una clase derivada, devuelve un valor que indica si se ha creado el tipo dinámico actual.
IsDefined(Type, Boolean)	Determina si un atributo personalizado se aplica al tipo actual.
IsEnumDefined(Object)	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsEquivalentTo(Type)	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsInstanceOfType(Object)	Define y crea nuevas instancias de clases en tiempo de ejecución. (Heredado de TypeInfo)
IsMarshalByRefImpl()	Implementa la propiedad IsMarshalByRef y determina si las referencias de Type se calculan por referencia. (Heredado de Type)
IsPointerImpl()	Cuando se invalida en una clase derivada, implementa la propiedad IsPointer y determina si Type es un puntero.
IsPrimitiveImpl()	Cuando se invalida en una clase derivada, implementa la propiedad IsPrimitive y determina si Type es uno de los tipos primitivos.
IsSubclassOf(Type)	Determina si este tipo se deriva de un tipo especificado.
IsValueTypeImpl()	Implementa la propiedad IsValueType y determina si Type es un tipo de valor; es decir, no es una clase ni una interfaz. (Heredado de Type)
MakeArrayType()	Devuelve un objeto Type que representa una matriz unidimensional del tipo actual, con un límite inferior de cero.
MakeArrayType(Int32)	Devuelve un objeto Type que representa una matriz del tipo actual, con el número de dimensiones especificado.
MakeByRefType()	Devuelve un objeto Type que representa el tipo actual cuando se pasa como un parámetro ref (ByRef en Visual Basic).
MakeGenericType(Type[])	Sustituye los elementos de una matriz de tipos por los parámetros de tipo de la definición de tipo genérico actual y devuelve el tipo construido resultante.
MakePointerType()	Devuelve un objeto Type que representa el tipo de puntero no administrado para el tipo actual.
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
SetCustomAttribute(ConstructorInfo, Byte[])	Establece un atributo personalizado mediante un blob de atributo personalizado especificado.
SetCustomAttribute(CustomAttributeBuilder)	Establece un atributo personalizado mediante un generador de atributos personalizado.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Cuando se reemplaza en una clase derivada, establece un atributo personalizado en este ensamblado.
SetParent(Type)	Establece el tipo base del tipo actualmente en construcción.
SetParentCore(Type)	Cuando se invalida en una clase derivada, establece el tipo base del tipo actualmente en construcción.
ToString()	Devuelve el nombre del tipo, excluido el espacio de nombres.

Implementaciones de interfaz explícitas

IReflectableType.GetTypeInfo()

Devuelve una representación del tipo actual en forma de objeto TypeInfo. (Heredado de TypeInfo)

Métodos de extensión

GetCustomAttribute(MemberInfo, Type)	Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro concreto.
GetCustomAttribute(MemberInfo, Type, Boolean)	Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro concreto y, opcionalmente, inspecciona los antecesores de dicho miembro.
GetCustomAttribute<T>(MemberInfo)	Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro concreto.
GetCustomAttribute<T>(MemberInfo, Boolean)	Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro concreto y, opcionalmente, inspecciona los antecesores de dicho miembro.
GetCustomAttributes(MemberInfo)	Recupera una colección de atributos personalizados que se aplican a un miembro especificado.
GetCustomAttributes(MemberInfo, Boolean)	Recupera una colección de atributos personalizados que se aplican a un miembro concreto y, opcionalmente, inspecciona los antecesores de dicho miembro.
GetCustomAttributes(MemberInfo, Type)	Recupera una colección de atributos personalizados de un tipo especificado que se aplican a un miembro concreto.
GetCustomAttributes(MemberInfo, Type, Boolean)	Recupera una colección de atributos personalizados de un tipo especificado que se aplican a un miembro concreto y, opcionalmente, inspecciona los antecesores de dicho miembro.
GetCustomAttributes<T>(MemberInfo)	Recupera una colección de atributos personalizados de un tipo especificado que se aplican a un miembro concreto.
GetCustomAttributes<T>(MemberInfo, Boolean)	Recupera una colección de atributos personalizados de un tipo especificado que se aplican a un miembro concreto y, opcionalmente, inspecciona los antecesores de dicho miembro.
IsDefined(MemberInfo, Type)	Indica si se deben aplicar atributos personalizados de un tipo especificado a un miembro especificado.
IsDefined(MemberInfo, Type, Boolean)	Indica si los atributos personalizados de un tipo especificado se aplican a un miembro especificado y, opcionalmente, se aplican a sus antecesores.
GetTypeInfo(Type)	Devuelve la representación de TypeInfo del tipo especificado.
GetMetadataToken(MemberInfo)	Obtiene un token de metadatos del miembro determinado, si está disponible.
HasMetadataToken(MemberInfo)	Devuelve un valor que indica si un token de metadatos está disponible para el miembro especificado.
GetRuntimeEvent(Type, String)	Recupera un objeto que representa el evento especificado.
GetRuntimeEvents(Type)	Recupera una colección que representa todos los eventos definidos en un tipo especificado.
GetRuntimeField(Type, String)	Recupera un objeto que representa un campo especificado.
GetRuntimeFields(Type)	Recupera una colección que representa todos los campos definidos en un tipo especificado.
GetRuntimeInterfaceMap(TypeInfo, Type)	Devuelve una asignación de interfaz para el tipo de interfaz y la interfaz especificada.
GetRuntimeMethod(Type, String, Type[])	Recupera un objeto que representa un método especificado.
GetRuntimeMethods(Type)	Recupera una colección que representa todos los métodos definidos en un tipo especificado.
GetRuntimeProperties(Type)	Recupera una colección que representa todas las propiedades definidas en un tipo especificado.
GetRuntimeProperty(Type, String)	Recupera un objeto que representa una propiedad especificada.
GetConstructor(Type, Type[])	Define y crea nuevas instancias de clases en tiempo de ejecución.
GetConstructors(Type)	Define y crea nuevas instancias de clases en tiempo de ejecución.
GetConstructors(Type, BindingFlags)	Define y crea nuevas instancias de clases en tiempo de ejecución.
GetFields(Type, BindingFlags)	Define y crea nuevas instancias de clases en tiempo de ejecución.
GetGenericArguments(Type)	Define y crea nuevas instancias de clases en tiempo de ejecución.
GetInterfaces(Type)	Define y crea nuevas instancias de clases en tiempo de ejecución.
GetMember(Type, String)	Define y crea nuevas instancias de clases en tiempo de ejecución.
GetMember(Type, String, BindingFlags)	Define y crea nuevas instancias de clases en tiempo de ejecución.
GetMembers(Type)	Define y crea nuevas instancias de clases en tiempo de ejecución.
GetMethods(Type)	Define y crea nuevas instancias de clases en tiempo de ejecución.
GetNestedType(Type, String, BindingFlags)	Define y crea nuevas instancias de clases en tiempo de ejecución.
GetProperties(Type)	Define y crea nuevas instancias de clases en tiempo de ejecución.
GetProperties(Type, BindingFlags)	Define y crea nuevas instancias de clases en tiempo de ejecución.
GetProperty(Type, String, BindingFlags)	Define y crea nuevas instancias de clases en tiempo de ejecución.
GetProperty(Type, String, Type)	Define y crea nuevas instancias de clases en tiempo de ejecución.
GetProperty(Type, String, Type, Type[])	Define y crea nuevas instancias de clases en tiempo de ejecución.
IsAssignableFrom(Type, Type)	Define y crea nuevas instancias de clases en tiempo de ejecución.
IsInstanceOfType(Type, Object)	Define y crea nuevas instancias de clases en tiempo de ejecución.

Consulte también

• Cómo: Definir un tipo genérico con emisión de reflexión