Udostępnij za pośrednictwem


GenericTypeParameterBuilder Klasa

Definicja

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

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
Dziedziczenie
GenericTypeParameterBuilder
Dziedziczenie
GenericTypeParameterBuilder
Dziedziczenie
GenericTypeParameterBuilder
Atrybuty

Przykłady

Poniższy przykład kodu tworzy typ ogólny z dwoma parametrami typu i zapisuje je w GenericEmitExample1.dll zestawu. Aby wyświetlić wygenerowane typy, można użyć Ildasm.exe (dezasembler IL ). Aby uzyskać bardziej szczegółowe wyjaśnienie kroków związanych z definiowaniem dynamicznego typu ogólnego, zobacz How to: Define a Generic Type with Reflection Emit (Jak zdefiniować typ ogólny z emitem odbicia).

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

Uwagi

Tablicę GenericTypeParameterBuilder obiektów można uzyskać przy użyciu TypeBuilder.DefineGenericParameters metody dodawania parametrów typu do typu dynamicznego, co czyni go typem ogólnym lub za pomocą MethodBuilder.DefineGenericParameters metody dodawania parametrów typu do metody dynamicznej. GenericTypeParameterBuilder Użyj obiektów, aby dodać ograniczenia do parametrów typu. Ograniczenia to trzy rodzaje:

  • Ograniczenie typu podstawowego określa, że każdy typ przypisany do parametru typu ogólnego musi pochodzić z określonego typu podstawowego. Ustaw to ograniczenie przy użyciu SetBaseTypeConstraint metody .

  • Ograniczenie interfejsu określa, że każdy typ przypisany do parametru typu ogólnego musi implementować określony interfejs. Ustaw ograniczenia interfejsu SetInterfaceConstraints przy użyciu metody .

  • Ograniczenia specjalne określają, że każdy typ przypisany do parametru typu ogólnego musi mieć konstruktor bez parametrów, musi być typem odwołania lub musi być typem wartości. Ustaw specjalne ograniczenia dla parametru typu przy użyciu SetGenericParameterAttributes metody .

Nie można pobrać ograniczeń interfejsu GenericTypeParameterBuilder i specjalnych ograniczeń przy użyciu metod klasy . Po utworzeniu typu ogólnego zawierającego parametry typu można użyć jego Type obiektu, aby odzwierciedlić ograniczenia. Type.GetGenericArguments Użyj metody , aby uzyskać parametry typu, a dla każdego parametru typu użyj Type.GetGenericParameterConstraints metody , aby uzyskać ograniczenie typu podstawowego i ograniczenia interfejsu oraz Type.GenericParameterAttributes właściwość w celu uzyskania specjalnych ograniczeń.

Konstruktory

GenericTypeParameterBuilder()

Inicjuje nowe wystąpienie klasy GenericTypeParameterBuilder.

Właściwości

Assembly

Assembly Pobiera obiekt reprezentujący zestaw dynamiczny zawierający definicję typu ogólnego, do którego należy bieżący parametr typu.

AssemblyQualifiedName

Pobiera null we wszystkich przypadkach.

Attributes

Pobiera atrybuty skojarzone z elementem Type.

Attributes

Pobiera atrybuty skojarzone z elementem Type.

(Odziedziczone po Type)
Attributes

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
BaseType

Pobiera ograniczenie typu podstawowego bieżącego parametru typu ogólnego.

ContainsGenericParameters

Pobiera true we wszystkich przypadkach.

CustomAttributes

Pobiera kolekcję zawierającą atrybuty niestandardowe tego elementu członkowskiego.

(Odziedziczone po MemberInfo)
DeclaredConstructors

Pobiera kolekcję konstruktorów zadeklarowanych przez bieżący typ.

(Odziedziczone po TypeInfo)
DeclaredEvents

Pobiera kolekcję zdarzeń zdefiniowanych przez bieżący typ.

(Odziedziczone po TypeInfo)
DeclaredFields

Pobiera kolekcję pól zdefiniowanych przez bieżący typ.

(Odziedziczone po TypeInfo)
DeclaredMembers

Pobiera kolekcję elementów członkowskich zdefiniowanych przez bieżący typ.

(Odziedziczone po TypeInfo)
DeclaredMethods

Pobiera kolekcję metod zdefiniowanych przez bieżący typ.

(Odziedziczone po TypeInfo)
DeclaredNestedTypes

Pobiera kolekcję zagnieżdżonych typów zdefiniowanych przez bieżący typ.

(Odziedziczone po TypeInfo)
DeclaredProperties

Pobiera kolekcję właściwości zdefiniowanych przez bieżący typ.

(Odziedziczone po TypeInfo)
DeclaringMethod

Pobiera obiekt MethodInfo reprezentujący metodę deklaratowania, jeśli bieżący GenericTypeParameterBuilder reprezentuje parametr typu metody ogólnej.

DeclaringType

Pobiera definicję typu ogólnego lub definicję metody ogólnej, do której należy parametr typu ogólnego.

FullName

Pobiera null we wszystkich przypadkach.

GenericParameterAttributes

Pobiera kombinację GenericParameterAttributes flag opisujących kowariancję i specjalne ograniczenia bieżącego parametru typu ogólnego.

GenericParameterAttributes

Pobiera kombinację GenericParameterAttributes flag opisujących kowariancję i specjalne ograniczenia bieżącego parametru typu ogólnego.

(Odziedziczone po Type)
GenericParameterPosition

Pobiera pozycję parametru typu na liście parametrów typu typu lub metody, która zadeklarowała parametr.

GenericTypeArguments

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

GenericTypeArguments

Pobiera tablicę argumentów typu ogólnego dla tego typu.

(Odziedziczone po Type)
GenericTypeArguments

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GenericTypeParameters

Pobiera tablicę parametrów typu ogólnego bieżącego wystąpienia.

(Odziedziczone po TypeInfo)
GUID

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

HasElementType

Pobiera wartość wskazującą, czy bieżący Type zawiera lub odwołuje się do innego typu; oznacza to, czy bieżący Type jest tablicą, wskaźnikiem, czy jest przekazywany przez odwołanie.

(Odziedziczone po Type)
HasElementType

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
ImplementedInterfaces

Pobiera kolekcję interfejsów implementowanych przez bieżący typ.

(Odziedziczone po TypeInfo)
IsAbstract

Pobiera wartość wskazującą, czy Type element jest abstrakcyjny i musi zostać zastąpiony.

(Odziedziczone po Type)
IsAbstract

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsAnsiClass

Pobiera wartość wskazującą, czy atrybut formatu ciągu jest wybrany dla .AnsiClassType

(Odziedziczone po Type)
IsAnsiClass

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsArray

Pobiera wartość wskazującą, czy typ jest tablicą.

(Odziedziczone po Type)
IsArray

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsAutoClass

Pobiera wartość wskazującą, czy atrybut formatu ciągu jest wybrany dla .AutoClassType

(Odziedziczone po Type)
IsAutoClass

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsAutoLayout

Pobiera wartość wskazującą, czy pola bieżącego typu są określane automatycznie przez środowisko uruchomieniowe języka wspólnego.

(Odziedziczone po Type)
IsAutoLayout

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsByRef

Pobiera wartość wskazującą, czy Type element jest przekazywany przez odwołanie.

(Odziedziczone po Type)
IsByRef

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsByRefLike

Pobiera wartość wskazującą, czy typ jest strukturą przypominającą byref.

IsByRefLike

Pobiera wartość wskazującą, czy typ jest strukturą przypominającą byref.

(Odziedziczone po Type)
IsClass

Pobiera wartość wskazującą, czy Type jest klasą, czy delegatem, czyli nie typem wartości lub interfejsem.

(Odziedziczone po Type)
IsClass

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsCollectible

Pobiera wartość wskazującą, czy ten MemberInfo obiekt jest częścią zestawu przechowywanego w obiekcie zbieralnym AssemblyLoadContext.

(Odziedziczone po MemberInfo)
IsCOMObject

Pobiera wartość wskazującą, czy Type obiekt COM jest obiektem COM.

(Odziedziczone po Type)
IsCOMObject

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsConstructedGenericType

Pobiera wartość wskazującą, czy ten obiekt reprezentuje skonstruowany typ ogólny.

IsConstructedGenericType

Pobiera wartość wskazującą, czy ten obiekt reprezentuje skonstruowany typ ogólny. Wystąpienia skonstruowanego typu ogólnego można utworzyć.

(Odziedziczone po Type)
IsContextful

Pobiera wartość wskazującą, czy Type może być hostowany w kontekście.

(Odziedziczone po Type)
IsEnum

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

IsEnum

Pobiera wartość wskazującą, czy bieżący Type reprezentuje wyliczenie.

(Odziedziczone po Type)
IsEnum

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsExplicitLayout

Pobiera wartość wskazującą, czy pola bieżącego typu są określone jawnie przesunięć.

(Odziedziczone po Type)
IsExplicitLayout

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsFunctionPointer

Pobiera wartość wskazującą, czy bieżący Type jest wskaźnikiem funkcji.

(Odziedziczone po Type)
IsGenericMethodParameter

Pobiera wartość wskazującą, czy bieżący Type reprezentuje parametr typu w definicji metody ogólnej.

(Odziedziczone po Type)
IsGenericParameter

Pobiera true we wszystkich przypadkach.

IsGenericType

Zwraca wartość false we wszystkich przypadkach.

IsGenericTypeDefinition

Pobiera false we wszystkich przypadkach.

IsGenericTypeParameter

Pobiera wartość wskazującą, czy bieżący Type reprezentuje parametr typu w definicji typu ogólnego.

(Odziedziczone po Type)
IsImport

Pobiera wartość wskazującąComImportAttribute, czy Type zastosowano atrybut wskazujący, że został zaimportowany z biblioteki typów COM.

(Odziedziczone po Type)
IsImport

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsInterface

Pobiera wartość wskazującą, czy Type element jest interfejsem, czyli nie klasą, czy typem wartości.

(Odziedziczone po Type)
IsInterface

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsLayoutSequential

Pobiera wartość wskazującą, czy pola bieżącego typu są ułożone sekwencyjnie, w kolejności, w której zostały zdefiniowane lub emitowane do metadanych.

(Odziedziczone po Type)
IsLayoutSequential

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsMarshalByRef

Pobiera wartość wskazującą, czy element Type jest marshaledowany przez odwołanie.

(Odziedziczone po Type)
IsMarshalByRef

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsNested

Pobiera wartość wskazującą, czy bieżący Type obiekt reprezentuje typ, którego definicja jest zagnieżdżona wewnątrz definicji innego typu.

(Odziedziczone po Type)
IsNested

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsNestedAssembly

Pobiera wartość wskazującą, czy Type obiekt jest zagnieżdżony i widoczny tylko w ramach własnego zestawu.

(Odziedziczone po Type)
IsNestedAssembly

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsNestedFamANDAssem

Pobiera wartość wskazującą, czy Type obiekt jest zagnieżdżony i widoczny tylko dla klas należących zarówno do własnej rodziny, jak i własnego zestawu.

(Odziedziczone po Type)
IsNestedFamANDAssem

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsNestedFamily

Pobiera wartość wskazującą, czy Type obiekt jest zagnieżdżony i widoczny tylko w obrębie własnej rodziny.

(Odziedziczone po Type)
IsNestedFamily

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsNestedFamORAssem

Pobiera wartość wskazującą, czy Type obiekt jest zagnieżdżony i widoczny tylko dla klas należących do własnej rodziny, czy do własnego zestawu.

(Odziedziczone po Type)
IsNestedFamORAssem

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsNestedPrivate

Pobiera wartość wskazującą, czy Type obiekt jest zagnieżdżony i zadeklarowany jako prywatny.

(Odziedziczone po Type)
IsNestedPrivate

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsNestedPublic

Pobiera wartość wskazującą, czy klasa jest zagnieżdżona i zadeklarowana jako publiczna.

(Odziedziczone po Type)
IsNestedPublic

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsNotPublic

Pobiera wartość wskazującą Type , czy element nie jest zadeklarowany jako publiczny.

(Odziedziczone po Type)
IsNotPublic

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsPointer

Pobiera wartość wskazującą, czy Type element jest wskaźnikiem.

(Odziedziczone po Type)
IsPointer

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsPrimitive

Pobiera wartość wskazującą, czy Type element jest jednym z typów pierwotnych.

(Odziedziczone po Type)
IsPrimitive

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsPublic

Pobiera wartość wskazującą Type , czy element jest zadeklarowany publicznie.

(Odziedziczone po Type)
IsPublic

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsSealed

Pobiera wartość wskazującą, czy Type element jest zadeklarowany jako zapieczętowany.

(Odziedziczone po Type)
IsSealed

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsSecurityCritical

Pobiera wartość wskazującą, czy bieżący typ jest krytyczny dla zabezpieczeń, czy krytyczny pod względem zabezpieczeń na bieżącym poziomie zaufania, a zatem może wykonywać operacje krytyczne.

(Odziedziczone po Type)
IsSecuritySafeCritical

Pobiera wartość wskazującą, czy bieżący typ jest krytyczny pod względem zabezpieczeń na bieżącym poziomie zaufania; oznacza to, czy może wykonywać operacje krytyczne i można uzyskiwać do niego dostęp za pomocą przezroczystego kodu.

(Odziedziczone po Type)
IsSecurityTransparent

Pobiera wartość wskazującą, czy bieżący typ jest przezroczysty na bieżącym poziomie zaufania i dlatego nie może wykonywać operacji krytycznych.

(Odziedziczone po Type)
IsSerializable

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

IsSerializable
Przestarzałe.

Pobiera wartość wskazującą Type , czy parametr jest możliwy do serializacji binarnej.

(Odziedziczone po Type)
IsSerializable

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsSignatureType

Pobiera wartość wskazującą, czy typ jest typem podpisu.

(Odziedziczone po Type)
IsSpecialName

Pobiera wartość wskazującą, czy typ ma nazwę, która wymaga specjalnej obsługi.

(Odziedziczone po Type)
IsSpecialName

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsSZArray

Pobiera wartość wskazującą, czy typ jest typem tablicy, który może reprezentować tylko tablicę jednowymiarową z zerową dolną granicą.

IsSZArray

Pobiera wartość wskazującą, czy typ jest typem tablicy, który może reprezentować tylko tablicę jednowymiarową z zerową dolną granicą.

(Odziedziczone po Type)
IsTypeDefinition

Pobiera wartość wskazującą, czy typ jest definicją typu.

IsTypeDefinition

Pobiera wartość wskazującą, czy typ jest definicją typu.

(Odziedziczone po Type)
IsUnicodeClass

Pobiera wartość wskazującą, czy atrybut formatu ciągu jest wybrany dla .UnicodeClassType

(Odziedziczone po Type)
IsUnicodeClass

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsUnmanagedFunctionPointer

Pobiera wartość wskazującą, czy bieżący Type jest wskaźnikiem funkcji niezarządzanej.

(Odziedziczone po Type)
IsValueType

Pobiera wartość wskazującą, czy Type jest typem wartości.

(Odziedziczone po Type)
IsValueType

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsVariableBoundArray

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

IsVariableBoundArray

Pobiera wartość wskazującą, czy typ jest typem tablicy, który może reprezentować tablicę wielowymiarową, czy tablicę z dowolną dolną granicą.

(Odziedziczone po Type)
IsVisible

Pobiera wartość wskazującą, czy Type można uzyskać dostęp za pomocą kodu poza zestawem.

(Odziedziczone po Type)
IsVisible

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
MemberType

Pobiera wartość wskazującą MemberTypes , że ten element członkowski jest typem lub typem zagnieżdżonym.

(Odziedziczone po Type)
MemberType

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
MetadataToken

Pobiera token identyfikujący bieżący moduł dynamiczny w metadanych.

MetadataToken

Pobiera wartość identyfikującą element metadanych.

(Odziedziczone po MemberInfo)
Module

Pobiera moduł dynamiczny zawierający parametr typu ogólnego.

Name

Pobiera nazwę parametru typu ogólnego.

Namespace

Pobiera null we wszystkich przypadkach.

ReflectedType

Type Pobiera obiekt, który został użyty do uzyskania obiektu GenericTypeParameterBuilder.

ReflectedType

Pobiera obiekt klasy, który został użyty do uzyskania tego wystąpienia klasy MemberInfo.

(Odziedziczone po MemberInfo)
StructLayoutAttribute

Pobiera element StructLayoutAttribute opisujący układ bieżącego typu.

(Odziedziczone po Type)
StructLayoutAttribute

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
TypeHandle

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

TypeInitializer

Pobiera inicjator dla typu.

(Odziedziczone po Type)
TypeInitializer

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
UnderlyingSystemType

Pobiera bieżący parametr typu ogólnego.

UnderlyingSystemType

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)

Metody

AsType()

Zwraca bieżący typ jako Type obiekt.

(Odziedziczone po TypeInfo)
Equals(Object)

Sprawdza, czy dany obiekt jest wystąpieniem EventToken elementu i jest równe bieżącemu wystąpieniu.

Equals(Type)

Określa, czy podstawowy typ systemu bieżącego Type jest taki sam jak podstawowy typ systemu określonego Type.

(Odziedziczone po Type)
FindInterfaces(TypeFilter, Object)

Zwraca tablicę Type obiektów reprezentujących filtrowaną listę interfejsów implementowanych lub dziedziczynych przez bieżący Typeelement .

(Odziedziczone po Type)
FindInterfaces(TypeFilter, Object)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)

Zwraca filtrowaną tablicę MemberInfo obiektów określonego typu elementu członkowskiego.

(Odziedziczone po Type)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetArrayRank()

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

GetArrayRank()

Pobiera liczbę wymiarów w tablicy.

(Odziedziczone po Type)
GetArrayRank()

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetAttributeFlagsImpl()

Po zastąpieniu w klasie pochodnej implementuje Attributes właściwość i pobiera bitową kombinację wartości wyliczenia, które wskazują atrybuty skojarzone z Type.

GetAttributeFlagsImpl()

Po zastąpieniu w klasie pochodnej implementuje Attributes właściwość i pobiera bitową kombinację wartości wyliczenia, które wskazują atrybuty skojarzone z Type.

(Odziedziczone po Type)
GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Wyszukuje konstruktora, którego parametry są zgodne z określonymi typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązań i określonej konwencji wywoływania.

(Odziedziczone po Type)
GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])

Wyszukuje konstruktora, którego parametry są zgodne z określonymi typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązania.

(Odziedziczone po Type)
GetConstructor(BindingFlags, Type[])

Wyszukuje konstruktora, którego parametry są zgodne z określonymi typami argumentów, przy użyciu określonych ograniczeń powiązania.

(Odziedziczone po Type)
GetConstructor(Type[])

Wyszukuje konstruktor wystąpienia publicznego, którego parametry są zgodne z typami w określonej tablicy.

(Odziedziczone po Type)
GetConstructor(Type[])

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Podczas zastępowania w klasie pochodnej wyszukuje konstruktora, którego parametry są zgodne z określonymi typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązania i określonej konwencji wywoływania.

(Odziedziczone po Type)
GetConstructors()

Zwraca wszystkie publiczne konstruktory zdefiniowane dla bieżącego Typeelementu .

(Odziedziczone po Type)
GetConstructors()

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetConstructors(BindingFlags)

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

GetConstructors(BindingFlags)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetCustomAttributes(Boolean)

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

GetCustomAttributes(Boolean)

Po zastąpieniu w klasie pochodnej zwraca tablicę wszystkich atrybutów niestandardowych zastosowanych do tego elementu członkowskiego.

(Odziedziczone po MemberInfo)
GetCustomAttributes(Type, Boolean)

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

GetCustomAttributes(Type, Boolean)

Po przesłonięciu w klasie pochodnej zwraca tablicę atrybutów niestandardowych zastosowanych do tego elementu członkowskiego i zidentyfikowaną przez Typeelement .

(Odziedziczone po MemberInfo)
GetCustomAttributesData()

Zwraca listę CustomAttributeData obiektów reprezentujących dane dotyczące atrybutów, które zostały zastosowane do elementu docelowego.

(Odziedziczone po MemberInfo)
GetDeclaredEvent(String)

Zwraca obiekt reprezentujący określone zdarzenie zadeklarowane przez bieżący typ.

(Odziedziczone po TypeInfo)
GetDeclaredField(String)

Zwraca obiekt reprezentujący określone pole zadeklarowane przez bieżący typ.

(Odziedziczone po TypeInfo)
GetDeclaredMethod(String)

Zwraca obiekt reprezentujący określoną metodę zadeklarowaną przez bieżący typ.

(Odziedziczone po TypeInfo)
GetDeclaredMethods(String)

Zwraca kolekcję zawierającą wszystkie metody zadeklarowane dla bieżącego typu zgodnego z określoną nazwą.

(Odziedziczone po TypeInfo)
GetDeclaredNestedType(String)

Zwraca obiekt reprezentujący określony typ zagnieżdżony zadeklarowany przez bieżący typ.

(Odziedziczone po TypeInfo)
GetDeclaredProperty(String)

Zwraca obiekt reprezentujący określoną właściwość zadeklarowaną przez bieżący typ.

(Odziedziczone po TypeInfo)
GetDefaultMembers()

Wyszukuje elementy członkowskie zdefiniowane dla bieżącego TypeDefaultMemberAttribute zestawu.

(Odziedziczone po Type)
GetDefaultMembers()

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetElementType()

Zgłasza wartość NotSupportedException we wszystkich przypadkach.

GetEnumName(Object)

Zwraca nazwę stałej, która ma określoną wartość dla bieżącego typu wyliczenia.

(Odziedziczone po Type)
GetEnumName(Object)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetEnumNames()

Zwraca nazwy elementów członkowskich bieżącego typu wyliczenia.

(Odziedziczone po Type)
GetEnumNames()

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetEnumUnderlyingType()

Zwraca typ bazowy bieżącego typu wyliczenia.

(Odziedziczone po Type)
GetEnumUnderlyingType()

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetEnumValues()

Zwraca tablicę wartości stałych w bieżącym typie wyliczenia.

(Odziedziczone po Type)
GetEnumValues()

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetEnumValuesAsUnderlyingType()

Pobiera tablicę wartości stałych typu bazowego tego typu wyliczenia.

(Odziedziczone po Type)
GetEvent(String)

EventInfo Zwraca obiekt reprezentujący określone zdarzenie publiczne.

(Odziedziczone po Type)
GetEvent(String)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetEvent(String, BindingFlags)

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

GetEvent(String, BindingFlags)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetEvents()

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

GetEvents()

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetEvents(BindingFlags)

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

GetEvents(BindingFlags)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetField(String)

Wyszukuje pole publiczne o określonej nazwie.

(Odziedziczone po Type)
GetField(String)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetField(String, BindingFlags)

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

GetField(String, BindingFlags)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetFields()

Zwraca wszystkie pola publiczne bieżącego Typeelementu .

(Odziedziczone po Type)
GetFields()

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetFields(BindingFlags)

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

GetFields(BindingFlags)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetFunctionPointerCallingConventions()

Po przesłonięciu w klasie pochodnej zwraca konwencje wywoływania bieżącego wskaźnika Typefunkcji .

(Odziedziczone po Type)
GetFunctionPointerParameterTypes()

Po zastąpieniu w klasie pochodnej zwraca typy parametrów bieżącego wskaźnika Typefunkcji .

(Odziedziczone po Type)
GetFunctionPointerReturnType()

Po zastąpieniu w klasie pochodnej zwraca zwracany typ bieżącego wskaźnika Typefunkcji .

(Odziedziczone po Type)
GetGenericArguments()

Nieprawidłowy dla parametrów typu ogólnego.

GetGenericArguments()

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetGenericParameterConstraints()

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

GetGenericParameterConstraints()

Zwraca tablicę Type obiektów reprezentujących ograniczenia dla bieżącego parametru typu ogólnego.

(Odziedziczone po Type)
GetGenericParameterConstraints()

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetGenericTypeDefinition()

Nieprawidłowy dla parametrów typu ogólnego.

GetHashCode()

Zwraca 32-bitowy kod skrótu liczby całkowitej dla bieżącego wystąpienia.

GetInterface(String)

Wyszukuje interfejs o określonej nazwie.

(Odziedziczone po Type)
GetInterface(String)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetInterface(String, Boolean)

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

GetInterface(String, Boolean)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetInterfaceMap(Type)

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

GetInterfaces()

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

GetInterfaces()

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetMember(String)

Wyszukuje publiczne elementy członkowskie o określonej nazwie.

(Odziedziczone po Type)
GetMember(String)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetMember(String, BindingFlags)

Wyszukuje określone elementy członkowskie przy użyciu określonych ograniczeń powiązania.

(Odziedziczone po Type)
GetMember(String, BindingFlags)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetMember(String, MemberTypes, BindingFlags)

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

GetMember(String, MemberTypes, BindingFlags)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetMembers()

Zwraca wszystkich publicznych członków bieżącego Typeelementu .

(Odziedziczone po Type)
GetMembers()

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetMembers(BindingFlags)

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

GetMembers(BindingFlags)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetMemberWithSameMetadataDefinitionAs(MemberInfo)

MemberInfo Wyszukuje element w bieżącymType, który jest zgodny z określonym MemberInfoelementem .

(Odziedziczone po Type)
GetMethod(String)

Wyszukuje metodę publiczną o określonej nazwie.

(Odziedziczone po Type)
GetMethod(String)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetMethod(String, BindingFlags)

Wyszukuje określoną metodę przy użyciu określonych ograniczeń powiązania.

(Odziedziczone po Type)
GetMethod(String, BindingFlags)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Wyszukuje określoną metodę, której parametry są zgodne z określonymi typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązań i określonej konwencji wywoływania.

(Odziedziczone po Type)
GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])

Wyszukuje określoną metodę, której parametry są zgodne z określonymi typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązania.

(Odziedziczone po Type)
GetMethod(String, BindingFlags, Type[])

Wyszukuje określoną metodę, której parametry są zgodne z określonymi typami argumentów przy użyciu określonych ograniczeń powiązania.

(Odziedziczone po Type)
GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Wyszukuje określoną metodę, której parametry są zgodne z określoną ogólną liczbą parametrów, typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązania i określonej konwencji wywoływania.

(Odziedziczone po Type)
GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[])

Wyszukuje określoną metodę, której parametry są zgodne z określoną ogólną liczbą parametrów, typami argumentów i modyfikatorami przy użyciu określonych ograniczeń powiązania.

(Odziedziczone po Type)
GetMethod(String, Int32, BindingFlags, Type[])

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po Type)
GetMethod(String, Int32, Type[])

Wyszukuje określoną metodę publiczną, której parametry są zgodne z określoną ogólną liczbą parametrów i typami argumentów.

(Odziedziczone po Type)
GetMethod(String, Int32, Type[], ParameterModifier[])

Wyszukuje określoną metodę publiczną, której parametry są zgodne z określoną ogólną liczbą parametrów, typami argumentów i modyfikatorami.

(Odziedziczone po Type)
GetMethod(String, Type[])

Wyszukuje określoną metodę publiczną, której parametry są zgodne z określonymi typami argumentów.

(Odziedziczone po Type)
GetMethod(String, Type[])

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetMethod(String, Type[], ParameterModifier[])

Wyszukuje określoną metodę publiczną, której parametry są zgodne z określonymi typami argumentów i modyfikatorami.

(Odziedziczone po Type)
GetMethod(String, Type[], ParameterModifier[])

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Podczas zastępowania w klasie pochodnej wyszukuje określoną metodę, której parametry są zgodne z określonymi typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązania i określonej konwencji wywoływania.

(Odziedziczone po Type)
GetMethodImpl(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Podczas zastępowania w klasie pochodnej wyszukuje określoną metodę, której parametry są zgodne z określoną ogólną liczbą parametrów, typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązania i określonej konwencji wywoływania.

(Odziedziczone po Type)
GetMethods()

Zwraca wszystkie publiczne metody bieżącego Typeelementu .

(Odziedziczone po Type)
GetMethods()

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetMethods(BindingFlags)

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

GetMethods(BindingFlags)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetNestedType(String)

Wyszukuje publiczny typ zagnieżdżony o określonej nazwie.

(Odziedziczone po Type)
GetNestedType(String)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetNestedType(String, BindingFlags)

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

GetNestedType(String, BindingFlags)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetNestedTypes()

Zwraca typy publiczne zagnieżdżone w bieżącym Typeobiekcie .

(Odziedziczone po Type)
GetNestedTypes()

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetNestedTypes(BindingFlags)

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

GetNestedTypes(BindingFlags)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetOptionalCustomModifiers()

Po przesłonięciu w klasie pochodnej zwraca opcjonalne modyfikatory niestandardowe bieżącego Typeelementu .

(Odziedziczone po Type)
GetProperties()

Zwraca wszystkie właściwości publiczne bieżącego Typeobiektu .

(Odziedziczone po Type)
GetProperties()

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetProperties(BindingFlags)

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

GetProperties(BindingFlags)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetProperty(String)

Wyszukuje właściwość publiczną o określonej nazwie.

(Odziedziczone po Type)
GetProperty(String)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetProperty(String, BindingFlags)

Wyszukuje określoną właściwość przy użyciu określonych ograniczeń powiązania.

(Odziedziczone po Type)
GetProperty(String, BindingFlags)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])

Wyszukuje określoną właściwość, której parametry są zgodne z określonymi typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązania.

(Odziedziczone po Type)
GetProperty(String, Type)

Wyszukuje właściwość publiczną o określonej nazwie i zwracany typ.

(Odziedziczone po Type)
GetProperty(String, Type)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetProperty(String, Type, Type[])

Wyszukuje określoną właściwość publiczną, której parametry są zgodne z określonymi typami argumentów.

(Odziedziczone po Type)
GetProperty(String, Type, Type[])

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetProperty(String, Type, Type[], ParameterModifier[])

Wyszukuje określoną właściwość publiczną, której parametry są zgodne z określonymi typami argumentów i modyfikatorami.

(Odziedziczone po Type)
GetProperty(String, Type, Type[], ParameterModifier[])

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetProperty(String, Type[])

Wyszukuje określoną właściwość publiczną, której parametry są zgodne z określonymi typami argumentów.

(Odziedziczone po Type)
GetProperty(String, Type[])

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])

Podczas zastępowania w klasie pochodnej wyszukuje określoną właściwość, której parametry są zgodne z określonymi typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązania.

(Odziedziczone po Type)
GetRequiredCustomModifiers()

Po przesłonięciu w klasie pochodnej zwraca wymagane modyfikatory niestandardowe bieżącego Typeelementu .

(Odziedziczone po Type)
GetType()

Pobiera bieżący Typeelement .

(Odziedziczone po Type)
GetType()

Odnajduje atrybuty elementu członkowskiego i zapewnia dostęp do metadanych składowych.

(Odziedziczone po MemberInfo)
GetTypeCodeImpl()

Zwraca podstawowy kod typu tego Type wystąpienia.

(Odziedziczone po Type)
HasElementTypeImpl()

Podczas zastępowania w klasie pochodnej implementuje HasElementType właściwość i określa, czy bieżący Type obejmuje lub odwołuje się do innego typu; oznacza to, czy bieżący Type jest tablicą, wskaźnikiem, czy jest przekazywany przez odwołanie.

HasElementTypeImpl()

Podczas zastępowania w klasie pochodnej implementuje HasElementType właściwość i określa, czy bieżący Type obejmuje lub odwołuje się do innego typu; oznacza to, czy bieżący Type jest tablicą, wskaźnikiem, czy jest przekazywany przez odwołanie.

(Odziedziczone po Type)
HasSameMetadataDefinitionAs(MemberInfo)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po MemberInfo)
InvokeMember(String, BindingFlags, Binder, Object, Object[])

Wywołuje określony element członkowski przy użyciu określonych ograniczeń powiązania i dopasowania do określonej listy argumentów.

(Odziedziczone po Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)

Wywołuje określony element członkowski przy użyciu określonych ograniczeń powiązania i dopasowania określonej listy argumentów i kultury.

(Odziedziczone po Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

IsArrayImpl()

Podczas zastępowania w klasie pochodnej implementuje IsArray właściwość i określa, czy Type jest tablicą.

IsArrayImpl()

Podczas zastępowania w klasie pochodnej implementuje IsArray właściwość i określa, czy Type jest tablicą.

(Odziedziczone po Type)
IsAssignableFrom(Type)

Zgłasza NotSupportedException wyjątek we wszystkich przypadkach.

IsAssignableFrom(Type)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsAssignableFrom(TypeInfo)

Zgłasza NotSupportedException wyjątek we wszystkich przypadkach.

IsAssignableTo(Type)

Określa, czy bieżący typ można przypisać do zmiennej określonego targetType.

(Odziedziczone po Type)
IsByRefImpl()

Podczas zastępowania w klasie pochodnej implementuje IsByRef właściwość i określa, czy Type element jest przekazywany przez odwołanie.

IsByRefImpl()

Podczas zastępowania w klasie pochodnej implementuje IsByRef właściwość i określa, czy Type element jest przekazywany przez odwołanie.

(Odziedziczone po Type)
IsCOMObjectImpl()

Podczas zastępowania w klasie pochodnej implementuje IsCOMObject właściwość i określa, czy Type obiekt COM jest obiektem COM.

IsCOMObjectImpl()

Podczas zastępowania w klasie pochodnej implementuje IsCOMObject właściwość i określa, czy Type obiekt COM jest obiektem COM.

(Odziedziczone po Type)
IsContextfulImpl()

Implementuje IsContextful właściwość i określa, czy Type obiekt może być hostowany w kontekście.

(Odziedziczone po Type)
IsDefined(Type, Boolean)

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

IsDefined(Type, Boolean)

Po przesłonięciu w klasie pochodnej wskazuje, czy do tego elementu członkowskiego zastosowano co najmniej jeden atrybut określonego typu lub jego typów pochodnych.

(Odziedziczone po MemberInfo)
IsEnumDefined(Object)

Zwraca wartość wskazującą, czy określona wartość istnieje w bieżącym typie wyliczenia.

(Odziedziczone po Type)
IsEnumDefined(Object)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsEquivalentTo(Type)

Określa, czy dwa typy MODELU COM mają tę samą tożsamość i kwalifikują się do równoważności typów.

(Odziedziczone po Type)
IsEquivalentTo(Type)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsInstanceOfType(Object)

Określa, czy określony obiekt jest wystąpieniem bieżącego Typeobiektu .

(Odziedziczone po Type)
IsInstanceOfType(Object)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

(Odziedziczone po TypeInfo)
IsMarshalByRefImpl()

Implementuje IsMarshalByRef właściwość i określa, czy obiekt Type jest marshaledowany przez odwołanie.

(Odziedziczone po Type)
IsPointerImpl()

Podczas zastępowania w klasie pochodnej implementuje IsPointer właściwość i określa, czy Type element jest wskaźnikiem.

IsPointerImpl()

Podczas zastępowania w klasie pochodnej implementuje IsPointer właściwość i określa, czy Type element jest wskaźnikiem.

(Odziedziczone po Type)
IsPrimitiveImpl()

Podczas zastępowania w klasie pochodnej implementuje IsPrimitive właściwość i określa, czy Type jest to jeden z typów pierwotnych.

IsPrimitiveImpl()

Podczas zastępowania w klasie pochodnej implementuje IsPrimitive właściwość i określa, czy Type jest to jeden z typów pierwotnych.

(Odziedziczone po Type)
IsSubclassOf(Type)

Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.

IsValueTypeImpl()

Implementuje IsValueType właściwość i określa, czy Type jest to typ wartości, czyli, a nie klasa lub interfejs.

IsValueTypeImpl()

Implementuje IsValueType właściwość i określa, czy Type jest to typ wartości, czyli, a nie klasa lub interfejs.

(Odziedziczone po Type)
MakeArrayType()

Zwraca typ tablicy jednowymiarowej, której typ elementu jest parametrem typu ogólnego.

MakeArrayType(Int32)

Zwraca typ tablicy, której typ elementu jest parametrem typu ogólnego z określoną liczbą wymiarów.

MakeByRefType()

Type Zwraca obiekt, który reprezentuje bieżący parametr typu ogólnego po przekazaniu jako parametr odwołania.

MakeGenericType(Type[])

Nieprawidłowy dla niekompletnych parametrów typu ogólnego.

MakePointerType()

Type Zwraca obiekt reprezentujący wskaźnik do bieżącego parametru typu ogólnego.

MemberwiseClone()

Tworzy płytkią kopię bieżącego Objectelementu .

(Odziedziczone po Object)
SetBaseTypeConstraint(Type)

Ustawia typ podstawowy, który typ musi dziedziczyć w celu zastąpienia parametru typu.

SetBaseTypeConstraintCore(Type)

Po zastąpieniu w klasie pochodnej ustawia typ podstawowy, który typ musi dziedziczyć, aby zastąpić parametr type.

SetCustomAttribute(ConstructorInfo, Byte[])

Ustawia atrybut niestandardowy przy użyciu określonego obiektu blob atrybutu niestandardowego.

SetCustomAttribute(CustomAttributeBuilder)

Ustaw atrybut niestandardowy przy użyciu konstruktora atrybutów niestandardowych.

SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)

Po zastąpieniu w klasie pochodnej ustawia atrybut niestandardowy dla tego zestawu.

SetGenericParameterAttributes(GenericParameterAttributes)

Ustawia charakterystyki wariancji i specjalne ograniczenia parametru ogólnego, takie jak ograniczenie konstruktora bez parametrów.

SetGenericParameterAttributesCore(GenericParameterAttributes)

Po przesłonięciu w klasie pochodnej ustawia właściwości wariancji i specjalne ograniczenia parametru ogólnego, takie jak ograniczenie konstruktora bez parametrów.

SetInterfaceConstraints(Type[])

Ustawia interfejsy typu musi implementować w celu zastąpienia parametru type.

SetInterfaceConstraintsCore(Type[])

Po przesłonięciu w klasie pochodnej ustawia interfejsy, które typ musi implementować, aby zastąpić parametr type.

ToString()

Zwraca reprezentację ciągu bieżącego parametru typu ogólnego.

Jawne implementacje interfejsu

_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Zestaw nazw jest mapowany na odpowiedni zestaw identyfikatorów wysyłania.

(Odziedziczone po MemberInfo)
_MemberInfo.GetType()

Type Pobiera obiekt reprezentujący klasęMemberInfo.

(Odziedziczone po MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Pobiera informacje o typie dla obiektu, których następnie można użyć do uzyskania informacji o typie interfejsu.

(Odziedziczone po MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

Pobiera informację o liczbie typów interfejsów, jakie zawiera obiekt (0 lub 1).

(Odziedziczone po MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Umożliwia dostęp do właściwości i metod udostępnianych przez obiekt.

(Odziedziczone po MemberInfo)
_Type.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Zestaw nazw jest mapowany na odpowiedni zestaw identyfikatorów wysyłania.

(Odziedziczone po Type)
_Type.GetTypeInfo(UInt32, UInt32, IntPtr)

Pobiera informacje o typie dla obiektu, których następnie można użyć do uzyskania informacji o typie interfejsu.

(Odziedziczone po Type)
_Type.GetTypeInfoCount(UInt32)

Pobiera informację o liczbie typów interfejsów, jakie zawiera obiekt (0 lub 1).

(Odziedziczone po Type)
_Type.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Umożliwia dostęp do właściwości i metod udostępnianych przez obiekt.

(Odziedziczone po Type)
ICustomAttributeProvider.GetCustomAttributes(Boolean)

Zwraca tablicę wszystkich atrybutów niestandardowych zdefiniowanych w tym elemencie członkowskim, z wyłączeniem nazwanych atrybutów lub pustą tablicą, jeśli nie ma atrybutów niestandardowych.

(Odziedziczone po MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)

Zwraca tablicę atrybutów niestandardowych zdefiniowanych na tym elemencie członkowskim, identyfikowaną przez typ lub pustą tablicę, jeśli nie ma atrybutów niestandardowych tego typu.

(Odziedziczone po MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean)

Wskazuje, czy na tym elemencie członkowskim zdefiniowano jedno lub więcej wystąpień attributeType .

(Odziedziczone po MemberInfo)
IReflectableType.GetTypeInfo()

Zwraca reprezentację bieżącego typu jako TypeInfo obiektu.

(Odziedziczone po TypeInfo)

Metody rozszerzania

GetCustomAttribute(MemberInfo, Type)

Pobiera atrybut niestandardowy określonego typu, który jest stosowany do określonego elementu członkowskiego.

GetCustomAttribute(MemberInfo, Type, Boolean)

Pobiera atrybut niestandardowy określonego typu, który jest stosowany do określonego elementu członkowskiego, i opcjonalnie sprawdza przodków tego elementu członkowskiego.

GetCustomAttribute<T>(MemberInfo)

Pobiera atrybut niestandardowy określonego typu, który jest stosowany do określonego elementu członkowskiego.

GetCustomAttribute<T>(MemberInfo, Boolean)

Pobiera atrybut niestandardowy określonego typu, który jest stosowany do określonego elementu członkowskiego, i opcjonalnie sprawdza przodków tego elementu członkowskiego.

GetCustomAttributes(MemberInfo)

Pobiera kolekcję atrybutów niestandardowych, które są stosowane do określonego elementu członkowskiego.

GetCustomAttributes(MemberInfo, Boolean)

Pobiera kolekcję atrybutów niestandardowych, które są stosowane do określonego elementu członkowskiego, i opcjonalnie sprawdza przodków tego elementu członkowskiego.

GetCustomAttributes(MemberInfo, Type)

Pobiera kolekcję atrybutów niestandardowych określonego typu, które są stosowane do określonego elementu członkowskiego.

GetCustomAttributes(MemberInfo, Type, Boolean)

Pobiera kolekcję atrybutów niestandardowych określonego typu, które są stosowane do określonego elementu członkowskiego, i opcjonalnie sprawdza przodków tego elementu członkowskiego.

GetCustomAttributes<T>(MemberInfo)

Pobiera kolekcję atrybutów niestandardowych określonego typu, które są stosowane do określonego elementu członkowskiego.

GetCustomAttributes<T>(MemberInfo, Boolean)

Pobiera kolekcję atrybutów niestandardowych określonego typu, które są stosowane do określonego elementu członkowskiego, i opcjonalnie sprawdza przodków tego elementu członkowskiego.

IsDefined(MemberInfo, Type)

Wskazuje, czy atrybuty niestandardowe określonego typu są stosowane do określonego elementu członkowskiego.

IsDefined(MemberInfo, Type, Boolean)

Wskazuje, czy atrybuty niestandardowe określonego typu są stosowane do określonego elementu członkowskiego i, opcjonalnie, stosowane do jego elementów nadrzędnych.

GetTypeInfo(Type)

Zwraca reprezentację TypeInfo określonego typu.

GetMetadataToken(MemberInfo)

Pobiera token metadanych dla danego elementu członkowskiego, jeśli jest dostępny.

HasMetadataToken(MemberInfo)

Zwraca wartość wskazującą, czy token metadanych jest dostępny dla określonego elementu członkowskiego.

GetRuntimeEvent(Type, String)

Pobiera obiekt reprezentujący określone zdarzenie.

GetRuntimeEvents(Type)

Pobiera kolekcję reprezentującą wszystkie zdarzenia zdefiniowane w określonym typie.

GetRuntimeField(Type, String)

Pobiera obiekt reprezentujący określone pole.

GetRuntimeFields(Type)

Pobiera kolekcję reprezentującą wszystkie pola zdefiniowane w określonym typie.

GetRuntimeInterfaceMap(TypeInfo, Type)

Zwraca mapowanie interfejsu dla określonego typu i określonego interfejsu.

GetRuntimeMethod(Type, String, Type[])

Pobiera obiekt reprezentujący określoną metodę.

GetRuntimeMethods(Type)

Pobiera kolekcję reprezentującą wszystkie metody zdefiniowane w określonym typie.

GetRuntimeProperties(Type)

Pobiera kolekcję reprezentującą wszystkie właściwości zdefiniowane w określonym typie.

GetRuntimeProperty(Type, String)

Pobiera obiekt reprezentujący określoną właściwość.

GetConstructor(Type, Type[])

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

GetConstructors(Type)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

GetConstructors(Type, BindingFlags)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

GetFields(Type, BindingFlags)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

GetGenericArguments(Type)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

GetInterfaces(Type)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

GetMember(Type, String)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

GetMember(Type, String, BindingFlags)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

GetMembers(Type)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

GetMethods(Type)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

GetNestedType(Type, String, BindingFlags)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

GetProperties(Type)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

GetProperties(Type, BindingFlags)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

GetProperty(Type, String, BindingFlags)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

GetProperty(Type, String, Type)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

GetProperty(Type, String, Type, Type[])

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

IsAssignableFrom(Type, Type)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

IsInstanceOfType(Type, Object)

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

Dotyczy

Zobacz też