TypeBuilder Klass

Definition

Namnområde:

System.Reflection.Emit

Sammansättning:

mscorlib.dll

Definierar och skapar nya instanser av klasser under körningstiden.

public ref class TypeBuilder sealed : System::Reflection::TypeInfo, 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

[<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 TypeInfo
Implements _TypeBuilder

Arv

Object

MemberInfo

Type

TypeInfo

TypeBuilder

Attribut

ClassInterfaceAttribute ComVisibleAttribute

Implementeringar

_TypeBuilder

Exempel

I följande kodexempel visas hur du definierar och använder en dynamisk sammansättning. Exempelsammansättningen innehåller en typ, MyDynamicType, som har ett privat fält, en egenskap som hämtar och anger det privata fältet, konstruktorer som initierar det privata fältet och en metod som multiplicerar ett användartilldelat tal med värdet för det privata fältet och returnerar resultatet.

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

Följande kodexempel visar hur du skapar en typ dynamiskt med hjälp TypeBuilderav .

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

Kommentarer

Mer information om det här API:et finns i Kompletterande API-kommentarer för TypeBuilder.

Fält

Name	Description
UnspecifiedTypeSize	Representerar att den totala storleken för typen inte har angetts.

Egenskaper

Name	Description
Assembly	Hämtar den dynamiska sammansättning som innehåller den här typdefinitionen.
AssemblyQualifiedName	Returnerar det fullständiga namnet på den här typen som kvalificerats av sammansättningens visningsnamn.
BaseType	Hämtar bastypen för den här typen.
CustomAttributes	Hämtar en samling som innehåller den här medlemmens anpassade attribut. (Ärvd från MemberInfo)
DeclaredConstructors	Hämtar en samling konstruktorer som deklarerats av den aktuella typen. (Ärvd från TypeInfo)
DeclaredEvents	Hämtar en samling händelser som definierats av den aktuella typen. (Ärvd från TypeInfo)
DeclaredFields	Hämtar en samling av fälten som definierats av den aktuella typen. (Ärvd från TypeInfo)
DeclaredMembers	Hämtar en samling medlemmar som definierats av den aktuella typen. (Ärvd från TypeInfo)
DeclaredMethods	Hämtar en samling av de metoder som definieras av den aktuella typen. (Ärvd från TypeInfo)
DeclaredNestedTypes	Hämtar en samling kapslade typer som definierats av den aktuella typen. (Ärvd från TypeInfo)
DeclaredProperties	Hämtar en samling av de egenskaper som definieras av den aktuella typen. (Ärvd från TypeInfo)
DeclaringMethod	Hämtar den metod som deklarerade den aktuella generiska typparametern.
DeclaringType	Returnerar den typ som deklarerade den här typen.
FullName	Hämtar den fullständiga sökvägen för den här typen.
GenericParameterAttributes	Hämtar ett värde som anger kovarians och särskilda begränsningar för den aktuella generiska typparametern.
GenericParameterPosition	Hämtar positionen för en typparameter i typparameterlistan för den generiska typ som deklarerade parametern.
GenericTypeParameters	Hämtar en matris med de allmänna typparametrarna för den aktuella instansen. (Ärvd från TypeInfo)
GUID	Hämtar GUID för den här typen.
ImplementedInterfaces	Hämtar en samling av de gränssnitt som implementeras av den aktuella typen. (Ärvd från TypeInfo)
IsConstructedGenericType	Hämtar ett värde som anger om det här objektet representerar en konstruerad allmän typ.
IsContextful	Hämtar ett värde som anger om Type kan hanteras i en kontext. (Ärvd från Type)
IsGenericParameter	Hämtar ett värde som anger om den aktuella typen är en allmän typparameter.
IsGenericType	Hämtar ett värde som anger om den aktuella typen är en allmän typ.
IsGenericTypeDefinition	Hämtar ett värde som anger om den aktuella TypeBuilder representerar en allmän typdefinition som andra generiska typer kan konstrueras från.
IsSecurityCritical	Hämtar ett värde som anger om den aktuella typen är säkerhetskritisk eller säkerhetssäker och därför kan utföra kritiska åtgärder.
IsSecuritySafeCritical	Hämtar ett värde som anger om den aktuella typen är säkerhetskritisk. det vill: om den kan utföra kritiska åtgärder och kan nås med transparent kod.
IsSecurityTransparent	Hämtar ett värde som anger om den aktuella typen är transparent och därför inte kan utföra kritiska åtgärder.
MetadataToken	Hämtar ett värde som identifierar ett metadataelement. (Ärvd från MemberInfo)
Module	Hämtar den dynamiska modulen som innehåller den här typdefinitionen.
Name	Hämtar namnet på den här typen.
Namespace	Hämtar namnområdet där detta TypeBuilder definieras.
PackingSize	Hämtar förpackningsstorleken för den här typen.
ReflectedType	Returnerar den typ som användes för att hämta den här typen.
Size	Hämtar den totala storleken på en typ.
TypeHandle	Stöds inte i dynamiska moduler.
TypeToken	Returnerar typtoken av den här typen.
UnderlyingSystemType	Returnerar den underliggande systemtypen för den här TypeBuilder.

Metoder

Name	Description
AddDeclarativeSecurity(SecurityAction, PermissionSet)	Lägger till deklarativ säkerhet för den här typen.
AddInterfaceImplementation(Type)	Lägger till ett gränssnitt som den här typen implementerar.
AsType()	Returnerar den aktuella typen som ett Type objekt. (Ärvd från TypeInfo)
CreateType()	Skapar ett Type objekt för klassen. När du har definierat fält och metoder i klassen CreateType anropas för att läsa in objektet Type .
CreateTypeInfo()	Hämtar ett TypeInfo objekt som representerar den här typen.
DefineConstructor(MethodAttributes, CallingConventions, Type[], Type[][], Type[][])	Lägger till en ny konstruktor till typen med angivna attribut, signaturer och anpassade modifierare.
DefineConstructor(MethodAttributes, CallingConventions, Type[])	Lägger till en ny konstruktor till typen med de angivna attributen och signaturen.
DefineDefaultConstructor(MethodAttributes)	Definierar den parameterlösa konstruktorn. Konstruktorn som definieras här anropar helt enkelt den överordnade konstruktorns parameterlösa konstruktor.
DefineEvent(String, EventAttributes, Type)	Lägger till en ny händelse i typen med förnamn, attribut och händelsetyp.
DefineField(String, Type, FieldAttributes)	Lägger till ett nytt fält i typen med det angivna namnet, attributen och fälttypen.
DefineField(String, Type, Type[], Type[], FieldAttributes)	Lägger till ett nytt fält i typen med förnamn, attribut, fälttyp och anpassade modifierare.
DefineGenericParameters(String[])	Definierar de allmänna typparametrarna för den aktuella typen, anger deras nummer och deras namn och returnerar en matris med GenericTypeParameterBuilder objekt som kan användas för att ange deras begränsningar.
DefineInitializedData(String, Byte[], FieldAttributes)	Definierar initierat datafält i avsnittet .sdata i den bärbara körbara filen (PE).
DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Lägger till en ny metod i typen med angivet namn, metodattribut, anropande konvention, metodsignatur och anpassade modifierare.
DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[])	Lägger till en ny metod i typen med angivet namn, metodattribut, anropande konvention och metodsignatur.
DefineMethod(String, MethodAttributes, CallingConventions)	Lägger till en ny metod i typen med det angivna namnet, metodattributen och anropskonventionen.
DefineMethod(String, MethodAttributes, Type, Type[])	Lägger till en ny metod i typen med det angivna namnet, metodattributen och metodsignaturen.
DefineMethod(String, MethodAttributes)	Lägger till en ny metod i typen med det angivna namnet och metodattributen.
DefineMethodOverride(MethodInfo, MethodInfo)	Anger en viss metodtext som implementerar en viss metoddeklaration, eventuellt med ett annat namn.
DefineNestedType(String, TypeAttributes, Type, Int32)	Definierar en kapslad typ, med tanke på dess namn, attribut, den totala storleken på typen och den typ som den utökar.
DefineNestedType(String, TypeAttributes, Type, PackingSize, Int32)	Definierar en kapslad typ med dess namn, attribut, storlek och den typ som den utökar.
DefineNestedType(String, TypeAttributes, Type, PackingSize)	Definierar en kapslad typ med dess namn, attribut, den typ som den utökar och förpackningsstorleken.
DefineNestedType(String, TypeAttributes, Type, Type[])	Definierar en kapslad typ, med tanke på dess namn, attribut, den typ som den utökar och de gränssnitt som den implementerar.
DefineNestedType(String, TypeAttributes, Type)	Definierar en kapslad typ med dess namn, attribut och den typ som den utökar.
DefineNestedType(String, TypeAttributes)	Definierar en kapslad typ med dess namn och attribut.
DefineNestedType(String)	Definierar en kapslad typ med namnet .
DefinePInvokeMethod(String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Definierar en PInvoke metod med namnet, namnet på den DLL där metoden definieras, metodens attribut, metodens anropande konvention, metodens returtyp, typen av parametrar för metoden och flaggorna PInvoke .
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Definierar en PInvoke metod med namnet, namnet på den DLL där metoden definieras, namnet på startpunkten, metodens attribut, metodens anropskonvention, metodens returtyp, typerna av parametrarna för metoden och flaggorna PInvoke .
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][], CallingConvention, CharSet)	Definierar en PInvoke metod med namnet, namnet på den DLL där metoden definieras, namnet på startpunkten, metodens attribut, metodens anropande konvention, metodens returtyp, typerna av parametrarna för metoden, flaggorna PInvoke och anpassade modifierare för parametrarna och returtypen.
DefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Lägger till en ny egenskap i typen, med det angivna namnet, anropskonventionen, egenskapssignaturen och anpassade modifierare.
DefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[])	Lägger till en ny egenskap i typen med förnamn, attribut, anropskonvention och egenskapssignatur.
DefineProperty(String, PropertyAttributes, Type, Type[], Type[], Type[], Type[][], Type[][])	Lägger till en ny egenskap i typen med förnamn, egenskapssignatur och anpassade modifierare.
DefineProperty(String, PropertyAttributes, Type, Type[])	Lägger till en ny egenskap i typen med förnamn och egenskapssignatur.
DefineTypeInitializer()	Definierar initieraren för den här typen.
DefineUninitializedData(String, Int32, FieldAttributes)	Definierar ett onitialiserat datafält i avsnittet i .sdata den bärbara körbara filen (PE).
Equals(Object)	Avgör om den underliggande systemtypen för det aktuella Type objektet är samma som den underliggande systemtypen för den angivna Object. (Ärvd från Type)
Equals(Type)	Avgör om den underliggande systemtypen för den aktuella är Type samma som den underliggande systemtypen för den angivna Type. (Ärvd från Type)
GetAttributeFlagsImpl()	När den åsidosätts i en härledd klass implementerar den Attributes egenskapen och får en bitvis kombination av uppräkningsvärden som anger de attribut som är associerade med Type. (Ärvd från Type)
GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Söker efter en konstruktor vars parametrar matchar de angivna argumenttyperna och modifierarna med hjälp av de angivna bindningsbegränsningarna och den angivna anropskonventionen. (Ärvd från Type)
GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])	Söker efter en konstruktor vars parametrar matchar de angivna argumenttyperna och modifierarna med hjälp av de angivna bindningsbegränsningarna. (Ärvd från Type)
GetConstructor(Type, ConstructorInfo)	Returnerar konstruktorn för den angivna konstruerade generiska typen som motsvarar den angivna konstruktorn för den generiska typdefinitionen.
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	När den åsidosättas i en härledd klass söker efter en konstruktor vars parametrar matchar de angivna argumenttyperna och modifierarna med hjälp av de angivna bindningsbegränsningarna och den angivna anropskonventionen. (Ärvd från Type)
GetConstructors(BindingFlags)	Returnerar en matris med ConstructorInfo objekt som representerar de offentliga och icke-offentliga konstruktorer som definierats för den här klassen enligt angivet.
GetCustomAttributes(Boolean)	Returnerar alla anpassade attribut som definierats för den här typen.
GetCustomAttributes(Type, Boolean)	Returnerar alla anpassade attribut av den aktuella typen som kan tilldelas till en angiven typ.
GetCustomAttributesData()	Returnerar en lista över CustomAttributeData objekt som representerar data om de attribut som har tillämpats på målmedlemmen. (Ärvd från MemberInfo)
GetDeclaredEvent(String)	Returnerar ett objekt som representerar den angivna händelsen som deklarerats av den aktuella typen. (Ärvd från TypeInfo)
GetDeclaredField(String)	Returnerar ett objekt som representerar det angivna fältet som deklarerats av den aktuella typen. (Ärvd från TypeInfo)
GetDeclaredMethod(String)	Returnerar ett objekt som representerar den angivna metoden som deklarerats av den aktuella typen. (Ärvd från TypeInfo)
GetDeclaredMethods(String)	Returnerar en samling som innehåller alla metoder som deklarerats för den aktuella typen som matchar det angivna namnet. (Ärvd från TypeInfo)
GetDeclaredNestedType(String)	Returnerar ett objekt som representerar den angivna kapslade typen som deklarerats av den aktuella typen. (Ärvd från TypeInfo)
GetDeclaredProperty(String)	Returnerar ett objekt som representerar den angivna egenskapen som deklarerats av den aktuella typen. (Ärvd från TypeInfo)
GetElementType()	Att anropa den här metoden genererar NotSupportedExceptionalltid .
GetEvent(String, BindingFlags)	Returnerar händelsen med det angivna namnet.
GetEvents()	Returnerar de offentliga händelser som deklarerats eller ärvts av den här typen.
GetEvents(BindingFlags)	Returnerar offentliga och icke-offentliga händelser som deklareras av den här typen.
GetField(String, BindingFlags)	Returnerar det fält som anges av det angivna namnet.
GetField(Type, FieldInfo)	Returnerar fältet för den angivna konstruerade generiska typen som motsvarar det angivna fältet i den generiska typdefinitionen.
GetFields(BindingFlags)	Returnerar de offentliga och icke-offentliga fält som deklareras av den här typen.
GetGenericArguments()	Returnerar en matris med Type objekt som representerar typargumenten av en allmän typ eller typparametrarna för en allmän typdefinition.
GetGenericTypeDefinition()	Returnerar ett Type objekt som representerar en allmän typdefinition som den aktuella typen kan hämtas från.
GetHashCode()	Returnerar hash-koden för den här instansen. (Ärvd från Type)
GetInterface(String, Boolean)	Returnerar gränssnittet som implementerats (direkt eller indirekt) av den här klassen med det fullständigt kvalificerade namnet som matchar det angivna gränssnittsnamnet.
GetInterfaceMap(Type)	Returnerar en gränssnittsmappning för det begärda gränssnittet.
GetInterfaces()	Returnerar en matris med alla gränssnitt som implementerats för den här typen och dess bastyper.
GetMember(String, MemberTypes, BindingFlags)	Returnerar alla offentliga och icke-offentliga medlemmar som deklarerats eller ärvts av den här typen enligt angiven.
GetMembers(BindingFlags)	Returnerar medlemmarna för de offentliga och icke-offentliga medlemmar som deklarerats eller ärvts av den här typen.
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Söker efter den angivna metoden vars parametrar matchar de angivna argumenttyperna och modifierarna med hjälp av de angivna bindningsbegränsningarna och den angivna anropskonventionen. (Ärvd från Type)
GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])	Söker efter den angivna metoden vars parametrar matchar de angivna argumenttyperna och modifierarna med hjälp av de angivna bindningsbegränsningarna. (Ärvd från Type)
GetMethod(Type, MethodInfo)	Returnerar metoden för den angivna konstruerade generiska typen som motsvarar den angivna metoden för den generiska typdefinitionen.
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	När den åsidosättas i en härledd klass söker du efter den angivna metoden vars parametrar matchar de angivna argumenttyperna och modifierarna med hjälp av de angivna bindningsbegränsningarna och den angivna anropskonventionen. (Ärvd från Type)
GetMethods(BindingFlags)	Returnerar alla offentliga och icke-offentliga metoder som deklarerats eller ärvts av den här typen enligt angiven.
GetNestedType(String, BindingFlags)	Returnerar de offentliga och icke-offentliga kapslade typerna som deklareras av den här typen.
GetNestedTypes(BindingFlags)	Returnerar de offentliga och icke-offentliga kapslade typerna som deklareras eller ärvs av den här typen.
GetProperties(BindingFlags)	Returnerar alla offentliga och icke-offentliga egenskaper som deklarerats eller ärvts av den här typen enligt angiven.
GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Söker efter den angivna egenskapen vars parametrar matchar de angivna argumenttyperna och modifierarna med hjälp av de angivna bindningsbegränsningarna. (Ärvd från Type)
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	När den åsidosättas i en härledd klass söker du efter den angivna egenskapen vars parametrar matchar de angivna argumenttyperna och modifierarna med hjälp av de angivna bindningsbegränsningarna. (Ärvd från Type)
GetType()	Hämtar den aktuella Type. (Ärvd från Type)
GetTypeCodeImpl()	Returnerar den underliggande typkoden för den här Type instansen. (Ärvd från Type)
HasElementTypeImpl()	När den åsidosätts i en härledd klass implementerar den HasElementType egenskapen och avgör om strömmen Type omfattar eller refererar till en annan typ, det vill: om den aktuella Type är en matris, en pekare eller skickas med referens. (Ärvd från Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)	Anropar den angivna medlemmen med de angivna bindningsbegränsningarna och matchar den angivna argumentlistan och kulturen. (Ärvd från Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])	Anropar den angivna medlemmen. Den metod som ska anropas måste vara tillgänglig och tillhandahålla den mest specifika matchningen med den angivna argumentlistan, under begränsningarna för de angivna attributen för pärm och anrop.
InvokeMember(String, BindingFlags, Binder, Object, Object[])	Anropar den angivna medlemmen med de angivna bindningsbegränsningarna och matchar den angivna argumentlistan. (Ärvd från Type)
IsArrayImpl()	När den åsidosättas i en härledd klass implementerar den IsArray egenskapen och avgör om Type är en matris. (Ärvd från Type)
IsAssignableFrom(Type)	Hämtar ett värde som anger om en angiven Type kan tilldelas till det här objektet.
IsAssignableFrom(TypeInfo)	Hämtar ett värde som anger om ett angivet TypeInfo objekt kan tilldelas till det här objektet.
IsByRefImpl()	När den åsidosättas i en härledd klass implementerar den IsByRef egenskapen och avgör om den Type skickas med referens. (Ärvd från Type)
IsCOMObjectImpl()	När den åsidosättas i en härledd klass implementerar den IsCOMObject egenskapen och avgör om Type är ett COM-objekt. (Ärvd från Type)
IsContextfulImpl()	Implementerar IsContextful egenskapen och avgör om den Type kan hanteras i en kontext. (Ärvd från Type)
IsCreated()	Returnerar ett värde som anger om den aktuella dynamiska typen har skapats.
IsDefined(Type, Boolean)	Avgör om ett anpassat attribut tillämpas på den aktuella typen.
IsMarshalByRefImpl()	Implementerar IsMarshalByRef egenskapen och avgör om den Type har konverterats med referens. (Ärvd från Type)
IsPointerImpl()	När den åsidosättas i en härledd klass implementerar den IsPointer egenskapen och avgör om Type är en pekare. (Ärvd från Type)
IsPrimitiveImpl()	När den åsidosätts i en härledd klass implementerar den IsPrimitive egenskapen och avgör om är Type en av de primitiva typerna. (Ärvd från Type)
IsSubclassOf(Type)	Avgör om den här typen härleds från en angiven typ.
IsValueTypeImpl()	Implementerar IsValueType egenskapen och avgör om Type är en värdetyp, dvs. inte en klass eller ett gränssnitt. (Ärvd från Type)
MakeArrayType()	Returnerar ett Type objekt som representerar en endimensionell matris av den aktuella typen, med en lägre gräns på noll.
MakeArrayType(Int32)	Returnerar ett Type objekt som representerar en matris av den aktuella typen, med det angivna antalet dimensioner.
MakeByRefType()	Returnerar ett Type-objekt som representerar den aktuella typen när det skickas som en ref-parameter (ByRef i Visual Basic).
MakeGenericType(Type[])	Ersätter elementen i en matris med typer för typparametrarna i den aktuella generiska typdefinitionen och returnerar den resulterande konstruerade typen.
MakePointerType()	Returnerar ett Type objekt som representerar typen av en ohanterad pekare till den aktuella typen.
MemberwiseClone()	Skapar en ytlig kopia av den aktuella Object. (Ärvd från Object)
SetCustomAttribute(ConstructorInfo, Byte[])	Anger ett anpassat attribut med en angiven anpassad attributblob.
SetCustomAttribute(CustomAttributeBuilder)	Ange ett anpassat attribut med hjälp av en anpassad attributbyggare.
SetParent(Type)	Anger bastypen för den typ som för närvarande håller på att byggas.
ToString()	Returnerar namnet på typen exklusive namnområdet.

Explicita gränssnittsimplementeringar

Name	Description
_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Mappar en uppsättning namn till en motsvarande uppsättning av sändningsidentifierare. (Ärvd från MemberInfo)
_MemberInfo.GetType()	Hämtar ett Type objekt som representerar MemberInfo klassen. (Ärvd från MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)	Hämtar typinformationen för ett objekt, som sedan kan användas för att hämta typinformationen för ett gränssnitt. (Ärvd från MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)	Hämtar antalet typinformationsgränssnitt som ett objekt tillhandahåller (antingen 0 eller 1). (Ärvd från MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Ger åtkomst till egenskaper och metoder som exponeras av ett objekt. (Ärvd från MemberInfo)
_Type.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Mappar en uppsättning namn till en motsvarande uppsättning av sändningsidentifierare. (Ärvd från Type)
_Type.GetTypeInfo(UInt32, UInt32, IntPtr)	Hämtar typinformationen för ett objekt, som sedan kan användas för att hämta typinformationen för ett gränssnitt. (Ärvd från Type)
_Type.GetTypeInfoCount(UInt32)	Hämtar antalet typinformationsgränssnitt som ett objekt tillhandahåller (antingen 0 eller 1). (Ärvd från Type)
_Type.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Ger åtkomst till egenskaper och metoder som exponeras av ett objekt. (Ärvd från Type)
_TypeBuilder.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Mappar en uppsättning namn till en motsvarande uppsättning av sändningsidentifierare.
_TypeBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)	Hämtar typinformationen för ett objekt, som sedan kan användas för att hämta typinformationen för ett gränssnitt.
_TypeBuilder.GetTypeInfoCount(UInt32)	Hämtar antalet typinformationsgränssnitt som ett objekt tillhandahåller (antingen 0 eller 1).
_TypeBuilder.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Ger åtkomst till egenskaper och metoder som exponeras av ett objekt.
IReflectableType.GetTypeInfo()	Returnerar en representation av den aktuella typen som ett TypeInfo objekt. (Ärvd från TypeInfo)

Tilläggsmetoder

Name	Description
GetCustomAttribute(MemberInfo, Type, Boolean)	Hämtar ett anpassat attribut av en angiven typ som tillämpas på en angiven medlem och kontrollerar eventuellt den medlemmens överordnade objekt.
GetCustomAttribute(MemberInfo, Type)	Hämtar ett anpassat attribut av en angiven typ som tillämpas på en angiven medlem.
GetCustomAttribute<T>(MemberInfo, Boolean)	Hämtar ett anpassat attribut av en angiven typ som tillämpas på en angiven medlem och kontrollerar eventuellt den medlemmens överordnade objekt.
GetCustomAttribute<T>(MemberInfo)	Hämtar ett anpassat attribut av en angiven typ som tillämpas på en angiven medlem.
GetCustomAttributes(MemberInfo, Boolean)	Hämtar en samling anpassade attribut som tillämpas på en angiven medlem och kontrollerar eventuellt den medlemmens överordnade.
GetCustomAttributes(MemberInfo, Type, Boolean)	Hämtar en samling anpassade attribut av en angiven typ som tillämpas på en angiven medlem och kontrollerar eventuellt den medlemmens överordnade.
GetCustomAttributes(MemberInfo, Type)	Hämtar en samling anpassade attribut av en angiven typ som tillämpas på en angiven medlem.
GetCustomAttributes(MemberInfo)	Hämtar en samling anpassade attribut som tillämpas på en angiven medlem.
GetCustomAttributes<T>(MemberInfo, Boolean)	Hämtar en samling anpassade attribut av en angiven typ som tillämpas på en angiven medlem och kontrollerar eventuellt den medlemmens överordnade.
GetCustomAttributes<T>(MemberInfo)	Hämtar en samling anpassade attribut av en angiven typ som tillämpas på en angiven medlem.
GetRuntimeEvent(Type, String)	Hämtar ett objekt som representerar den angivna händelsen.
GetRuntimeEvents(Type)	Hämtar en samling som representerar alla händelser som definierats för en angiven typ.
GetRuntimeField(Type, String)	Hämtar ett objekt som representerar ett angivet fält.
GetRuntimeFields(Type)	Hämtar en samling som representerar alla fält som definierats för en angiven typ.
GetRuntimeInterfaceMap(TypeInfo, Type)	Returnerar en gränssnittsmappning för den angivna typen och det angivna gränssnittet.
GetRuntimeMethod(Type, String, Type[])	Hämtar ett objekt som representerar en angiven metod.
GetRuntimeMethods(Type)	Hämtar en samling som representerar alla metoder som definierats för en angiven typ.
GetRuntimeProperties(Type)	Hämtar en samling som representerar alla egenskaper som definierats för en angiven typ.
GetRuntimeProperty(Type, String)	Hämtar ett objekt som representerar en angiven egenskap.
GetTypeInfo(Type)	Returnerar representationen TypeInfo av den angivna typen.
IsDefined(MemberInfo, Type, Boolean)	Anger om anpassade attribut av en angiven typ tillämpas på en angiven medlem och eventuellt tillämpas på dess överordnade.
IsDefined(MemberInfo, Type)	Anger om anpassade attribut av en angiven typ tillämpas på en angiven medlem.

Se även

• Gör så här: Definiera en generisk typ med Reflection.Emit