GenericTypeParameterBuilder Sınıf

Tanım

Ad Alanı:

System.Reflection.Emit

Bütünleştirilmiş Kod:

System.Reflection.Emit.dll

Kaynak:

GenericTypeParameterBuilder.cs

Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.

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

public abstract class GenericTypeParameterBuilder : System.Reflection.TypeInfo

type GenericTypeParameterBuilder = class
    inherit TypeInfo

Public MustInherit Class GenericTypeParameterBuilder
Inherits TypeInfo

Devralma

Object

MemberInfo

Type

TypeInfo

GenericTypeParameterBuilder

Örnekler

Aşağıdaki kod örneği, iki tür parametresiyle genel bir tür oluşturur ve bunları derleme GenericEmitExample1.dll kaydeder. Oluşturulan türleri görüntülemek için Ildasm.exe (IL Ayrıştırıcısı) kullanabilirsiniz. Dinamik genel tür tanımlamayla ilgili adımların daha ayrıntılı açıklaması için bkz . Nasıl yapılır: Yansıma Yayma ile Genel Tür Tanımlama.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
using namespace System::Collections::Generic;

// Dummy class to satisfy TFirst constraints.
//
public ref class Example {};

// Define a trivial base class and two trivial interfaces 
// to use when demonstrating constraints.
//
public ref class ExampleBase {};
public interface class IExampleA {};
public interface class IExampleB {};

// Define a trivial type that can substitute for type parameter 
// TSecond.
//
public ref class ExampleDerived : ExampleBase, IExampleA, IExampleB {};

// List the constraint flags. The GenericParameterAttributes
// enumeration contains two sets of attributes, variance and
// constraints. For this example, only constraints are used.
//
static void ListConstraintAttributes( Type^ t )
{
   // Mask off the constraint flags. 
   GenericParameterAttributes constraints = 
       t->GenericParameterAttributes & 
       GenericParameterAttributes::SpecialConstraintMask;

   if ((constraints & GenericParameterAttributes::ReferenceTypeConstraint)
           != GenericParameterAttributes::None)
       Console::WriteLine( L"    ReferenceTypeConstraint");

   if ((constraints & GenericParameterAttributes::NotNullableValueTypeConstraint)
           != GenericParameterAttributes::None)
       Console::WriteLine( L"    NotNullableValueTypeConstraint");

   if ((constraints & GenericParameterAttributes::DefaultConstructorConstraint)
           != GenericParameterAttributes::None)
       Console::WriteLine( L"    DefaultConstructorConstraint");
}

static void DisplayGenericParameters( Type^ t )
{
   if (!t->IsGenericType)
   {
       Console::WriteLine( L"Type '{0}' is not generic." );
       return;
   }
   if (!t->IsGenericTypeDefinition)
       t = t->GetGenericTypeDefinition();

   array<Type^>^ typeParameters = t->GetGenericArguments();
   Console::WriteLine( L"\r\nListing {0} type parameters for type '{1}'.", 
       typeParameters->Length, t );

   for each ( Type^ tParam in typeParameters )
   {
       Console::WriteLine( L"\r\nType parameter {0}:", 
           tParam->ToString() );

       for each (Type^ c in tParam->GetGenericParameterConstraints())
       {
           if (c->IsInterface)
               Console::WriteLine( L"    Interface constraint: {0}", c);
           else
               Console::WriteLine( L"    Base type constraint: {0}", c);
       }
       ListConstraintAttributes(tParam);
   }
}

void main()
{
   // Define a dynamic assembly to contain the sample type. The
   // assembly will be run and also saved to disk, so
   // AssemblyBuilderAccess.RunAndSave is specified.
   //
   AppDomain^ myDomain = AppDomain::CurrentDomain;
   AssemblyName^ myAsmName = gcnew AssemblyName( L"GenericEmitExample1" );
   AssemblyBuilder^ myAssembly = myDomain->DefineDynamicAssembly( 
       myAsmName, AssemblyBuilderAccess::RunAndSave );

   // An assembly is made up of executable modules. For a single-
   // module assembly, the module name and file name are the same 
   // as the assembly name. 
   //
   ModuleBuilder^ myModule = myAssembly->DefineDynamicModule( 
       myAsmName->Name, String::Concat( myAsmName->Name, L".dll" ) );

   // Get type objects for the base class trivial interfaces to
   // be used as constraints.
   //
   Type^ baseType = ExampleBase::typeid; 
   Type^ interfaceA = IExampleA::typeid; 
   Type^ interfaceB = IExampleB::typeid;
   
   // Define the sample type.
   //
   TypeBuilder^ myType = myModule->DefineType( L"Sample", 
       TypeAttributes::Public );
   
   Console::WriteLine( L"Type 'Sample' is generic: {0}", 
       myType->IsGenericType );
   
   // Define type parameters for the type. Until you do this, 
   // the type is not generic, as the preceding and following 
   // WriteLine statements show. The type parameter names are
   // specified as an array of strings. To make the code
   // easier to read, each GenericTypeParameterBuilder is placed
   // in a variable with the same name as the type parameter.
   // 
   array<String^>^typeParamNames = {L"TFirst",L"TSecond"};
   array<GenericTypeParameterBuilder^>^typeParams = 
       myType->DefineGenericParameters( typeParamNames );

   GenericTypeParameterBuilder^ TFirst = typeParams[0];
   GenericTypeParameterBuilder^ TSecond = typeParams[1];

   Console::WriteLine( L"Type 'Sample' is generic: {0}", 
       myType->IsGenericType );
   
   // Apply constraints to the type parameters.
   //
   // A type that is substituted for the first parameter, TFirst,
   // must be a reference type and must have a parameterless
   // constructor.
   TFirst->SetGenericParameterAttributes( 
       GenericParameterAttributes::DefaultConstructorConstraint | 
       GenericParameterAttributes::ReferenceTypeConstraint 
   );

   // A type that is substituted for the second type
   // parameter must implement IExampleA and IExampleB, and
   // inherit from the trivial test class ExampleBase. The
   // interface constraints are specified as an array
   // containing the interface types. 
   array<Type^>^interfaceTypes = { interfaceA, interfaceB };
   TSecond->SetInterfaceConstraints( interfaceTypes );
   TSecond->SetBaseTypeConstraint( baseType );

   // The following code adds a private field named ExampleField,
   // of type TFirst.
   FieldBuilder^ exField = 
       myType->DefineField("ExampleField", TFirst, 
           FieldAttributes::Private);

   // Define a static method that takes an array of TFirst and 
   // returns a List<TFirst> containing all the elements of 
   // the array. To define this method it is necessary to create
   // the type List<TFirst> by calling MakeGenericType on the
   // generic type definition, generic<T> List. 
   // The parameter type is created by using the
   // MakeArrayType method. 
   //
   Type^ listOf = List::typeid;
   Type^ listOfTFirst = listOf->MakeGenericType(TFirst);
   array<Type^>^ mParamTypes = { TFirst->MakeArrayType() };

   MethodBuilder^ exMethod = 
       myType->DefineMethod("ExampleMethod", 
           MethodAttributes::Public | MethodAttributes::Static, 
           listOfTFirst, 
           mParamTypes);

   // Emit the method body. 
   // The method body consists of just three opcodes, to load 
   // the input array onto the execution stack, to call the 
   // List<TFirst> constructor that takes IEnumerable<TFirst>,
   // which does all the work of putting the input elements into
   // the list, and to return, leaving the list on the stack. The
   // hard work is getting the constructor.
   // 
   // The GetConstructor method is not supported on a 
   // GenericTypeParameterBuilder, so it is not possible to get 
   // the constructor of List<TFirst> directly. There are two
   // steps, first getting the constructor of generic<T> List and then
   // calling a method that converts it to the corresponding 
   // constructor of List<TFirst>.
   //
   // The constructor needed here is the one that takes an
   // IEnumerable<T>. Note, however, that this is not the 
   // generic type definition of generic<T> IEnumerable; instead, the
   // T from generic<T> List must be substituted for the T of 
   // generic<T> IEnumerable. (This seems confusing only because both
   // types have type parameters named T. That is why this example
   // uses the somewhat silly names TFirst and TSecond.) To get
   // the type of the constructor argument, take the generic
   // type definition generic<T> IEnumerable and 
   // call MakeGenericType with the first generic type parameter
   // of generic<T> List. The constructor argument list must be passed
   // as an array, with just one argument in this case.
   // 
   // Now it is possible to get the constructor of generic<T> List,
   // using GetConstructor on the generic type definition. To get
   // the constructor of List<TFirst>, pass List<TFirst> and
   // the constructor from generic<T> List to the static
   // TypeBuilder.GetConstructor method.
   //
   ILGenerator^ ilgen = exMethod->GetILGenerator();
        
   Type^ ienumOf = IEnumerable::typeid;
   Type^ TfromListOf = listOf->GetGenericArguments()[0];
   Type^ ienumOfT = ienumOf->MakeGenericType(TfromListOf);
   array<Type^>^ ctorArgs = {ienumOfT};

   ConstructorInfo^ ctorPrep = listOf->GetConstructor(ctorArgs);
   ConstructorInfo^ ctor = 
       TypeBuilder::GetConstructor(listOfTFirst, ctorPrep);

   ilgen->Emit(OpCodes::Ldarg_0);
   ilgen->Emit(OpCodes::Newobj, ctor);
   ilgen->Emit(OpCodes::Ret);

   // Create the type and save the assembly. 
   Type^ finished = myType->CreateType();
   myAssembly->Save( String::Concat( myAsmName->Name, L".dll" ) );

   // Invoke the method.
   // ExampleMethod is not generic, but the type it belongs to is
   // generic, so in order to get a MethodInfo that can be invoked
   // it is necessary to create a constructed type. The Example 
   // class satisfies the constraints on TFirst, because it is a 
   // reference type and has a default constructor. In order to
   // have a class that satisfies the constraints on TSecond, 
   // this code example defines the ExampleDerived type. These
   // two types are passed to MakeGenericMethod to create the
   // constructed type.
   //
   array<Type^>^ typeArgs = 
       { Example::typeid, ExampleDerived::typeid };
   Type^ constructed = finished->MakeGenericType(typeArgs);
   MethodInfo^ mi = constructed->GetMethod("ExampleMethod");

   // Create an array of Example objects, as input to the generic
   // method. This array must be passed as the only element of an 
   // array of arguments. The first argument of Invoke is 
   // null, because ExampleMethod is static. Display the count
   // on the resulting List<Example>.
   // 
   array<Example^>^ input = { gcnew Example(), gcnew Example() };
   array<Object^>^ arguments = { input };

   List<Example^>^ listX = 
       (List<Example^>^) mi->Invoke(nullptr, arguments);

   Console::WriteLine(
       "\nThere are {0} elements in the List<Example>.", 
       listX->Count);

   DisplayGenericParameters(finished);
}

/* This code example produces the following output:

Type 'Sample' is generic: False
Type 'Sample' is generic: True

There are 2 elements in the List<Example>.

Listing 2 type parameters for type 'Sample[TFirst,TSecond]'.

Type parameter TFirst:
    ReferenceTypeConstraint
    DefaultConstructorConstraint

Type parameter TSecond:
    Interface constraint: IExampleA
    Interface constraint: IExampleB
    Base type constraint: ExampleBase
 */

using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Collections.Generic;

// Define a trivial base class and two trivial interfaces
// to use when demonstrating constraints.
//
public class ExampleBase {}

public interface IExampleA {}

public interface IExampleB {}

// Define a trivial type that can substitute for type parameter
// TSecond.
//
public class ExampleDerived : ExampleBase, IExampleA, IExampleB {}

public class Example
{
    public static void Main()
    {
        // Define a dynamic assembly to contain the sample type. The
        // assembly will not be run, but only saved to disk, so
        // AssemblyBuilderAccess.Save is specified.
        //
        AppDomain myDomain = AppDomain.CurrentDomain;
        AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
        AssemblyBuilder myAssembly =
            myDomain.DefineDynamicAssembly(myAsmName,
                AssemblyBuilderAccess.RunAndSave);

        // An assembly is made up of executable modules. For a single-
        // module assembly, the module name and file name are the same
        // as the assembly name.
        //
        ModuleBuilder myModule =
            myAssembly.DefineDynamicModule(myAsmName.Name,
               myAsmName.Name + ".dll");

        // Get type objects for the base class trivial interfaces to
        // be used as constraints.
        //
        Type baseType = typeof(ExampleBase);
        Type interfaceA = typeof(IExampleA);
        Type interfaceB = typeof(IExampleB);

        // Define the sample type.
        //
        TypeBuilder myType =
            myModule.DefineType("Sample", TypeAttributes.Public);

        Console.WriteLine("Type 'Sample' is generic: {0}",
            myType.IsGenericType);

        // Define type parameters for the type. Until you do this,
        // the type is not generic, as the preceding and following
        // WriteLine statements show. The type parameter names are
        // specified as an array of strings. To make the code
        // easier to read, each GenericTypeParameterBuilder is placed
        // in a variable with the same name as the type parameter.
        //
        string[] typeParamNames = {"TFirst", "TSecond"};
        GenericTypeParameterBuilder[] typeParams =
            myType.DefineGenericParameters(typeParamNames);

        GenericTypeParameterBuilder TFirst = typeParams[0];
        GenericTypeParameterBuilder TSecond = typeParams[1];

        Console.WriteLine("Type 'Sample' is generic: {0}",
            myType.IsGenericType);

        // Apply constraints to the type parameters.
        //
        // A type that is substituted for the first parameter, TFirst,
        // must be a reference type and must have a parameterless
        // constructor.
        TFirst.SetGenericParameterAttributes(
            GenericParameterAttributes.DefaultConstructorConstraint |
            GenericParameterAttributes.ReferenceTypeConstraint);

        // A type that is substituted for the second type
        // parameter must implement IExampleA and IExampleB, and
        // inherit from the trivial test class ExampleBase. The
        // interface constraints are specified as an array
        // containing the interface types.
        TSecond.SetBaseTypeConstraint(baseType);
        Type[] interfaceTypes = {interfaceA, interfaceB};
        TSecond.SetInterfaceConstraints(interfaceTypes);

        // The following code adds a private field named ExampleField,
        // of type TFirst.
        FieldBuilder exField =
            myType.DefineField("ExampleField", TFirst,
                FieldAttributes.Private);

        // Define a static method that takes an array of TFirst and
        // returns a List<TFirst> containing all the elements of
        // the array. To define this method it is necessary to create
        // the type List<TFirst> by calling MakeGenericType on the
        // generic type definition, List<T>. (The T is omitted with
        // the typeof operator when you get the generic type
        // definition.) The parameter type is created by using the
        // MakeArrayType method.
        //
        Type listOf = typeof(List<>);
        Type listOfTFirst = listOf.MakeGenericType(TFirst);
        Type[] mParamTypes = {TFirst.MakeArrayType()};

        MethodBuilder exMethod =
            myType.DefineMethod("ExampleMethod",
                MethodAttributes.Public | MethodAttributes.Static,
                listOfTFirst,
                mParamTypes);

        // Emit the method body.
        // The method body consists of just three opcodes, to load
        // the input array onto the execution stack, to call the
        // List<TFirst> constructor that takes IEnumerable<TFirst>,
        // which does all the work of putting the input elements into
        // the list, and to return, leaving the list on the stack. The
        // hard work is getting the constructor.
        //
        // The GetConstructor method is not supported on a
        // GenericTypeParameterBuilder, so it is not possible to get
        // the constructor of List<TFirst> directly. There are two
        // steps, first getting the constructor of List<T> and then
        // calling a method that converts it to the corresponding
        // constructor of List<TFirst>.
        //
        // The constructor needed here is the one that takes an
        // IEnumerable<T>. Note, however, that this is not the
        // generic type definition of IEnumerable<T>; instead, the
        // T from List<T> must be substituted for the T of
        // IEnumerable<T>. (This seems confusing only because both
        // types have type parameters named T. That is why this example
        // uses the somewhat silly names TFirst and TSecond.) To get
        // the type of the constructor argument, take the generic
        // type definition IEnumerable<T> (expressed as
        // IEnumerable<> when you use the typeof operator) and
        // call MakeGenericType with the first generic type parameter
        // of List<T>. The constructor argument list must be passed
        // as an array, with just one argument in this case.
        //
        // Now it is possible to get the constructor of List<T>,
        // using GetConstructor on the generic type definition. To get
        // the constructor of List<TFirst>, pass List<TFirst> and
        // the constructor from List<T> to the static
        // TypeBuilder.GetConstructor method.
        //
        ILGenerator ilgen = exMethod.GetILGenerator();

        Type ienumOf = typeof(IEnumerable<>);
        Type TfromListOf = listOf.GetGenericArguments()[0];
        Type ienumOfT = ienumOf.MakeGenericType(TfromListOf);
        Type[] ctorArgs = {ienumOfT};

        ConstructorInfo ctorPrep = listOf.GetConstructor(ctorArgs);
        ConstructorInfo ctor =
            TypeBuilder.GetConstructor(listOfTFirst, ctorPrep);

        ilgen.Emit(OpCodes.Ldarg_0);
        ilgen.Emit(OpCodes.Newobj, ctor);
        ilgen.Emit(OpCodes.Ret);

        // Create the type and save the assembly.
        Type finished = myType.CreateType();
        myAssembly.Save(myAsmName.Name+".dll");

        // Invoke the method.
        // ExampleMethod is not generic, but the type it belongs to is
        // generic, so in order to get a MethodInfo that can be invoked
        // it is necessary to create a constructed type. The Example
        // class satisfies the constraints on TFirst, because it is a
        // reference type and has a default constructor. In order to
        // have a class that satisfies the constraints on TSecond,
        // this code example defines the ExampleDerived type. These
        // two types are passed to MakeGenericMethod to create the
        // constructed type.
        //
        Type[] typeArgs = {typeof(Example), typeof(ExampleDerived)};
        Type constructed = finished.MakeGenericType(typeArgs);
        MethodInfo mi = constructed.GetMethod("ExampleMethod");

        // Create an array of Example objects, as input to the generic
        // method. This array must be passed as the only element of an
        // array of arguments. The first argument of Invoke is
        // null, because ExampleMethod is static. Display the count
        // on the resulting List<Example>.
        //
        Example[] input = {new Example(), new Example()};
        object[] arguments = {input};

        List<Example> listX =
            (List<Example>) mi.Invoke(null, arguments);

        Console.WriteLine(
            "\nThere are {0} elements in the List<Example>.",
            listX.Count);

        DisplayGenericParameters(finished);
    }

    private static void DisplayGenericParameters(Type t)
    {
        if (!t.IsGenericType)
        {
            Console.WriteLine("Type '{0}' is not generic.");
            return;
        }
        if (!t.IsGenericTypeDefinition)
        {
            t = t.GetGenericTypeDefinition();
        }

        Type[] typeParameters = t.GetGenericArguments();
        Console.WriteLine("\nListing {0} type parameters for type '{1}'.",
            typeParameters.Length, t);

        foreach( Type tParam in typeParameters )
        {
            Console.WriteLine("\r\nType parameter {0}:", tParam.ToString());

            foreach( Type c in tParam.GetGenericParameterConstraints() )
            {
                if (c.IsInterface)
                {
                    Console.WriteLine("    Interface constraint: {0}", c);
                }
                else
                {
                    Console.WriteLine("    Base type constraint: {0}", c);
                }
            }

            ListConstraintAttributes(tParam);
        }
    }

    // List the constraint flags. The GenericParameterAttributes
    // enumeration contains two sets of attributes, variance and
    // constraints. For this example, only constraints are used.
    //
    private static void ListConstraintAttributes(Type t)
    {
        // Mask off the constraint flags.
        GenericParameterAttributes constraints =
            t.GenericParameterAttributes & GenericParameterAttributes.SpecialConstraintMask;

        if ((constraints & GenericParameterAttributes.ReferenceTypeConstraint)
            != GenericParameterAttributes.None)
        {
            Console.WriteLine("    ReferenceTypeConstraint");
        }

        if ((constraints & GenericParameterAttributes.NotNullableValueTypeConstraint)
            != GenericParameterAttributes.None)
        {
            Console.WriteLine("    NotNullableValueTypeConstraint");
        }

        if ((constraints & GenericParameterAttributes.DefaultConstructorConstraint)
            !=GenericParameterAttributes.None)
        {
            Console.WriteLine("    DefaultConstructorConstraint");
        }
    }
}

/* This code example produces the following output:

Type 'Sample' is generic: False
Type 'Sample' is generic: True

There are 2 elements in the List<Example>.

Listing 2 type parameters for type 'Sample[TFirst,TSecond]'.

Type parameter TFirst:
    ReferenceTypeConstraint
    DefaultConstructorConstraint

Type parameter TSecond:
    Interface constraint: IExampleA
    Interface constraint: IExampleB
    Base type constraint: ExampleBase
 */

Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Collections.Generic

' Define a trivial base class and two trivial interfaces 
' to use when demonstrating constraints.
'
Public Class ExampleBase
End Class

Public Interface IExampleA
End Interface

Public Interface IExampleB
End Interface

' Define a trivial type that can substitute for type parameter 
' TSecond.
'
Public Class ExampleDerived
    Inherits ExampleBase
    Implements IExampleA, IExampleB
End Class

Public Class Example
    Public Shared Sub Main()
        ' Define a dynamic assembly to contain the sample type. The
        ' assembly will not be run, but only saved to disk, so
        ' AssemblyBuilderAccess.Save is specified.
        '
        Dim myDomain As AppDomain = AppDomain.CurrentDomain
        Dim myAsmName As New AssemblyName("GenericEmitExample1")
        Dim myAssembly As AssemblyBuilder = myDomain.DefineDynamicAssembly( _
            myAsmName, _
            AssemblyBuilderAccess.RunAndSave)

        ' An assembly is made up of executable modules. For a single-
        ' module assembly, the module name and file name are the same 
        ' as the assembly name. 
        '
        Dim myModule As ModuleBuilder = myAssembly.DefineDynamicModule( _
            myAsmName.Name, _
            myAsmName.Name & ".dll")

        ' Get type objects for the base class trivial interfaces to
        ' be used as constraints.
        '
        Dim baseType As Type = GetType(ExampleBase)
        Dim interfaceA As Type = GetType(IExampleA)
        Dim interfaceB As Type = GetType(IExampleB)
                
        ' Define the sample type.
        '
        Dim myType As TypeBuilder = myModule.DefineType( _
            "Sample", _
            TypeAttributes.Public)

        Console.WriteLine("Type 'Sample' is generic: {0}", _
            myType.IsGenericType)

        ' Define type parameters for the type. Until you do this, 
        ' the type is not generic, as the preceding and following 
        ' WriteLine statements show. The type parameter names are
        ' specified as an array of strings. To make the code
        ' easier to read, each GenericTypeParameterBuilder is placed
        ' in a variable with the same name as the type parameter.
        ' 
        Dim typeParamNames() As String = {"TFirst", "TSecond"}
        Dim typeParams() As GenericTypeParameterBuilder = _
            myType.DefineGenericParameters(typeParamNames)

        Dim TFirst As GenericTypeParameterBuilder = typeParams(0)
        Dim TSecond As GenericTypeParameterBuilder = typeParams(1)

        Console.WriteLine("Type 'Sample' is generic: {0}", _
            myType.IsGenericType)

        ' Apply constraints to the type parameters.
        '
        ' A type that is substituted for the first parameter, TFirst,
        ' must be a reference type and must have a parameterless
        ' constructor.
        TFirst.SetGenericParameterAttributes( _
            GenericParameterAttributes.DefaultConstructorConstraint _
            Or GenericParameterAttributes.ReferenceTypeConstraint)

        ' A type that is substituted for the second type
        ' parameter must implement IExampleA and IExampleB, and
        ' inherit from the trivial test class ExampleBase. The
        ' interface constraints are specified as an array 
        ' containing the interface types.
        TSecond.SetBaseTypeConstraint(baseType)
        Dim interfaceTypes() As Type = {interfaceA, interfaceB}
        TSecond.SetInterfaceConstraints(interfaceTypes)

        ' The following code adds a private field named ExampleField,
        ' of type TFirst.
        Dim exField As FieldBuilder = _
            myType.DefineField("ExampleField", TFirst, _
                FieldAttributes.Private)

        ' Define a Shared method that takes an array of TFirst and 
        ' returns a List(Of TFirst) containing all the elements of 
        ' the array. To define this method it is necessary to create
        ' the type List(Of TFirst) by calling MakeGenericType on the
        ' generic type definition, List(Of T). (The T is omitted with
        ' the GetType operator when you get the generic type 
        ' definition.) The parameter type is created by using the
        ' MakeArrayType method. 
        '
        Dim listOf As Type = GetType(List(Of ))
        Dim listOfTFirst As Type = listOf.MakeGenericType(TFirst)
        Dim mParamTypes() As Type = { TFirst.MakeArrayType() }

        Dim exMethod As MethodBuilder = _
            myType.DefineMethod("ExampleMethod", _
                MethodAttributes.Public Or MethodAttributes.Static, _
                listOfTFirst, _
                mParamTypes)

        ' Emit the method body. 
        ' The method body consists of just three opcodes, to load 
        ' the input array onto the execution stack, to call the 
        ' List(Of TFirst) constructor that takes IEnumerable(Of TFirst),
        ' which does all the work of putting the input elements into
        ' the list, and to return, leaving the list on the stack. The
        ' hard work is getting the constructor.
        ' 
        ' The GetConstructor method is not supported on a 
        ' GenericTypeParameterBuilder, so it is not possible to get 
        ' the constructor of List(Of TFirst) directly. There are two
        ' steps, first getting the constructor of List(Of T) and then
        ' calling a method that converts it to the corresponding 
        ' constructor of List(Of TFirst).
        '
        ' The constructor needed here is the one that takes an
        ' IEnumerable(Of T). Note, however, that this is not the 
        ' generic type definition of IEnumerable(Of T); instead, the
        ' T from List(Of T) must be substituted for the T of 
        ' IEnumerable(Of T). (This seems confusing only because both
        ' types have type parameters named T. That is why this example
        ' uses the somewhat silly names TFirst and TSecond.) To get
        ' the type of the constructor argument, take the generic
        ' type definition IEnumerable(Of T) (expressed as 
        ' IEnumerable(Of ) when you use the GetType operator) and 
        ' call MakeGenericType with the first generic type parameter
        ' of List(Of T). The constructor argument list must be passed
        ' as an array, with just one argument in this case.
        ' 
        ' Now it is possible to get the constructor of List(Of T),
        ' using GetConstructor on the generic type definition. To get
        ' the constructor of List(Of TFirst), pass List(Of TFirst) and
        ' the constructor from List(Of T) to the static
        ' TypeBuilder.GetConstructor method.
        '
        Dim ilgen As ILGenerator = exMethod.GetILGenerator()
        
        Dim ienumOf As Type = GetType(IEnumerable(Of ))
        Dim listOfTParams() As Type = listOf.GetGenericArguments()
        Dim TfromListOf As Type = listOfTParams(0)
        Dim ienumOfT As Type = ienumOf.MakeGenericType(TfromListOf)
        Dim ctorArgs() As Type = { ienumOfT }

        Dim ctorPrep As ConstructorInfo = _
            listOf.GetConstructor(ctorArgs)
        Dim ctor As ConstructorInfo = _
            TypeBuilder.GetConstructor(listOfTFirst, ctorPrep)

        ilgen.Emit(OpCodes.Ldarg_0)
        ilgen.Emit(OpCodes.Newobj, ctor)
        ilgen.Emit(OpCodes.Ret)

        ' Create the type and save the assembly. 
        Dim finished As Type = myType.CreateType()
        myAssembly.Save(myAsmName.Name & ".dll")

        ' Invoke the method.
        ' ExampleMethod is not generic, but the type it belongs to is
        ' generic, so in order to get a MethodInfo that can be invoked
        ' it is necessary to create a constructed type. The Example 
        ' class satisfies the constraints on TFirst, because it is a 
        ' reference type and has a default constructor. In order to
        ' have a class that satisfies the constraints on TSecond, 
        ' this code example defines the ExampleDerived type. These
        ' two types are passed to MakeGenericMethod to create the
        ' constructed type.
        '
        Dim typeArgs() As Type = _
            { GetType(Example), GetType(ExampleDerived) }
        Dim constructed As Type = finished.MakeGenericType(typeArgs)
        Dim mi As MethodInfo = constructed.GetMethod("ExampleMethod")

        ' Create an array of Example objects, as input to the generic
        ' method. This array must be passed as the only element of an 
        ' array of arguments. The first argument of Invoke is 
        ' Nothing, because ExampleMethod is Shared. Display the count
        ' on the resulting List(Of Example).
        ' 
        Dim input() As Example = { New Example(), New Example() }
        Dim arguments() As Object = { input }

        Dim listX As List(Of Example) = mi.Invoke(Nothing, arguments)

        Console.WriteLine(vbLf & _
            "There are {0} elements in the List(Of Example).", _
            listX.Count _ 
        )

        DisplayGenericParameters(finished)
    End Sub

    Private Shared Sub DisplayGenericParameters(ByVal t As Type)

        If Not t.IsGenericType Then
            Console.WriteLine("Type '{0}' is not generic.")
            Return
        End If
        If Not t.IsGenericTypeDefinition Then _
            t = t.GetGenericTypeDefinition()

        Dim typeParameters() As Type = t.GetGenericArguments()
        Console.WriteLine(vbCrLf & _
            "Listing {0} type parameters for type '{1}'.", _
            typeParameters.Length, t)

        For Each tParam As Type In typeParameters

            Console.WriteLine(vbCrLf & "Type parameter {0}:", _
                tParam.ToString())

            For Each c As Type In tParam.GetGenericParameterConstraints()
                If c.IsInterface Then
                    Console.WriteLine("    Interface constraint: {0}", c)
                Else
                    Console.WriteLine("    Base type constraint: {0}", c)
                End If
            Next 

            ListConstraintAttributes(tParam)
        Next tParam
    End Sub

    ' List the constraint flags. The GenericParameterAttributes
    ' enumeration contains two sets of attributes, variance and
    ' constraints. For this example, only constraints are used.
    '
    Private Shared Sub ListConstraintAttributes(ByVal t As Type)

        ' Mask off the constraint flags. 
        Dim constraints As GenericParameterAttributes = _
            t.GenericParameterAttributes And _
            GenericParameterAttributes.SpecialConstraintMask

        If (constraints And GenericParameterAttributes.ReferenceTypeConstraint) _
                <> GenericParameterAttributes.None Then _
            Console.WriteLine("    ReferenceTypeConstraint")

        If (constraints And GenericParameterAttributes.NotNullableValueTypeConstraint) _
                <> GenericParameterAttributes.None Then _
            Console.WriteLine("    NotNullableValueTypeConstraint")

        If (constraints And GenericParameterAttributes.DefaultConstructorConstraint) _
                <> GenericParameterAttributes.None Then _
            Console.WriteLine("    DefaultConstructorConstraint")

    End Sub 

End Class

' This code example produces the following output:
'
'Type 'Sample' is generic: False
'Type 'Sample' is generic: True
'
'There are 2 elements in the List(Of Example).
'
'Listing 2 type parameters for type 'Sample[TFirst,TSecond]'.
'
'Type parameter TFirst:
'    ReferenceTypeConstraint
'    DefaultConstructorConstraint
'
'Type parameter TSecond:
'    Interface constraint: IExampleA
'    Interface constraint: IExampleB
'    Base type constraint: ExampleBase

Açıklamalar

Bir nesne dizisini GenericTypeParameterBuilder almak için yöntemini kullanarak TypeBuilder.DefineGenericParameters dinamik bir türe tür parametreleri ekleyebilir, böylece bunu genel bir tür haline getirebilirsiniz veya yöntemini kullanarak MethodBuilder.DefineGenericParameters dinamik bir yönteme tür parametreleri ekleyebilirsiniz. GenericTypeParameterBuilder Tür parametrelerine kısıtlamalar eklemek için nesneleri kullanın. Kısıtlamalar üç türdedir:

• Temel tür kısıtlaması, genel tür parametresine atanan herhangi bir türün belirli bir temel türden türetilmiş olması gerektiğini belirtir. yöntemini kullanarak bu kısıtlamayı SetBaseTypeConstraint ayarlayın.

• Arabirim kısıtlaması, genel tür parametresine atanan herhangi bir türün belirli bir arabirimi uygulaması gerektiğini belirtir. yöntemini kullanarak SetInterfaceConstraints arabirim kısıtlamalarını ayarlayın.

• Özel kısıtlamalar, genel tür parametresine atanan herhangi bir türün parametresiz bir oluşturucuya sahip olması, bir başvuru türü veya bir değer türü olması gerektiğini belirtir. yöntemini kullanarak SetGenericParameterAttributes tür parametresi için özel kısıtlamaları ayarlayın.

Arabirim kısıtlamaları ve özel kısıtlamalar sınıfının yöntemleri GenericTypeParameterBuilder kullanılarak alınamaz. Tür parametrelerini içeren genel türü oluşturduktan sonra, kısıtlamalarını yansıtmak için nesnesini Type kullanabilirsiniz. Type.GetGenericArguments tür parametrelerini almak için yöntemini kullanın ve her tür parametresi için temel tür kısıtlamasını ve arabirim kısıtlamalarını almak için yöntemini ve Type.GenericParameterAttributes özel kısıtlamaları almak için özelliğini kullanınType.GetGenericParameterConstraints.

Oluşturucular

GenericTypeParameterBuilder()

Yeni bir GenericTypeParameterBuilder sınıfı örneğini başlatır.

Özellikler

Assembly	Geçerli tür parametresinin ait olduğu genel tür tanımını içeren dinamik derlemeyi temsil eden bir Assembly nesne alır.
AssemblyQualifiedName	Her durumda alır null .
Attributes	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
BaseType	Geçerli genel tür parametresinin temel tür kısıtlamasını alır.
ContainsGenericParameters	Her durumda alır true .
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 GenericTypeParameterBuilder genel bir MethodInfo yöntemin tür parametresini temsil ediyorsa bildirim yöntemini temsil eden bir alır.
DeclaringType	Genel tür parametresinin ait olduğu genel tür tanımını veya genel yöntem tanımını alır.
FullName	Her durumda alır null .
GenericParameterAttributes	Geçerli genel tür parametresinin GenericParameterAttributes kovaryansı ve özel kısıtlamalarını açıklayan bayrakların bir bileşimini alır.
GenericParameterPosition	Type parametresinin, parametreyi bildiren genel türün veya yöntemin tür parametre listesindeki konumunu alır.
GenericTypeArguments	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GenericTypeParameters	Geçerli örneğin genel tür parametrelerinin dizisini alır. (Devralındığı yer: TypeInfo)
GUID	Tamamlanmamış genel tür parametreleri için desteklenmez.
HasElementType	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
ImplementedInterfaces	Geçerli tür tarafından uygulanan arabirimlerin koleksiyonunu alır. (Devralındığı yer: TypeInfo)
IsAbstract	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsAnsiClass	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsArray	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsAutoClass	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsAutoLayout	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsByRef	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsByRefLike	Türün byref benzeri bir yapı olup olmadığını gösteren bir değer alır.
IsClass	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (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	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsConstructedGenericType	Bu nesnenin, bir yapılı genel türü temsil edip etmediğini 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	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsExplicitLayout	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (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	Her durumda alır true .
IsGenericType	Her durumda döndürür false .
IsGenericTypeDefinition	Her durumda alır false .
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	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsInterface	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsLayoutSequential	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsMarshalByRef	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsNested	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsNestedAssembly	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsNestedFamANDAssem	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsNestedFamily	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsNestedFamORAssem	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsNestedPrivate	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsNestedPublic	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsNotPublic	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsPointer	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsPrimitive	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsPublic	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsSealed	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsSecurityCritical	Geçerli türün geçerli güven düzeyinde güvenlik açısından kritik veya güvenlik açısından güvenli-kritik olup olmadığını belirten bir değer alır ve bu nedenle kritik işlemleri gerçekleştirebilir. (Devralındığı yer: Type)
IsSecuritySafeCritical	Geçerli türün geçerli güven düzeyinde güvenlik açısından güvenli-kritik olup olmadığını belirten bir değer alır; yani, kritik işlemler gerçekleştirip gerçekleştiremeyeceği ve saydam kod tarafından erişilip erişilemeyeceği. (Devralındığı yer: Type)
IsSecurityTransparent	Geçerli türün geçerli güven düzeyinde saydam olup olmadığını belirten bir değer alır ve bu nedenle kritik işlemleri gerçekleştiremez. (Devralındığı yer: Type)
IsSerializable	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (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	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsSZArray	Türün yalnızca sıfır alt sınıra sahip tek boyutlu bir diziyi temsil eden bir dizi türü olup olmadığını gösteren bir değer alır.
IsTypeDefinition	Türün tür tanımı olup olmadığını gösteren bir değer alır.
IsUnicodeClass	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (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	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (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	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
MemberType	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
MetadataToken	Meta verilerdeki geçerli dinamik modülü tanımlayan bir belirteç alır.
Module	Genel tür parametresini içeren dinamik modülü alır.
Name	Genel tür parametresinin adını alır.
Namespace	Her durumda alır null .
ReflectedType	Type elde GenericTypeParameterBuilderetmek için kullanılan nesneyi alır.
StructLayoutAttribute	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
TypeHandle	Tamamlanmamış genel tür parametreleri için desteklenmez.
TypeInitializer	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
UnderlyingSystemType	Geçerli genel tür parametresini alır.

Yöntemler

AsType()	Geçerli türü nesne Type olarak döndürür. (Devralındığı yer: TypeInfo)
Equals(Object)	Verilen nesnenin bir örneği EventToken olup olmadığını ve geçerli örneğe eşit olup olmadığını sınar.
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)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetArrayRank()	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (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[])	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Tamamlanmamış genel tür parametreleri için desteklenmez.
GetConstructors()	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetConstructors(BindingFlags)	Tamamlanmamış genel tür parametreleri için desteklenmez.
GetCustomAttributes(Boolean)	Tamamlanmamış genel tür parametreleri için desteklenmez.
GetCustomAttributes(Type, Boolean)	Tamamlanmamış genel tür parametreleri için desteklenmez.
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()	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetElementType()	Her durumda bir NotSupportedException atar.
GetEnumName(Object)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetEnumNames()	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetEnumUnderlyingType()	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetEnumValues()	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (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)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetEvent(String, BindingFlags)	Tamamlanmamış genel tür parametreleri için desteklenmez.
GetEvents()	Tamamlanmamış genel tür parametreleri için desteklenmez.
GetEvents(BindingFlags)	Tamamlanmamış genel tür parametreleri için desteklenmez.
GetField(String)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetField(String, BindingFlags)	Tamamlanmamış genel tür parametreleri için desteklenmez.
GetFields()	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetFields(BindingFlags)	Tamamlanmamış genel tür parametreleri için desteklenmez.
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 tür parametreleri için geçerli değil.
GetGenericParameterConstraints()	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetGenericTypeDefinition()	Genel tür parametreleri için geçerli değil.
GetHashCode()	Geçerli örnek için 32 bit tamsayı karma kodu döndürür.
GetInterface(String)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetInterface(String, Boolean)	Tamamlanmamış genel tür parametreleri için desteklenmez.
GetInterfaceMap(Type)	Tamamlanmamış genel tür parametreleri için desteklenmez.
GetInterfaces()	Tamamlanmamış genel tür parametreleri için desteklenmez.
GetMember(String)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetMember(String, BindingFlags)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetMember(String, MemberTypes, BindingFlags)	Tamamlanmamış genel tür parametreleri için desteklenmez.
GetMembers()	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetMembers(BindingFlags)	Tamamlanmamış genel tür parametreleri için desteklenmez.
GetMemberWithSameMetadataDefinitionAs(MemberInfo)	Belirtilen MemberInfoile MemberInfo eşleşen geçerli Type üzerinde öğesini arar. (Devralındığı yer: Type)
GetMethod(String)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetMethod(String, BindingFlags)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (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[])	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (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[])	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetMethod(String, Type[], ParameterModifier[])	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Tamamlanmamış genel tür parametreleri için desteklenmez.
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()	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetMethods(BindingFlags)	Tamamlanmamış genel tür parametreleri için desteklenmez.
GetNestedType(String)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetNestedType(String, BindingFlags)	Tamamlanmamış genel tür parametreleri için desteklenmez.
GetNestedTypes()	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetNestedTypes(BindingFlags)	Tamamlanmamış genel tür parametreleri için desteklenmez.
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()	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetProperties(BindingFlags)	Tamamlanmamış genel tür parametreleri için desteklenmez.
GetProperty(String)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetProperty(String, BindingFlags)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (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ştiricilerle eşleşen belirtilen özelliği arar. (Devralındığı yer: Type)
GetProperty(String, Type)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetProperty(String, Type, Type[])	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetProperty(String, Type, Type[], ParameterModifier[])	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetProperty(String, Type[])	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Tamamlanmamış genel tür parametreleri için desteklenmez.
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ü kapsayıp kapsamadığını veya başka bir türe başvuruda bulunup bulunmayacağını belirler; yani, geçerlinin Type bir dizi mi, işaretçi mi yoksa başvuruyla mı geçirildiğini belirler.
HasSameMetadataDefinitionAs(MemberInfo)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (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[])	Tamamlanmamış genel tür parametreleri için desteklenmez.
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)	Her durumda bir NotSupportedException özel durum oluşturur.
IsAssignableFrom(TypeInfo)	Her durumda bir NotSupportedException özel durum oluşturur.
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 ve öğesinin IsByRefType başvuru tarafından geçirilip geçirilmediğini 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)
IsDefined(Type, Boolean)	Tamamlanmamış genel tür parametreleri için desteklenmez.
IsEnumDefined(Object)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsEquivalentTo(Type)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (Devralındığı yer: TypeInfo)
IsInstanceOfType(Object)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz. (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 IsPointer ve işaretçi olup olmadığını Type 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)	Tamamlanmamış genel tür parametreleri için desteklenmez.
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.
MakeArrayType()	Öğe türü genel tür parametresi olan tek boyutlu bir dizinin türünü döndürür.
MakeArrayType(Int32)	Öğe türü belirtilen boyut sayısıyla genel tür parametresi olan bir dizinin türünü döndürür.
MakeByRefType()	Type Başvuru parametresi olarak geçirildiğinde geçerli genel tür parametresini temsil eden bir nesne döndürür.
MakeGenericType(Type[])	Tamamlanmamış genel tür parametreleri için geçerli değil.
MakePointerType()	Geçerli genel tür parametresinin işaretçisini temsil eden bir Type nesne döndürür.
MemberwiseClone()	Geçerli Objectöğesinin sığ bir kopyasını oluşturur. (Devralındığı yer: Object)
SetBaseTypeConstraint(Type)	Tür parametresinin yerini alması için bir türün devralması gereken temel türü ayarlar.
SetBaseTypeConstraintCore(Type)	Türetilmiş bir sınıfta geçersiz kılındığında, tür parametresinin yerini almak için bir türün devralması gereken temel türü ayarlar.
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.
SetGenericParameterAttributes(GenericParameterAttributes)	Değişken özelliklerini ve parametresiz oluşturucu kısıtlaması gibi genel parametrenin özel kısıtlamalarını ayarlar.
SetGenericParameterAttributesCore(GenericParameterAttributes)	Türetilmiş bir sınıfta geçersiz kılındığında, değişken özelliklerini ve parametresiz oluşturucu kısıtlaması gibi genel parametrenin özel kısıtlamalarını ayarlar.
SetInterfaceConstraints(Type[])	Tür parametresiyle değiştirilebilmesi için bir türün uygulaması gereken arabirimleri ayarlar.
SetInterfaceConstraintsCore(Type[])	Türetilmiş bir sınıfta geçersiz kılındığında, tür parametresinin yerini almak için bir türün uygulaması gereken arabirimleri ayarlar.
ToString()	Geçerli genel tür parametresinin dize gösterimini 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[])	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetConstructors(Type)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetConstructors(Type, BindingFlags)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetFields(Type, BindingFlags)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetGenericArguments(Type)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetInterfaces(Type)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetMember(Type, String)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetMember(Type, String, BindingFlags)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetMembers(Type)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetMethods(Type)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetNestedType(Type, String, BindingFlags)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetProperties(Type)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetProperties(Type, BindingFlags)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetProperty(Type, String, BindingFlags)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetProperty(Type, String, Type)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetProperty(Type, String, Type, Type[])	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
IsAssignableFrom(Type, Type)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
IsInstanceOfType(Type, Object)	Dinamik olarak tanımlanmış genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.

Ayrıca bkz.

• DefineGenericParameters(String[])
• Nasıl yapılır: Yansıma Yayma ile Genel Tür Tanımlama