GenericTypeParameterBuilder Sınıf

Başvuru

Tanım

Ad Alanı:: System.Reflection.Emit

Bütünleştirilmiş Kod:: System.Reflection.Emit.dll

Bütünleştirilmiş Kod:: mscorlib.dll

Bütünleştirilmiş Kod:: netstandard.dll

Paket:: System.Reflection.Emit v4.7.0

Kaynak:: GenericTypeParameterBuilder.cs

Kaynak:: GenericTypeParameterBuilder.cs

Kaynak:: GenericTypeParameterBuilder.cs

Önemli

Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.

Dinamik olarak tanımlanan 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 sealed : Type

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

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

public sealed class GenericTypeParameterBuilder : Type

public sealed class GenericTypeParameterBuilder : System.Reflection.TypeInfo

public abstract class GenericTypeParameterBuilder : System.Reflection.TypeInfo

[System.Runtime.InteropServices.ComVisible(true)]
public sealed class GenericTypeParameterBuilder : Type

[System.Runtime.InteropServices.ComVisible(true)]
public sealed class GenericTypeParameterBuilder : System.Reflection.TypeInfo

type GenericTypeParameterBuilder = class
    inherit Type

type GenericTypeParameterBuilder = class
    inherit TypeInfo

[<System.Runtime.InteropServices.ComVisible(true)>]
type GenericTypeParameterBuilder = class
    inherit Type

[<System.Runtime.InteropServices.ComVisible(true)>]
type GenericTypeParameterBuilder = class
    inherit TypeInfo

Public NotInheritable Class GenericTypeParameterBuilder
Inherits Type

Public NotInheritable Class GenericTypeParameterBuilder
Inherits TypeInfo

Public MustInherit Class GenericTypeParameterBuilder
Inherits TypeInfo

Devralma: Object

MemberInfo

Type
GenericTypeParameterBuilder

Devralma: Object

MemberInfo

TypeInfo
GenericTypeParameterBuilder

Devralma: Object

MemberInfo

Type

TypeInfo
GenericTypeParameterBuilder

Öznitelikler: ComVisibleAttribute

Örnekler

Aşağıdaki kod örneği, iki tür parametresiyle genel bir tür oluşturur ve bunları GenericEmitExample1.dllderlemesine kaydeder. Oluşturulan türleri görüntülemek için Ildasm.exe (IL Disassembler) 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 Yaymaile 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

TypeBuilder.DefineGenericParameters yöntemini kullanarak bir dizi GenericTypeParameterBuilder nesnesi alabilir ve böylece bunu genel bir tür haline getirebilirsiniz veya dinamik bir yönteme tür parametreleri eklemek için MethodBuilder.DefineGenericParameters yöntemini kullanabilirsiniz. tür parametrelerine kısıtlamalar eklemek için GenericTypeParameterBuilder nesnelerini 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. SetBaseTypeConstraint yöntemini kullanarak bu kısıtlamayı ayarlayın.
Arabirim kısıtlaması, genel tür parametresine atanan herhangi bir türün belirli bir arabirimi uygulaması gerektiğini belirtir. SetInterfaceConstraints yöntemini kullanarak 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. SetGenericParameterAttributes yöntemini kullanarak tür parametresi için özel kısıtlamaları ayarlayın.

Arabirim kısıtlamaları ve özel kısıtlamalar GenericTypeParameterBuilder sınıfının yöntemleri kullanılarak alınamaz. Tür parametrelerini içeren genel türü oluşturduktan sonra, kısıtlamaları yansıtmak için Type nesnesini kullanabilirsiniz. Tür parametrelerini almak için Type.GetGenericArguments 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 Type.GetGenericParameterConstraints yöntemini ve özel kısıtlamaları almak için Type.GenericParameterAttributes özelliğini kullanın.

Oluşturucular

GenericTypeParameterBuilder()

GenericTypeParameterBuilder sınıfının yeni bir ö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 nesnesi alır.
AssemblyQualifiedName	Her durumda `null` alır.
Attributes	Typeile ilişkili öznitelikleri alır.
Attributes	Typeile ilişkili öznitelikleri alır. (Devralındığı yer: Type)
Attributes	Dinamik olarak tanımlanan 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 `true` alır.
CustomAttributes	Bu üyenin özel özniteliklerini içeren bir koleksiyon alır. (Devralındığı yer: MemberInfo)
DeclaredConstructors	Geçerli tür tarafından bildirilen oluşturucuların koleksiyonunu alır. (Devralındığı yer: TypeInfo)
DeclaredEvents	Geçerli tür tarafından tanımlanan olayların koleksiyonunu alır. (Devralındığı yer: TypeInfo)
DeclaredFields	Geçerli tür tarafından tanımlanan alanların koleksiyonunu alır. (Devralındığı yer: TypeInfo)
DeclaredMembers	Geçerli tür tarafından tanımlanan üyelerin koleksiyonunu alır. (Devralındığı yer: TypeInfo)
DeclaredMethods	Geçerli tür tarafından tanımlanan yöntemlerin koleksiyonunu alır. (Devralındığı yer: TypeInfo)
DeclaredNestedTypes	Geçerli tür tarafından tanımlanan iç içe türlerin koleksiyonunu alır. (Devralındığı yer: TypeInfo)
DeclaredProperties	Geçerli tür tarafından tanımlanan özelliklerin koleksiyonunu alır. (Devralındığı yer: TypeInfo)
DeclaringMethod	Geçerli GenericTypeParameterBuilder genel bir yöntemin tür parametresini temsil ederse bildirim yöntemini temsil eden bir MethodInfo 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 `null` alır.
GenericParameterAttributes	Geçerli genel tür parametresinin kovaryans ve özel kısıtlamalarını açıklayan GenericParameterAttributes bayraklarının bir bileşimini alır.
GenericParameterAttributes	Geçerli genel tür parametresinin kovaryans ve özel kısıtlamalarını açıklayan GenericParameterAttributes bayraklarının bir bileşimini alır. (Devralındığı yer: Type)
GenericParameterPosition	Tür parametresinin, parametreyi bildiren genel türün veya yöntemin tür parametre listesindeki konumunu alır.
GenericTypeArguments	Dinamik olarak tanımlanan genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GenericTypeArguments	Bu tür için genel tür bağımsız değişkenlerinden oluşan bir dizi alır. (Devralındığı yer: Type)
GenericTypeArguments	Dinamik olarak tanımlanan 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	Geçerli Type başka bir türü kapsadığını veya başvurduğunu belirten bir değer alır; yani geçerli Type bir dizi mi, işaretçi mi yoksa başvuruyla mı geçirilir? (Devralındığı yer: Type)
HasElementType	Dinamik olarak tanımlanan 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	Type soyut olduğunu ve geçersiz kılınması gerektiğini belirten bir değer alır. (Devralındığı yer: Type)
IsAbstract	Dinamik olarak tanımlanan 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	Typeiçin dize biçimi özniteliğinin `AnsiClass` seçilip seçilmediğini belirten bir değer alır. (Devralındığı yer: Type)
IsAnsiClass	Dinamik olarak tanımlanan 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	Türün bir dizi olup olmadığını gösteren bir değer alır. (Devralındığı yer: Type)
IsArray	Dinamik olarak tanımlanan 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	Typeiçin dize biçimi özniteliğinin `AutoClass` seçilip seçilmediğini belirten bir değer alır. (Devralındığı yer: Type)
IsAutoClass	Dinamik olarak tanımlanan 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	Geçerli türdeki alanların ortak dil çalışma zamanı tarafından otomatik olarak yerleştirilip yerleştirildiğini belirten bir değer alır. (Devralındığı yer: Type)
IsAutoLayout	Dinamik olarak tanımlanan 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	Type başvuruyla geçirilip geçirilmediğini belirten bir değer alır. (Devralındığı yer: Type)
IsByRef	Dinamik olarak tanımlanan 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.
IsByRefLike	Türün byref benzeri bir yapı olup olmadığını gösteren bir değer alır. (Devralındığı yer: Type)
IsClass	Type bir sınıf mı yoksa temsilci mi olduğunu belirten bir değer alır; yani, bir değer türü veya arabirim değil. (Devralındığı yer: Type)
IsClass	Dinamik olarak tanımlanan 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 nesnesinin bir koleksiyon AssemblyLoadContexttutulan bir derlemenin parçası olup olmadığını gösteren bir değer alır. (Devralındığı yer: MemberInfo)
IsCOMObject	Type bir COM nesnesi olup olmadığını gösteren bir değer alır. (Devralındığı yer: Type)
IsCOMObject	Dinamik olarak tanımlanan 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 genel tür oluşturup oluşturmadığını gösteren bir değer alır.
IsConstructedGenericType	Bu nesnenin, bir genel tür oluşturup oluşturmadığını gösteren bir değer alır. Oluşturduğunuz genel türün örneklerini oluşturabilirsiniz. (Devralındığı yer: Type)
IsContextful	Type bir bağlamda barındırılıp barındırılamayacağını gösteren bir değer alır. (Devralındığı yer: Type)
IsEnum	Dinamik olarak tanımlanan genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
IsEnum	Geçerli Type bir numaralandırmayı temsil edip etmediğini gösteren bir değer alır. (Devralındığı yer: Type)
IsEnum	Dinamik olarak tanımlanan 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	Geçerli türdeki alanların açıkça belirtilen uzaklıklarda yerleştirilip yerleştirildiğini belirten bir değer alır. (Devralındığı yer: Type)
IsExplicitLayout	Dinamik olarak tanımlanan 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çerli Type işlev işaretçisi olup olmadığını gösteren bir değer alır. (Devralındığı yer: Type)
IsGenericMethodParameter	Geçerli 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 `true` alır.
IsGenericType	Her durumda `false` döndürür.
IsGenericTypeDefinition	Her durumda `false` alır.
IsGenericTypeParameter	Geçerli Type genel 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	Type bir COM türü kitaplığından içeri aktarıldığını belirten bir ComImportAttribute özniteliği uygulanıp uygulanmadığını belirten bir değer alır. (Devralındığı yer: Type)
IsImport	Dinamik olarak tanımlanan 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	Type bir arabirim olup olmadığını belirten bir değer alır; yani, bir sınıf veya değer türü değil. (Devralındığı yer: Type)
IsInterface	Dinamik olarak tanımlanan 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	Geçerli türdeki alanların meta verilerde tanımlandığı veya yayıldığı sırada sıralı olarak düzenlendiğini belirten bir değer alır. (Devralındığı yer: Type)
IsLayoutSequential	Dinamik olarak tanımlanan 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	Type başvuruya göre sıralanıp sıralanmadığını gösteren bir değer alır. (Devralındığı yer: Type)
IsMarshalByRef	Dinamik olarak tanımlanan 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	Geçerli Type nesnesinin tanımı başka bir türün tanımı içinde iç içe yerleştirilmiş bir türü temsil edip etmediğini gösteren bir değer alır. (Devralındığı yer: Type)
IsNested	Dinamik olarak tanımlanan 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	Type iç içe olup olmadığını ve yalnızca kendi derlemesinde görünür olup olmadığını belirten bir değer alır. (Devralındığı yer: Type)
IsNestedAssembly	Dinamik olarak tanımlanan 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	Type iç içe olup olmadığını ve yalnızca kendi ailesine ve kendi derlemesine ait sınıflar için görünür olup olmadığını belirten bir değer alır. (Devralındığı yer: Type)
IsNestedFamANDAssem	Dinamik olarak tanımlanan 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	Type iç içe olup olmadığını ve yalnızca kendi ailesi içinde görünür olup olmadığını belirten bir değer alır. (Devralındığı yer: Type)
IsNestedFamily	Dinamik olarak tanımlanan 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	Type iç içe olup olmadığını ve yalnızca kendi ailesine veya kendi derlemesine ait sınıflar için görünür olup olmadığını belirten bir değer alır. (Devralındığı yer: Type)
IsNestedFamORAssem	Dinamik olarak tanımlanan 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	Type iç içe olup olmadığını ve özel olarak bildirildiğini belirten bir değer alır. (Devralındığı yer: Type)
IsNestedPrivate	Dinamik olarak tanımlanan 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	Bir sınıfın iç içe geçmiş ve genel olarak bildirilmiş olup olmadığını gösteren bir değer alır. (Devralındığı yer: Type)
IsNestedPublic	Dinamik olarak tanımlanan 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	Type genel olarak bildirilip bildirilmediğini belirten bir değer alır. (Devralındığı yer: Type)
IsNotPublic	Dinamik olarak tanımlanan 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	Type işaretçi olup olmadığını gösteren bir değer alır. (Devralındığı yer: Type)
IsPointer	Dinamik olarak tanımlanan 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	Type ilkel türlerden biri olup olmadığını gösteren bir değer alır. (Devralındığı yer: Type)
IsPrimitive	Dinamik olarak tanımlanan 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	Type genel olarak bildirilip bildirildiğini belirten bir değer alır. (Devralındığı yer: Type)
IsPublic	Dinamik olarak tanımlanan 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	Type korumalı olarak bildirilip bildirildiğini belirten bir değer alır. (Devralındığı yer: Type)
IsSealed	Dinamik olarak tanımlanan 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 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. (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ı gösteren bir değer alır; başka bir ifadeyle, kritik işlemler gerçekleştirip gerçekleştiremeyeceği ve saydam kodla erişilip erişilemeyeceği. (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ımlanan genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
IsSerializable	Geçersiz. Type ikili serileştirilebilir olup olmadığını belirten bir değer alır. (Devralındığı yer: Type)
IsSerializable	Dinamik olarak tanımlanan 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 bir imza türü olup olmadığını gösteren bir değer alır. (Devralındığı yer: Type)
IsSpecialName	Türün özel işleme gerektiren bir ada sahip olup olmadığını belirten bir değer alır. (Devralındığı yer: Type)
IsSpecialName	Dinamik olarak tanımlanan 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.
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. (Devralındığı yer: Type)
IsTypeDefinition	Türün tür tanımı 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. (Devralındığı yer: Type)
IsUnicodeClass	Typeiçin dize biçimi özniteliğinin `UnicodeClass` seçilip seçilmediğini belirten bir değer alır. (Devralındığı yer: Type)
IsUnicodeClass	Dinamik olarak tanımlanan 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çerli Type yönetilmeyen bir işlev işaretçisi olup olmadığını gösteren bir değer alır. (Devralındığı yer: Type)
IsValueType	Type bir değer türü olup olmadığını belirten bir değer alır. (Devralındığı yer: Type)
IsValueType	Dinamik olarak tanımlanan 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	Dinamik olarak tanımlanan genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
IsVariableBoundArray	Türün çok boyutlu bir diziyi veya rastgele alt sınıra sahip bir diziyi temsil eden bir dizi türü olup olmadığını gösteren bir değer alır. (Devralındığı yer: Type)
IsVisible	Type derleme dışındaki kod tarafından erişilip erişilemeyeceğini belirten bir değer alır. (Devralındığı yer: Type)
IsVisible	Dinamik olarak tanımlanan 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	Bu üyenin bir tür veya iç içe yerleştirilmiş bir tür olduğunu belirten bir MemberTypes değeri alır. (Devralındığı yer: Type)
MemberType	Dinamik olarak tanımlanan 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.
MetadataToken	Meta veri öğesini tanımlayan bir değer alır. (Devralındığı yer: MemberInfo)
Module	Genel tür parametresini içeren dinamik modülü alır.
Name	Genel tür parametresinin adını alır.
Namespace	Her durumda `null` alır.
ReflectedType	GenericTypeParameterBuilderelde etmek için kullanılan Type nesnesini alır.
ReflectedType	bu `MemberInfo`örneğini almak için kullanılan sınıf nesnesini alır. (Devralındığı yer: MemberInfo)
StructLayoutAttribute	Geçerli türün düzenini açıklayan bir StructLayoutAttribute alır. (Devralındığı yer: Type)
StructLayoutAttribute	Dinamik olarak tanımlanan 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	Türü için başlatıcıyı alır. (Devralındığı yer: Type)
TypeInitializer	Dinamik olarak tanımlanan 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.
UnderlyingSystemType	Dinamik olarak tanımlanan 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)

Yöntemler

AsType()	Geçerli türü Type nesnesi olarak döndürür. (Devralındığı yer: TypeInfo)
Equals(Object)	Verilen nesnenin bir `EventToken` örneği olup olmadığını ve geçerli örneğe eşit olup olmadığını sınar.
Equals(Type)	Geçerli Type temel alınan sistem türünün, belirtilen Typetemel alınan sistem türüyle aynı olup olmadığını belirler. (Devralındığı yer: Type)
FindInterfaces(TypeFilter, Object)	Geçerli Typetarafından uygulanan veya devralınan arabirimlerin filtrelenmiş listesini temsil eden Type nesne dizisi döndürür. (Devralındığı yer: Type)
FindInterfaces(TypeFilter, Object)	Dinamik olarak tanımlanan 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)	Belirtilen üye türündeki MemberInfo nesnelerinden oluşan filtrelenmiş bir dizi döndürür. (Devralındığı yer: Type)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)	Dinamik olarak tanımlanan 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ımlanan genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetArrayRank()	Dizideki boyut sayısını alır. (Devralındığı yer: Type)
GetArrayRank()	Dinamik olarak tanımlanan 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, Attributes özelliğini uygular ve Typeile ilişkili öznitelikleri gösteren sabit listesi değerlerinin bit düzeyinde bir birleşimini alır.
GetAttributeFlagsImpl()	Türetilmiş bir sınıfta geçersiz kılındığında, Attributes özelliğini uygular ve Typeile ilişkili öznitelikleri gösteren sabit listesi değerlerinin bit düzeyinde bir birleşimini alır. (Devralındığı yer: Type)
GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Belirtilen bağlama kısıtlamalarını ve belirtilen çağırma kuralını kullanarak parametreleri belirtilen bağımsız değişken türleri ve değiştiricilerle eşleşen bir oluşturucu arar. (Devralındığı yer: Type)
GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])	Belirtilen bağlama kısıtlamalarını kullanarak parametreleri belirtilen bağımsız değişken türleri ve değiştiricilerle eşleşen bir oluşturucu arar. (Devralındığı yer: Type)
GetConstructor(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[])	Parametreleri belirtilen dizideki türlerle eşleşen bir genel örnek oluşturucu arar. (Devralındığı yer: Type)
GetConstructor(Type[])	Dinamik olarak tanımlanan 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.
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen bağlama kısıtlamalarını ve belirtilen çağırma kuralını kullanarak parametreleri belirtilen bağımsız değişken türleri ve değiştiricilerle eşleşen bir oluşturucu arar. (Devralındığı yer: Type)
GetConstructors()	Geçerli Typeiçin tanımlanan tüm ortak oluşturucuları döndürür. (Devralındığı yer: Type)
GetConstructors()	Dinamik olarak tanımlanan 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.
GetConstructors(BindingFlags)	Dinamik olarak tanımlanan 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)
GetCustomAttributes(Boolean)	Tamamlanmamış genel tür parametreleri için desteklenmez.
GetCustomAttributes(Boolean)	Türetilmiş bir sınıfta geçersiz kılındığında, bu üyeye uygulanan tüm özel özniteliklerden oluşan bir dizi döndürür. (Devralındığı yer: MemberInfo)
GetCustomAttributes(Type, Boolean)	Tamamlanmamış genel tür parametreleri için desteklenmez.
GetCustomAttributes(Type, Boolean)	Türetilmiş bir sınıfta geçersiz kılındığında, bu üyeye uygulanan ve Typetarafından tanımlanan bir özel öznitelik dizisi döndürür. (Devralındığı yer: MemberInfo)
GetCustomAttributesData()	Hedef üyeye uygulanmış öznitelikler hakkındaki verileri temsil eden CustomAttributeData nesnelerinin listesini döndürür. (Devralındığı yer: MemberInfo)
GetDeclaredEvent(String)	Geçerli tür tarafından bildirilen belirtilen olayı temsil eden bir nesne döndürür. (Devralındığı yer: TypeInfo)
GetDeclaredField(String)	Geçerli tür tarafından bildirilen belirtilen alanı temsil eden bir nesne döndürür. (Devralındığı yer: TypeInfo)
GetDeclaredMethod(String)	Geçerli tür tarafından bildirilen belirtilen yöntemi temsil eden bir nesne döndürür. (Devralındığı yer: TypeInfo)
GetDeclaredMethods(String)	Belirtilen adla eşleşen geçerli türde bildirilen tüm yöntemleri içeren bir koleksiyon döndürür. (Devralındığı yer: TypeInfo)
GetDeclaredNestedType(String)	Geçerli tür tarafından bildirilen belirtilen iç içe türü temsil eden bir nesne döndürür. (Devralındığı yer: TypeInfo)
GetDeclaredProperty(String)	Geçerli tür tarafından bildirilen belirtilen özelliği temsil eden bir nesne döndürür. (Devralındığı yer: TypeInfo)
GetDefaultMembers()	DefaultMemberAttribute ayarlanmış geçerli Type için tanımlanan üyeleri arar. (Devralındığı yer: Type)
GetDefaultMembers()	Dinamik olarak tanımlanan 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)	Geçerli sabit listesi türü için belirtilen değere sahip sabitin adını döndürür. (Devralındığı yer: Type)
GetEnumName(Object)	Dinamik olarak tanımlanan 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()	Geçerli sabit listesi türünün üyelerinin adlarını döndürür. (Devralındığı yer: Type)
GetEnumNames()	Dinamik olarak tanımlanan 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()	Geçerli sabit listesi türünün temel türünü döndürür. (Devralındığı yer: Type)
GetEnumUnderlyingType()	Dinamik olarak tanımlanan 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()	Geçerli sabit listesi türündeki sabitlerin değerlerinin bir dizisini döndürür. (Devralındığı yer: Type)
GetEnumValues()	Dinamik olarak tanımlanan 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, BindingFlags)	Tamamlanmamış genel tür parametreleri için desteklenmez.
GetEvent(String, BindingFlags)	Dinamik olarak tanımlanan 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)	Belirtilen ortak olayı temsil eden EventInfo nesnesini döndürür. (Devralındığı yer: Type)
GetEvent(String)	Dinamik olarak tanımlanan 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)
GetEvents()	Tamamlanmamış genel tür parametreleri için desteklenmez.
GetEvents()	Dinamik olarak tanımlanan 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)
GetEvents(BindingFlags)	Tamamlanmamış genel tür parametreleri için desteklenmez.
GetEvents(BindingFlags)	Dinamik olarak tanımlanan 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.
GetField(String, BindingFlags)	Dinamik olarak tanımlanan 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)	Belirtilen ada sahip ortak alanı arar. (Devralındığı yer: Type)
GetField(String)	Dinamik olarak tanımlanan 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()	Geçerli Typetüm genel alanlarını döndürür. (Devralındığı yer: Type)
GetFields()	Dinamik olarak tanımlanan 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.
GetFields(BindingFlags)	Dinamik olarak tanımlanan 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)
GetFunctionPointerCallingConventions()	Türetilmiş bir sınıfta geçersiz kılındığında, Typegeçerli işlev işaretçisinin ç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, Typegeçerli işlev işaretçisinin parametre türlerini döndürür. (Devralındığı yer: Type)
GetFunctionPointerReturnType()	Türetilmiş bir sınıfta geçersiz kılındığında, Typegeçerli işlev işaretçisinin dönüş türünü döndürür. (Devralındığı yer: Type)
GetGenericArguments()	Genel tür parametreleri için geçerli değil.
GetGenericArguments()	Dinamik olarak tanımlanan 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)
GetGenericParameterConstraints()	Dinamik olarak tanımlanan genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetGenericParameterConstraints()	Geçerli genel tür parametresindeki kısıtlamaları temsil eden bir Type nesnesi dizisi döndürür. (Devralındığı yer: Type)
GetGenericParameterConstraints()	Dinamik olarak tanımlanan 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, Boolean)	Tamamlanmamış genel tür parametreleri için desteklenmez.
GetInterface(String, Boolean)	Dinamik olarak tanımlanan 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)	Belirtilen ada sahip arabirimi arar. (Devralındığı yer: Type)
GetInterface(String)	Dinamik olarak tanımlanan 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)
GetInterfaceMap(Type)	Tamamlanmamış genel tür parametreleri için desteklenmez.
GetInterfaces()	Tamamlanmamış genel tür parametreleri için desteklenmez.
GetInterfaces()	Dinamik olarak tanımlanan 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)	Belirtilen bağlama kısıtlamalarını kullanarak belirtilen üyeleri arar. (Devralındığı yer: Type)
GetMember(String, BindingFlags)	Dinamik olarak tanımlanan 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.
GetMember(String, MemberTypes, BindingFlags)	Dinamik olarak tanımlanan 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)	Belirtilen ada sahip genel üyeleri arar. (Devralındığı yer: Type)
GetMember(String)	Dinamik olarak tanımlanan 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()	Geçerli Typetüm genel üyelerini döndürür. (Devralındığı yer: Type)
GetMembers()	Dinamik olarak tanımlanan 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.
GetMembers(BindingFlags)	Dinamik olarak tanımlanan 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)
GetMemberWithSameMetadataDefinitionAs(MemberInfo)	Geçerli Type belirtilen MemberInfoile eşleşen MemberInfo arar. (Devralındığı yer: Type)
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, BindingFlags)	Belirtilen bağlama kısıtlamalarını kullanarak belirtilen yöntemi arar. (Devralındığı yer: Type)
GetMethod(String, BindingFlags)	Dinamik olarak tanımlanan 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, 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[])	Belirtilen bağlama kısıtlamalarını kullanarak parametreleri belirtilen genel parametre sayısı ve bağımsız değişken türleriyle eşleşen belirtilen 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, 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, Type[], ParameterModifier[])	Parametreleri belirtilen 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[], ParameterModifier[])	Dinamik olarak tanımlanan 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[])	Parametreleri belirtilen bağımsız değişken türleriyle eşleşen belirtilen ortak yöntemi arar. (Devralındığı yer: Type)
GetMethod(String, Type[])	Dinamik olarak tanımlanan 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)	Belirtilen ada sahip ortak yöntemi arar. (Devralındığı yer: Type)
GetMethod(String)	Dinamik olarak tanımlanan 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, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen bağlama kısıtlamalarını ve belirtilen çağırma kuralını kullanarak parametreleri belirtilen bağımsız değişken türleri ve değiştiricilerle eşleşen belirtilen yöntemi arar. (Devralındığı yer: Type)
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ıyla, bağımsız değişken türleriyle ve değiştiricilerle eşleşen belirtilen yöntemi arar. (Devralındığı yer: Type)
GetMethods()	Geçerli Typetüm genel yöntemlerini döndürür. (Devralındığı yer: Type)
GetMethods()	Dinamik olarak tanımlanan 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.
GetMethods(BindingFlags)	Dinamik olarak tanımlanan 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.
GetNestedType(String, BindingFlags)	Dinamik olarak tanımlanan 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)	Belirtilen ada sahip genel iç içe türü arar. (Devralındığı yer: Type)
GetNestedType(String)	Dinamik olarak tanımlanan 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()	Geçerli Typeiç içe yerleştirilmiş genel türleri döndürür. (Devralındığı yer: Type)
GetNestedTypes()	Dinamik olarak tanımlanan 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.
GetNestedTypes(BindingFlags)	Dinamik olarak tanımlanan 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)
GetOptionalCustomModifiers()	Türetilmiş bir sınıfta geçersiz kılındığında, geçerli Typeisteğe bağlı özel değiştiricilerini döndürür. (Devralındığı yer: Type)
GetProperties()	Geçerli Typetüm genel özelliklerini döndürür. (Devralındığı yer: Type)
GetProperties()	Dinamik olarak tanımlanan 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.
GetProperties(BindingFlags)	Dinamik olarak tanımlanan 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, BindingFlags)	Belirtilen bağlama kısıtlamalarını kullanarak belirtilen özelliği arar. (Devralındığı yer: Type)
GetProperty(String, BindingFlags)	Dinamik olarak tanımlanan 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[])	Parametreleri belirtilen bağımsız değişken türleri ve değiştiricilerle eşleşen belirtilen ortak özelliği arar. (Devralındığı yer: Type)
GetProperty(String, Type, Type[], ParameterModifier[])	Dinamik olarak tanımlanan 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[])	Parametreleri belirtilen bağımsız değişken türleriyle eşleşen belirtilen ortak özelliği arar. (Devralındığı yer: Type)
GetProperty(String, Type, Type[])	Dinamik olarak tanımlanan 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)	Belirtilen ada ve dönüş türüne sahip ortak özelliği arar. (Devralındığı yer: Type)
GetProperty(String, Type)	Dinamik olarak tanımlanan 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[])	Parametreleri belirtilen bağımsız değişken türleriyle eşleşen belirtilen ortak özelliği arar. (Devralındığı yer: Type)
GetProperty(String, Type[])	Dinamik olarak tanımlanan 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)	Belirtilen ada sahip ortak özelliği arar. (Devralındığı yer: Type)
GetProperty(String)	Dinamik olarak tanımlanan 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.
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen bağlama kısıtlamalarını kullanarak parametreleri belirtilen bağımsız değişken türleri ve değiştiricilerle eşleşen belirtilen özelliği arar. (Devralındığı yer: Type)
GetRequiredCustomModifiers()	Türetilmiş bir sınıfta geçersiz kılındığında, geçerli Typegerekli özel değiştiricilerini döndürür. (Devralındığı yer: Type)
GetType()	Geçerli Typealır. (Devralındığı yer: Type)
GetType()	Bir üyenin özniteliklerini bulur ve üye meta verilerine erişim sağlar. (Devralındığı yer: MemberInfo)
GetTypeCodeImpl()	Bu Type örneğinin temel tür kodunu döndürür. (Devralındığı yer: Type)
HasElementTypeImpl()	Türetilmiş bir sınıfta geçersiz kılındığında, HasElementType özelliğini uygular ve geçerli Type başka bir türü kapsayıp kapsayamayacağını veya başka bir türe başvurup başvurmayacağını belirler; yani geçerli Type bir dizi mi, işaretçi mi yoksa başvuruyla mı geçirilir?
HasElementTypeImpl()	Türetilmiş bir sınıfta geçersiz kılındığında, HasElementType özelliğini uygular ve geçerli Type başka bir türü kapsayıp kapsayamayacağını veya başka bir türe başvurup başvurmayacağını belirler; yani geçerli Type bir dizi mi, işaretçi mi yoksa başvuruyla mı geçirilir? (Devralındığı yer: Type)
HasSameMetadataDefinitionAs(MemberInfo)	Dinamik olarak tanımlanan 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[], 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.
InvokeMember(String, BindingFlags, Binder, Object, Object[])	Belirtilen bağlama kısıtlamalarını kullanarak ve belirtilen bağımsız değişken listesiyle eşleşen belirtilen üyeyi çağırır. (Devralındığı yer: Type)
IsArrayImpl()	Türetilmiş bir sınıfta geçersiz kılındığında, IsArray özelliğini uygular ve Type bir dizi olup olmadığını belirler.
IsArrayImpl()	Türetilmiş bir sınıfta geçersiz kılındığında, IsArray özelliğini uygular ve Type bir dizi olup olmadığını belirler. (Devralındığı yer: Type)
IsAssignableFrom(Type)	Her durumda bir NotSupportedException özel durumu oluşturur.
IsAssignableFrom(Type)	Dinamik olarak tanımlanan 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)
IsAssignableFrom(TypeInfo)	Her durumda bir NotSupportedException özel durumu oluşturur.
IsAssignableTo(Type)	Geçerli türün belirtilen `targetType`değişkenine atanıp atanamayacağını belirler. (Devralındığı yer: Type)
IsByRefImpl()	Türetilmiş bir sınıfta geçersiz kılındığında, IsByRef özelliğini uygular ve Type başvuruyla geçirilip geçirilmeyeceğini belirler.
IsByRefImpl()	Türetilmiş bir sınıfta geçersiz kılındığında, IsByRef özelliğini uygular ve Type başvuruyla geçirilip geçirilmeyeceğini belirler. (Devralındığı yer: Type)
IsCOMObjectImpl()	Türetilmiş bir sınıfta geçersiz kılındığında, IsCOMObject özelliğini uygular ve Type bir COM nesnesi olup olmadığını belirler.
IsCOMObjectImpl()	Türetilmiş bir sınıfta geçersiz kılındığında, IsCOMObject özelliğini uygular ve Type bir COM nesnesi olup olmadığını belirler. (Devralındığı yer: Type)
IsContextfulImpl()	IsContextful özelliğini uygular ve Type bir bağlamda barındırılıp barındırılamayacağını belirler. (Devralındığı yer: Type)
IsDefined(Type, Boolean)	Tamamlanmamış genel tür parametreleri için desteklenmez.
IsDefined(Type, Boolean)	Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen türde veya türetilmiş türlerdeki bir veya daha fazla özniteliğin bu üyeye uygulanıp uygulanmadığını gösterir. (Devralındığı yer: MemberInfo)
IsEnumDefined(Object)	Belirtilen değerin geçerli sabit listesi türünde var olup olmadığını gösteren bir değer döndürür. (Devralındığı yer: Type)
IsEnumDefined(Object)	Dinamik olarak tanımlanan 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)	İki COM türünün aynı kimliğe sahip olup olmadığını ve tür eşdeğerliği için uygun olup olmadığını belirler. (Devralındığı yer: Type)
IsEquivalentTo(Type)	Dinamik olarak tanımlanan 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)	Belirtilen nesnenin geçerli Typebir örneği olup olmadığını belirler. (Devralındığı yer: Type)
IsInstanceOfType(Object)	Dinamik olarak tanımlanan 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()	IsMarshalByRef özelliğini uygular ve Type başvuruya göre sıralanıp sıralanmamış olduğunu belirler. (Devralındığı yer: Type)
IsPointerImpl()	Türetilmiş bir sınıfta geçersiz kılındığında, IsPointer özelliğini uygular ve Type bir işaretçi olup olmadığını belirler.
IsPointerImpl()	Türetilmiş bir sınıfta geçersiz kılındığında, IsPointer özelliğini uygular ve Type bir işaretçi olup olmadığını belirler. (Devralındığı yer: Type)
IsPrimitiveImpl()	Türetilmiş bir sınıfta geçersiz kılındığında, IsPrimitive özelliğini uygular ve Type ilkel türlerden biri olup olmadığını belirler.
IsPrimitiveImpl()	Türetilmiş bir sınıfta geçersiz kılındığında, IsPrimitive özelliğini uygular ve Type ilkel türlerden biri olup olmadığını belirler. (Devralındığı yer: Type)
IsSubclassOf(Type)	Tamamlanmamış genel tür parametreleri için desteklenmez.
IsValueTypeImpl()	IsValueType özelliğini uygular ve Type bir değer türü olup olmadığını belirler; yani, bir sınıf veya arabirim değil.
IsValueTypeImpl()	IsValueType özelliğini uygular ve Type bir değer türü olup olmadığını belirler; yani, bir sınıf veya arabirim değil. (Devralındığı yer: Type)
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()	Başvuru parametresi olarak geçirildiğinde geçerli genel tür parametresini temsil eden bir Type nesnesi 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 nesnesi döndürür.
MemberwiseClone()	Geçerli Objectbasit bir kopyasını oluşturur. (Devralındığı yer: Object)
SetBaseTypeConstraint(Type)	Tür parametresiyle değiştirilebilmesi 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 parametresiyle değiştirilebilmesi için 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 parametresiyle değiştirilebilmesi 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ı

_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Bir ad kümesini ilgili dağıtım tanımlayıcıları kümesiyle eşler. (Devralındığı yer: MemberInfo)
_MemberInfo.GetType()	MemberInfo sınıfını temsil eden bir Type nesnesi alır. (Devralındığı yer: MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)	Bir nesnenin tür bilgilerini alır ve daha sonra arabirim için tür bilgilerini almak için kullanılabilir. (Devralındığı yer: MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)	Bir nesnenin sağladığı tür bilgisi arabirimlerinin sayısını alır (0 veya 1). (Devralındığı yer: MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Bir nesne tarafından kullanıma sunulan özelliklere ve yöntemlere erişim sağlar. (Devralındığı yer: MemberInfo)
_Type.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Bir ad kümesini ilgili dağıtım tanımlayıcıları kümesiyle eşler. (Devralındığı yer: Type)
_Type.GetTypeInfo(UInt32, UInt32, IntPtr)	Bir nesnenin tür bilgilerini alır ve daha sonra arabirim için tür bilgilerini almak için kullanılabilir. (Devralındığı yer: Type)
_Type.GetTypeInfoCount(UInt32)	Bir nesnenin sağladığı tür bilgisi arabirimlerinin sayısını alır (0 veya 1). (Devralındığı yer: Type)
_Type.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Bir nesne tarafından kullanıma sunulan özelliklere ve yöntemlere erişim sağlar. (Devralındığı yer: Type)
ICustomAttributeProvider.GetCustomAttributes(Boolean)	Adlandırılmış öznitelikler hariç olmak üzere bu üyede tanımlanan tüm özel özniteliklerden oluşan bir dizi veya özel öznitelik yoksa boş bir dizi döndürür. (Devralındığı yer: MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)	Bu üyede tanımlanan, türe göre tanımlanan bir özel öznitelik dizisi veya bu türdeki özel öznitelikler yoksa boş bir dizi döndürür. (Devralındığı yer: MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean)	Bu üyede bir veya daha fazla `attributeType` örneğinin tanımlanıp tanımlanmadığını gösterir. (Devralındığı yer: MemberInfo)
IReflectableType.GetTypeInfo()	Geçerli türün bir gösterimini TypeInfo nesnesi olarak döndürür. (Devralındığı yer: TypeInfo)

Uzantı Metotları

GetCustomAttribute(MemberInfo, Type, Boolean)	Belirtilen bir üyeye uygulanan belirtilen türdeki özel özniteliği alır ve isteğe bağlı olarak bu üyenin atalarını inceler.
GetCustomAttribute(MemberInfo, Type)	Belirtilen üyeye uygulanan belirtilen türde bir özel özniteliği alır.
GetCustomAttribute<T>(MemberInfo, Boolean)	Belirtilen bir üyeye uygulanan belirtilen türdeki özel özniteliği alır ve isteğe bağlı olarak bu üyenin atalarını inceler.
GetCustomAttribute<T>(MemberInfo)	Belirtilen üyeye uygulanan belirtilen türde bir özel özniteliği alır.
GetCustomAttributes(MemberInfo, Boolean)	Belirli bir üyeye uygulanan özel öznitelikler koleksiyonunu alır ve isteğe bağlı olarak bu üyenin atalarını inceler.
GetCustomAttributes(MemberInfo, Type, Boolean)	Belirtilen bir üyeye uygulanan belirtilen türdeki özel özniteliklerden oluşan bir koleksiyonu alır ve isteğe bağlı olarak bu üyenin atalarını inceler.
GetCustomAttributes(MemberInfo, Type)	Belirtilen üyeye uygulanan belirtilen türde özel özniteliklerden oluşan bir koleksiyonu alır.
GetCustomAttributes(MemberInfo)	Belirtilen üyeye uygulanan özel öznitelik koleksiyonunu alır.
GetCustomAttributes<T>(MemberInfo, Boolean)	Belirtilen bir üyeye uygulanan belirtilen türdeki özel özniteliklerden oluşan bir koleksiyonu alır ve isteğe bağlı olarak bu üyenin atalarını inceler.
GetCustomAttributes<T>(MemberInfo)	Belirtilen üyeye uygulanan belirtilen türde özel özniteliklerden oluşan bir koleksiyonu alır.
IsDefined(MemberInfo, Type, Boolean)	Belirtilen türde özel özniteliklerin belirtilen bir üyeye uygulanıp uygulanmadığını ve isteğe bağlı olarak üst öğeye uygulanıp uygulanmadığını gösterir.
IsDefined(MemberInfo, Type)	Belirtilen türde özel özniteliklerin belirtilen üyeye uygulanıp uygulanmadığını gösterir.
GetTypeInfo(Type)	Belirtilen türün TypeInfo 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 nesne alır.
GetRuntimeEvents(Type)	Belirtilen türde tanımlanan tüm olayları temsil eden bir koleksiyon alır.
GetRuntimeField(Type, String)	Belirtilen bir alanı temsil eden bir nesneyi alır.
GetRuntimeFields(Type)	Belirtilen türde tanımlanan tüm alanları temsil eden bir koleksiyon alır.
GetRuntimeInterfaceMap(TypeInfo, Type)	Belirtilen tür ve belirtilen arabirim için bir arabirim eşlemesi döndürür.
GetRuntimeMethod(Type, String, Type[])	Belirtilen yöntemi temsil eden bir nesneyi alır.
GetRuntimeMethods(Type)	Belirtilen türde tanımlanan tüm yöntemleri temsil eden bir koleksiyon alır.
GetRuntimeProperties(Type)	Belirtilen türde tanımlanan tüm özellikleri temsil eden bir koleksiyon alır.
GetRuntimeProperty(Type, String)	Belirtilen özelliği temsil eden bir nesneyi alır.
GetConstructor(Type, Type[])	Dinamik olarak tanımlanan 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ımlanan 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ımlanan genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetDefaultMembers(Type)	Dinamik olarak tanımlanan genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetEvent(Type, String, BindingFlags)	Dinamik olarak tanımlanan genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetEvent(Type, String)	Dinamik olarak tanımlanan genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetEvents(Type, BindingFlags)	Dinamik olarak tanımlanan genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetField(Type, String, BindingFlags)	Dinamik olarak tanımlanan genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetField(Type, String)	Dinamik olarak tanımlanan 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ımlanan 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)	Dinamik olarak tanımlanan 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ımlanan 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ımlanan genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetMethod(Type, String, BindingFlags)	Dinamik olarak tanımlanan genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.
GetMethod(Type, String, Type[])	Dinamik olarak tanımlanan 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ımlanan 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ımlanan 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ımlanan 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ımlanan 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ımlanan 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ımlanan genel türler ve yöntemler için genel tür parametreleri tanımlar ve oluşturur. Bu sınıf devralınamaz.

Şunlara uygulanır

Ayrıca bkz.

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

Aracılığıyla paylaş