TypeBuilder Sınıf

Tanım

Ad Alanı:

System.Reflection.Emit

Bütünleştirilmiş Kod:

System.Reflection.Emit.dll

Kaynak:

TypeBuilder.cs

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

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

public abstract class TypeBuilder : System.Reflection.TypeInfo

type TypeBuilder = class
    inherit TypeInfo

Public MustInherit Class TypeBuilder
Inherits TypeInfo

Devralma

Object

MemberInfo

Type

TypeInfo

TypeBuilder

Örnekler

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

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;

void main()
{
    // This code creates an assembly that contains one type,
    // named "MyDynamicType", that has a private field, a property
    // that gets and sets the private field, constructors that
    // initialize the private field, and a method that multiplies
    // a user-supplied number by the private field value and returns
    // the result. In Visual C++ the type might look like this:
    /*
      public ref class MyDynamicType
      {
      private:
          int m_number;

      public:
          MyDynamicType() : m_number(42) {};
          MyDynamicType(int initNumber) : m_number(initNumber) {};
      
          property int Number
          {
              int get() { return m_number; }
              void set(int value) { m_number = value; }
          }

          int MyMethod(int multiplier)
          {
              return m_number * multiplier;
          }
      };
    */
      
    AssemblyName^ aName = gcnew AssemblyName("DynamicAssemblyExample");
    AssemblyBuilder^ ab = 
        AssemblyBuilder::DefineDynamicAssembly(
            aName, 
            AssemblyBuilderAccess::Run);

    // The module name is usually the same as the assembly name
    ModuleBuilder^ mb = 
        ab->DefineDynamicModule(aName->Name);
      
    TypeBuilder^ tb = mb->DefineType(
        "MyDynamicType", 
         TypeAttributes::Public);

    // Add a private field of type int (Int32).
    FieldBuilder^ fbNumber = tb->DefineField(
        "m_number", 
        int::typeid, 
        FieldAttributes::Private);

    // Define a constructor that takes an integer argument and 
    // stores it in the private field. 
    array<Type^>^ parameterTypes = { int::typeid };
    ConstructorBuilder^ ctor1 = tb->DefineConstructor(
        MethodAttributes::Public, 
        CallingConventions::Standard, 
        parameterTypes);

    ILGenerator^ ctor1IL = ctor1->GetILGenerator();
    // For a constructor, argument zero is a reference to the new
    // instance. Push it on the stack before calling the base
    // class constructor. Specify the default constructor of the 
    // base class (System::Object) by passing an empty array of 
    // types (Type::EmptyTypes) to GetConstructor.
    ctor1IL->Emit(OpCodes::Ldarg_0);
    ctor1IL->Emit(OpCodes::Call, 
        Object::typeid->GetConstructor(Type::EmptyTypes));
    // Push the instance on the stack before pushing the argument
    // that is to be assigned to the private field m_number.
    ctor1IL->Emit(OpCodes::Ldarg_0);
    ctor1IL->Emit(OpCodes::Ldarg_1);
    ctor1IL->Emit(OpCodes::Stfld, fbNumber);
    ctor1IL->Emit(OpCodes::Ret);

    // Define a default constructor that supplies a default value
    // for the private field. For parameter types, pass the empty
    // array of types or pass nullptr.
    ConstructorBuilder^ ctor0 = tb->DefineConstructor(
        MethodAttributes::Public, 
        CallingConventions::Standard, 
        Type::EmptyTypes);

    ILGenerator^ ctor0IL = ctor0->GetILGenerator();
    ctor0IL->Emit(OpCodes::Ldarg_0);
    ctor0IL->Emit(OpCodes::Call, 
        Object::typeid->GetConstructor(Type::EmptyTypes));
    // For a constructor, argument zero is a reference to the new
    // instance. Push it on the stack before pushing the default
    // value on the stack.
    ctor0IL->Emit(OpCodes::Ldarg_0);
    ctor0IL->Emit(OpCodes::Ldc_I4_S, 42);
    ctor0IL->Emit(OpCodes::Stfld, fbNumber);
    ctor0IL->Emit(OpCodes::Ret);

    // Define a property named Number that gets and sets the private 
    // field.
    //
    // The last argument of DefineProperty is nullptr, because the
    // property has no parameters. (If you don't specify nullptr, you must
    // specify an array of Type objects. For a parameterless property,
    // use the built-in array with no elements: Type::EmptyTypes)
    PropertyBuilder^ pbNumber = tb->DefineProperty(
        "Number", 
        PropertyAttributes::HasDefault, 
        int::typeid, 
        nullptr);
      
    // The property "set" and property "get" methods require a special
    // set of attributes.
    MethodAttributes getSetAttr = MethodAttributes::Public | 
        MethodAttributes::SpecialName | MethodAttributes::HideBySig;

    // Define the "get" accessor method for Number. The method returns
    // an integer and has no arguments. (Note that nullptr could be 
    // used instead of Types::EmptyTypes)
    MethodBuilder^ mbNumberGetAccessor = tb->DefineMethod(
        "get_Number", 
        getSetAttr, 
        int::typeid, 
        Type::EmptyTypes);
      
    ILGenerator^ numberGetIL = mbNumberGetAccessor->GetILGenerator();
    // For an instance property, argument zero is the instance. Load the 
    // instance, then load the private field and return, leaving the
    // field value on the stack.
    numberGetIL->Emit(OpCodes::Ldarg_0);
    numberGetIL->Emit(OpCodes::Ldfld, fbNumber);
    numberGetIL->Emit(OpCodes::Ret);
    
    // Define the "set" accessor method for Number, which has no return
    // type and takes one argument of type int (Int32).
    MethodBuilder^ mbNumberSetAccessor = tb->DefineMethod(
        "set_Number", 
        getSetAttr, 
        nullptr, 
        gcnew array<Type^> { int::typeid });
      
    ILGenerator^ numberSetIL = mbNumberSetAccessor->GetILGenerator();
    // Load the instance and then the numeric argument, then store the
    // argument in the field.
    numberSetIL->Emit(OpCodes::Ldarg_0);
    numberSetIL->Emit(OpCodes::Ldarg_1);
    numberSetIL->Emit(OpCodes::Stfld, fbNumber);
    numberSetIL->Emit(OpCodes::Ret);
      
    // Last, map the "get" and "set" accessor methods to the 
    // PropertyBuilder. The property is now complete. 
    pbNumber->SetGetMethod(mbNumberGetAccessor);
    pbNumber->SetSetMethod(mbNumberSetAccessor);

    // Define a method that accepts an integer argument and returns
    // the product of that integer and the private field m_number. This
    // time, the array of parameter types is created on the fly.
    MethodBuilder^ meth = tb->DefineMethod(
        "MyMethod", 
        MethodAttributes::Public, 
        int::typeid, 
        gcnew array<Type^> { int::typeid });

    ILGenerator^ methIL = meth->GetILGenerator();
    // To retrieve the private instance field, load the instance it
    // belongs to (argument zero). After loading the field, load the 
    // argument one and then multiply. Return from the method with 
    // the return value (the product of the two numbers) on the 
    // execution stack.
    methIL->Emit(OpCodes::Ldarg_0);
    methIL->Emit(OpCodes::Ldfld, fbNumber);
    methIL->Emit(OpCodes::Ldarg_1);
    methIL->Emit(OpCodes::Mul);
    methIL->Emit(OpCodes::Ret);

    // Finish the type->
    Type^ t = tb->CreateType();

    // Because AssemblyBuilderAccess includes Run, the code can be
    // executed immediately. Start by getting reflection objects for
    // the method and the property.
    MethodInfo^ mi = t->GetMethod("MyMethod");
    PropertyInfo^ pi = t->GetProperty("Number");
  
    // Create an instance of MyDynamicType using the default 
    // constructor. 
    Object^ o1 = Activator::CreateInstance(t);

    // Display the value of the property, then change it to 127 and 
    // display it again. Use nullptr to indicate that the property
    // has no index.
    Console::WriteLine("o1->Number: {0}", pi->GetValue(o1, nullptr));
    pi->SetValue(o1, 127, nullptr);
    Console::WriteLine("o1->Number: {0}", pi->GetValue(o1, nullptr));

    // Call MyMethod, passing 22, and display the return value, 22
    // times 127. Arguments must be passed as an array, even when
    // there is only one.
    array<Object^>^ arguments = { 22 };
    Console::WriteLine("o1->MyMethod(22): {0}", 
        mi->Invoke(o1, arguments));

    // Create an instance of MyDynamicType using the constructor
    // that specifies m_Number. The constructor is identified by
    // matching the types in the argument array. In this case, 
    // the argument array is created on the fly. Display the 
    // property value.
    Object^ o2 = Activator::CreateInstance(t, 
        gcnew array<Object^> { 5280 });
    Console::WriteLine("o2->Number: {0}", pi->GetValue(o2, nullptr));
};

/* This code produces the following output:

o1->Number: 42
o1->Number: 127
o1->MyMethod(22): 2794
o2->Number: 5280
 */

using System;
using System.Reflection;
using System.Reflection.Emit;

class DemoAssemblyBuilder
{
    public static void Main()
    {
        // This code creates an assembly that contains one type,
        // named "MyDynamicType", that has a private field, a property
        // that gets and sets the private field, constructors that
        // initialize the private field, and a method that multiplies
        // a user-supplied number by the private field value and returns
        // the result. In C# the type might look like this:
        /*
        public class MyDynamicType
        {
            private int m_number;

            public MyDynamicType() : this(42) {}
            public MyDynamicType(int initNumber)
            {
                m_number = initNumber;
            }

            public int Number
            {
                get { return m_number; }
                set { m_number = value; }
            }

            public int MyMethod(int multiplier)
            {
                return m_number * multiplier;
            }
        }
        */

        var aName = new AssemblyName("DynamicAssemblyExample");
        AssemblyBuilder ab =
            AssemblyBuilder.DefineDynamicAssembly(
                aName,
                AssemblyBuilderAccess.Run);

        // The module name is usually the same as the assembly name.
        ModuleBuilder mb = ab.DefineDynamicModule(aName.Name ?? "DynamicAssemblyExample");

        TypeBuilder tb = mb.DefineType(
            "MyDynamicType",
             TypeAttributes.Public);

        // Add a private field of type int (Int32).
        FieldBuilder fbNumber = tb.DefineField(
            "m_number",
            typeof(int),
            FieldAttributes.Private);

        // Define a constructor that takes an integer argument and
        // stores it in the private field.
        Type[] parameterTypes = { typeof(int) };
        ConstructorBuilder ctor1 = tb.DefineConstructor(
            MethodAttributes.Public,
            CallingConventions.Standard,
            parameterTypes);

        ILGenerator ctor1IL = ctor1.GetILGenerator();
        // For a constructor, argument zero is a reference to the new
        // instance. Push it on the stack before calling the base
        // class constructor. Specify the default constructor of the
        // base class (System.Object) by passing an empty array of
        // types (Type.EmptyTypes) to GetConstructor.
        ctor1IL.Emit(OpCodes.Ldarg_0);
        ConstructorInfo? ci = typeof(object).GetConstructor(Type.EmptyTypes);
        ctor1IL.Emit(OpCodes.Call, ci!);
        // Push the instance on the stack before pushing the argument
        // that is to be assigned to the private field m_number.
        ctor1IL.Emit(OpCodes.Ldarg_0);
        ctor1IL.Emit(OpCodes.Ldarg_1);
        ctor1IL.Emit(OpCodes.Stfld, fbNumber);
        ctor1IL.Emit(OpCodes.Ret);

        // Define a default constructor that supplies a default value
        // for the private field. For parameter types, pass the empty
        // array of types or pass null.
        ConstructorBuilder ctor0 = tb.DefineConstructor(
            MethodAttributes.Public,
            CallingConventions.Standard,
            Type.EmptyTypes);

        ILGenerator ctor0IL = ctor0.GetILGenerator();
        // For a constructor, argument zero is a reference to the new
        // instance. Push it on the stack before pushing the default
        // value on the stack, then call constructor ctor1.
        ctor0IL.Emit(OpCodes.Ldarg_0);
        ctor0IL.Emit(OpCodes.Ldc_I4_S, 42);
        ctor0IL.Emit(OpCodes.Call, ctor1);
        ctor0IL.Emit(OpCodes.Ret);

        // Define a property named Number that gets and sets the private
        // field.
        //
        // The last argument of DefineProperty is null, because the
        // property has no parameters. (If you don't specify null, you must
        // specify an array of Type objects. For a parameterless property,
        // use the built-in array with no elements: Type.EmptyTypes)
        PropertyBuilder pbNumber = tb.DefineProperty(
            "Number",
            PropertyAttributes.HasDefault,
            typeof(int),
            null);

        // The property "set" and property "get" methods require a special
        // set of attributes.
        MethodAttributes getSetAttr = MethodAttributes.Public |
            MethodAttributes.SpecialName | MethodAttributes.HideBySig;

        // Define the "get" accessor method for Number. The method returns
        // an integer and has no arguments. (Note that null could be
        // used instead of Types.EmptyTypes)
        MethodBuilder mbNumberGetAccessor = tb.DefineMethod(
            "get_Number",
            getSetAttr,
            typeof(int),
            Type.EmptyTypes);

        ILGenerator numberGetIL = mbNumberGetAccessor.GetILGenerator();
        // For an instance property, argument zero is the instance. Load the
        // instance, then load the private field and return, leaving the
        // field value on the stack.
        numberGetIL.Emit(OpCodes.Ldarg_0);
        numberGetIL.Emit(OpCodes.Ldfld, fbNumber);
        numberGetIL.Emit(OpCodes.Ret);

        // Define the "set" accessor method for Number, which has no return
        // type and takes one argument of type int (Int32).
        MethodBuilder mbNumberSetAccessor = tb.DefineMethod(
            "set_Number",
            getSetAttr,
            null,
            new Type[] { typeof(int) });

        ILGenerator numberSetIL = mbNumberSetAccessor.GetILGenerator();
        // Load the instance and then the numeric argument, then store the
        // argument in the field.
        numberSetIL.Emit(OpCodes.Ldarg_0);
        numberSetIL.Emit(OpCodes.Ldarg_1);
        numberSetIL.Emit(OpCodes.Stfld, fbNumber);
        numberSetIL.Emit(OpCodes.Ret);

        // Last, map the "get" and "set" accessor methods to the
        // PropertyBuilder. The property is now complete.
        pbNumber.SetGetMethod(mbNumberGetAccessor);
        pbNumber.SetSetMethod(mbNumberSetAccessor);

        // Define a method that accepts an integer argument and returns
        // the product of that integer and the private field m_number. This
        // time, the array of parameter types is created on the fly.
        MethodBuilder meth = tb.DefineMethod(
            "MyMethod",
            MethodAttributes.Public,
            typeof(int),
            new Type[] { typeof(int) });

        ILGenerator methIL = meth.GetILGenerator();
        // To retrieve the private instance field, load the instance it
        // belongs to (argument zero). After loading the field, load the
        // argument one and then multiply. Return from the method with
        // the return value (the product of the two numbers) on the
        // execution stack.
        methIL.Emit(OpCodes.Ldarg_0);
        methIL.Emit(OpCodes.Ldfld, fbNumber);
        methIL.Emit(OpCodes.Ldarg_1);
        methIL.Emit(OpCodes.Mul);
        methIL.Emit(OpCodes.Ret);

        // Finish the type.
        Type? t = tb.CreateType();

        // Because AssemblyBuilderAccess includes Run, the code can be
        // executed immediately. Start by getting reflection objects for
        // the method and the property.
        MethodInfo? mi = t?.GetMethod("MyMethod");
        PropertyInfo? pi = t?.GetProperty("Number");

        // Create an instance of MyDynamicType using the default
        // constructor.
        object? o1 = null;
        if (t is not null)
            o1 = Activator.CreateInstance(t);

        // Display the value of the property, then change it to 127 and
        // display it again. Use null to indicate that the property
        // has no index.
        Console.WriteLine("o1.Number: {0}", pi?.GetValue(o1, null));
        pi?.SetValue(o1, 127, null);
        Console.WriteLine("o1.Number: {0}", pi?.GetValue(o1, null));

        // Call MyMethod, passing 22, and display the return value, 22
        // times 127. Arguments must be passed as an array, even when
        // there is only one.
        object[] arguments = { 22 };
        Console.WriteLine("o1.MyMethod(22): {0}",
            mi?.Invoke(o1, arguments));

        // Create an instance of MyDynamicType using the constructor
        // that specifies m_Number. The constructor is identified by
        // matching the types in the argument array. In this case,
        // the argument array is created on the fly. Display the
        // property value.
        object? o2 = null;
        if (t is not null)
            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ği, kullanarak TypeBuilderdinamik olarak bir türün nasıl derlenmiş olduğunu gösterir.

using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
Type^ DynamicDotProductGen()
{
   Type^ ivType = nullptr;
   array<Type^>^temp0 = {int::typeid,int::typeid,int::typeid};
   array<Type^>^ctorParams = temp0;
   AppDomain^ myDomain = Thread::GetDomain();
   AssemblyName^ myAsmName = gcnew AssemblyName;
   myAsmName->Name = "IntVectorAsm";
   AssemblyBuilder^ myAsmBuilder = myDomain->DefineDynamicAssembly( myAsmName, AssemblyBuilderAccess::RunAndSave );
   ModuleBuilder^ IntVectorModule = myAsmBuilder->DefineDynamicModule( "IntVectorModule", "Vector.dll" );
   TypeBuilder^ ivTypeBld = IntVectorModule->DefineType( "IntVector", TypeAttributes::Public );
   FieldBuilder^ xField = ivTypeBld->DefineField( "x", int::typeid, FieldAttributes::Private );
   FieldBuilder^ yField = ivTypeBld->DefineField( "y", int::typeid, FieldAttributes::Private );
   FieldBuilder^ zField = ivTypeBld->DefineField( "z", int::typeid, FieldAttributes::Private );
   Type^ objType = Type::GetType( "System.Object" );
   ConstructorInfo^ objCtor = objType->GetConstructor( gcnew array<Type^>(0) );
   ConstructorBuilder^ ivCtor = ivTypeBld->DefineConstructor( MethodAttributes::Public, CallingConventions::Standard, ctorParams );
   ILGenerator^ ctorIL = ivCtor->GetILGenerator();
   ctorIL->Emit( OpCodes::Ldarg_0 );
   ctorIL->Emit( OpCodes::Call, objCtor );
   ctorIL->Emit( OpCodes::Ldarg_0 );
   ctorIL->Emit( OpCodes::Ldarg_1 );
   ctorIL->Emit( OpCodes::Stfld, xField );
   ctorIL->Emit( OpCodes::Ldarg_0 );
   ctorIL->Emit( OpCodes::Ldarg_2 );
   ctorIL->Emit( OpCodes::Stfld, yField );
   ctorIL->Emit( OpCodes::Ldarg_0 );
   ctorIL->Emit( OpCodes::Ldarg_3 );
   ctorIL->Emit( OpCodes::Stfld, zField );
   ctorIL->Emit( OpCodes::Ret );
   
   // This method will find the dot product of the stored vector
   // with another.
   array<Type^>^temp1 = {ivTypeBld};
   array<Type^>^dpParams = temp1;
   
   // Here, you create a MethodBuilder containing the
   // name, the attributes (public, static, private, and so on),
   // the return type (int, in this case), and a array of Type
   // indicating the type of each parameter. Since the sole parameter
   // is a IntVector, the very class you're creating, you will
   // pass in the TypeBuilder (which is derived from Type) instead of
   // a Type object for IntVector, avoiding an exception.
   // -- This method would be declared in C# as:
   //    public int DotProduct(IntVector aVector)
   MethodBuilder^ dotProductMthd = ivTypeBld->DefineMethod( "DotProduct", MethodAttributes::Public, int::typeid, dpParams );
   
   // A ILGenerator can now be spawned, attached to the MethodBuilder.
   ILGenerator^ mthdIL = dotProductMthd->GetILGenerator();
   
   // Here's the body of our function, in MSIL form. We're going to find the
   // "dot product" of the current vector instance with the passed vector
   // instance. For reference purposes, the equation is:
   // (x1 * x2) + (y1 * y2) + (z1 * z2) = the dot product
   // First, you'll load the reference to the current instance "this"
   // stored in argument 0 (ldarg.0) onto the stack. Ldfld, the subsequent
   // instruction, will pop the reference off the stack and look up the
   // field "x", specified by the FieldInfo token "xField".
   mthdIL->Emit( OpCodes::Ldarg_0 );
   mthdIL->Emit( OpCodes::Ldfld, xField );
   
   // That completed, the value stored at field "x" is now atop the stack.
   // Now, you'll do the same for the Object reference we passed as a
   // parameter, stored in argument 1 (ldarg.1). After Ldfld executed,
   // you'll have the value stored in field "x" for the passed instance
   // atop the stack.
   mthdIL->Emit( OpCodes::Ldarg_1 );
   mthdIL->Emit( OpCodes::Ldfld, xField );
   
   // There will now be two values atop the stack - the "x" value for the
   // current vector instance, and the "x" value for the passed instance.
   // You'll now multiply them, and push the result onto the evaluation stack.
   mthdIL->Emit( OpCodes::Mul_Ovf_Un );
   
   // Now, repeat this for the "y" fields of both vectors.
   mthdIL->Emit( OpCodes::Ldarg_0 );
   mthdIL->Emit( OpCodes::Ldfld, yField );
   mthdIL->Emit( OpCodes::Ldarg_1 );
   mthdIL->Emit( OpCodes::Ldfld, yField );
   mthdIL->Emit( OpCodes::Mul_Ovf_Un );
   
   // At this time, the results of both multiplications should be atop
   // the stack. You'll now add them and push the result onto the stack.
   mthdIL->Emit( OpCodes::Add_Ovf_Un );
   
   // Multiply both "z" field and push the result onto the stack.
   mthdIL->Emit( OpCodes::Ldarg_0 );
   mthdIL->Emit( OpCodes::Ldfld, zField );
   mthdIL->Emit( OpCodes::Ldarg_1 );
   mthdIL->Emit( OpCodes::Ldfld, zField );
   mthdIL->Emit( OpCodes::Mul_Ovf_Un );
   
   // Finally, add the result of multiplying the "z" fields with the
   // result of the earlier addition, and push the result - the dot product -
   // onto the stack.
   mthdIL->Emit( OpCodes::Add_Ovf_Un );
   
   // The "ret" opcode will pop the last value from the stack and return it
   // to the calling method. You're all done!
   mthdIL->Emit( OpCodes::Ret );
   ivType = ivTypeBld->CreateType();
   return ivType;
}

int main()
{
   Type^ IVType = nullptr;
   Object^ aVector1 = nullptr;
   Object^ aVector2 = nullptr;
   array<Type^>^temp2 = {int::typeid,int::typeid,int::typeid};
   array<Type^>^aVtypes = temp2;
   array<Object^>^temp3 = {10,10,10};
   array<Object^>^aVargs1 = temp3;
   array<Object^>^temp4 = {20,20,20};
   array<Object^>^aVargs2 = temp4;
   
   // Call the  method to build our dynamic class.
   IVType = DynamicDotProductGen();
   Console::WriteLine( "---" );
   ConstructorInfo^ myDTctor = IVType->GetConstructor( aVtypes );
   aVector1 = myDTctor->Invoke( aVargs1 );
   aVector2 = myDTctor->Invoke( aVargs2 );
   array<Object^>^passMe = gcnew array<Object^>(1);
   passMe[ 0 ] = dynamic_cast<Object^>(aVector2);
   Console::WriteLine( "(10, 10, 10) . (20, 20, 20) = {0}", IVType->InvokeMember( "DotProduct", BindingFlags::InvokeMethod, nullptr, aVector1, passMe ) );
}

// +++ OUTPUT +++
// ---
// (10, 10, 10) . (20, 20, 20) = 600

using System;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;

class TestILGenerator
{
    public static Type DynamicDotProductGen()
    {
       Type ivType = null;
       Type[] ctorParams = new Type[] { typeof(int),
                                typeof(int),
                        typeof(int)};
    
       AppDomain myDomain = Thread.GetDomain();
       AssemblyName myAsmName = new AssemblyName();
       myAsmName.Name = "IntVectorAsm";
    
       AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
                      myAsmName,
                      AssemblyBuilderAccess.RunAndSave);

       ModuleBuilder IntVectorModule = myAsmBuilder.DefineDynamicModule("IntVectorModule",
                                        "Vector.dll");

       TypeBuilder ivTypeBld = IntVectorModule.DefineType("IntVector",
                                      TypeAttributes.Public);

       FieldBuilder xField = ivTypeBld.DefineField("x", typeof(int),
                                                       FieldAttributes.Private);
       FieldBuilder yField = ivTypeBld.DefineField("y", typeof(int),
                                                       FieldAttributes.Private);
       FieldBuilder zField = ivTypeBld.DefineField("z", typeof(int),
                                                       FieldAttributes.Private);

           Type objType = Type.GetType("System.Object");
           ConstructorInfo objCtor = objType.GetConstructor(new Type[0]);

       ConstructorBuilder ivCtor = ivTypeBld.DefineConstructor(
                      MethodAttributes.Public,
                      CallingConventions.Standard,
                      ctorParams);
       ILGenerator ctorIL = ivCtor.GetILGenerator();
           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Call, objCtor);
           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Ldarg_1);
           ctorIL.Emit(OpCodes.Stfld, xField);
           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Ldarg_2);
           ctorIL.Emit(OpCodes.Stfld, yField);
           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Ldarg_3);
           ctorIL.Emit(OpCodes.Stfld, zField);
       ctorIL.Emit(OpCodes.Ret);

       // This method will find the dot product of the stored vector
       // with another.

       Type[] dpParams = new Type[] { ivTypeBld };

           // Here, you create a MethodBuilder containing the
       // name, the attributes (public, static, private, and so on),
       // the return type (int, in this case), and a array of Type
       // indicating the type of each parameter. Since the sole parameter
       // is a IntVector, the very class you're creating, you will
       // pass in the TypeBuilder (which is derived from Type) instead of
       // a Type object for IntVector, avoiding an exception.

       // -- This method would be declared in C# as:
       //    public int DotProduct(IntVector aVector)

           MethodBuilder dotProductMthd = ivTypeBld.DefineMethod(
                                  "DotProduct",
                          MethodAttributes.Public,
                                          typeof(int),
                                          dpParams);

       // A ILGenerator can now be spawned, attached to the MethodBuilder.

       ILGenerator mthdIL = dotProductMthd.GetILGenerator();
    
       // Here's the body of our function, in MSIL form. We're going to find the
       // "dot product" of the current vector instance with the passed vector
       // instance. For reference purposes, the equation is:
       // (x1 * x2) + (y1 * y2) + (z1 * z2) = the dot product

       // First, you'll load the reference to the current instance "this"
       // stored in argument 0 (ldarg.0) onto the stack. Ldfld, the subsequent
       // instruction, will pop the reference off the stack and look up the
       // field "x", specified by the FieldInfo token "xField".

       mthdIL.Emit(OpCodes.Ldarg_0);
       mthdIL.Emit(OpCodes.Ldfld, xField);

       // That completed, the value stored at field "x" is now atop the stack.
       // Now, you'll do the same for the object reference we passed as a
       // parameter, stored in argument 1 (ldarg.1). After Ldfld executed,
       // you'll have the value stored in field "x" for the passed instance
       // atop the stack.

       mthdIL.Emit(OpCodes.Ldarg_1);
       mthdIL.Emit(OpCodes.Ldfld, xField);

           // There will now be two values atop the stack - the "x" value for the
       // current vector instance, and the "x" value for the passed instance.
       // You'll now multiply them, and push the result onto the evaluation stack.

       mthdIL.Emit(OpCodes.Mul_Ovf_Un);

       // Now, repeat this for the "y" fields of both vectors.

       mthdIL.Emit(OpCodes.Ldarg_0);
       mthdIL.Emit(OpCodes.Ldfld, yField);
       mthdIL.Emit(OpCodes.Ldarg_1);
       mthdIL.Emit(OpCodes.Ldfld, yField);
       mthdIL.Emit(OpCodes.Mul_Ovf_Un);

       // At this time, the results of both multiplications should be atop
       // the stack. You'll now add them and push the result onto the stack.

       mthdIL.Emit(OpCodes.Add_Ovf_Un);

       // Multiply both "z" field and push the result onto the stack.
       mthdIL.Emit(OpCodes.Ldarg_0);
       mthdIL.Emit(OpCodes.Ldfld, zField);
       mthdIL.Emit(OpCodes.Ldarg_1);
       mthdIL.Emit(OpCodes.Ldfld, zField);
       mthdIL.Emit(OpCodes.Mul_Ovf_Un);

       // Finally, add the result of multiplying the "z" fields with the
       // result of the earlier addition, and push the result - the dot product -
       // onto the stack.
       mthdIL.Emit(OpCodes.Add_Ovf_Un);

       // The "ret" opcode will pop the last value from the stack and return it
       // to the calling method. You're all done!

       mthdIL.Emit(OpCodes.Ret);

       ivType = ivTypeBld.CreateType();

       return ivType;
    }

    public static void Main() {
    
       Type IVType = null;
           object aVector1 = null;
           object aVector2 = null;
       Type[] aVtypes = new Type[] {typeof(int), typeof(int), typeof(int)};
           object[] aVargs1 = new object[] {10, 10, 10};
           object[] aVargs2 = new object[] {20, 20, 20};
    
       // Call the  method to build our dynamic class.

       IVType = DynamicDotProductGen();

           Console.WriteLine("---");

       ConstructorInfo myDTctor = IVType.GetConstructor(aVtypes);
       aVector1 = myDTctor.Invoke(aVargs1);
       aVector2 = myDTctor.Invoke(aVargs2);

       object[] passMe = new object[1];
           passMe[0] = (object)aVector2;

       Console.WriteLine("(10, 10, 10) . (20, 20, 20) = {0}",
                 IVType.InvokeMember("DotProduct",
                          BindingFlags.InvokeMethod,
                          null,
                          aVector1,
                          passMe));

       // +++ OUTPUT +++
       // ---
       // (10, 10, 10) . (20, 20, 20) = 600
    }
}

Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit

 _


Class TestILGenerator
   
   
   Public Shared Function DynamicDotProductGen() As Type
      
      Dim ivType As Type = Nothing
      Dim ctorParams() As Type = {GetType(Integer), GetType(Integer), GetType(Integer)}
      
      Dim myDomain As AppDomain = Thread.GetDomain()
      Dim myAsmName As New AssemblyName()
      myAsmName.Name = "IntVectorAsm"
      
      Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly( _
                        myAsmName, _
                        AssemblyBuilderAccess.RunAndSave)
      
      Dim IntVectorModule As ModuleBuilder = myAsmBuilder.DefineDynamicModule( _
                         "IntVectorModule", _
                         "Vector.dll")
      
      Dim ivTypeBld As TypeBuilder = IntVectorModule.DefineType("IntVector", TypeAttributes.Public)
      
      Dim xField As FieldBuilder = ivTypeBld.DefineField("x", _
                                 GetType(Integer), _
                                 FieldAttributes.Private)
      Dim yField As FieldBuilder = ivTypeBld.DefineField("y", _ 
                                 GetType(Integer), _
                                 FieldAttributes.Private)
      Dim zField As FieldBuilder = ivTypeBld.DefineField("z", _
                                 GetType(Integer), _
                                 FieldAttributes.Private)
      
      
      Dim objType As Type = Type.GetType("System.Object")
      Dim objCtor As ConstructorInfo = objType.GetConstructor(New Type() {})
      
      Dim ivCtor As ConstructorBuilder = ivTypeBld.DefineConstructor( _
                     MethodAttributes.Public, _
                     CallingConventions.Standard, _
                     ctorParams)
      Dim ctorIL As ILGenerator = ivCtor.GetILGenerator()
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Call, objCtor)
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_1)
      ctorIL.Emit(OpCodes.Stfld, xField)
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_2)
      ctorIL.Emit(OpCodes.Stfld, yField)
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_3)
      ctorIL.Emit(OpCodes.Stfld, zField)
      ctorIL.Emit(OpCodes.Ret)
     

      ' Now, you'll construct the method find the dot product of two vectors. First,
      ' let's define the parameters that will be accepted by the method. In this case,
      ' it's an IntVector itself!

      Dim dpParams() As Type = {ivTypeBld}
      
      ' Here, you create a MethodBuilder containing the
      ' name, the attributes (public, static, private, and so on),
      ' the return type (int, in this case), and a array of Type
      ' indicating the type of each parameter. Since the sole parameter
      ' is a IntVector, the very class you're creating, you will
      ' pass in the TypeBuilder (which is derived from Type) instead of 
      ' a Type object for IntVector, avoiding an exception. 
      ' -- This method would be declared in VB.NET as:
      '    Public Function DotProduct(IntVector aVector) As Integer

      Dim dotProductMthd As MethodBuilder = ivTypeBld.DefineMethod("DotProduct", _
                        MethodAttributes.Public, GetType(Integer), _
                                            dpParams)
      
      ' A ILGenerator can now be spawned, attached to the MethodBuilder.
      Dim mthdIL As ILGenerator = dotProductMthd.GetILGenerator()
      
      ' Here's the body of our function, in MSIL form. We're going to find the
      ' "dot product" of the current vector instance with the passed vector 
      ' instance. For reference purposes, the equation is:
      ' (x1 * x2) + (y1 * y2) + (z1 * z2) = the dot product
      ' First, you'll load the reference to the current instance "this"
      ' stored in argument 0 (ldarg.0) onto the stack. Ldfld, the subsequent
      ' instruction, will pop the reference off the stack and look up the
      ' field "x", specified by the FieldInfo token "xField".
      mthdIL.Emit(OpCodes.Ldarg_0)
      mthdIL.Emit(OpCodes.Ldfld, xField)
      
      ' That completed, the value stored at field "x" is now atop the stack.
      ' Now, you'll do the same for the object reference we passed as a
      ' parameter, stored in argument 1 (ldarg.1). After Ldfld executed,
      ' you'll have the value stored in field "x" for the passed instance
      ' atop the stack.
      mthdIL.Emit(OpCodes.Ldarg_1)
      mthdIL.Emit(OpCodes.Ldfld, xField)
      
      ' There will now be two values atop the stack - the "x" value for the
      ' current vector instance, and the "x" value for the passed instance.
      ' You'll now multiply them, and push the result onto the evaluation stack.
      mthdIL.Emit(OpCodes.Mul_Ovf_Un)
      
      ' Now, repeat this for the "y" fields of both vectors.
      mthdIL.Emit(OpCodes.Ldarg_0)
      mthdIL.Emit(OpCodes.Ldfld, yField)
      mthdIL.Emit(OpCodes.Ldarg_1)
      mthdIL.Emit(OpCodes.Ldfld, yField)
      mthdIL.Emit(OpCodes.Mul_Ovf_Un)
      
      ' At this time, the results of both multiplications should be atop
      ' the stack. You'll now add them and push the result onto the stack.
      mthdIL.Emit(OpCodes.Add_Ovf_Un)
      
      ' Multiply both "z" field and push the result onto the stack.
      mthdIL.Emit(OpCodes.Ldarg_0)
      mthdIL.Emit(OpCodes.Ldfld, zField)
      mthdIL.Emit(OpCodes.Ldarg_1)
      mthdIL.Emit(OpCodes.Ldfld, zField)
      mthdIL.Emit(OpCodes.Mul_Ovf_Un)
      
      ' Finally, add the result of multiplying the "z" fields with the
      ' result of the earlier addition, and push the result - the dot product -
      ' onto the stack.
      mthdIL.Emit(OpCodes.Add_Ovf_Un)
      
      ' The "ret" opcode will pop the last value from the stack and return it
      ' to the calling method. You're all done!
      mthdIL.Emit(OpCodes.Ret)
      
      
      ivType = ivTypeBld.CreateType()
      
      Return ivType
   End Function 'DynamicDotProductGen
    
   
   Public Shared Sub Main()
      
      Dim IVType As Type = Nothing
      Dim aVector1 As Object = Nothing
      Dim aVector2 As Object = Nothing
      Dim aVtypes() As Type = {GetType(Integer), GetType(Integer), GetType(Integer)}
      Dim aVargs1() As Object = {10, 10, 10}
      Dim aVargs2() As Object = {20, 20, 20}
      
      ' Call the  method to build our dynamic class.
      IVType = DynamicDotProductGen()
      
      
      Dim myDTctor As ConstructorInfo = IVType.GetConstructor(aVtypes)
      aVector1 = myDTctor.Invoke(aVargs1)
      aVector2 = myDTctor.Invoke(aVargs2)
      
      Console.WriteLine("---")
      Dim passMe(0) As Object
      passMe(0) = CType(aVector2, Object)
      
      Console.WriteLine("(10, 10, 10) . (20, 20, 20) = {0}", _
                        IVType.InvokeMember("DotProduct", BindingFlags.InvokeMethod, _
                        Nothing, aVector1, passMe))
   End Sub
End Class



' +++ OUTPUT +++
' ---
' (10, 10, 10) . (20, 20, 20) = 600

Açıklamalar

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

Oluşturucular

TypeBuilder()

TypeBuilder sınıfının yeni bir örneğini başlatır.

Alanlar

UnspecifiedTypeSize

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

Özellikler

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.
Attributes	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
BaseType	Bu türün temel türünü alır.
ContainsGenericParameters	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
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.
GenericTypeArguments	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
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.
HasElementType	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
ImplementedInterfaces	Geçerli tür tarafından uygulanan arabirimlerin koleksiyonunu alır. (Devralındığı yer: TypeInfo)
IsAbstract	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsAnsiClass	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsArray	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsAutoClass	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsAutoLayout	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsByRef	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsByRefLike	Türün byref benzeri bir yapı olup olmadığını gösteren bir değer alır.
IsClass	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsCollectible	Bu MemberInfo nesnenin bir collectible AssemblyLoadContextiçinde tutulan derlemenin parçası olup olmadığını gösteren bir değer alır. (Devralındığı yer: MemberInfo)
IsCOMObject	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (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)
IsEnum	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsExplicitLayout	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsFunctionPointer	Geçerlinin Type işlev işaretçisi olup olmadığını gösteren bir değer alır. (Devralındığı yer: Type)
IsGenericMethodParameter	Geçerlinin Type genel bir yöntemin tanımında tür parametresini temsil edip etmediğini gösteren 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ı belirten 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.
IsGenericTypeParameter	Geçerli Type değerin genel bir türün tanımında tür parametresini temsil edip etmediğini gösteren bir değer alır. (Devralındığı yer: Type)
IsImport	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsInterface	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsLayoutSequential	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsMarshalByRef	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsNested	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsNestedAssembly	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsNestedFamANDAssem	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsNestedFamily	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsNestedFamORAssem	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsNestedPrivate	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsNestedPublic	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsNotPublic	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsPointer	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsPrimitive	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsPublic	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsSealed	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
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şlemler 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; yani, kritik işlemler gerçekleştirip gerçekleştiremeyeceğini ve saydam kodla erişilip erişilemeyeceğini gösterir.
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.
IsSerializable	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsSignatureType	Türün imza türü olup olmadığını gösteren bir değer alır. (Devralındığı yer: Type)
IsSpecialName	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsSZArray	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
IsTypeDefinition	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
IsUnicodeClass	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsUnmanagedFunctionPointer	Geçerlinin Type yönetilmeyen bir işlev işaretçisi olup olmadığını gösteren bir değer alır. (Devralındığı yer: Type)
IsValueType	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsVariableBoundArray	Türün çok boyutlu bir diziyi mi yoksa rastgele alt sınıra sahip bir diziyi mi temsil ettiğini gösteren bir değer alır. (Devralındığı yer: Type)
IsVisible	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
MemberType	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
MetadataToken	Meta verilerdeki geçerli dinamik modülü tanımlayan bir belirteç alır.
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.
PackingSizeCore	Türetilmiş bir sınıfta geçersiz kılındığında, 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.
SizeCore	Türetilmiş bir sınıfta geçersiz kılındığında, türün toplam boyutunu alır.
StructLayoutAttribute	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
TypeHandle	Dinamik modüllerde desteklenmez.
TypeInitializer	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
UnderlyingSystemType	Bu TypeBuilderiçin temel alınan sistem türünü döndürür.

Yöntemler

AddInterfaceImplementation(Type)	Bu türün uyguladığı bir arabirim ekler.
AddInterfaceImplementationCore(Type)	Türetilmiş bir sınıfta geçersiz kılındığında, 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ında 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.
CreateTypeInfoCore()	Türetilmiş bir sınıfta geçersiz kılındığında, bu türü temsil eden bir TypeInfo nesne alır.
DefineConstructor(MethodAttributes, CallingConventions, Type[])	Belirtilen öznitelikler ve imza ile türüne yeni bir oluşturucu ekler.
DefineConstructor(MethodAttributes, CallingConventions, Type[], Type[][], Type[][])	Belirtilen öznitelikler, imza ve özel değiştiricilerle türüne yeni bir oluşturucu ekler.
DefineConstructorCore(MethodAttributes, CallingConventions, Type[], Type[][], Type[][])	Türetilmiş bir sınıfta geçersiz kılındığında, türüne verilen öznitelikler, imza ve özel değiştiricilerle 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.
DefineDefaultConstructorCore(MethodAttributes)	Türetilmiş bir sınıfta geçersiz kılındığında parametresiz oluşturucuyu tanımlar. Burada tanımlanan oluşturucu, üst öğesinin parametresiz oluşturucusunu çağırır.
DefineEvent(String, EventAttributes, Type)	Türüne verilen ad, öznitelikler ve olay türüyle yeni bir olay ekler.
DefineEventCore(String, EventAttributes, Type)	Türetilmiş bir sınıfta geçersiz kılındığında, 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.
DefineFieldCore(String, Type, Type[], Type[], FieldAttributes)	Türetilmiş bir sınıfta geçersiz kılındığında, 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.
DefineGenericParametersCore(String[])	Türetilmiş bir sınıfta geçersiz kılındığında, geçerli türün genel tür parametrelerini tanımlar ve bunların sayılarını ve adlarını belirtir.
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.
DefineInitializedDataCore(String, Byte[], FieldAttributes)	Türetilmiş bir sınıfta geçersiz kılındığında, 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)	Belirtilen ad ve yöntem öznitelikleriyle türüne yeni bir yöntem ekler.
DefineMethod(String, MethodAttributes, CallingConventions)	Türüne belirtilen ada, yöntem özniteliklerine ve çağırma kuralına sahip yeni bir yöntem ekler.
DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[])	Belirtilen ad, yöntem öznitelikleri, çağırma kuralı ve yöntem imzası ile türüne yeni bir yöntem ekler.
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, Type, Type[])	Türüne, belirtilen ad, yöntem öznitelikleri ve yöntem imzasıyla yeni bir yöntem ekler.
DefineMethodCore(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Türetilmiş bir sınıfta geçersiz kılındığında, türüne belirtilen ad, yöntem öznitelikleri, çağırma kuralı, yöntem imzası ve özel değiştiricilerle yeni bir yöntem ekler.
DefineMethodOverride(MethodInfo, MethodInfo)	Belirli bir yöntem bildirimini uygulayan ve farklı bir ada sahip olabilecek belirli bir yöntem gövdesini belirtir.
DefineMethodOverrideCore(MethodInfo, MethodInfo)	Türetilmiş bir sınıfta geçersiz kılındığında, belirli bir yöntem bildirimini uygulayan belirli bir yöntem gövdesini belirtir( farklı bir adla olabilir).
DefineNestedType(String)	adı verilen 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, 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, 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)	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, 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, Type[])	adı, öznitelikleri, genişletilen türü ve uyguladığı arabirimleri göz önünde bulundurarak iç içe bir tür tanımlar.
DefineNestedTypeCore(String, TypeAttributes, Type, Type[], PackingSize, Int32)	Türetilmiş bir sınıfta geçersiz kılındığında, adı, öznitelikleri, boyutu ve genişlettiği türe göre iç içe bir tür tanımlar.
DefinePInvokeMethod(String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)	Adı, yöntemin 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 parametrelerinin türleri, PInvoke bayraklar ve parametreler ve dönüş türü için özel değiştiriciler verilen bir PInvoke yöntemi tanımlar.
DefinePInvokeMethodCore(String, String, String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][], CallingConvention, CharSet)	Türetilmiş bir sınıfta geçersiz kılındığında, sağlanan ad, DLL adı, giriş noktası adı, öznitelikler, çağırma kuralı, dönüş türü, parametre türleri, PInvoke bayrakları ve parametreler ve dönüş türü için özel değiştiriciler ile bir PInvoke yöntemi tanımlar.
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, 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, Type, Type[])	Türüne verilen ad 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.
DefinePropertyCore(String, PropertyAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Türetilmiş bir sınıfta geçersiz kılındığında, türe verilen ad, çağırma kuralı, özellik imzası ve özel değiştiricilerle yeni bir özellik ekler.
DefineTypeInitializer()	Bu tür için başlatıcıyı tanımlar.
DefineTypeInitializerCore()	Türetilmiş bir sınıfta geçersiz kılındığında, 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.
DefineUninitializedDataCore(String, Int32, FieldAttributes)	Türetilmiş bir sınıfta geçersiz kılındığında, taşınabilir yürütülebilir dosya (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)
FindInterfaces(TypeFilter, Object)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
GetArrayRank()	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
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.
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ştiricileriyle 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(BindingFlags, Type[])	Belirtilen bağlama kısıtlamalarını kullanarak parametreleri belirtilen bağımsız değişken türleriyle 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ün oluşturucusunu döndürür.
GetConstructor(Type[])	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
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.
GetConstructors()	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
GetConstructors(BindingFlags)	Belirtilen şekilde, bu sınıf için tanımlanan genel ve genel 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ış özniteliklerle ilgili 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ür üzerinde 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)
GetDefaultMembers()	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
GetElementType()	Bu yöntemin çağrılması her zaman oluşturur NotSupportedException.
GetEnumName(Object)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
GetEnumNames()	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
GetEnumUnderlyingType()	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
GetEnumValues()	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
GetEnumValuesAsUnderlyingType()	Bu numaralandırma türünün temel tür sabitlerinin değerlerinin dizisini alır. (Devralındığı yer: Type)
GetEvent(String)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
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)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
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()	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
GetFields(BindingFlags)	Bu tür tarafından bildirilen genel ve ortak olmayan alanları döndürür.
GetFunctionPointerCallingConventions()	Türetilmiş bir sınıfta geçersiz kılındığında, geçerli işlev işaretçisinin Typeçağırma kurallarını döndürür. (Devralındığı yer: Type)
GetFunctionPointerParameterTypes()	Türetilmiş bir sınıfta geçersiz kılındığında, geçerli işlev işaretçisinin Typeparametre türlerini döndürür. (Devralındığı yer: Type)
GetFunctionPointerReturnType()	Türetilmiş bir sınıfta geçersiz kılındığında, geçerli işlev işaretçisinin Typedönüş türünü döndürür. (Devralındığı yer: Type)
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.
GetGenericParameterConstraints()	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
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ğe ilişkin karma kodu döndürür. (Devralındığı yer: Type)
GetInterface(String)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
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)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
GetMember(String, BindingFlags)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
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()	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
GetMembers(BindingFlags)	Bu tür tarafından bildirilen veya devralınan genel ve genel olmayan üyelerin üyelerini döndürür.
GetMemberWithSameMetadataDefinitionAs(MemberInfo)	Belirtilen MemberInfoile MemberInfo eşleşen geçerli Type üzerinde öğesini arar. (Devralındığı yer: Type)
GetMethod(String)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
GetMethod(String, BindingFlags)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
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(String, BindingFlags, Type[])	Belirtilen bağlama kısıtlamalarını kullanarak parametreleri belirtilen bağımsız değişken türleriyle eşleşen belirtilen yöntemi arar. (Devralındığı yer: Type)
GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Belirtilen bağlama kısıtlamalarını ve belirtilen çağırma kuralını kullanarak parametreleri belirtilen genel parametre sayısıyla, bağımsız değişken türleriyle ve değiştiricilerle eşleşen belirtilen yöntemi arar. (Devralındığı yer: Type)
GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[])	Belirtilen bağlama kısıtlamalarını kullanarak parametreleri belirtilen genel parametre sayısıyla, bağımsız değişken türleriyle ve değiştiricilerle eşleşen belirtilen yöntemi arar. (Devralındığı yer: Type)
GetMethod(String, Int32, BindingFlags, Type[])	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: Type)
GetMethod(String, Int32, Type[])	Parametreleri belirtilen genel parametre sayısı ve bağımsız değişken türleriyle eşleşen belirtilen ortak yöntemi arar. (Devralındığı yer: Type)
GetMethod(String, Int32, Type[], ParameterModifier[])	Parametreleri belirtilen genel parametre sayısı, bağımsız değişken türleri ve değiştiricilerle eşleşen belirtilen ortak yöntemi arar. (Devralındığı yer: Type)
GetMethod(String, Type[])	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
GetMethod(String, Type[], ParameterModifier[])	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
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ştiricileriyle eşleşen belirtilen yöntemi arar.
GetMethodImpl(String, Int32, 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 genel parametre sayısı, bağımsız değişken türleri ve değiştiricilerle eşleşen belirtilen yöntemi arar. (Devralındığı yer: Type)
GetMethods()	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
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)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
GetNestedType(String, BindingFlags)	Bu tür tarafından bildirilen genel ve genel olmayan iç içe türleri döndürür.
GetNestedTypes()	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
GetNestedTypes(BindingFlags)	Bu tür tarafından bildirilen veya devralınan genel ve genel olmayan iç içe türleri döndürür.
GetOptionalCustomModifiers()	Türetilmiş bir sınıfta geçersiz kılındığında, geçerli Typeöğesinin isteğe bağlı özel değiştiricilerini döndürür. (Devralındığı yer: Type)
GetProperties()	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
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)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
GetProperty(String, BindingFlags)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
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ştiricileriyle eşleşen belirtilen özelliği arar. (Devralındığı yer: Type)
GetProperty(String, Type)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
GetProperty(String, Type, Type[])	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
GetProperty(String, Type, Type[], ParameterModifier[])	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
GetProperty(String, Type[])	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
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ştiricileriyle eşleşen belirtilen özelliği arar.
GetRequiredCustomModifiers()	Türetilmiş bir sınıfta geçersiz kılındığında, geçerli Typeöğesinin gerekli özel değiştiricilerini döndürür. (Devralındığı yer: Type)
GetType()	Geçerli Typeöğesini alır. (Devralındığı yer: Type)
GetTypeCodeImpl()	Bu Type örneğin temel alınan 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 Type başka bir türü mü kapsadığını veya başvurduğunu belirler; yani, geçerlinin Type bir dizi mi, işaretçi mi yoksa başvuruyla mı geçirildiğini belirler.
HasSameMetadataDefinitionAs(MemberInfo)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: MemberInfo)
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)
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.
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.
IsAssignableFrom(Type)	Belirtilen Type bir nesnenin bu nesneye atanıp atanamayacağını belirten bir değer alır.
IsAssignableFrom(TypeInfo)	Belirtilen TypeInfo bir nesnenin bu nesneye atanıp atanamayacağını gösteren bir değer alır.
IsAssignableTo(Type)	Geçerli türün belirtilen targetTypedeğişkenine atanıp atanamayacağını belirler. (Devralındığı yer: Type)
IsByRefImpl()	Türetilmiş bir sınıfta geçersiz kılındığında, özelliğini uygular IsByRef ve başvurusu tarafından geçirilip geçirilmediğini Type belirler.
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.
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.
IsCreatedCore()	Türetilmiş bir sınıfta geçersiz kılındığında, 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 öznitelik uygulanıp uygulanmadığını belirler.
IsEnumDefined(Object)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsEquivalentTo(Type)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsInstanceOfType(Object)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur. (Devralındığı yer: TypeInfo)
IsMarshalByRefImpl()	özelliğini uygular ve öğesinin IsMarshalByRefType başvuruya göre sıralanıp sıralı olmadığını 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.
IsPrimitiveImpl()	Türetilmiş bir sınıfta geçersiz kılındığında, özelliğini uygular IsPrimitive ve öğesinin ilkel türlerden biri olup olmadığını Type belirler.
IsSubclassOf(Type)	Bu türün belirtilen türden türetilip türetilmez olduğunu belirler.
IsValueTypeImpl()	özelliğini uygular ve değerinin IsValueTypeType bir değer türü olup olmadığını belirler; bir sınıf veya arabirim değil. (Devralındığı yer: Type)
MakeArrayType()	Type Alt sınırı sıfır olan geçerli türün tek boyutlu dizisini temsil eden bir nesne döndürür.
MakeArrayType(Int32)	Type Belirtilen sayıda boyutla geçerli türdeki bir diziyi temsil eden bir nesne döndürür.
MakeByRefType()	Type ParametreByRef (Visual Basic'te) olarak geçirildiğinde geçerli türü temsil eden bir ref nesne 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 Objectöğesinin sığ 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.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Türetilmiş bir sınıfta geçersiz kılındığında, bu derlemede özel bir öznitelik ayarlar.
SetParent(Type)	Şu anda yapım aşamasında olan türün temel türünü ayarlar.
SetParentCore(Type)	Türetilmiş bir sınıfta geçersiz kılındığında, şu anda yapım aşamasında olan türün temel türünü ayarlar.
ToString()	Ad alanı dışında türün adını döndürür.

Belirtik Arabirim Kullanımları

IReflectableType.GetTypeInfo()

Geçerli türün bir gösterimini nesne TypeInfo olarak döndürür. (Devralındığı yer: TypeInfo)

Uzantı Metotları

GetCustomAttribute(MemberInfo, Type)	Belirtilen üyeye uygulanan belirtilen türde bir özel özniteliği alır.
GetCustomAttribute(MemberInfo, Type, Boolean)	Belirtilen üyeye uygulanan belirtilen türde bir özel özniteliği alır ve isteğe bağlı olarak bu üyenin üstlerini inceler.
GetCustomAttribute<T>(MemberInfo)	Belirtilen üyeye uygulanan belirtilen türde bir özel özniteliği alır.
GetCustomAttribute<T>(MemberInfo, Boolean)	Belirtilen üyeye uygulanan belirtilen türde bir özel özniteliği alır ve isteğe bağlı olarak bu üyenin üstlerini inceler.
GetCustomAttributes(MemberInfo)	Belirtilen üyeye uygulanan özel öznitelikler koleksiyonunu alır.
GetCustomAttributes(MemberInfo, Boolean)	Belirtilen üyeye uygulanan özel özniteliklerden oluşan bir koleksiyonu alır ve isteğe bağlı olarak bu üyenin atalarını inceler.
GetCustomAttributes(MemberInfo, Type)	Belirtilen bir üyeye uygulanan belirtilen türde özel özniteliklerden oluşan bir koleksiyonu alır.
GetCustomAttributes(MemberInfo, Type, Boolean)	Belirtilen bir üyeye uygulanan belirtilen türde özel özniteliklerden oluşan bir koleksiyonu alır ve isteğe bağlı olarak bu üyenin üstlerini inceler.
GetCustomAttributes<T>(MemberInfo)	Belirtilen bir üyeye uygulanan belirtilen türde özel özniteliklerden oluşan bir koleksiyonu alır.
GetCustomAttributes<T>(MemberInfo, Boolean)	Belirtilen bir üyeye uygulanan belirtilen türde özel özniteliklerden oluşan bir koleksiyonu alır ve isteğe bağlı olarak bu üyenin üstlerini inceler.
IsDefined(MemberInfo, Type)	Belirtilen türde özel özniteliklerin belirtilen üyeye uygulanıp uygulanmadığını gösterir.
IsDefined(MemberInfo, Type, Boolean)	Belirtilen türlerdeki özel özniteliklerin belirtilen üyeye uygulanıp uygulanmadığını ve isteğe bağlı olarak, üstlerine uygulanıp uygulanmadığını gösterir.
GetTypeInfo(Type)	TypeInfo Belirtilen türün gösterimini döndürür.
GetMetadataToken(MemberInfo)	Varsa, verilen üye için bir meta veri belirteci alır.
HasMetadataToken(MemberInfo)	Belirtilen üye için bir meta veri belirtecinin kullanılabilir olup olmadığını gösteren bir değer döndürür.
GetRuntimeEvent(Type, String)	Belirtilen olayı temsil eden bir nesnesi alır.
GetRuntimeEvents(Type)	Belirtilen türde tanımlanan tüm olayları temsil eden bir koleksiyon alır.
GetRuntimeField(Type, String)	Belirtilen alanı temsil eden bir nesneyi alır.
GetRuntimeFields(Type)	Belirtilen türde tanımlanan tüm alanları temsil eden bir koleksiyonu 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.
GetConstructor(Type, Type[])	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetConstructors(Type)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetConstructors(Type, BindingFlags)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetDefaultMembers(Type)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetEvent(Type, String)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetEvent(Type, String, BindingFlags)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetEvents(Type)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetEvents(Type, BindingFlags)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetField(Type, String)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetField(Type, String, BindingFlags)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetFields(Type)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetFields(Type, BindingFlags)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetGenericArguments(Type)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetInterfaces(Type)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetMember(Type, String)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetMember(Type, String, BindingFlags)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetMembers(Type)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetMembers(Type, BindingFlags)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetMethod(Type, String)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetMethod(Type, String, BindingFlags)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetMethod(Type, String, Type[])	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetMethods(Type)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetMethods(Type, BindingFlags)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetNestedType(Type, String, BindingFlags)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetNestedTypes(Type, BindingFlags)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetProperties(Type)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetProperties(Type, BindingFlags)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetProperty(Type, String)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetProperty(Type, String, BindingFlags)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetProperty(Type, String, Type)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
GetProperty(Type, String, Type, Type[])	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
IsAssignableFrom(Type, Type)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.
IsInstanceOfType(Type, Object)	Çalışma zamanında sınıfların yeni örneklerini tanımlar ve oluşturur.

Ayrıca bkz.

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