TypeBuilder Sınıf

Tanım

Ad Alanı:

System.Reflection.Emit

Bütünleştirilmiş Kod:

mscorlib.dll

Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

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

Devralma

Object

MemberInfo

Type

TypeInfo

TypeBuilder

Öznitelikler

ClassInterfaceAttribute ComVisibleAttribute

Uygulamalar

_TypeBuilder

Örnekler

Aşağıdaki kod örneğinde dinamik derleme tanımlama ve kullanma gösterilmektedir. Örnek derleme, özel alanı olan bir tür, MyDynamicTypeözel alanı alan ve ayarlayan bir özellik, özel alanı başlatan oluşturucular ve kullanıcı tarafından sağlanan bir sayıyı özel alan değeriyle çarparak sonucu döndüren bir yöntem içerir.

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

Aşağıdaki kod örneğinde kullanarak TypeBuilderdinamik olarak bir türün nasıl derlenmiş olduğu gösterilmektedir.

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

Açıklamalar

Bu API hakkında daha fazla bilgi için bkz. TypeBuilder için ek API açıklamaları.

Alanlar

Name	Description
UnspecifiedTypeSize	Türün toplam boyutunun belirtilmediğini temsil eder.

Özellikler

Name	Description
Assembly	Bu tür tanımını içeren dinamik derlemeyi alır.
AssemblyQualifiedName	Derlemenin görünen adıyla nitelenen bu türün tam adını döndürür.
BaseType	Bu türün temel türünü alır.
CustomAttributes	Bu üyenin özel özniteliklerini içeren bir koleksiyon alır. (Devralındığı yer: MemberInfo)
DeclaredConstructors	Geçerli tür tarafından bildirilen oluşturucuların koleksiyonunu alır. (Devralındığı yer: TypeInfo)
DeclaredEvents	Geçerli tür tarafından tanımlanan olayların koleksiyonunu alır. (Devralındığı yer: TypeInfo)
DeclaredFields	Geçerli tür tarafından tanımlanan alanların koleksiyonunu alır. (Devralındığı yer: TypeInfo)
DeclaredMembers	Geçerli tür tarafından tanımlanan üyelerin koleksiyonunu alır. (Devralındığı yer: TypeInfo)
DeclaredMethods	Geçerli tür tarafından tanımlanan yöntemlerin koleksiyonunu alır. (Devralındığı yer: TypeInfo)
DeclaredNestedTypes	Geçerli tür tarafından tanımlanan iç içe türlerin koleksiyonunu alır. (Devralındığı yer: TypeInfo)
DeclaredProperties	Geçerli tür tarafından tanımlanan özelliklerin koleksiyonunu alır. (Devralındığı yer: TypeInfo)
DeclaringMethod	Geçerli genel tür parametresini bildiren yöntemi alır.
DeclaringType	Bu türü belirten türü döndürür.
FullName	Bu türün tam yolunu alır.
GenericParameterAttributes	Geçerli genel tür parametresinin kovaryansını ve özel kısıtlamalarını gösteren bir değer alır.
GenericParameterPosition	Bir tür parametresinin, parametreyi bildiren genel türün tür parametre listesindeki konumunu alır.
GenericTypeParameters	Geçerli örneğin genel tür parametrelerinin dizisini alır. (Devralındığı yer: TypeInfo)
GUID	Bu türün GUID'sini alır.
ImplementedInterfaces	Geçerli tür tarafından uygulanan arabirimlerin koleksiyonunu alır. (Devralındığı yer: TypeInfo)
IsConstructedGenericType	Bu nesnenin, bir genel tür oluşturup oluşturmadığını gösteren bir değer alır.
IsContextful	öğesinin bir bağlamda barındırılıp Type barındırılamayacağını belirten bir değer alır. (Devralındığı yer: Type)
IsGenericParameter	Geçerli türün genel tür parametresi olup olmadığını belirten bir değer alır.
IsGenericType	Geçerli türün genel bir tür olup olmadığını gösteren bir değer alır.
IsGenericTypeDefinition	Geçerli TypeBuilder değerin, diğer genel türlerin oluşturulabileceği genel tür tanımını temsil edip etmediğini belirten bir değer alır.
IsSecurityCritical	Geçerli türün güvenlik açısından kritik mi yoksa güvenlik açısından güvenli mi olduğunu belirten bir değer alır ve bu nedenle kritik işlemleri gerçekleştirebilir.
IsSecuritySafeCritical	Geçerli türün güvenlik açısından güvenli-kritik olup olmadığını gösteren bir değer alır; başka bir ifadeyle, kritik işlemler gerçekleştirip gerçekleştiremeyeceği ve saydam kodla erişilip erişilemeyeceği.
IsSecurityTransparent	Geçerli türün saydam olup olmadığını belirten bir değer alır ve bu nedenle kritik işlemler gerçekleştiremez.
MetadataToken	Meta veri öğesini tanımlayan bir değer alır. (Devralındığı yer: MemberInfo)
Module	Bu tür tanımını içeren dinamik modülü alır.
Name	Bu türün adını alır.
Namespace	Bunun TypeBuilder tanımlandığı ad alanını alır.
PackingSize	Bu türün paketleme boyutunu alır.
ReflectedType	Bu türü elde etmek için kullanılan türü döndürür.
Size	Bir türün toplam boyutunu alır.
TypeHandle	Dinamik modüllerde desteklenmez.
TypeToken	Bu türün tür belirtecini döndürür.
UnderlyingSystemType	Bu TypeBuilderiçin temel alınan sistem türünü döndürür.

Yöntemler

Name	Description
AddDeclarativeSecurity(SecurityAction, PermissionSet)	Bu türe bildirim temelli güvenlik ekler.
AddInterfaceImplementation(Type)	Bu türün uyguladığı bir arabirim ekler.
AsType()	Geçerli türü nesne Type olarak döndürür. (Devralındığı yer: TypeInfo)
CreateType()	sınıfı için bir Type nesnesi oluşturur. sınıfındaki alanları ve yöntemleri tanımladıktan sonra, CreateType nesnesini yüklemek için çağrılır Type .
CreateTypeInfo()	Bu türü temsil eden bir TypeInfo nesne alır.
DefineConstructor(MethodAttributes, CallingConventions, Type[], Type[][], Type[][])	Türüne, verilen öznitelikler, imza ve özel değiştiricilerle yeni bir oluşturucu ekler.
DefineConstructor(MethodAttributes, CallingConventions, Type[])	Belirtilen öznitelikler ve imza ile türüne yeni bir oluşturucu ekler.
DefineDefaultConstructor(MethodAttributes)	Parametresiz oluşturucuyu tanımlar. Burada tanımlanan oluşturucu yalnızca üst öğesinin parametresiz oluşturucuyu çağırır.
DefineEvent(String, EventAttributes, Type)	Türüne, verilen ad, öznitelikler ve olay türüyle yeni bir olay ekler.
DefineField(String, Type, FieldAttributes)	Türe, verilen ad, öznitelikler ve alan türüyle yeni bir alan ekler.
DefineField(String, Type, Type[], Type[], FieldAttributes)	Türe, verilen ad, öznitelikler, alan türü ve özel değiştiricilerle yeni bir alan ekler.
DefineGenericParameters(String[])	Geçerli türün genel tür parametrelerini tanımlar, sayılarını ve adlarını belirtir ve kısıtlamalarını ayarlamak için kullanılabilecek bir nesne dizisi GenericTypeParameterBuilder döndürür.
DefineInitializedData(String, Byte[], FieldAttributes)	Taşınabilir yürütülebilir (PE) dosyasının .sdata bölümünde başlatılan veri alanını tanımlar.
DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Türüne belirtilen ad, yöntem öznitelikleri, çağırma kuralı, yöntem imzası ve özel değiştiricilerle yeni bir yöntem ekler.
DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[])	Türüne belirtilen ad, yöntem öznitelikleri, çağırma kuralı ve yöntem imzası ile yeni bir yöntem ekler.
DefineMethod(String, MethodAttributes, CallingConventions)	Türüne, belirtilen ad, yöntem öznitelikleri ve çağırma kuralıyla yeni bir yöntem ekler.
DefineMethod(String, MethodAttributes, Type, Type[])	Türüne belirtilen ad, yöntem öznitelikleri ve yöntem imzasıyla yeni bir yöntem ekler.
DefineMethod(String, MethodAttributes)	Türüne, belirtilen ad ve yöntem öznitelikleriyle yeni bir yöntem ekler.
DefineMethodOverride(MethodInfo, MethodInfo)	Belirli bir yöntem bildirimi uygulayan belirli bir yöntem gövdesini belirtir ve bu durum farklı bir adla olabilir.
DefineNestedType(String, TypeAttributes, Type, Int32)	Adı, öznitelikleri, türün toplam boyutu ve genişletilen türü göz önünde bulundurarak iç içe bir tür tanımlar.
DefineNestedType(String, TypeAttributes, Type, PackingSize, Int32)	Adı, öznitelikleri, boyutu ve genişletilen türü göz önünde bulundurularak iç içe bir tür tanımlar.
DefineNestedType(String, TypeAttributes, Type, PackingSize)	Adı, öznitelikleri, genişletilen türü ve paketleme boyutu göz önünde bulundurularak iç içe bir tür tanımlar.
DefineNestedType(String, TypeAttributes, Type, Type[])	Adı, öznitelikleri, genişletilen türü ve uyguladığı arabirimleri göz önünde bulundurarak iç içe bir tür tanımlar.
DefineNestedType(String, TypeAttributes, Type)	Adı, öznitelikleri ve genişletilen türü göz önünde bulundurularak iç içe bir tür tanımlar.
DefineNestedType(String, TypeAttributes)	Adı ve öznitelikleri göz önünde bulundurularak iç içe bir tür tanımlar.
DefineNestedType(String)	Adı verilen iç içe bir tür tanımlar.
DefinePInvokeMethod(String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Adı, yönteminin tanımlandığı DLL'nin adı, yöntemin öznitelikleri, yöntemin çağırma kuralı, yöntemin dönüş türü, yöntemin parametrelerinin türleri ve PInvoke bayraklar verilen bir PInvoke yöntemi tanımlar.
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Adı, yöntemin tanımlandığı DLL'nin adı, giriş noktasının adı, yöntemin öznitelikleri, yöntemin çağırma kuralı, yöntemin dönüş türü, yöntemin parametrelerinin türleri ve PInvoke bayraklar verilen bir PInvoke yöntemi tanımlar.
DefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][], CallingConvention, CharSet)	Adı, yönteminin tanımlandığı DLL'nin adı, giriş noktasının adı, yöntemin öznitelikleri, yöntemin çağırma kuralı, yöntemin dönüş türü, yöntemin parametre türleri, PInvoke bayraklar ve parametreler ve dönüş türü için özel değiştiriciler verilen bir PInvoke yöntemi tanımlar.
DefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Türüne, verilen ad, çağırma kuralı, özellik imzası ve özel değiştiricilerle yeni bir özellik ekler.
DefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[])	Türüne, verilen ad, öznitelikler, çağırma kuralı ve özellik imzası ile yeni bir özellik ekler.
DefineProperty(String, PropertyAttributes, Type, Type[], Type[], Type[], Type[][], Type[][])	Türüne verilen ad, özellik imzası ve özel değiştiricilerle yeni bir özellik ekler.
DefineProperty(String, PropertyAttributes, Type, Type[])	Türüne, verilen ad ve özellik imzasıyla yeni bir özellik ekler.
DefineTypeInitializer()	Bu tür için başlatıcıyı tanımlar.
DefineUninitializedData(String, Int32, FieldAttributes)	Taşınabilir yürütülebilir (PE) dosyasının .sdata bölümünde başlatılmamış bir veri alanı tanımlar.
Equals(Object)	Geçerli Type nesnenin temel sistem türünün belirtilen Objecttemel sistem türüyle aynı olup olmadığını belirler. (Devralındığı yer: Type)
Equals(Type)	Geçerlinin Type temel sistem türünün belirtilen Typetemel sistem türüyle aynı olup olmadığını belirler. (Devralındığı yer: Type)
GetAttributeFlagsImpl()	Türetilmiş bir sınıfta geçersiz kılındığında, özelliğini uygular Attributes ve ile ilişkili öznitelikleri gösteren sabit listesi değerlerinin bit düzeyinde bir bileşimini Typealır. (Devralındığı yer: Type)
GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Belirtilen bağlama kısıtlamalarını ve belirtilen çağırma kuralını kullanarak parametreleri belirtilen bağımsız değişken türleri ve değiştiricilerle eşleşen bir oluşturucu arar. (Devralındığı yer: Type)
GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])	Belirtilen bağlama kısıtlamalarını kullanarak parametreleri belirtilen bağımsız değişken türleri ve değiştiricilerle eşleşen bir oluşturucu arar. (Devralındığı yer: Type)
GetConstructor(Type, ConstructorInfo)	Belirtilen genel tür tanımının belirtilen oluşturucusunun karşılık gelen, belirtilen genel tür oluşturucusunun oluşturucusunu döndürür.
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen bağlama kısıtlamalarını ve belirtilen çağırma kuralını kullanarak parametreleri belirtilen bağımsız değişken türleri ve değiştiricilerle eşleşen bir oluşturucu arar. (Devralındığı yer: Type)
GetConstructors(BindingFlags)	Belirtilen şekilde, bu sınıf için tanımlanan genel ve ortak olmayan oluşturucuları temsil eden bir nesne dizisi ConstructorInfo döndürür.
GetCustomAttributes(Boolean)	Bu tür için tanımlanan tüm özel öznitelikleri döndürür.
GetCustomAttributes(Type, Boolean)	Geçerli türün belirtilen türe atanabilen tüm özel özniteliklerini döndürür.
GetCustomAttributesData()	Hedef üyeye CustomAttributeData uygulanmış öznitelikler hakkındaki verileri temsil eden nesnelerin listesini döndürür. (Devralındığı yer: MemberInfo)
GetDeclaredEvent(String)	Geçerli tür tarafından bildirilen belirtilen olayı temsil eden bir nesne döndürür. (Devralındığı yer: TypeInfo)
GetDeclaredField(String)	Geçerli tür tarafından bildirilen belirtilen alanı temsil eden bir nesne döndürür. (Devralındığı yer: TypeInfo)
GetDeclaredMethod(String)	Geçerli tür tarafından bildirilen belirtilen yöntemi temsil eden bir nesne döndürür. (Devralındığı yer: TypeInfo)
GetDeclaredMethods(String)	Belirtilen adla eşleşen geçerli türde bildirilen tüm yöntemleri içeren bir koleksiyon döndürür. (Devralındığı yer: TypeInfo)
GetDeclaredNestedType(String)	Geçerli tür tarafından bildirilen belirtilen iç içe türü temsil eden bir nesne döndürür. (Devralındığı yer: TypeInfo)
GetDeclaredProperty(String)	Geçerli tür tarafından bildirilen belirtilen özelliği temsil eden bir nesne döndürür. (Devralındığı yer: TypeInfo)
GetElementType()	Bu yöntemin çağrılması her zaman oluşturur NotSupportedException.
GetEvent(String, BindingFlags)	Belirtilen ada sahip olayı döndürür.
GetEvents()	Bu tür tarafından bildirilen veya devralınan genel olayları döndürür.
GetEvents(BindingFlags)	Bu tür tarafından bildirilen genel ve genel olmayan olayları döndürür.
GetField(String, BindingFlags)	Verilen adla belirtilen alanı döndürür.
GetField(Type, FieldInfo)	Belirtilen oluşturulan genel türün, genel tür tanımının belirtilen alanına karşılık gelen alanını döndürür.
GetFields(BindingFlags)	Bu tür tarafından bildirilen genel ve genel olmayan alanları döndürür.
GetGenericArguments()	Genel bir türün Type tür bağımsız değişkenlerini veya genel tür tanımının tür parametrelerini temsil eden bir nesne dizisi döndürür.
GetGenericTypeDefinition()	Type Geçerli türün alınabileceği genel tür tanımını temsil eden bir nesne döndürür.
GetHashCode()	Bu örneğin karma kodunu döndürür. (Devralındığı yer: Type)
GetInterface(String, Boolean)	Bu sınıf tarafından uygulanan arabirimi (doğrudan veya dolaylı olarak) ve verilen arabirim adıyla eşleşen tam adı döndürür.
GetInterfaceMap(Type)	İstenen arabirim için bir arabirim eşlemesi döndürür.
GetInterfaces()	Bu tür ve temel türleri üzerinde uygulanan tüm arabirimlerden oluşan bir dizi döndürür.
GetMember(String, MemberTypes, BindingFlags)	Belirtilen şekilde, bu tür tarafından bildirilen veya devralınan tüm genel ve genel olmayan üyeleri döndürür.
GetMembers(BindingFlags)	Bu tür tarafından bildirilen veya devralınan genel ve genel olmayan üyelerin üyelerini döndürür.
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Belirtilen bağlama kısıtlamalarını ve belirtilen çağırma kuralını kullanarak parametreleri belirtilen bağımsız değişken türleri ve değiştiricilerle eşleşen belirtilen yöntemi arar. (Devralındığı yer: Type)
GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])	Belirtilen bağlama kısıtlamalarını kullanarak parametreleri belirtilen bağımsız değişken türleri ve değiştiricilerle eşleşen belirtilen yöntemi arar. (Devralındığı yer: Type)
GetMethod(Type, MethodInfo)	Belirtilen genel tür tanımının belirtilen yöntemine karşılık gelen belirtilen genel türün yöntemini döndürür.
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen bağlama kısıtlamalarını ve belirtilen çağırma kuralını kullanarak parametreleri belirtilen bağımsız değişken türleri ve değiştiricilerle eşleşen belirtilen yöntemi arar. (Devralındığı yer: Type)
GetMethods(BindingFlags)	Belirtilen şekilde, bu tür tarafından bildirilen veya devralınan tüm genel ve genel olmayan yöntemleri döndürür.
GetNestedType(String, BindingFlags)	Bu tür tarafından bildirilen genel ve genel olmayan iç içe türleri döndürür.
GetNestedTypes(BindingFlags)	Bu tür tarafından bildirilen veya devralınan genel ve genel olmayan iç içe türleri döndürür.
GetProperties(BindingFlags)	Belirtilen şekilde, bu tür tarafından bildirilen veya devralınan tüm genel ve genel olmayan özellikleri döndürür.
GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Belirtilen bağlama kısıtlamalarını kullanarak parametreleri belirtilen bağımsız değişken türleri ve değiştiricilerle eşleşen belirtilen özelliği arar. (Devralındığı yer: Type)
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen bağlama kısıtlamalarını kullanarak parametreleri belirtilen bağımsız değişken türleri ve değiştiricilerle eşleşen belirtilen özelliği arar. (Devralındığı yer: Type)
GetType()	Geçerli Typealır. (Devralındığı yer: Type)
GetTypeCodeImpl()	Bu Type örneğin temel tür kodunu döndürür. (Devralındığı yer: Type)
HasElementTypeImpl()	Türetilmiş bir sınıfta geçersiz kılındığında, özelliğini uygular HasElementType ve geçerlinin başka bir türe mi başvurduğunu, yani geçerlinin TypeType bir dizi mi, işaretçi mi yoksa başvuruyla mı geçirildiğini belirler. (Devralındığı yer: Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)	Belirtilen bağlama kısıtlamalarını kullanarak ve belirtilen bağımsız değişken listesi ve kültürüyle eşleşen belirtilen üyeyi çağırır. (Devralındığı yer: Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])	Belirtilen üyeyi çağırır. Çağrılacak yöntemin erişilebilir olması ve belirtilen bağlayıcı ve çağırma özniteliklerinin kısıtlamaları altında belirtilen bağımsız değişken listesiyle en özel eşleşmeyi sağlaması gerekir.
InvokeMember(String, BindingFlags, Binder, Object, Object[])	Belirtilen bağlama kısıtlamalarını kullanarak ve belirtilen bağımsız değişken listesiyle eşleşen belirtilen üyeyi çağırır. (Devralındığı yer: Type)
IsArrayImpl()	Türetilmiş bir sınıfta geçersiz kılındığında özelliğini uygular ve öğesinin IsArrayType bir dizi olup olmadığını belirler. (Devralındığı yer: Type)
IsAssignableFrom(Type)	Belirtilen Type bir nesnenin bu nesneye atanıp atanamayacağını gösteren bir değer alır.
IsAssignableFrom(TypeInfo)	Belirtilen TypeInfo bir nesnenin bu nesneye atanıp atanamayacağını gösteren bir değer alır.
IsByRefImpl()	Türetilmiş bir sınıfta geçersiz kılındığında özelliğini uygular ve öğesinin IsByRefType başvuruya göre geçirilip geçirilmediğini belirler. (Devralındığı yer: Type)
IsCOMObjectImpl()	Türetilmiş bir sınıfta geçersiz kılındığında, özelliğini uygular ve öğesinin IsCOMObjectType bir COM nesnesi olup olmadığını belirler. (Devralındığı yer: Type)
IsContextfulImpl()	özelliğini uygular ve öğesinin IsContextful bir bağlamda barındırılıp Type barındırılamayacağını belirler. (Devralındığı yer: Type)
IsCreated()	Geçerli dinamik türün oluşturulup oluşturulmadığını gösteren bir değer döndürür.
IsDefined(Type, Boolean)	Geçerli türe özel bir özniteliğin uygulanıp uygulanmadığını belirler.
IsMarshalByRefImpl()	özelliğini uygular ve öğesinin IsMarshalByRef başvuruya göre sıralanıp sıralı olmadığını Type belirler. (Devralındığı yer: Type)
IsPointerImpl()	Türetilmiş bir sınıfta geçersiz kılındığında, özelliğini uygular ve öğesinin IsPointerType bir işaretçi olup olmadığını belirler. (Devralındığı yer: Type)
IsPrimitiveImpl()	Türetilmiş bir sınıfta geçersiz kılındığında özelliğini uygular ve öğesinin IsPrimitive ilkel türlerden biri olup olmadığını Type belirler. (Devralındığı yer: Type)
IsSubclassOf(Type)	Bu türün belirtilen türden türetilip türemediğini belirler.
IsValueTypeImpl()	özelliğini uygular ve değerinin IsValueType bir değer türü olup olmadığını Type belirler; bir sınıf veya arabirim değil. (Devralındığı yer: Type)
MakeArrayType()	Geçerli türün bir boyutlu dizisini temsil eden ve Type sıfırın alt sınırına sahip bir nesne döndürür.
MakeArrayType(Int32)	Type Belirtilen boyut sayısıyla geçerli türde bir diziyi temsil eden bir nesne döndürür.
MakeByRefType()	ref parametresi (Visual Basic'de ByRef) olarak geçirildiğinde geçerli türü temsil eden bir Type nesnesi döndürür.
MakeGenericType(Type[])	Geçerli genel tür tanımının tür parametreleri için bir tür dizisinin öğelerinin yerini alır ve sonuçta elde edilen türü döndürür.
MakePointerType()	Type Geçerli türe yönelik yönetilmeyen işaretçinin türünü temsil eden bir nesne döndürür.
MemberwiseClone()	Geçerli Objectbasit bir kopyasını oluşturur. (Devralındığı yer: Object)
SetCustomAttribute(ConstructorInfo, Byte[])	Belirtilen özel öznitelik blobu kullanarak özel bir öznitelik ayarlar.
SetCustomAttribute(CustomAttributeBuilder)	Özel öznitelik oluşturucu kullanarak özel bir öznitelik ayarlayın.
SetParent(Type)	Şu anda yapım aşamasında olan türün taban türünü ayarlar.
ToString()	Ad alanı dışında türün adını döndürür.

Belirtik Arabirim Kullanımları

Name	Description
_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Bir ad kümesini karşılık gelen bir dağıtma tanımlayıcısı kümesine eşler. (Devralındığı yer: MemberInfo)
_MemberInfo.GetType()	Sınıfını temsil eden Type bir MemberInfo nesne alır. (Devralındığı yer: MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)	Bir nesne için tür bilgilerini alır ve bu da bir arabirimin tür bilgisini almak için kullanılabilir. (Devralındığı yer: MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)	Bir nesnenin sağladığı tür bilgisi arabirimlerinin sayısını alır (0 ya da 1). (Devralındığı yer: MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Bir nesne tarafından kullanıma sunulan özelliklere ve yöntemlere erişim sağlar. (Devralındığı yer: MemberInfo)
_Type.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Bir ad kümesini karşılık gelen bir dağıtma tanımlayıcısı kümesine eşler. (Devralındığı yer: Type)
_Type.GetTypeInfo(UInt32, UInt32, IntPtr)	Bir nesne için tür bilgilerini alır ve bu da bir arabirimin tür bilgisini almak için kullanılabilir. (Devralındığı yer: Type)
_Type.GetTypeInfoCount(UInt32)	Bir nesnenin sağladığı tür bilgisi arabirimlerinin sayısını alır (0 ya da 1). (Devralındığı yer: Type)
_Type.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Bir nesne tarafından kullanıma sunulan özelliklere ve yöntemlere erişim sağlar. (Devralındığı yer: Type)
_TypeBuilder.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Bir ad kümesini karşılık gelen bir dağıtma tanımlayıcısı kümesine eşler.
_TypeBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)	Bir nesne için tür bilgilerini alır ve bu da bir arabirimin tür bilgisini almak için kullanılabilir.
_TypeBuilder.GetTypeInfoCount(UInt32)	Bir nesnenin sağladığı tür bilgisi arabirimlerinin sayısını alır (0 ya da 1).
_TypeBuilder.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Bir nesne tarafından kullanıma sunulan özelliklere ve yöntemlere erişim sağlar.
IReflectableType.GetTypeInfo()	Geçerli türün bir TypeInfo gösterimini nesne olarak döndürür. (Devralındığı yer: TypeInfo)

Uzantı Metotları

Name	Description
GetCustomAttribute(MemberInfo, Type, Boolean)	Belirtilen bir üyeye uygulanan belirtilen türdeki özel özniteliği alır ve isteğe bağlı olarak bu üyenin atalarını inceler.
GetCustomAttribute(MemberInfo, Type)	Belirtilen üyeye uygulanan belirtilen türde bir özel özniteliği alır.
GetCustomAttribute<T>(MemberInfo, Boolean)	Belirtilen bir üyeye uygulanan belirtilen türdeki özel özniteliği alır ve isteğe bağlı olarak bu üyenin atalarını inceler.
GetCustomAttribute<T>(MemberInfo)	Belirtilen üyeye uygulanan belirtilen türde bir özel özniteliği alır.
GetCustomAttributes(MemberInfo, Boolean)	Belirli bir üyeye uygulanan özel öznitelikler koleksiyonunu alır ve isteğe bağlı olarak bu üyenin atalarını inceler.
GetCustomAttributes(MemberInfo, Type, Boolean)	Belirtilen bir üyeye uygulanan belirtilen türdeki özel özniteliklerden oluşan bir koleksiyonu alır ve isteğe bağlı olarak bu üyenin atalarını inceler.
GetCustomAttributes(MemberInfo, Type)	Belirtilen üyeye uygulanan belirtilen türde özel özniteliklerden oluşan bir koleksiyonu alır.
GetCustomAttributes(MemberInfo)	Belirtilen üyeye uygulanan özel öznitelik koleksiyonunu alır.
GetCustomAttributes<T>(MemberInfo, Boolean)	Belirtilen bir üyeye uygulanan belirtilen türdeki özel özniteliklerden oluşan bir koleksiyonu alır ve isteğe bağlı olarak bu üyenin atalarını inceler.
GetCustomAttributes<T>(MemberInfo)	Belirtilen üyeye uygulanan belirtilen türde özel özniteliklerden oluşan bir koleksiyonu alır.
GetRuntimeEvent(Type, String)	Belirtilen olayı temsil eden bir nesne alır.
GetRuntimeEvents(Type)	Belirtilen türde tanımlanan tüm olayları temsil eden bir koleksiyon alır.
GetRuntimeField(Type, String)	Belirtilen bir alanı temsil eden bir nesneyi alır.
GetRuntimeFields(Type)	Belirtilen türde tanımlanan tüm alanları temsil eden bir koleksiyon alır.
GetRuntimeInterfaceMap(TypeInfo, Type)	Belirtilen tür ve belirtilen arabirim için bir arabirim eşlemesi döndürür.
GetRuntimeMethod(Type, String, Type[])	Belirtilen yöntemi temsil eden bir nesneyi alır.
GetRuntimeMethods(Type)	Belirtilen türde tanımlanan tüm yöntemleri temsil eden bir koleksiyon alır.
GetRuntimeProperties(Type)	Belirtilen türde tanımlanan tüm özellikleri temsil eden bir koleksiyon alır.
GetRuntimeProperty(Type, String)	Belirtilen özelliği temsil eden bir nesneyi alır.
GetTypeInfo(Type)	TypeInfo Belirtilen türün gösterimini döndürür.
IsDefined(MemberInfo, Type, Boolean)	Belirtilen türde özel özniteliklerin belirtilen bir üyeye uygulanıp uygulanmadığını ve isteğe bağlı olarak üst öğeye uygulanıp uygulanmadığını gösterir.
IsDefined(MemberInfo, Type)	Belirtilen türde özel özniteliklerin belirtilen üyeye uygulanıp uygulanmadığını gösterir.

Ayrıca bkz.

• Nasıl yapılır: Yansıma Yayma ile Genel Tür Tanımlama