Bagikan melalui


GenericTypeParameterBuilder Kelas

Definisi

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

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
Warisan
GenericTypeParameterBuilder
Warisan
GenericTypeParameterBuilder
Warisan
GenericTypeParameterBuilder
Atribut

Contoh

Contoh kode berikut membuat jenis generik dengan dua parameter jenis, dan menyimpannya di GenericEmitExample1.dll perakitan. Anda dapat menggunakan Ildasm.exe (Il Disassembler) untuk melihat jenis yang dihasilkan. Untuk penjelasan yang lebih rinci tentang langkah-langkah yang terlibat dalam menentukan jenis generik dinamis, lihat Cara: Menentukan Jenis Generik dengan Pancaran.

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

Keterangan

Anda bisa mendapatkan array GenericTypeParameterBuilder objek dengan menggunakan TypeBuilder.DefineGenericParameters metode untuk menambahkan parameter jenis ke jenis dinamis, sehingga menjadikannya jenis generik, atau dengan menggunakan MethodBuilder.DefineGenericParameters metode untuk menambahkan parameter jenis ke metode dinamis. GenericTypeParameterBuilder Gunakan objek untuk menambahkan batasan ke parameter jenis. Batasannya adalah tiga jenis:

  • Batasan jenis dasar menentukan bahwa jenis apa pun yang ditetapkan ke parameter jenis generik harus berasal dari jenis dasar tertentu. Atur SetBaseTypeConstraint batasan ini dengan menggunakan metode .

  • Batasan antarmuka menentukan bahwa jenis apa pun yang ditetapkan ke parameter jenis generik harus menerapkan antarmuka tertentu. Atur batasan antarmuka dengan menggunakan SetInterfaceConstraints metode .

  • Batasan khusus menentukan bahwa jenis apa pun yang ditetapkan ke parameter jenis generik harus memiliki konstruktor tanpa parameter, harus merupakan jenis referensi, atau harus merupakan jenis nilai. Atur batasan khusus untuk parameter jenis dengan menggunakan SetGenericParameterAttributes metode .

Batasan antarmuka dan batasan khusus tidak dapat diambil menggunakan metode GenericTypeParameterBuilder kelas . Setelah Anda membuat jenis generik yang berisi parameter jenis, Anda dapat menggunakan objeknya Type untuk mencerminkan batasan. Type.GetGenericArguments Gunakan metode untuk mendapatkan parameter jenis, dan untuk setiap parameter jenis gunakan Type.GetGenericParameterConstraints metode untuk mendapatkan batasan jenis dasar dan batasan antarmuka, dan Type.GenericParameterAttributes properti untuk mendapatkan batasan khusus.

Konstruktor

GenericTypeParameterBuilder()

Menginisialisasi instans GenericTypeParameterBuilder kelas baru.

Properti

Assembly

Mendapatkan objek yang Assembly mewakili rakitan dinamis yang berisi definisi jenis generik yang dimiliki parameter jenis saat ini.

AssemblyQualifiedName

null Mendapatkan dalam semua kasus.

Attributes

Mendapatkan atribut yang terkait dengan Type.

Attributes

Mendapatkan atribut yang terkait dengan Type.

(Diperoleh dari Type)
Attributes

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
BaseType

Mendapatkan batasan jenis dasar dari parameter jenis generik saat ini.

ContainsGenericParameters

true Mendapatkan dalam semua kasus.

CustomAttributes

Mendapatkan koleksi yang berisi atribut kustom anggota ini.

(Diperoleh dari MemberInfo)
DeclaredConstructors

Mendapatkan koleksi konstruktor yang dideklarasikan oleh jenis saat ini.

(Diperoleh dari TypeInfo)
DeclaredEvents

Mendapatkan kumpulan peristiwa yang ditentukan oleh jenis saat ini.

(Diperoleh dari TypeInfo)
DeclaredFields

Mendapatkan kumpulan bidang yang ditentukan oleh jenis saat ini.

(Diperoleh dari TypeInfo)
DeclaredMembers

Mendapatkan kumpulan anggota yang ditentukan oleh jenis saat ini.

(Diperoleh dari TypeInfo)
DeclaredMethods

Mendapatkan kumpulan metode yang ditentukan oleh jenis saat ini.

(Diperoleh dari TypeInfo)
DeclaredNestedTypes

Mendapatkan kumpulan jenis berlapis yang ditentukan oleh jenis saat ini.

(Diperoleh dari TypeInfo)
DeclaredProperties

Mendapatkan kumpulan properti yang ditentukan oleh jenis saat ini.

(Diperoleh dari TypeInfo)
DeclaringMethod

MethodInfo Mendapatkan yang mewakili metode deklarasi, jika saat ini GenericTypeParameterBuilder mewakili parameter jenis metode generik.

DeclaringType

Mendapatkan definisi jenis generik atau definisi metode generik tempat parameter jenis generik berada.

FullName

null Mendapatkan dalam semua kasus.

GenericParameterAttributes

Mendapatkan kombinasi GenericParameterAttributes bendera yang menjelaskan kovariansi dan batasan khusus dari parameter jenis generik saat ini.

GenericParameterAttributes

Mendapatkan kombinasi GenericParameterAttributes bendera yang menjelaskan kovariansi dan batasan khusus dari parameter jenis generik saat ini.

(Diperoleh dari Type)
GenericParameterPosition

Mendapatkan posisi parameter jenis dalam daftar parameter jenis jenis atau metode generik yang mendeklarasikan parameter.

GenericTypeArguments

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

GenericTypeArguments

Mendapatkan array argumen jenis generik untuk jenis ini.

(Diperoleh dari Type)
GenericTypeArguments

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GenericTypeParameters

Mendapatkan array parameter jenis generik dari instans saat ini.

(Diperoleh dari TypeInfo)
GUID

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

HasElementType

Mendapatkan nilai yang menunjukkan apakah saat ini Type mencakup atau merujuk ke jenis lain; yaitu, apakah saat ini Type adalah array, pointer, atau diteruskan oleh referensi.

(Diperoleh dari Type)
HasElementType

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
ImplementedInterfaces

Mendapatkan koleksi antarmuka yang diimplementasikan oleh jenis saat ini.

(Diperoleh dari TypeInfo)
IsAbstract

Mendapatkan nilai yang menunjukkan apakah Type abstrak dan harus ditimpa.

(Diperoleh dari Type)
IsAbstract

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsAnsiClass

Mendapatkan nilai yang menunjukkan apakah atribut AnsiClass format string dipilih untuk Type.

(Diperoleh dari Type)
IsAnsiClass

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsArray

Mendapatkan nilai yang menunjukkan apakah jenisnya adalah array.

(Diperoleh dari Type)
IsArray

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsAutoClass

Mendapatkan nilai yang menunjukkan apakah atribut AutoClass format string dipilih untuk Type.

(Diperoleh dari Type)
IsAutoClass

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsAutoLayout

Mendapatkan nilai yang menunjukkan apakah bidang jenis saat ini ditata secara otomatis oleh runtime bahasa umum.

(Diperoleh dari Type)
IsAutoLayout

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsByRef

Mendapatkan nilai yang menunjukkan apakah Type diteruskan oleh referensi.

(Diperoleh dari Type)
IsByRef

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsByRefLike

Mendapatkan nilai yang menunjukkan apakah jenisnya adalah struktur seperti byref.

IsByRefLike

Mendapatkan nilai yang menunjukkan apakah jenisnya adalah struktur seperti byref.

(Diperoleh dari Type)
IsClass

Mendapatkan nilai yang menunjukkan apakah Type adalah kelas atau delegasi; yaitu, bukan jenis nilai atau antarmuka.

(Diperoleh dari Type)
IsClass

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsCollectible

Mendapatkan nilai yang menunjukkan apakah objek ini MemberInfo adalah bagian dari perakitan yang dipegang dalam koleksi AssemblyLoadContext.

(Diperoleh dari MemberInfo)
IsCOMObject

Mendapatkan nilai yang menunjukkan apakah Type adalah objek COM.

(Diperoleh dari Type)
IsCOMObject

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsConstructedGenericType

Mendapatkan nilai yang menunjukkan apakah objek ini mewakili jenis generik yang dibangun.

IsConstructedGenericType

Mendapatkan nilai yang menunjukkan apakah objek ini mewakili jenis generik yang dibangun. Anda dapat membuat instans jenis generik yang dibangun.

(Diperoleh dari Type)
IsContextful

Mendapatkan nilai yang menunjukkan apakah Type dapat dihosting dalam konteks.

(Diperoleh dari Type)
IsEnum

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

IsEnum

Mendapatkan nilai yang menunjukkan apakah saat ini Type mewakili enumerasi.

(Diperoleh dari Type)
IsEnum

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsExplicitLayout

Mendapatkan nilai yang menunjukkan apakah bidang jenis saat ini ditata pada offset yang ditentukan secara eksplisit.

(Diperoleh dari Type)
IsExplicitLayout

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsFunctionPointer

Mendapatkan nilai yang menunjukkan apakah saat ini Type adalah penunjuk fungsi.

(Diperoleh dari Type)
IsGenericMethodParameter

Mendapatkan nilai yang menunjukkan apakah saat ini Type mewakili parameter jenis dalam definisi metode generik.

(Diperoleh dari Type)
IsGenericParameter

true Mendapatkan dalam semua kasus.

IsGenericType

Mengembalikan false dalam semua kasus.

IsGenericTypeDefinition

false Mendapatkan dalam semua kasus.

IsGenericTypeParameter

Mendapatkan nilai yang menunjukkan apakah saat ini Type mewakili parameter jenis dalam definisi jenis generik.

(Diperoleh dari Type)
IsImport

Mendapatkan nilai yang menunjukkan apakah Type memiliki atribut yang ComImportAttribute diterapkan, menunjukkan bahwa atribut tersebut diimpor dari pustaka jenis COM.

(Diperoleh dari Type)
IsImport

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsInterface

Mendapatkan nilai yang menunjukkan apakah Type itu antarmuka; yaitu, bukan kelas atau jenis nilai.

(Diperoleh dari Type)
IsInterface

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsLayoutSequential

Mendapatkan nilai yang menunjukkan apakah bidang jenis saat ini ditata secara berurutan, dalam urutan yang ditentukan atau dipancarkan ke metadata.

(Diperoleh dari Type)
IsLayoutSequential

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsMarshalByRef

Mendapatkan nilai yang menunjukkan apakah Type marshaled by reference.

(Diperoleh dari Type)
IsMarshalByRef

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsNested

Mendapatkan nilai yang menunjukkan apakah objek saat ini Type mewakili jenis yang definisinya ditumpuk di dalam definisi jenis lain.

(Diperoleh dari Type)
IsNested

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsNestedAssembly

Mendapatkan nilai yang menunjukkan apakah Type berlapis dan hanya terlihat dalam perakitannya sendiri.

(Diperoleh dari Type)
IsNestedAssembly

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsNestedFamANDAssem

Mendapatkan nilai yang menunjukkan apakah Type berlapis dan hanya terlihat oleh kelas yang termasuk dalam keluarganya sendiri dan perakitannya sendiri.

(Diperoleh dari Type)
IsNestedFamANDAssem

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsNestedFamily

Mendapatkan nilai yang menunjukkan apakah Type berlapis dan hanya terlihat dalam keluarganya sendiri.

(Diperoleh dari Type)
IsNestedFamily

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsNestedFamORAssem

Mendapatkan nilai yang menunjukkan apakah Type berlapis dan hanya terlihat oleh kelas yang termasuk dalam keluarganya sendiri atau perakitannya sendiri.

(Diperoleh dari Type)
IsNestedFamORAssem

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsNestedPrivate

Mendapatkan nilai yang menunjukkan apakah Type berlapis dan dinyatakan privat.

(Diperoleh dari Type)
IsNestedPrivate

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsNestedPublic

Mendapatkan nilai yang menunjukkan apakah kelas ditumpuk dan dinyatakan publik.

(Diperoleh dari Type)
IsNestedPublic

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsNotPublic

Mendapatkan nilai yang menunjukkan apakah Type tidak dinyatakan publik.

(Diperoleh dari Type)
IsNotPublic

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsPointer

Mendapatkan nilai yang menunjukkan apakah Type adalah penunjuk.

(Diperoleh dari Type)
IsPointer

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsPrimitive

Mendapatkan nilai yang menunjukkan apakah Type adalah salah satu jenis primitif.

(Diperoleh dari Type)
IsPrimitive

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsPublic

Mendapatkan nilai yang menunjukkan apakah Type dinyatakan publik.

(Diperoleh dari Type)
IsPublic

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsSealed

Mendapatkan nilai yang menunjukkan apakah Type dinyatakan disegel.

(Diperoleh dari Type)
IsSealed

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsSecurityCritical

Mendapatkan nilai yang menunjukkan apakah jenis saat ini kritis terhadap keamanan atau keamanan-aman-kritis pada tingkat kepercayaan saat ini, dan karenanya dapat melakukan operasi penting.

(Diperoleh dari Type)
IsSecuritySafeCritical

Mendapatkan nilai yang menunjukkan apakah jenis saat ini adalah keamanan-aman-kritis pada tingkat kepercayaan saat ini; yaitu, apakah dapat melakukan operasi penting dan dapat diakses dengan kode transparan.

(Diperoleh dari Type)
IsSecurityTransparent

Mendapatkan nilai yang menunjukkan apakah jenis saat ini transparan pada tingkat kepercayaan saat ini, dan karenanya tidak dapat melakukan operasi penting.

(Diperoleh dari Type)
IsSerializable

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

IsSerializable
Kedaluwarsa.

Mendapatkan nilai yang menunjukkan apakah biner dapat diserialisasikan Type .

(Diperoleh dari Type)
IsSerializable

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsSignatureType

Mendapatkan nilai yang menunjukkan apakah jenisnya adalah jenis tanda tangan.

(Diperoleh dari Type)
IsSpecialName

Mendapatkan nilai yang menunjukkan apakah jenis memiliki nama yang memerlukan penanganan khusus.

(Diperoleh dari Type)
IsSpecialName

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsSZArray

Mendapatkan nilai yang menunjukkan apakah jenisnya adalah jenis array yang hanya dapat mewakili array dimensi tunggal dengan batas nol yang lebih rendah.

IsSZArray

Mendapatkan nilai yang menunjukkan apakah jenisnya adalah jenis array yang hanya dapat mewakili array dimensi tunggal dengan batas nol yang lebih rendah.

(Diperoleh dari Type)
IsTypeDefinition

Mendapatkan nilai yang menunjukkan apakah jenisnya adalah definisi jenis.

IsTypeDefinition

Mendapatkan nilai yang menunjukkan apakah jenisnya adalah definisi jenis.

(Diperoleh dari Type)
IsUnicodeClass

Mendapatkan nilai yang menunjukkan apakah atribut UnicodeClass format string dipilih untuk Type.

(Diperoleh dari Type)
IsUnicodeClass

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsUnmanagedFunctionPointer

Mendapatkan nilai yang menunjukkan apakah saat ini Type adalah penunjuk fungsi yang tidak dikelola.

(Diperoleh dari Type)
IsValueType

Mendapatkan nilai yang menunjukkan apakah Type adalah jenis nilai.

(Diperoleh dari Type)
IsValueType

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsVariableBoundArray

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

IsVariableBoundArray

Mendapatkan nilai yang menunjukkan apakah jenisnya adalah jenis array yang dapat mewakili array multi-dimensi atau array dengan batas bawah arbitrer.

(Diperoleh dari Type)
IsVisible

Mendapatkan nilai yang menunjukkan apakah Type dapat diakses oleh kode di luar perakitan.

(Diperoleh dari Type)
IsVisible

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
MemberType

Mendapatkan nilai yang MemberTypes menunjukkan bahwa anggota ini adalah jenis atau jenis berlapis.

(Diperoleh dari Type)
MemberType

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
MetadataToken

Mendapatkan token yang mengidentifikasi modul dinamis saat ini dalam metadata.

MetadataToken

Mendapatkan nilai yang mengidentifikasi elemen metadata.

(Diperoleh dari MemberInfo)
Module

Mendapatkan modul dinamis yang berisi parameter jenis generik.

Name

Mendapatkan nama parameter jenis generik.

Namespace

null Mendapatkan dalam semua kasus.

ReflectedType

Type Mendapatkan objek yang digunakan untuk mendapatkan GenericTypeParameterBuilder.

ReflectedType

Mendapatkan objek kelas yang digunakan untuk mendapatkan instans ini dari MemberInfo.

(Diperoleh dari MemberInfo)
StructLayoutAttribute

Mendapatkan yang StructLayoutAttribute menjelaskan tata letak jenis saat ini.

(Diperoleh dari Type)
StructLayoutAttribute

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
TypeHandle

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

TypeInitializer

Mendapatkan penginisialisasi untuk jenis tersebut.

(Diperoleh dari Type)
TypeInitializer

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
UnderlyingSystemType

Mendapatkan parameter jenis generik saat ini.

UnderlyingSystemType

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)

Metode

AsType()

Mengembalikan tipe saat ini sebagai Type objek.

(Diperoleh dari TypeInfo)
Equals(Object)

Menguji apakah objek yang diberikan adalah instans EventToken dan sama dengan instans saat ini.

Equals(Type)

Menentukan apakah jenis sistem yang mendasar dari saat ini Type sama dengan jenis sistem yang mendasar dari yang ditentukan Type.

(Diperoleh dari Type)
FindInterfaces(TypeFilter, Object)

Mengembalikan array Type objek yang mewakili daftar antarmuka yang difilter yang diimplementasikan atau diwarisi oleh saat ini Type.

(Diperoleh dari Type)
FindInterfaces(TypeFilter, Object)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)

Mengembalikan array MemberInfo objek yang difilter dari jenis anggota yang ditentukan.

(Diperoleh dari Type)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetArrayRank()

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

GetArrayRank()

Mendapatkan jumlah dimensi dalam array.

(Diperoleh dari Type)
GetArrayRank()

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetAttributeFlagsImpl()

Ketika ditimpa di kelas turunan, terapkan Attributes properti dan dapatkan kombinasi bitwise dari nilai enumerasi yang menunjukkan atribut yang terkait dengan Type.

GetAttributeFlagsImpl()

Ketika ditimpa di kelas turunan, mengimplementasikan Attributes properti dan mendapatkan kombinasi bitwise dari nilai enumerasi yang menunjukkan atribut yang terkait dengan Type.

(Diperoleh dari Type)
GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Mencari konstruktor yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan konvensi panggilan yang ditentukan.

(Diperoleh dari Type)
GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])

Mencari konstruktor yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan.

(Diperoleh dari Type)
GetConstructor(BindingFlags, Type[])

Mencari konstruktor yang parameternya cocok dengan jenis argumen yang ditentukan, menggunakan batasan pengikatan yang ditentukan.

(Diperoleh dari Type)
GetConstructor(Type[])

Mencari konstruktor instans publik yang parameternya cocok dengan jenis dalam array yang ditentukan.

(Diperoleh dari Type)
GetConstructor(Type[])

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

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

Saat ditimpa di kelas turunan, cari konstruktor yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan konvensi panggilan yang ditentukan.

(Diperoleh dari Type)
GetConstructors()

Mengembalikan semua konstruktor publik yang ditentukan untuk saat ini Type.

(Diperoleh dari Type)
GetConstructors()

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetConstructors(BindingFlags)

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

GetConstructors(BindingFlags)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetCustomAttributes(Boolean)

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

GetCustomAttributes(Boolean)

Saat ditimpa di kelas turunan, mengembalikan array semua atribut kustom yang diterapkan ke anggota ini.

(Diperoleh dari MemberInfo)
GetCustomAttributes(Type, Boolean)

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

GetCustomAttributes(Type, Boolean)

Saat ditimpa di kelas turunan, mengembalikan array atribut kustom yang diterapkan ke anggota ini dan diidentifikasi oleh Type.

(Diperoleh dari MemberInfo)
GetCustomAttributesData()

Mengembalikan daftar CustomAttributeData objek yang mewakili data tentang atribut yang telah diterapkan ke anggota target.

(Diperoleh dari MemberInfo)
GetDeclaredEvent(String)

Mengembalikan objek yang mewakili peristiwa yang ditentukan yang dideklarasikan oleh jenis saat ini.

(Diperoleh dari TypeInfo)
GetDeclaredField(String)

Mengembalikan objek yang mewakili bidang yang ditentukan yang dideklarasikan oleh jenis saat ini.

(Diperoleh dari TypeInfo)
GetDeclaredMethod(String)

Mengembalikan objek yang mewakili metode yang ditentukan yang dideklarasikan oleh jenis saat ini.

(Diperoleh dari TypeInfo)
GetDeclaredMethods(String)

Mengembalikan koleksi yang berisi semua metode yang dideklarasikan pada tipe saat ini yang cocok dengan nama yang ditentukan.

(Diperoleh dari TypeInfo)
GetDeclaredNestedType(String)

Mengembalikan objek yang mewakili tipe berlapis yang ditentukan yang dideklarasikan oleh jenis saat ini.

(Diperoleh dari TypeInfo)
GetDeclaredProperty(String)

Mengembalikan objek yang mewakili properti yang ditentukan yang dideklarasikan oleh tipe saat ini.

(Diperoleh dari TypeInfo)
GetDefaultMembers()

Mencari anggota yang ditentukan untuk saat ini Type yang DefaultMemberAttribute ditetapkan.

(Diperoleh dari Type)
GetDefaultMembers()

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetElementType()

NotSupportedException Melempar dalam semua kasus.

GetEnumName(Object)

Mengembalikan nama konstanta yang memiliki nilai yang ditentukan, untuk jenis enumerasi saat ini.

(Diperoleh dari Type)
GetEnumName(Object)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetEnumNames()

Mengembalikan nama anggota dari jenis enumerasi saat ini.

(Diperoleh dari Type)
GetEnumNames()

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetEnumUnderlyingType()

Mengembalikan jenis yang mendasar dari jenis enumerasi saat ini.

(Diperoleh dari Type)
GetEnumUnderlyingType()

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetEnumValues()

Mengembalikan array nilai konstanta dalam jenis enumerasi saat ini.

(Diperoleh dari Type)
GetEnumValues()

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetEnumValuesAsUnderlyingType()

Mengambil array nilai dari konstanta jenis dasar dari jenis enumerasi ini.

(Diperoleh dari Type)
GetEvent(String)

Mengembalikan objek yang EventInfo mewakili peristiwa publik yang ditentukan.

(Diperoleh dari Type)
GetEvent(String)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetEvent(String, BindingFlags)

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

GetEvent(String, BindingFlags)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetEvents()

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

GetEvents()

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetEvents(BindingFlags)

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

GetEvents(BindingFlags)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetField(String)

Mencari bidang publik dengan nama yang ditentukan.

(Diperoleh dari Type)
GetField(String)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetField(String, BindingFlags)

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

GetField(String, BindingFlags)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetFields()

Mengembalikan semua bidang publik dari saat ini Type.

(Diperoleh dari Type)
GetFields()

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetFields(BindingFlags)

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

GetFields(BindingFlags)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetFunctionPointerCallingConventions()

Saat ditimpa di kelas turunan, mengembalikan konvensi panggilan dari penunjuk Typefungsi saat ini .

(Diperoleh dari Type)
GetFunctionPointerParameterTypes()

Saat ditimpa dalam kelas turunan, mengembalikan jenis parameter penunjuk Typefungsi saat ini .

(Diperoleh dari Type)
GetFunctionPointerReturnType()

Saat ditimpa di kelas turunan, mengembalikan jenis pengembalian dari penunjuk Typefungsi saat ini .

(Diperoleh dari Type)
GetGenericArguments()

Tidak valid untuk parameter jenis generik.

GetGenericArguments()

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetGenericParameterConstraints()

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

GetGenericParameterConstraints()

Menghasilkan larik objek Type yang mewakili batasan pada parameter jenis generik saat ini.

(Diperoleh dari Type)
GetGenericParameterConstraints()

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetGenericTypeDefinition()

Tidak valid untuk parameter jenis generik.

GetHashCode()

Mengembalikan kode hash bilangan bulat 32-bit untuk instans saat ini.

GetInterface(String)

Mencari antarmuka dengan nama yang ditentukan.

(Diperoleh dari Type)
GetInterface(String)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetInterface(String, Boolean)

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

GetInterface(String, Boolean)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetInterfaceMap(Type)

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

GetInterfaces()

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

GetInterfaces()

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetMember(String)

Mencari anggota publik dengan nama yang ditentukan.

(Diperoleh dari Type)
GetMember(String)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetMember(String, BindingFlags)

Mencari anggota yang ditentukan, menggunakan batasan pengikatan yang ditentukan.

(Diperoleh dari Type)
GetMember(String, BindingFlags)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetMember(String, MemberTypes, BindingFlags)

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

GetMember(String, MemberTypes, BindingFlags)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetMembers()

Mengembalikan semua anggota publik dari saat ini Type.

(Diperoleh dari Type)
GetMembers()

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetMembers(BindingFlags)

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

GetMembers(BindingFlags)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetMemberWithSameMetadataDefinitionAs(MemberInfo)

MemberInfo Mencari pada saat ini Type yang cocok dengan yang ditentukanMemberInfo.

(Diperoleh dari Type)
GetMethod(String)

Mencari metode publik dengan nama yang ditentukan.

(Diperoleh dari Type)
GetMethod(String)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetMethod(String, BindingFlags)

Mencari metode yang ditentukan, menggunakan batasan pengikatan yang ditentukan.

(Diperoleh dari Type)
GetMethod(String, BindingFlags)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Mencari metode yang ditentukan yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan konvensi panggilan yang ditentukan.

(Diperoleh dari Type)
GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])

Mencari metode yang ditentukan yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan.

(Diperoleh dari Type)
GetMethod(String, BindingFlags, Type[])

Mencari metode yang ditentukan yang parameternya cocok dengan jenis argumen yang ditentukan, menggunakan batasan pengikatan yang ditentukan.

(Diperoleh dari Type)
GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Mencari metode yang ditentukan yang parameternya cocok dengan jumlah parameter generik, jenis argumen, dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan konvensi panggilan yang ditentukan.

(Diperoleh dari Type)
GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[])

Mencari metode yang ditentukan yang parameternya cocok dengan jumlah parameter generik, jenis argumen, dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan.

(Diperoleh dari Type)
GetMethod(String, Int32, BindingFlags, Type[])

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari Type)
GetMethod(String, Int32, Type[])

Mencari metode publik yang ditentukan yang parameternya cocok dengan jumlah parameter generik dan jenis argumen yang ditentukan.

(Diperoleh dari Type)
GetMethod(String, Int32, Type[], ParameterModifier[])

Mencari metode publik yang ditentukan yang parameternya cocok dengan jumlah parameter generik, jenis argumen, dan pengubah yang ditentukan.

(Diperoleh dari Type)
GetMethod(String, Type[])

Mencari metode publik yang ditentukan yang parameternya cocok dengan jenis argumen yang ditentukan.

(Diperoleh dari Type)
GetMethod(String, Type[])

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetMethod(String, Type[], ParameterModifier[])

Mencari metode publik yang ditentukan yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan.

(Diperoleh dari Type)
GetMethod(String, Type[], ParameterModifier[])

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

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

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

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

Saat ditimpa dalam kelas turunan, cari metode yang ditentukan yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan konvensi panggilan yang ditentukan.

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

Saat ditimpa dalam kelas turunan, cari metode yang ditentukan yang parameternya cocok dengan jumlah parameter generik, jenis argumen, dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan konvensi panggilan yang ditentukan.

(Diperoleh dari Type)
GetMethods()

Mengembalikan semua metode publik dari saat ini Type.

(Diperoleh dari Type)
GetMethods()

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetMethods(BindingFlags)

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

GetMethods(BindingFlags)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetNestedType(String)

Mencari jenis berlapis publik dengan nama yang ditentukan.

(Diperoleh dari Type)
GetNestedType(String)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetNestedType(String, BindingFlags)

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

GetNestedType(String, BindingFlags)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetNestedTypes()

Mengembalikan jenis publik yang ditumpuk di saat ini Type.

(Diperoleh dari Type)
GetNestedTypes()

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetNestedTypes(BindingFlags)

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

GetNestedTypes(BindingFlags)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetOptionalCustomModifiers()

Saat ditimpa di kelas turunan, mengembalikan pengubah kustom opsional dari saat ini Type.

(Diperoleh dari Type)
GetProperties()

Mengembalikan semua properti publik dari saat ini Type.

(Diperoleh dari Type)
GetProperties()

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetProperties(BindingFlags)

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

GetProperties(BindingFlags)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetProperty(String)

Mencari properti publik dengan nama yang ditentukan.

(Diperoleh dari Type)
GetProperty(String)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetProperty(String, BindingFlags)

Mencari properti yang ditentukan, menggunakan batasan pengikatan yang ditentukan.

(Diperoleh dari Type)
GetProperty(String, BindingFlags)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])

Mencari properti yang ditentukan yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan.

(Diperoleh dari Type)
GetProperty(String, Type)

Mencari properti publik dengan nama dan jenis pengembalian yang ditentukan.

(Diperoleh dari Type)
GetProperty(String, Type)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetProperty(String, Type, Type[])

Mencari properti publik yang ditentukan yang parameternya cocok dengan jenis argumen yang ditentukan.

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

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetProperty(String, Type, Type[], ParameterModifier[])

Mencari properti publik yang ditentukan yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan.

(Diperoleh dari Type)
GetProperty(String, Type, Type[], ParameterModifier[])

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetProperty(String, Type[])

Mencari properti publik yang ditentukan yang parameternya cocok dengan jenis argumen yang ditentukan.

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

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

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

Saat ditimpa di kelas turunan, cari properti yang ditentukan yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan.

(Diperoleh dari Type)
GetRequiredCustomModifiers()

Ketika ditimpa di kelas turunan, mengembalikan pengubah kustom yang diperlukan dari saat ini Type.

(Diperoleh dari Type)
GetType()

Mendapatkan saat ini Type.

(Diperoleh dari Type)
GetType()

Menemukan atribut anggota dan menyediakan akses ke metadata anggota.

(Diperoleh dari MemberInfo)
GetTypeCodeImpl()

Mengembalikan kode jenis yang mendasar dari instans ini Type .

(Diperoleh dari Type)
HasElementTypeImpl()

Ketika ditimpa di kelas turunan, terapkan HasElementType properti dan tentukan apakah saat ini Type mencakup atau mengacu pada jenis lain; yaitu, apakah saat ini Type adalah array, penunjuk, atau diteruskan oleh referensi.

HasElementTypeImpl()

Ketika ditimpa di kelas turunan, mengimplementasikan HasElementType properti dan menentukan apakah saat ini Type mencakup atau merujuk ke jenis lain; yaitu, apakah saat ini Type adalah array, pointer, atau diteruskan oleh referensi.

(Diperoleh dari Type)
HasSameMetadataDefinitionAs(MemberInfo)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari MemberInfo)
InvokeMember(String, BindingFlags, Binder, Object, Object[])

Memanggil anggota yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan cocok dengan daftar argumen yang ditentukan.

(Diperoleh dari Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)

Memanggil anggota yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan mencocokkan daftar argumen dan budaya yang ditentukan.

(Diperoleh dari Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

IsArrayImpl()

Saat ditimpa di kelas turunan, terapkan IsArray properti dan tentukan Type apakah itu array.

IsArrayImpl()

Saat ditimpa di kelas turunan, terapkan IsArray properti dan tentukan Type apakah itu array.

(Diperoleh dari Type)
IsAssignableFrom(Type)

NotSupportedException Memberikan pengecualian dalam semua kasus.

IsAssignableFrom(Type)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsAssignableFrom(TypeInfo)

NotSupportedException Memberikan pengecualian dalam semua kasus.

IsAssignableTo(Type)

Menentukan apakah jenis saat ini dapat ditetapkan ke variabel dari yang ditentukan targetType.

(Diperoleh dari Type)
IsByRefImpl()

Ketika ditimpa di kelas turunan, terapkan IsByRef properti dan tentukan apakah Type diteruskan oleh referensi.

IsByRefImpl()

Ketika ditimpa di kelas turunan, mengimplementasikan IsByRef properti dan menentukan apakah Type diteruskan oleh referensi.

(Diperoleh dari Type)
IsCOMObjectImpl()

Ketika ditimpa di kelas turunan, terapkan IsCOMObject properti dan tentukan Type apakah itu objek COM.

IsCOMObjectImpl()

Ketika ditimpa di kelas turunan, mengimplementasikan IsCOMObject properti dan menentukan apakah Type itu objek COM.

(Diperoleh dari Type)
IsContextfulImpl()

IsContextful Menerapkan properti dan menentukan apakah Type dapat dihosting dalam konteks.

(Diperoleh dari Type)
IsDefined(Type, Boolean)

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

IsDefined(Type, Boolean)

Ketika ditimpa di kelas turunan, menunjukkan apakah satu atau beberapa atribut dari jenis yang ditentukan atau jenis turunannya diterapkan kepada anggota ini.

(Diperoleh dari MemberInfo)
IsEnumDefined(Object)

Mengembalikan nilai yang menunjukkan apakah nilai yang ditentukan ada dalam jenis enumerasi saat ini.

(Diperoleh dari Type)
IsEnumDefined(Object)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsEquivalentTo(Type)

Menentukan apakah dua jenis COM memiliki identitas yang sama dan memenuhi syarat untuk kesetaraan jenis.

(Diperoleh dari Type)
IsEquivalentTo(Type)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsInstanceOfType(Object)

Menentukan apakah objek yang ditentukan adalah instans dari saat ini Type.

(Diperoleh dari Type)
IsInstanceOfType(Object)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

(Diperoleh dari TypeInfo)
IsMarshalByRefImpl()

IsMarshalByRef Mengimplementasikan properti dan menentukan apakah Type marshaled by reference.

(Diperoleh dari Type)
IsPointerImpl()

Ketika ditimpa di kelas turunan, terapkan IsPointer properti dan tentukan Type apakah itu penunjuk.

IsPointerImpl()

Saat ditimpa di kelas turunan, terapkan IsPointer properti dan tentukan Type apakah itu pointer.

(Diperoleh dari Type)
IsPrimitiveImpl()

Ketika ditimpa dalam kelas turunan, terapkan IsPrimitive properti dan tentukan apakah Type itu salah satu jenis primitif.

IsPrimitiveImpl()

Ketika ditimpa di kelas turunan, terapkan IsPrimitive properti dan tentukan apakah Type itu salah satu jenis primitif.

(Diperoleh dari Type)
IsSubclassOf(Type)

Tidak didukung untuk parameter jenis generik yang tidak lengkap.

IsValueTypeImpl()

IsValueType Mengimplementasikan properti dan menentukan apakah Type adalah jenis nilai; yaitu, bukan kelas atau antarmuka.

IsValueTypeImpl()

IsValueType Mengimplementasikan properti dan menentukan apakah Type adalah jenis nilai; yaitu, bukan kelas atau antarmuka.

(Diperoleh dari Type)
MakeArrayType()

Mengembalikan jenis array satu dimensi yang jenis elemennya adalah parameter jenis generik.

MakeArrayType(Int32)

Mengembalikan jenis array yang jenis elemennya adalah parameter jenis generik, dengan jumlah dimensi yang ditentukan.

MakeByRefType()

Mengembalikan Type objek yang mewakili parameter jenis generik saat ini saat diteruskan sebagai parameter referensi.

MakeGenericType(Type[])

Tidak valid untuk parameter jenis generik yang tidak lengkap.

MakePointerType()

Mengembalikan Type objek yang mewakili penunjuk ke parameter jenis generik saat ini.

MemberwiseClone()

Membuat salinan dangkal dari yang saat ini Object.

(Diperoleh dari Object)
SetBaseTypeConstraint(Type)

Mengatur jenis dasar yang harus diwarisi jenis agar diganti dengan parameter jenis.

SetBaseTypeConstraintCore(Type)

Saat ditimpa di kelas turunan, mengatur jenis dasar yang harus diwarisi jenis agar diganti dengan parameter jenis.

SetCustomAttribute(ConstructorInfo, Byte[])

Mengatur atribut kustom menggunakan blob atribut kustom tertentu.

SetCustomAttribute(CustomAttributeBuilder)

Atur atribut kustom menggunakan penyusun atribut kustom.

SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)

Saat ditimpa di kelas turunan, mengatur atribut kustom pada rakitan ini.

SetGenericParameterAttributes(GenericParameterAttributes)

Mengatur karakteristik varians dan batasan khusus dari parameter generik, seperti batasan konstruktor tanpa parameter.

SetGenericParameterAttributesCore(GenericParameterAttributes)

Ketika ditimpa dalam kelas turunan, mengatur karakteristik varians dan batasan khusus dari parameter generik, seperti batasan konstruktor tanpa parameter.

SetInterfaceConstraints(Type[])

Mengatur antarmuka yang harus diimplementasikan jenis agar diganti dengan parameter jenis.

SetInterfaceConstraintsCore(Type[])

Ketika ditimpa di kelas turunan, mengatur antarmuka yang harus diterapkan jenis agar diganti dengan parameter jenis.

ToString()

Mengembalikan representasi string dari parameter jenis generik saat ini.

Implementasi Antarmuka Eksplisit

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

Memetakan sekumpulan nama ke sekumpulan pengidentifikasi pengiriman yang sesuai.

(Diperoleh dari MemberInfo)
_MemberInfo.GetType()

Mendapatkan objek yang Type mewakili MemberInfo kelas .

(Diperoleh dari MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Mengambil informasi jenis untuk objek, yang kemudian dapat digunakan untuk mendapatkan informasi jenis untuk antarmuka.

(Diperoleh dari MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

Mengambil jumlah antarmuka informasi jenis yang disediakan objek (baik 0 atau 1).

(Diperoleh dari MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Menyediakan akses ke properti dan metode yang diekspos oleh objek.

(Diperoleh dari MemberInfo)
_Type.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Memetakan sekumpulan nama ke sekumpulan pengidentifikasi pengiriman yang sesuai.

(Diperoleh dari Type)
_Type.GetTypeInfo(UInt32, UInt32, IntPtr)

Mengambil informasi jenis untuk objek, yang kemudian dapat digunakan untuk mendapatkan informasi jenis untuk antarmuka.

(Diperoleh dari Type)
_Type.GetTypeInfoCount(UInt32)

Mengambil jumlah antarmuka informasi jenis yang disediakan objek (baik 0 atau 1).

(Diperoleh dari Type)
_Type.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Menyediakan akses ke properti dan metode yang diekspos oleh objek.

(Diperoleh dari Type)
ICustomAttributeProvider.GetCustomAttributes(Boolean)

Mengembalikan array dari semua atribut kustom yang ditentukan pada anggota ini, tidak termasuk atribut bernama, atau array kosong jika tidak ada atribut kustom.

(Diperoleh dari MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)

Mengembalikan array atribut kustom yang ditentukan pada anggota ini, diidentifikasi berdasarkan jenis, atau array kosong jika tidak ada atribut kustom dari jenis tersebut.

(Diperoleh dari MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean)

Menunjukkan apakah satu atau beberapa attributeType instans ditentukan pada anggota ini.

(Diperoleh dari MemberInfo)
IReflectableType.GetTypeInfo()

Mengembalikan representasi dari jenis saat ini sebagai TypeInfo objek.

(Diperoleh dari TypeInfo)

Metode Ekstensi

GetCustomAttribute(MemberInfo, Type)

Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.

GetCustomAttribute(MemberInfo, Type, Boolean)

Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.

GetCustomAttribute<T>(MemberInfo)

Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.

GetCustomAttribute<T>(MemberInfo, Boolean)

Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.

GetCustomAttributes(MemberInfo)

Mengambil kumpulan atribut kustom yang diterapkan ke anggota tertentu.

GetCustomAttributes(MemberInfo, Boolean)

Mengambil kumpulan atribut kustom yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.

GetCustomAttributes(MemberInfo, Type)

Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.

GetCustomAttributes(MemberInfo, Type, Boolean)

Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.

GetCustomAttributes<T>(MemberInfo)

Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.

GetCustomAttributes<T>(MemberInfo, Boolean)

Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.

IsDefined(MemberInfo, Type)

Menunjukkan apakah atribut kustom dari jenis tertentu diterapkan ke anggota tertentu.

IsDefined(MemberInfo, Type, Boolean)

Menunjukkan apakah atribut kustom dari jenis tertentu diterapkan ke anggota tertentu, dan, secara opsional, diterapkan ke leluhurnya.

GetTypeInfo(Type)

Mengembalikan TypeInfo representasi dari jenis yang ditentukan.

GetMetadataToken(MemberInfo)

Mendapatkan token metadata untuk anggota tertentu, jika tersedia.

HasMetadataToken(MemberInfo)

Mengembalikan nilai yang menunjukkan apakah token metadata tersedia untuk anggota yang ditentukan.

GetRuntimeEvent(Type, String)

Mengambil objek yang mewakili peristiwa yang ditentukan.

GetRuntimeEvents(Type)

Mengambil koleksi yang mewakili semua peristiwa yang ditentukan pada jenis tertentu.

GetRuntimeField(Type, String)

Mengambil objek yang mewakili bidang tertentu.

GetRuntimeFields(Type)

Mengambil koleksi yang mewakili semua bidang yang ditentukan pada jenis tertentu.

GetRuntimeInterfaceMap(TypeInfo, Type)

Mengembalikan pemetaan antarmuka untuk jenis yang ditentukan dan antarmuka yang ditentukan.

GetRuntimeMethod(Type, String, Type[])

Mengambil objek yang mewakili metode tertentu.

GetRuntimeMethods(Type)

Mengambil koleksi yang mewakili semua metode yang ditentukan pada jenis tertentu.

GetRuntimeProperties(Type)

Mengambil koleksi yang mewakili semua properti yang ditentukan pada jenis tertentu.

GetRuntimeProperty(Type, String)

Mengambil objek yang mewakili properti tertentu.

GetConstructor(Type, Type[])

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

GetConstructors(Type)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

GetConstructors(Type, BindingFlags)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

GetFields(Type, BindingFlags)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

GetGenericArguments(Type)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

GetInterfaces(Type)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

GetMember(Type, String)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

GetMember(Type, String, BindingFlags)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

GetMembers(Type)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

GetMethods(Type)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

GetNestedType(Type, String, BindingFlags)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

GetProperties(Type)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

GetProperties(Type, BindingFlags)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

GetProperty(Type, String, BindingFlags)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

GetProperty(Type, String, Type)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

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

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

IsAssignableFrom(Type, Type)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

IsInstanceOfType(Type, Object)

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

Berlaku untuk

Lihat juga