TypeBuilder Classe

Definizione

Definisce e crea nuove istanze delle classi in fase di esecuzione.

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
Ereditarietà
TypeBuilder
Ereditarietà
TypeBuilder
Ereditarietà
Attributi
Implementazioni

Esempio

Nell'esempio di codice seguente viene illustrato come definire e usare un assembly dinamico. L'assembly di esempio contiene un tipo, MyDynamicType, che ha un campo privato, una proprietà che ottiene e imposta il campo privato, i costruttori che inizializzano il campo privato e un metodo che moltiplica un numero fornito dall'utente in base al valore del campo privato e restituisce il risultato.

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

Nell'esempio di codice seguente viene illustrato come compilare un tipo in modo dinamico usando 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

Commenti

Per altre informazioni su questa API, vedere Osservazioni api supplementari per TypeBuilder.

Costruttori

TypeBuilder()

Inizializza una nuova istanza della classe TypeBuilder.

Campi

UnspecifiedTypeSize

Indica che le dimensioni totali per il tipo non sono specificate.

Proprietà

Assembly

Recupera l'assembly dinamico che contiene la definizione di tipo.

AssemblyQualifiedName

Restituisce il nome completo di questo tipo qualificato dal nome visualizzato dell'assembly.

Attributes

Definisce e crea nuove istanze delle classi in fase di esecuzione.

Attributes

Ottiene gli attributi associati all'oggetto Type.

(Ereditato da Type)
Attributes

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
BaseType

Recupera il tipo di base del tipo.

ContainsGenericParameters

Definisce e crea nuove istanze delle classi in fase di esecuzione.

ContainsGenericParameters

Ottiene un valore che indica se l'oggetto Type dispone di parametri di tipo che non sono stati sostituiti da tipi specifici.

(Ereditato da Type)
ContainsGenericParameters

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
CustomAttributes

Ottiene una raccolta che contiene gli attributi personalizzati del membro.

(Ereditato da MemberInfo)
DeclaredConstructors

Ottiene una raccolta di costruttori dichiarati dal tipo corrente.

(Ereditato da TypeInfo)
DeclaredEvents

Ottiene una raccolta di eventi definiti dal tipo corrente.

(Ereditato da TypeInfo)
DeclaredFields

Ottiene una raccolta di campi definiti dal tipo corrente.

(Ereditato da TypeInfo)
DeclaredMembers

Ottiene una raccolta di membri definiti dal tipo corrente.

(Ereditato da TypeInfo)
DeclaredMethods

Ottiene una raccolta di metodi definiti dal tipo corrente.

(Ereditato da TypeInfo)
DeclaredNestedTypes

Ottiene una raccolta di tipi annidati definiti dal tipo corrente.

(Ereditato da TypeInfo)
DeclaredProperties

Ottiene una raccolta di proprietà definite dal tipo corrente.

(Ereditato da TypeInfo)
DeclaringMethod

Ottiene il metodo che ha dichiarato il parametro di tipo generico corrente.

DeclaringMethod

Ottiene una classe MethodBase che rappresenta il metodo dichiarante se la classe Type corrente rappresenta un parametro di tipo di un metodo generico.

(Ereditato da Type)
DeclaringType

Restituisce il tipo con cui è stato dichiarato questo tipo.

FullName

Recupera il percorso completo di questo tipo.

GenericParameterAttributes

Ottiene un valore che indica la covarianza e i vincoli speciali del parametro di tipo generico corrente.

GenericParameterAttributes

Ottiene una combinazione di flag GenericParameterAttributes che descrivono la covariante e i vincoli speciali del parametro di tipo generico corrente.

(Ereditato da Type)
GenericParameterPosition

Ottiene la posizione di un parametro di tipo nell'elenco dei parametri di tipo del tipo generico che ha dichiarato il parametro.

GenericParameterPosition

Ottiene la posizione del parametro di tipo nell'elenco di parametri di tipo del tipo o del metodo generico che ha dichiarato il parametro, quando l'oggetto Type rappresenta un parametro di tipo di un tipo o un metodo generico.

(Ereditato da Type)
GenericTypeArguments

Definisce e crea nuove istanze delle classi in fase di esecuzione.

GenericTypeArguments

Ottiene una matrice di argomenti di tipo generico per questo tipo.

(Ereditato da Type)
GenericTypeArguments

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GenericTypeParameters

Ottiene una matrice dei parametri generici dell'istanza corrente.

(Ereditato da TypeInfo)
GUID

Recupera il GUID di questo tipo.

HasElementType

Ottiene un valore che indica se l'oggetto Type corrente comprende o si riferisce a un altro tipo, ovvero se l'oggetto Type corrente è una matrice, un puntatore o viene passato per riferimento.

(Ereditato da Type)
HasElementType

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
ImplementedInterfaces

Ottiene una raccolta delle interfacce implementate dal tipo corrente.

(Ereditato da TypeInfo)
IsAbstract

Ottiene un valore che indica se Type è astratto e se deve essere sottoposto a override.

(Ereditato da Type)
IsAbstract

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsAnsiClass

Ottiene un valore che indica se l'attributo di formato della stringa AnsiClass è selezionato per Type.

(Ereditato da Type)
IsAnsiClass

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsArray

Ottiene un valore che indica se il tipo è una matrice.

(Ereditato da Type)
IsArray

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsAutoClass

Ottiene un valore che indica se l'attributo di formato della stringa AutoClass è selezionato per Type.

(Ereditato da Type)
IsAutoClass

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsAutoLayout

Ottiene un valore che indica se i campi del tipo corrente sono disposti automaticamente dal Common Language Runtime.

(Ereditato da Type)
IsAutoLayout

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsByRef

Ottiene un valore che indica se l'oggetto Type viene passato per riferimento.

(Ereditato da Type)
IsByRef

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsByRefLike

Ottiene un valore che indica se il tipo è una struttura simile a byref.

IsByRefLike

Ottiene un valore che indica se il tipo è una struttura simile a byref.

(Ereditato da Type)
IsClass

Ottiene un valore che indica se Type è una classe o un delegato, ovvero se non è un tipo di valore o un'interfaccia.

(Ereditato da Type)
IsClass

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsCollectible

Ottiene un valore che indica se questo oggetto MemberInfo fa parte di un assembly conservato in un AssemblyLoadContext ritirabile.

(Ereditato da MemberInfo)
IsCOMObject

Ottiene un valore che indica se Type è un oggetto COM.

(Ereditato da Type)
IsCOMObject

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsConstructedGenericType

Ottiene un valore che indica se l'oggetto rappresenta un tipo generico costruito.

IsConstructedGenericType

Ottiene un valore che indica se l'oggetto rappresenta un tipo generico costruito. È possibile creare istanze di un tipo generico costruito.

(Ereditato da Type)
IsContextful

Ottiene un valore che indica se è possibile includere Type in un contesto.

(Ereditato da Type)
IsEnum

Definisce e crea nuove istanze delle classi in fase di esecuzione.

IsEnum

Ottiene un valore che indica se l'oggetto Type è un'enumerazione.

(Ereditato da Type)
IsEnum

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsExplicitLayout

Ottiene un valore che indica se i campi del tipo corrente sono disposti a offset specificati in modo esplicito.

(Ereditato da Type)
IsExplicitLayout

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsFunctionPointer

Ottiene un valore che indica se l'oggetto corrente Type è un puntatore di funzione.

(Ereditato da Type)
IsGenericMethodParameter

Ottiene un valore che indica se l'oggetto Type corrente rappresenta un parametro di tipo nella definizione di un metodo generico.

(Ereditato da Type)
IsGenericParameter

Ottiene un valore che indica se il tipo corrente è un parametro di tipo generico.

IsGenericParameter

Ottiene un valore che indica se l'oggetto Type corrente rappresenta un parametro di tipo nella definizione di un tipo o metodo generico.

(Ereditato da Type)
IsGenericType

Ottiene un valore che indica se il tipo corrente è un tipo generico.

IsGenericType

Ottiene un valore che indica se il tipo corrente è un tipo generico.

(Ereditato da Type)
IsGenericTypeDefinition

Ottiene un valore che indica se la classe TypeBuilder corrente rappresenta una definizione di tipo generico, da cui è possibile costruire altri tipi generici.

IsGenericTypeDefinition

Ottiene un valore che indica se la classe Type corrente rappresenta una definizione di tipo generico, da cui è possibile costruire altri tipi generici.

(Ereditato da Type)
IsGenericTypeParameter

Ottiene un valore che indica se l'oggetto Type corrente rappresenta un parametro di tipo nella definizione di un tipo generico.

(Ereditato da Type)
IsImport

Ottiene un valore che indica se Type dispone di un attributo ComImportAttribute applicato, che ne indica l'importazione da una libreria di tipi COM.

(Ereditato da Type)
IsImport

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsInterface

Ottiene un valore che indica se Type è un'interfaccia, ovvero non è una classe né un tipo di valore.

(Ereditato da Type)
IsInterface

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsLayoutSequential

Ottiene un valore che indica se i campi del tipo corrente sono disposti in sequenza, nell'ordine in cui sono stati definiti o rilasciati ai metadati.

(Ereditato da Type)
IsLayoutSequential

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsMarshalByRef

Ottiene un valore che indica se l'oggetto Type viene sottoposto a marshalling per riferimento.

(Ereditato da Type)
IsMarshalByRef

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsNested

Ottiene un valore che indica se l'oggetto Type corrente rappresenta un tipo la cui definizione è annidata all'interno della definizione di un altro tipo.

(Ereditato da Type)
IsNested

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsNestedAssembly

Ottiene un valore che indica se Type è annidato e visibile soltanto all'interno dell'assembly.

(Ereditato da Type)
IsNestedAssembly

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsNestedFamANDAssem

Ottiene un valore che indica se Type è annidato e visibile soltanto alle classi della stessa famiglia e dello stesso assembly.

(Ereditato da Type)
IsNestedFamANDAssem

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsNestedFamily

Ottiene un valore che indica se Type è annidato e visibile solo all'interno della famiglia.

(Ereditato da Type)
IsNestedFamily

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsNestedFamORAssem

Ottiene un valore che indica se Type è annidato e visibile solo alle classi della stessa famiglia o dello stesso assembly.

(Ereditato da Type)
IsNestedFamORAssem

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsNestedPrivate

Ottiene un valore che indica se Type è annidato e dichiarato privato.

(Ereditato da Type)
IsNestedPrivate

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsNestedPublic

Ottiene un valore che indica se una classe è annidata e dichiarata pubblica.

(Ereditato da Type)
IsNestedPublic

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsNotPublic

Ottiene un valore che indica se l'oggetto Type non è dichiarato pubblico.

(Ereditato da Type)
IsNotPublic

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsPointer

Ottiene un valore che indica se Type è un puntatore.

(Ereditato da Type)
IsPointer

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsPrimitive

Ottiene un valore che indica se Type è uno dei tipi primitivi.

(Ereditato da Type)
IsPrimitive

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsPublic

Ottiene un valore che indica se l'oggetto Type è dichiarato pubblico.

(Ereditato da Type)
IsPublic

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsSealed

Ottiene un valore che indica se Type è dichiarato sealed.

(Ereditato da Type)
IsSealed

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsSecurityCritical

Ottiene un valore che indica se il tipo corrente è critico per la sicurezza o critico per la sicurezza e richiamabile da codice trasparente e può pertanto eseguire operazioni critiche.

IsSecurityCritical

Ottiene un valore che indica se il tipo corrente è SecurityCritical o SecuritySafeCritical al livello di attendibilità corrente e può pertanto eseguire operazioni critiche.

(Ereditato da Type)
IsSecuritySafeCritical

Ottiene un valore che indica se il tipo corrente è critico per la sicurezza, vale a dire se può eseguire operazioni critiche e se è possibile accedervi tramite codice trasparente.

IsSecuritySafeCritical

Ottiene un valore che indica se il tipo corrente è SecuritySafeCritical al livello di attendibilità corrente, vale a dire se può eseguire operazioni critiche e se è possibile accedervi tramite codice trasparente.

(Ereditato da Type)
IsSecurityTransparent

Ottiene un valore che indica se il tipo corrente è trasparente e pertanto non può eseguire operazioni critiche.

IsSecurityTransparent

Ottiene un valore che indica se il tipo corrente è trasparente al livello di attendibilità corrente e non può quindi eseguire operazioni critiche.

(Ereditato da Type)
IsSerializable

Definisce e crea nuove istanze delle classi in fase di esecuzione.

IsSerializable
Obsoleti.

Ottiene un valore che indica se l'oggetto Type è serializzabile binario.

(Ereditato da Type)
IsSerializable

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsSignatureType

Ottiene un valore che indica se il tipo è un tipo di firma.

(Ereditato da Type)
IsSpecialName

Ottiene un valore che indica se per il nome del tipo richiede una gestione speciale.

(Ereditato da Type)
IsSpecialName

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsSZArray

Definisce e crea nuove istanze delle classi in fase di esecuzione.

IsSZArray

Ottiene un valore che indica se il tipo è un tipo di matrice che può rappresentare solo una matrice unidimensionale con un limite inferiore pari a zero.

(Ereditato da Type)
IsTypeDefinition

Definisce e crea nuove istanze delle classi in fase di esecuzione.

IsTypeDefinition

Ottiene un valore che indica se il tipo è una definizione di tipo.

(Ereditato da Type)
IsUnicodeClass

Ottiene un valore che indica se l'attributo di formato della stringa UnicodeClass è selezionato per Type.

(Ereditato da Type)
IsUnicodeClass

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsUnmanagedFunctionPointer

Ottiene un valore che indica se l'oggetto corrente Type è un puntatore di funzione non gestito.

(Ereditato da Type)
IsValueType

Ottiene un valore che indica se Type è un tipo di valore.

(Ereditato da Type)
IsValueType

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsVariableBoundArray

Definisce e crea nuove istanze delle classi in fase di esecuzione.

IsVariableBoundArray

Ottiene un valore che indica se il tipo è un tipo di matrice che può rappresentare una matrice multidimensionale o una matrice con un limite inferiore arbitrario.

(Ereditato da Type)
IsVisible

Ottiene un valore che indica se è possibile accedere a Type da codice esterno all'assembly.

(Ereditato da Type)
IsVisible

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
MemberType

Ottiene un valore MemberTypes che indica che questo membro è un tipo o un tipo annidato.

(Ereditato da Type)
MemberType

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
MetadataToken

Ottiene un token che identifica il modulo dinamico corrente nei metadati.

MetadataToken

Ottiene un valore che identifica un elemento di metadati.

(Ereditato da MemberInfo)
Module

Recupera il modulo dinamico che contiene la definizione di tipo.

Name

Recupera il nome di questo tipo.

Namespace

Recupera lo spazio dei nomi in cui è definito TypeBuilder.

PackingSize

Recupera la dimensione di compressione di questo tipo.

PackingSizeCore

In caso di override in una classe derivata, ottiene le dimensioni di compressione di questo tipo.

ReflectedType

Restituisce il tipo usato per ottenere questo tipo.

ReflectedType

Ottiene l'oggetto classe utilizzato per ottenere questa istanza di MemberInfo.

(Ereditato da MemberInfo)
Size

Recupera la dimensione totale di un tipo.

SizeCore

Quando sottoposto a override in una classe derivata, ottiene le dimensioni totali di un tipo.

StructLayoutAttribute

Ottiene una classe StructLayoutAttribute che descrive il layout del tipo corrente.

(Ereditato da Type)
StructLayoutAttribute

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
TypeHandle

Non supportato in moduli dinamici.

TypeInitializer

Ottiene l'inizializzatore per il tipo.

(Ereditato da Type)
TypeInitializer

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
TypeToken

Restituisce il token di tipo per questo tipo.

UnderlyingSystemType

Restituisce il tipo di sistema sottostante per l'oggetto TypeBuilder.

UnderlyingSystemType

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)

Metodi

AddDeclarativeSecurity(SecurityAction, PermissionSet)

Aggiunge sicurezza dichiarativa a questo tipo.

AddInterfaceImplementation(Type)

Aggiunge un'interfaccia implementata da questo tipo.

AddInterfaceImplementationCore(Type)

Quando sottoposto a override in una classe derivata, aggiunge un'interfaccia implementata da questo tipo.

AsType()

Restituisce il tipo corrente come oggetto Type.

(Ereditato da TypeInfo)
CreateType()

Crea un oggetto Type per la classe. Dopo aver definito i campi e metodi della classe CreateType viene chiamato per caricare il relativo oggetto Type.

CreateTypeInfo()

Ottiene un oggetto TypeInfo che rappresenta il tipo.

CreateTypeInfoCore()

Quando sottoposto a override in una classe derivata, ottiene un TypeInfo oggetto che rappresenta questo tipo.

DefineConstructor(MethodAttributes, CallingConventions, Type[])

Aggiunge un nuovo costruttore al tipo, con la firma e gli attributi specificati.

DefineConstructor(MethodAttributes, CallingConventions, Type[], Type[][], Type[][])

Aggiunge un nuovo costruttore al tipo, con gli attributi specificati, la firma e i modificatori personalizzati.

DefineConstructorCore(MethodAttributes, CallingConventions, Type[], Type[][], Type[][])

In caso di override in una classe derivata, aggiunge un nuovo costruttore al tipo, con gli attributi, la firma e i modificatori personalizzati specificati.

DefineDefaultConstructor(MethodAttributes)

Definisce il costruttore senza parametri. Il costruttore definito qui chiamerà semplicemente il costruttore senza parametri dell'elemento padre.

DefineDefaultConstructorCore(MethodAttributes)

Quando sottoposto a override in una classe derivata, definisce il costruttore senza parametri. Il costruttore definito qui chiama il costruttore senza parametri dell'elemento padre.

DefineEvent(String, EventAttributes, Type)

Aggiunge un nuovo evento al tipo, con il nome, gli attributi e il tipo di evento specificati.

DefineEventCore(String, EventAttributes, Type)

Quando sottoposto a override in una classe derivata, aggiunge un nuovo evento al tipo, con il nome, gli attributi e il tipo di evento specificati.

DefineField(String, Type, FieldAttributes)

Aggiunge un nuovo campo al tipo, con il nome, gli attributi e il tipo di campo specificati.

DefineField(String, Type, Type[], Type[], FieldAttributes)

Aggiunge un nuovo campo al tipo, con il nome, gli attributi, il tipo di campo e i modificatori personalizzati specificati.

DefineFieldCore(String, Type, Type[], Type[], FieldAttributes)

In caso di override in una classe derivata, aggiunge un nuovo campo al tipo, con il nome, gli attributi, il tipo di campo e i modificatori personalizzati specificati.

DefineGenericParameters(String[])

Definisce parametri di tipo generico per il tipo corrente, specificandone il numero e i nomi e restituisce una matrice di oggetti GenericTypeParameterBuilder che possono essere usati per impostare i vincoli.

DefineGenericParametersCore(String[])

Quando sottoposto a override in una classe derivata, definisce i parametri di tipo generico per il tipo corrente, specificando il numero e i relativi nomi.

DefineInitializedData(String, Byte[], FieldAttributes)

Definisce il campo di dati inizializzati nella sezione .sdata del file eseguibile di tipo PE.

DefineInitializedDataCore(String, Byte[], FieldAttributes)

Quando ne viene eseguito l'override in una classe derivata, definisce il campo dati inizializzato nella sezione sdata del file eseguibile portabile (PE).

DefineMethod(String, MethodAttributes)

Aggiunge un nuovo metodo al tipo, con il nome e gli attributi del metodo specificati.

DefineMethod(String, MethodAttributes, CallingConventions)

Aggiunge un nuovo metodo al tipo, con il nome e gli attributi del metodo e la convenzione di chiamata specificati.

DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[])

Aggiunge un nuovo metodo al tipo, con il nome, gli attributi del metodo, la convenzione di chiamata e la firma del metodo specificati.

DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])

Aggiunge un nuovo metodo al tipo, con il nome, gli attributi del metodo, la convenzione di chiamata, la firma del metodo e i modificatori personalizzati specificati.

DefineMethod(String, MethodAttributes, Type, Type[])

Aggiunge un nuovo metodo al tipo, con il nome, gli attributi e la firma del metodo specificati.

DefineMethodCore(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])

Quando ne viene eseguito l'override in una classe derivata, aggiunge un nuovo metodo al tipo, con il nome, gli attributi del metodo, la convenzione di chiamata, la firma del metodo e i modificatori personalizzati specificati.

DefineMethodOverride(MethodInfo, MethodInfo)

Specifica un corpo del metodo che implementa una data dichiarazione di metodo, potenzialmente con un nome diverso.

DefineMethodOverrideCore(MethodInfo, MethodInfo)

Quando sottoposto a override in una classe derivata, specifica un determinato corpo del metodo che implementa una determinata dichiarazione di metodo, potenzialmente con un nome diverso.

DefineNestedType(String)

Definisce un tipo annidato, dato il relativo nome.

DefineNestedType(String, TypeAttributes)

Definisce un tipo annidato, dato il relativo nome e attributi.

DefineNestedType(String, TypeAttributes, Type)

Definisce un tipo annidato a partire dal nome, dagli attributi e dal tipo che estende.

DefineNestedType(String, TypeAttributes, Type, Int32)

Definisce un tipo annidato a partire dal nome, dagli attributi, dalla dimensione totale del tipo e dal tipo che estende.

DefineNestedType(String, TypeAttributes, Type, PackingSize)

Definisce un tipo annidato a partire dal nome, dagli attributi, dal tipo che estende e dalla dimensione di compressione.

DefineNestedType(String, TypeAttributes, Type, PackingSize, Int32)

Definisce un tipo annidato a partire dal nome, dagli attributi, dalla dimensione e dal tipo che estende.

DefineNestedType(String, TypeAttributes, Type, Type[])

Definisce un tipo annidato a partire dal nome, dagli attributi, dal tipo che estende e dalle interfacce che implementa.

DefineNestedTypeCore(String, TypeAttributes, Type, Type[], PackingSize, Int32)

Quando ne viene eseguito l'override in una classe derivata, definisce un tipo annidato, in base al nome, agli attributi, alle dimensioni e al tipo esteso.

DefinePInvokeMethod(String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)

Definisce un metodo PInvoke in base al nome, al nome della DLL in cui è definito il metodo, agli attributi del metodo, alla convenzione di chiamata del metodo, al tipo restituito del metodo, ai tipi di parametri del metodo e ai flag PInvoke.

DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)

Definisce un metodo PInvoke in base al nome, al nome della DLL in cui è definito il metodo, al nome del punto di ingresso, agli attributi del metodo, alla convenzione di chiamata del metodo, al tipo restituito del metodo, ai tipi di parametri del metodo e ai flag PInvoke.

DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][], CallingConvention, CharSet)

Definisce un metodo PInvoke in base al nome, al nome della DLL in cui è definito il metodo, al nome del punto di ingresso, agli attributi del metodo, alla convenzione di chiamata del metodo, al tipo restituito del metodo, ai tipi di parametri del metodo, ai flag PInvoke e ai modificatori personalizzati relativi ai parametri e al tipo restituito.

DefinePInvokeMethodCore(String, String, String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][], CallingConvention, CharSet)

In caso di override in una classe derivata, definisce un metodo PInvoke con il nome, il nome della DLL, il nome del punto di ingresso, gli attributi, la convenzione di chiamata, il tipo restituito, i tipi dei parametri, i flag PInvoke e i modificatori personalizzati per i parametri e il tipo restituito.

DefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[])

Aggiunge una nuova proprietà al tipo, con il nome, gli attributi, la convenzione di chiamata e la firma della proprietà specificati.

DefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])

Aggiunge una nuova proprietà al tipo, con il nome, la convenzione di chiamata, la firma e i modificatori personalizzati specificati.

DefineProperty(String, PropertyAttributes, Type, Type[])

Aggiunge una nuova proprietà al tipo, con il nome e la firma della proprietà specificati.

DefineProperty(String, PropertyAttributes, Type, Type[], Type[], Type[], Type[][], Type[][])

Aggiunge una nuova proprietà al tipo, con il nome, la firma della proprietà e i modificatori personalizzati specificati.

DefinePropertyCore(String, PropertyAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])

Quando ne viene eseguito l'override in una classe derivata, aggiunge una nuova proprietà al tipo, con il nome specificato, la convenzione di chiamata, la firma della proprietà e i modificatori personalizzati.

DefineTypeInitializer()

Definisce l'inizializzatore per questo tipo.

DefineTypeInitializerCore()

Quando sottoposto a override in una classe derivata, definisce l'inizializzatore per questo tipo.

DefineUninitializedData(String, Int32, FieldAttributes)

Definisce un campo di dati non inizializzati nella sezione .sdata del file eseguibile di tipo PE.

DefineUninitializedDataCore(String, Int32, FieldAttributes)

In caso di override in una classe derivata, definisce un campo dati non inizializzato nella .sdata sezione del file eseguibile portabile (PE).

Equals(Object)

Determina se il tipo di sistema sottostante dell'oggetto Type corrente coincide con il tipo di sistema sottostante dell'oggetto Object specificato.

(Ereditato da Type)
Equals(Object)

Restituisce un valore che indica se questa istanza è uguale a un oggetto specificato.

(Ereditato da MemberInfo)
Equals(Type)

Determina se il tipo di sistema sottostante dell'oggetto Type corrente coincide con il tipo di sistema sottostante dell'oggetto Type specificato.

(Ereditato da Type)
FindInterfaces(TypeFilter, Object)

Restituisce una matrice di oggetti Type che rappresenta un elenco filtrato di interfacce implementate o ereditate dall'oggetto Type corrente.

(Ereditato da Type)
FindInterfaces(TypeFilter, Object)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)

Restituisce una matrice filtrata di oggetti MemberInfo del tipo di membro specificato.

(Ereditato da Type)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetArrayRank()

Definisce e crea nuove istanze delle classi in fase di esecuzione.

GetArrayRank()

Ottiene il numero di dimensioni in una matrice.

(Ereditato da Type)
GetArrayRank()

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetAttributeFlagsImpl()

Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà Attributes e ottiene una combinazione bit per bit di valori di enumerazione che indicano gli attributi associati a Type.

GetAttributeFlagsImpl()

Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà Attributes e ottiene una combinazione bit per bit di valori di enumerazione che indicano gli attributi associati a Type.

(Ereditato da Type)
GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Cerca il costruttore i cui parametri corrispondono ai tipi di argomenti e ai modificatori specificati, usando i vincoli di associazione e la convenzione di chiamata specificati.

(Ereditato da Type)
GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])

Cerca un costruttore i cui parametri corrispondono ai tipi e ai modificatori dell'argomento specificato, usando i vincoli di associazione specificati.

(Ereditato da Type)
GetConstructor(BindingFlags, Type[])

Cerca un costruttore i cui parametri corrispondono ai tipi di argomento specificati, usando i vincoli di associazione specificati.

(Ereditato da Type)
GetConstructor(Type, ConstructorInfo)

Restituisce il costruttore del tipo generico costruito specificato che corrisponde al costruttore specificato della definizione di tipo generico.

GetConstructor(Type[])

Cerca un costruttore di istanza pubblica i cui parametri corrispondono ai tipi nella matrice specificata.

(Ereditato da Type)
GetConstructor(Type[])

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Quando ne viene eseguito l'override in una classe derivata, cerca un costruttore i cui parametri corrispondono ai modificatori e ai tipi di argomento specificati, usando i vincoli di binding e la convenzione di chiamata specificati.

GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Quando ne viene eseguito l'override in una classe derivata, cerca un costruttore i cui parametri corrispondono ai modificatori e ai tipi di argomento specificati, usando i vincoli di binding e la convenzione di chiamata specificati.

(Ereditato da Type)
GetConstructors()

Restituisce tutti i costruttori di tipo pubblico definiti per l'oggetto Type corrente.

(Ereditato da Type)
GetConstructors()

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetConstructors(BindingFlags)

Restituisce una matrice di oggetti ConstructorInfo che rappresentano i costruttori pubblici e non pubblici definiti per questa classe, come specificato.

GetConstructors(BindingFlags)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetCustomAttributes(Boolean)

Restituisce tutti gli attributi personalizzati definiti per questo tipo.

GetCustomAttributes(Boolean)

Se sottoposto a override in una classe derivata, restituisce una matrice di tutti gli attributi personalizzati applicati a questo membro.

(Ereditato da MemberInfo)
GetCustomAttributes(Type, Boolean)

Restituisce tutti gli attributi personalizzati del tipo corrente che è possibile assegnare a un tipo specificato.

GetCustomAttributes(Type, Boolean)

Quando viene sottoposto a override in una classe derivata, questo metodo restituisce una matrice di attributi personalizzati applicati a questo membro e identificati da Type.

(Ereditato da MemberInfo)
GetCustomAttributesData()

Restituisce un elenco di oggetti CustomAttributeData che rappresentano i dati relativi agli attributi applicati al membro di destinazione.

(Ereditato da MemberInfo)
GetDeclaredEvent(String)

Restituisce un oggetto che rappresenta l'evento specificato dichiarato dal tipo corrente.

(Ereditato da TypeInfo)
GetDeclaredField(String)

Restituisce un oggetto che rappresenta il campo specificato dichiarato dal tipo corrente.

(Ereditato da TypeInfo)
GetDeclaredMethod(String)

Restituisce un oggetto che rappresenta il metodo specificato dichiarato dal tipo corrente.

(Ereditato da TypeInfo)
GetDeclaredMethods(String)

Restituisce un insieme che contiene tutti i metodi dichiarati nel tipo corrente che corrispondono al nome specificato.

(Ereditato da TypeInfo)
GetDeclaredNestedType(String)

Restituisce un oggetto che rappresenta il tipo annidato specificato dichiarato dal tipo corrente.

(Ereditato da TypeInfo)
GetDeclaredProperty(String)

Restituisce un oggetto che rappresenta la proprietà specificata dichiarata dal tipo corrente.

(Ereditato da TypeInfo)
GetDefaultMembers()

Cerca i membri definiti per l'oggetto Type corrente per cui è impostato il DefaultMemberAttribute.

(Ereditato da Type)
GetDefaultMembers()

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetElementType()

La chiamata di questo metodo genera sempre un'eccezione NotSupportedException.

GetEnumName(Object)

Restituisce il nome della costante avente il valore specificato, per il tipo di enumerazione corrente.

(Ereditato da Type)
GetEnumName(Object)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetEnumNames()

Restituisce i nomi dei membri del tipo di enumerazione corrente.

(Ereditato da Type)
GetEnumNames()

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetEnumUnderlyingType()

Restituisce il tipo sottostante del tipo di enumerazione corrente.

(Ereditato da Type)
GetEnumUnderlyingType()

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetEnumValues()

Restituisce una matrice dei valori delle costanti nel tipo di enumerazione corrente.

(Ereditato da Type)
GetEnumValues()

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetEnumValuesAsUnderlyingType()

Recupera una matrice dei valori delle costanti del tipo sottostante di questo tipo di enumerazione.

(Ereditato da Type)
GetEvent(String)

Restituisce l'oggetto EventInfo che rappresenta l'evento pubblico specificato.

(Ereditato da Type)
GetEvent(String)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetEvent(String, BindingFlags)

Restituisce l'evento con il nome specificato.

GetEvent(String, BindingFlags)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetEvents()

Restituisce gli eventi pubblici dichiarati o ereditati da questo tipo.

GetEvents()

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetEvents(BindingFlags)

Restituisce gli eventi pubblici e non pubblici dichiarati da questo tipo.

GetEvents(BindingFlags)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetField(String)

Cerca il campo pubblico con il nome specificato.

(Ereditato da Type)
GetField(String)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetField(String, BindingFlags)

Restituisce il campo specificato con il nome specificato.

GetField(String, BindingFlags)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetField(Type, FieldInfo)

Restituisce il campo del tipo generico specificato che corrisponde al campo specificato della definizione di tipo generico.

GetFields()

Restituisce tutti i campi pubblici dell'oggetto Type corrente.

(Ereditato da Type)
GetFields()

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetFields(BindingFlags)

Restituisce i campi pubblici e non pubblici dichiarati da questo tipo.

GetFields(BindingFlags)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetFunctionPointerCallingConventions()

In caso di override in una classe derivata, restituisce le convenzioni di chiamata del puntatore Typedi funzione corrente.

(Ereditato da Type)
GetFunctionPointerParameterTypes()

In caso di override in una classe derivata, restituisce i tipi di parametro del puntatore Typea funzione corrente.

(Ereditato da Type)
GetFunctionPointerReturnType()

In caso di override in una classe derivata, restituisce il tipo restituito del puntatore Typealla funzione corrente.

(Ereditato da Type)
GetGenericArguments()

Restituisce una matrice di oggetti Type che rappresentano gli argomenti di tipo di un tipo generico o i parametri di tipo di una definizione di tipo generico.

GetGenericArguments()

Restituisce una matrice di oggetti Type che rappresentano gli argomenti di tipo di un tipo generico chiuso o i parametri di tipo di una definizione di tipo generico.

(Ereditato da Type)
GetGenericArguments()

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetGenericParameterConstraints()

Definisce e crea nuove istanze delle classi in fase di esecuzione.

GetGenericParameterConstraints()

Restituisce una matrice di oggetti Type che rappresentano i vincoli sul parametro di tipo generico corrente.

(Ereditato da Type)
GetGenericParameterConstraints()

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetGenericTypeDefinition()

Restituisce un oggetto Type che rappresenta una definizione di tipo generico da cui è possibile ottenere il tipo generico.

GetGenericTypeDefinition()

Restituisce un oggetto Type che rappresenta una definizione di tipo generico da cui è possibile costruire il tipo generico corrente.

(Ereditato da Type)
GetHashCode()

Restituisce il codice hash per l'istanza.

(Ereditato da Type)
GetHashCode()

Restituisce il codice hash per l'istanza.

(Ereditato da MemberInfo)
GetInterface(String)

Cerca l'interfaccia con il nome specificato.

(Ereditato da Type)
GetInterface(String)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetInterface(String, Boolean)

Restituisce l'interfaccia implementata (direttamente o indirettamente) da questa classe, con il nome completo corrispondente al nome di interfaccia specificato.

GetInterface(String, Boolean)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetInterfaceMap(Type)

Restituisce un mapping di interfaccia per l'interfaccia richiesta.

GetInterfaces()

Restituisce una matrice di tutte le interfacce implementate nel tipo e nei relativi tipi di base.

GetInterfaces()

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetMember(String)

Cerca i membri pubblici con il nome specificato.

(Ereditato da Type)
GetMember(String)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetMember(String, BindingFlags)

Cerca i membri specificati, usando i vincoli di binding specificati.

(Ereditato da Type)
GetMember(String, BindingFlags)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetMember(String, MemberTypes, BindingFlags)

Restituisce tutti i membri pubblici e non pubblici dichiarati o ereditati da questo tipo, come specificato.

GetMember(String, MemberTypes, BindingFlags)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetMembers()

Restituisce tutti i membri pubblici dell'oggetto Type corrente.

(Ereditato da Type)
GetMembers()

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetMembers(BindingFlags)

Restituisce i membri per i membri pubblici e non pubblici dichiarati o ereditati da questo tipo.

GetMembers(BindingFlags)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetMemberWithSameMetadataDefinitionAs(MemberInfo)

Cerca l'oggetto MemberInfo nell'oggetto corrente Type che corrisponde all'oggetto specificato MemberInfo.

(Ereditato da Type)
GetMethod(String)

Cerca il metodo pubblico con il nome specificato.

(Ereditato da Type)
GetMethod(String)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetMethod(String, BindingFlags)

Cerca il metodo specificato, usando i vincoli di binding specificati.

(Ereditato da Type)
GetMethod(String, BindingFlags)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Cerca il metodo specificato i cui parametri corrispondono ai tipi di argomenti e ai modificatori specificati, usando i vincoli di binding e la convenzione di chiamata specificati.

(Ereditato da Type)
GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])

Cerca il metodo specificato i cui parametri corrispondono ai tipi di argomenti e ai modificatori specificati, usando i vincoli di binding specificati.

(Ereditato da Type)
GetMethod(String, BindingFlags, Type[])

Cerca il metodo specificato i cui parametri corrispondono ai tipi di argomento specificati, utilizzando i vincoli di associazione specificati.

(Ereditato da Type)
GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Cerca il metodo specificato i cui parametri corrispondono al numero di parametri generici, ai tipi di argomenti e ai modificatori specificati, usando i vincoli di binding e la convenzione di chiamata specificati.

(Ereditato da Type)
GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[])

Cerca il metodo specificato i cui parametri corrispondono al numero di parametri generici, ai tipi di argomenti e ai modificatori specificati, usando i vincoli di binding specificati.

(Ereditato da Type)
GetMethod(String, Int32, BindingFlags, Type[])

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da Type)
GetMethod(String, Int32, Type[])

Cerca il metodo pubblico specificato i cui parametri corrispondono al numero di parametri generici e ai tipi di argomenti specificati.

(Ereditato da Type)
GetMethod(String, Int32, Type[], ParameterModifier[])

Cerca il metodo pubblico specificato i cui parametri corrispondono al numero di parametri generici, ai tipi di argomenti e ai modificatori specificati.

(Ereditato da Type)
GetMethod(String, Type[])

Cerca il metodo pubblico specificato i cui parametri corrispondono ai tipi di argomenti specificati.

(Ereditato da Type)
GetMethod(String, Type[])

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetMethod(String, Type[], ParameterModifier[])

Cerca il metodo pubblico specificato i cui parametri corrispondono ai modificatori e ai tipi di argomenti specificati.

(Ereditato da Type)
GetMethod(String, Type[], ParameterModifier[])

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetMethod(Type, MethodInfo)

Restituisce il metodo del tipo generico costruito specificato che corrisponde al metodo specificato della definizione di tipo generico.

GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Quando ne viene eseguito l'override in una classe derivata, cerca il metodo specificato i cui parametri corrispondono ai modificatori e ai tipi di argomento definiti, usando i vincoli di binding e la convenzione di chiamata specificati.

GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Quando ne viene eseguito l'override in una classe derivata, cerca il metodo specificato i cui parametri corrispondono ai modificatori e ai tipi di argomento definiti, usando i vincoli di binding e la convenzione di chiamata specificati.

(Ereditato da Type)
GetMethodImpl(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Se sottoposto a override in una classe derivata, cerca il metodo specificato i cui parametri corrispondono al numero di parametri generici, ai tipi di argomenti e ai modificatori specificati, usando i vincoli di binding e la convenzione di chiamata specificati.

(Ereditato da Type)
GetMethods()

Restituisce tutti i metodi pubblici dell'oggetto Type corrente.

(Ereditato da Type)
GetMethods()

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetMethods(BindingFlags)

Restituisce tutti i metodi pubblici e non pubblici dichiarati o ereditati da questo tipo, come specificato.

GetMethods(BindingFlags)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetNestedType(String)

Cerca il tipo annidato pubblico con il nome specificato.

(Ereditato da Type)
GetNestedType(String)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetNestedType(String, BindingFlags)

Restituisce i tipi annidati pubblici e non pubblici dichiarati da questo tipo.

GetNestedType(String, BindingFlags)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetNestedTypes()

Restituisce i tipi pubblici annidati all'interno dell'oggetto Type corrente.

(Ereditato da Type)
GetNestedTypes()

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetNestedTypes(BindingFlags)

Restituisce i tipi annidati pubblici e non pubblici dichiarati o ereditati da questo tipo.

GetNestedTypes(BindingFlags)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetOptionalCustomModifiers()

In caso di override in una classe derivata, restituisce i modificatori personalizzati facoltativi dell'oggetto corrente Type.

(Ereditato da Type)
GetProperties()

Restituisce tutte le proprietà pubbliche dell'oggetto Type corrente.

(Ereditato da Type)
GetProperties()

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetProperties(BindingFlags)

Restituisce tutte le proprietà pubbliche e non pubbliche dichiarate o ereditate da questo tipo, come specificato.

GetProperties(BindingFlags)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetProperty(String)

Cerca la proprietà pubblica con il nome specificato.

(Ereditato da Type)
GetProperty(String)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetProperty(String, BindingFlags)

Cerca la proprietà specificata, usando i vincoli di binding specificati.

(Ereditato da Type)
GetProperty(String, BindingFlags)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])

Cerca la proprietà specificata i cui parametri corrispondono ai tipi di argomenti e ai modificatori specificati, usando i vincoli di binding specificati.

(Ereditato da Type)
GetProperty(String, Type)

Cerca la proprietà pubblica con il nome e il tipo restituito specificati.

(Ereditato da Type)
GetProperty(String, Type)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetProperty(String, Type, Type[])

Cerca la proprietà pubblica specificata i cui parametri corrispondono ai tipi di argomenti specificati.

(Ereditato da Type)
GetProperty(String, Type, Type[])

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetProperty(String, Type, Type[], ParameterModifier[])

Cerca la proprietà pubblica specificata i cui parametri corrispondono ai tipi di argomenti e ai modificatori specificati.

(Ereditato da Type)
GetProperty(String, Type, Type[], ParameterModifier[])

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetProperty(String, Type[])

Cerca la proprietà pubblica specificata i cui parametri corrispondono ai tipi di argomenti specificati.

(Ereditato da Type)
GetProperty(String, Type[])

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])

Quando viene sottoposto a override in una classe derivata, cerca la proprietà specificata i cui parametri corrispondono ai modificatori e ai tipi di argomenti definiti, usando i vincoli di binding specificati.

GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])

Quando viene sottoposto a override in una classe derivata, cerca la proprietà specificata i cui parametri corrispondono ai modificatori e ai tipi di argomenti definiti, usando i vincoli di binding specificati.

(Ereditato da Type)
GetRequiredCustomModifiers()

In caso di override in una classe derivata, restituisce i modificatori personalizzati obbligatori dell'oggetto corrente Type.

(Ereditato da Type)
GetType()

Ottiene l'oggetto Type corrente.

(Ereditato da Type)
GetType()

Individua gli attributi di un membro e consente di accedere ai metadati del membro.

(Ereditato da MemberInfo)
GetTypeCodeImpl()

Restituisce il codice del tipo sottostante di questa istanza di Type.

(Ereditato da Type)
HasElementTypeImpl()

Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà HasElementType e determina se l'oggetto Type corrente include o contiene riferimenti a un altro tipo, ovvero se l'oggetto Type corrente è costituito da una matrice o da un puntatore o è passato come riferimento.

HasElementTypeImpl()

Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà HasElementType e determina se l'oggetto Type corrente include o contiene riferimenti a un altro tipo, ovvero se l'oggetto Type corrente è costituito da una matrice o da un puntatore o è passato come riferimento.

(Ereditato da Type)
HasSameMetadataDefinitionAs(MemberInfo)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da MemberInfo)
InvokeMember(String, BindingFlags, Binder, Object, Object[])

Chiama il membro specificato, usando i vincoli di associazione specificati e associando l'elenco di argomenti specificato.

(Ereditato da Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)

Chiama il membro specificato, usando i vincoli di binding specificati e associando l'elenco di argomenti specificati e le impostazioni cultura.

(Ereditato da Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])

Richiama il membro specificato. Il metodo da richiamare deve essere accessibile e fornire massima corrispondenza con l'elenco di argomenti specificato, in conformità ai vincoli del binder e degli attributi di chiamata specificati.

IsArrayImpl()

Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà IsArray e determina se l'oggetto Type è una matrice.

IsArrayImpl()

Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà IsArray e determina se l'oggetto Type è una matrice.

(Ereditato da Type)
IsAssignableFrom(Type)

Ottiene un valore che indica se all'oggetto è possibile assegnare un oggetto Type specificato.

IsAssignableFrom(Type)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsAssignableFrom(TypeInfo)

Ottiene un valore che indica se a questo oggetto è possibile assegnare un oggetto TypeInfo specificato.

IsAssignableTo(Type)

Determina se il tipo corrente può essere assegnato a una variabile del tipo targetType specificato.

(Ereditato da Type)
IsByRefImpl()

Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà IsByRef e determina se l'oggetto Type viene passato per riferimento.

IsByRefImpl()

Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà IsByRef e determina se l'oggetto Type viene passato per riferimento.

(Ereditato da Type)
IsCOMObjectImpl()

Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà IsCOMObject e determina se Type è un oggetto COM.

IsCOMObjectImpl()

Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà IsCOMObject e determina se Type è un oggetto COM.

(Ereditato da Type)
IsContextfulImpl()

Implementa la proprietà IsContextful e determina se Type può essere contenuto in un contesto.

(Ereditato da Type)
IsCreated()

Restituisce un valore che indica se è stato creato il tipo dinamico corrente.

IsCreatedCore()

In caso di override in una classe derivata, restituisce un valore che indica se è stato creato il tipo dinamico corrente.

IsDefined(Type, Boolean)

Determina se un attributo personalizzato viene applicato al tipo corrente.

IsDefined(Type, Boolean)

Quando se ne effettua l'override in una classe derivata, indica se a questo membro sono applicati uno o più attributi del tipo specificato o dei tipi derivati.

(Ereditato da MemberInfo)
IsEnumDefined(Object)

Restituisce un valore che indica se il valore specificato esiste nel tipo di enumerazione corrente.

(Ereditato da Type)
IsEnumDefined(Object)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsEquivalentTo(Type)

Determina se due tipi COM presentano la stessa identità e sono idonei per l'equivalenza di tipo.

(Ereditato da Type)
IsEquivalentTo(Type)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsInstanceOfType(Object)

Determina se l'oggetto specificato è un'istanza dell'oggetto Type corrente.

(Ereditato da Type)
IsInstanceOfType(Object)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsMarshalByRefImpl()

Implementa la proprietà IsMarshalByRef e determina se l'oggetto Type viene sottoposto a marshalling per riferimento.

(Ereditato da Type)
IsPointerImpl()

Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà IsPointer e determina se l'oggetto Type è un puntatore.

IsPointerImpl()

Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà IsPointer e determina se l'oggetto Type è un puntatore.

(Ereditato da Type)
IsPrimitiveImpl()

Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà IsPrimitive e determina se l'oggetto Type corrisponde a uno dei tipi primitivi.

IsPrimitiveImpl()

Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà IsPrimitive e determina se l'oggetto Type corrisponde a uno dei tipi primitivi.

(Ereditato da Type)
IsSubclassOf(Type)

Determina se questo tipo è derivato da un tipo specificato.

IsSubclassOf(Type)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

(Ereditato da TypeInfo)
IsValueTypeImpl()

Implementa la proprietà IsValueType e determina se l'oggetto Type è un tipo di valore, ovvero, non una classe o un'interfaccia.

(Ereditato da Type)
MakeArrayType()

Restituisce un oggetto Type che rappresenta una matrice unidimensionale del tipo corrente con un limite inferiore a zero.

MakeArrayType()

Restituisce un oggetto Type che rappresenta una matrice unidimensionale del tipo corrente, con limite inferiore zero.

(Ereditato da Type)
MakeArrayType(Int32)

Restituisce un oggetto Type che rappresenta una matrice del tipo corrente, con il numero specificato di dimensioni.

MakeArrayType(Int32)

Restituisce un oggetto Type che rappresenta una matrice del tipo corrente, con il numero specificato di dimensioni.

(Ereditato da Type)
MakeByRefType()

Restituisce un oggetto Type che rappresenta il tipo corrente quando viene passato come parametro ref (ByRef in Visual Basic).

MakeByRefType()

Restituisce un oggetto Type che rappresenta il tipo corrente quando viene passato come parametro ref (parametro ByRef in Visual Basic).

(Ereditato da Type)
MakeGenericType(Type[])

Sostituisce gli elementi di una matrice di tipi ai parametri di tipo della definizione di tipo generico corrente e restituisce il tipo costruito risultante.

MakeGenericType(Type[])

Sostituisce gli elementi di una matrice di tipi ai parametri di tipo della definizione di tipo generico corrente e restituisce un oggetto Type che rappresenta il tipo costruito risultante.

(Ereditato da Type)
MakePointerType()

Restituisce un oggetto Type che rappresenta il tipo di un puntatore non gestito al tipo corrente.

MakePointerType()

Restituisce un oggetto Type che rappresenta un puntatore al tipo corrente.

(Ereditato da Type)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
SetCustomAttribute(ConstructorInfo, Byte[])

Imposta un attributo personalizzato usando un BLOB di attributi personalizzati specificato.

SetCustomAttribute(CustomAttributeBuilder)

Impostare un attributo personalizzato usando un generatore di attributi personalizzati.

SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)

Quando ne viene eseguito l'override in una classe derivata, imposta un attributo personalizzato su questo assembly.

SetParent(Type)

Imposta il tipo di base del tipo che si sta creando.

SetParentCore(Type)

Quando ne viene eseguito l'override in una classe derivata, imposta il tipo di base del tipo attualmente in fase di costruzione.

ToString()

Restituisce il nome del tipo escluso lo spazio dei nomi.

Implementazioni dell'interfaccia esplicita

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

Esegue il mapping di un set di nomi a un set corrispondente di ID dispatch.

(Ereditato da MemberInfo)
_MemberInfo.GetType()

Ottiene un oggetto Type che rappresenta la classe MemberInfo.

(Ereditato da MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera le informazioni sul tipo relative a un oggetto che può quindi essere usato per ottenere informazioni sul tipo relative a un'interfaccia.

(Ereditato da MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

Recupera il numero delle interfacce di informazioni sul tipo fornite da un oggetto (0 o 1).

(Ereditato da MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fornisce l'accesso a proprietà e metodi esposti da un oggetto.

(Ereditato da MemberInfo)
_Type.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Esegue il mapping di un set di nomi a un set corrispondente di ID dispatch.

(Ereditato da Type)
_Type.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera le informazioni sul tipo relative a un oggetto che può quindi essere usato per ottenere informazioni sul tipo relative a un'interfaccia.

(Ereditato da Type)
_Type.GetTypeInfoCount(UInt32)

Recupera il numero delle interfacce di informazioni sul tipo fornite da un oggetto (0 o 1).

(Ereditato da Type)
_Type.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fornisce l'accesso a proprietà e metodi esposti da un oggetto.

(Ereditato da Type)
_TypeBuilder.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Esegue il mapping di un set di nomi a un set corrispondente di ID dispatch.

_TypeBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera le informazioni sul tipo relative a un oggetto che può quindi essere usato per ottenere informazioni sul tipo relative a un'interfaccia.

_TypeBuilder.GetTypeInfoCount(UInt32)

Recupera il numero delle interfacce di informazioni sul tipo fornite da un oggetto (0 o 1).

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

Fornisce l'accesso a proprietà e metodi esposti da un oggetto.

ICustomAttributeProvider.GetCustomAttributes(Boolean)

Restituisce una matrice di tutti gli attributi personalizzati definiti in questo membro, esclusi gli attributi denominati, oppure una matrice vuota se non sono presenti attributi personalizzati.

(Ereditato da MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)

Restituisce una matrice di attributi personalizzati definiti in questo membro, identificati dal tipo o da una matrice vuota, se non sono presenti attributi personalizzati di quel tipo.

(Ereditato da MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean)

Indica se per questo membro sono definite una o più istanze di attributeType.

(Ereditato da MemberInfo)
IReflectableType.GetTypeInfo()

Restituisce una rappresentazione del tipo corrente come oggetto TypeInfo.

(Ereditato da TypeInfo)

Metodi di estensione

GetCustomAttribute(MemberInfo, Type)

Recupera una attributo personalizzato di un tipo specificato che viene applicato a un membro specificato.

GetCustomAttribute(MemberInfo, Type, Boolean)

Recupera un attributo personalizzato di un tipo specificato che viene applicato a un membro specificato e verifica facoltativamente i predecessori di tale membro.

GetCustomAttribute<T>(MemberInfo)

Recupera una attributo personalizzato di un tipo specificato che viene applicato a un membro specificato.

GetCustomAttribute<T>(MemberInfo, Boolean)

Recupera un attributo personalizzato di un tipo specificato che viene applicato a un membro specificato e verifica facoltativamente i predecessori di tale membro.

GetCustomAttributes(MemberInfo)

Recupera una raccolta di attributi personalizzati che vengono applicati a un membro specificato.

GetCustomAttributes(MemberInfo, Boolean)

Recupera una raccolta di attributi personalizzati che vengono applicati a un membro specificato e verifica facoltativamente i predecessori di tale membro.

GetCustomAttributes(MemberInfo, Type)

Recupera una raccolta di attributi personalizzati di un tipo specificato che vengono applicati a un membro specificato.

GetCustomAttributes(MemberInfo, Type, Boolean)

Recupera una raccolta di attributi personalizzati di un tipo specificato che vengono applicati a un membro specificato e verifica facoltativamente i predecessori di tale membro.

GetCustomAttributes<T>(MemberInfo)

Recupera una raccolta di attributi personalizzati di un tipo specificato che vengono applicati a un membro specificato.

GetCustomAttributes<T>(MemberInfo, Boolean)

Recupera una raccolta di attributi personalizzati di un tipo specificato che vengono applicati a un membro specificato e verifica facoltativamente i predecessori di tale membro.

IsDefined(MemberInfo, Type)

Indica se vengono applicati attributi personalizzati del tipo specificato a un membro specificato.

IsDefined(MemberInfo, Type, Boolean)

Indica se gli attributi personalizzati di un tipo specificato vengono applicati a un membro specificato e, facoltativamente, ai relativi predecessori.

GetTypeInfo(Type)

Restituisce la rappresentazione TypeInfo del tipo specificato.

GetMetadataToken(MemberInfo)

Ottiene un token di metadati per il membro specificato, se disponibile.

HasMetadataToken(MemberInfo)

Restituisce un valore che indica se un token di metadati è disponibile per il membro specificato.

GetRuntimeEvent(Type, String)

Recupera un oggetto che rappresenta l’evento specificato.

GetRuntimeEvents(Type)

Recupera una raccolta che rappresenta tutti gli eventi definiti in un tipo specificato.

GetRuntimeField(Type, String)

Recupera un oggetto che rappresenta un campo specificato.

GetRuntimeFields(Type)

Recupera una raccolta che rappresenta tutti i campi definiti in un tipo specificato.

GetRuntimeInterfaceMap(TypeInfo, Type)

Restituisce un mapping di interfaccia per il tipo specificato e per l'interfaccia specificata.

GetRuntimeMethod(Type, String, Type[])

Recupera un oggetto che rappresenta un metodo specificato.

GetRuntimeMethods(Type)

Recupera una raccolta che rappresenta tutti i metodi definiti in un tipo specificato.

GetRuntimeProperties(Type)

Recupera una raccolta che rappresenta tutte le proprietà definite in un tipo specificato.

GetRuntimeProperty(Type, String)

Recupera un oggetto che rappresenta una proprietà specificata.

GetConstructor(Type, Type[])

Definisce e crea nuove istanze delle classi in fase di esecuzione.

GetConstructors(Type)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

GetConstructors(Type, BindingFlags)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

GetFields(Type, BindingFlags)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

GetGenericArguments(Type)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

GetInterfaces(Type)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

GetMember(Type, String)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

GetMember(Type, String, BindingFlags)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

GetMembers(Type)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

GetMethods(Type)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

GetNestedType(Type, String, BindingFlags)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

GetProperties(Type)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

GetProperties(Type, BindingFlags)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

GetProperty(Type, String, BindingFlags)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

GetProperty(Type, String, Type)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

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

Definisce e crea nuove istanze delle classi in fase di esecuzione.

IsAssignableFrom(Type, Type)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

IsInstanceOfType(Type, Object)

Definisce e crea nuove istanze delle classi in fase di esecuzione.

Si applica a

Vedi anche