GenericTypeParameterBuilder Classe
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata.
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
- Ereditarietà
- Ereditarietà
- Ereditarietà
- Attributi
Esempio
L'esempio di codice seguente crea un tipo generico con due parametri di tipo e li salva nell'assembly GenericEmitExample1.dll. È possibile usare il Ildasm.exe (Disassembler IL) per visualizzare i tipi generati. Per una spiegazione più dettagliata dei passaggi necessari per definire un tipo generico dinamico, vedere Procedura: Definire un tipo generico con Reflection Emit.
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
Commenti
È possibile ottenere una matrice di oggetti usando il TypeBuilder.DefineGenericParameters metodo per aggiungere parametri di GenericTypeParameterBuilder tipo a un tipo dinamico, rendendolo quindi un tipo generico o usando il MethodBuilder.DefineGenericParameters metodo per aggiungere parametri di tipo a un metodo dinamico. Utilizzare gli GenericTypeParameterBuilder oggetti per aggiungere vincoli ai parametri di tipo. I vincoli sono di tre tipi:
Il vincolo del tipo di base specifica che qualsiasi tipo assegnato al parametro di tipo generico deve derivare da un tipo di base specifico. Impostare questo vincolo usando il SetBaseTypeConstraint metodo .
Un vincolo di interfaccia specifica che qualsiasi tipo assegnato al parametro di tipo generico deve implementare una particolare interfaccia. Impostare i vincoli di interfaccia usando il SetInterfaceConstraints metodo .
I vincoli speciali specificano che qualsiasi tipo assegnato al parametro di tipo generico deve avere un costruttore senza parametri, deve essere un tipo riferimento o deve essere un tipo valore. Impostare i vincoli speciali per un parametro di tipo usando il SetGenericParameterAttributes metodo .
Non è possibile recuperare vincoli di interfaccia e vincoli speciali usando i metodi della GenericTypeParameterBuilder classe . Dopo aver creato il tipo generico contenente i parametri di tipo, è possibile usare il relativo Type oggetto per riflettere i vincoli. Usare il Type.GetGenericArguments metodo per ottenere i parametri di tipo e per ogni parametro di tipo usare il Type.GetGenericParameterConstraints metodo per ottenere il vincolo di tipo di base e i vincoli di interfaccia e la Type.GenericParameterAttributes proprietà per ottenere i vincoli speciali.
Costruttori
GenericTypeParameterBuilder() |
Inizializza una nuova istanza della classe GenericTypeParameterBuilder. |
Proprietà
Assembly |
Ottiene un oggetto Assembly che rappresenta l'assembly dinamico che contene la definizione di tipo generico a cui appartiene il parametro di tipo corrente. |
AssemblyQualifiedName |
Ottiene |
Attributes |
Ottiene gli attributi associati all'oggetto Type. |
Attributes |
Ottiene gli attributi associati all'oggetto Type. (Ereditato da Type) |
Attributes |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
BaseType |
Ottiene il vincolo di tipo di base del parametro di tipo generico corrente. |
ContainsGenericParameters |
Ottiene |
CustomAttributes |
Ottiene una raccolta che contiene gli attributi personalizzati del membro. (Ereditato da MemberInfo) |
DeclaredConstructors |
Ottiene una raccolta di costruttori dichiarati dal tipo corrente. (Ereditato da TypeInfo) |
DeclaredEvents |
Ottiene una raccolta di eventi definiti dal tipo corrente. (Ereditato da TypeInfo) |
DeclaredFields |
Ottiene una raccolta di campi definiti dal tipo corrente. (Ereditato da TypeInfo) |
DeclaredMembers |
Ottiene una raccolta di membri definiti dal tipo corrente. (Ereditato da TypeInfo) |
DeclaredMethods |
Ottiene una raccolta di metodi definiti dal tipo corrente. (Ereditato da TypeInfo) |
DeclaredNestedTypes |
Ottiene una raccolta di tipi annidati definiti dal tipo corrente. (Ereditato da TypeInfo) |
DeclaredProperties |
Ottiene una raccolta di proprietà definite dal tipo corrente. (Ereditato da TypeInfo) |
DeclaringMethod |
Ottiene una classe MethodInfo che rappresenta il metodo dichiarante se la classe GenericTypeParameterBuilder corrente rappresenta un parametro di tipo di un metodo generico. |
DeclaringType |
Ottiene la definizione di tipo generico o di metodo generico a cui appartiene il parametro di tipo generico. |
FullName |
Ottiene |
GenericParameterAttributes |
Ottiene una combinazione di flag GenericParameterAttributes che descrivono la covariante e i vincoli speciali del parametro di tipo generico corrente. |
GenericParameterAttributes |
Ottiene una combinazione di flag GenericParameterAttributes che descrivono la covariante e i vincoli speciali del parametro di tipo generico corrente. (Ereditato da Type) |
GenericParameterPosition |
Ottiene la posizione del parametro di tipo nell'elenco dei parametri di tipo del tipo o del metodo generico che ha dichiarato il parametro. |
GenericTypeArguments |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. |
GenericTypeArguments |
Ottiene una matrice di argomenti di tipo generico per questo tipo. (Ereditato da Type) |
GenericTypeArguments |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GenericTypeParameters |
Ottiene una matrice dei parametri generici dell'istanza corrente. (Ereditato da TypeInfo) |
GUID |
Valore non supportato per i parametri di tipo generico incompleti. |
HasElementType |
Ottiene un valore che indica se l'oggetto Type corrente comprende o si riferisce a un altro tipo, ovvero se l'oggetto Type corrente è una matrice, un puntatore o viene passato per riferimento. (Ereditato da Type) |
HasElementType |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
ImplementedInterfaces |
Ottiene una raccolta delle interfacce implementate dal tipo corrente. (Ereditato da TypeInfo) |
IsAbstract |
Ottiene un valore che indica se Type è astratto e se deve essere sottoposto a override. (Ereditato da Type) |
IsAbstract |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsAnsiClass |
Ottiene un valore che indica se l'attributo di formato della stringa |
IsAnsiClass |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsArray |
Ottiene un valore che indica se il tipo è una matrice. (Ereditato da Type) |
IsArray |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsAutoClass |
Ottiene un valore che indica se l'attributo di formato della stringa |
IsAutoClass |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsAutoLayout |
Ottiene un valore che indica se i campi del tipo corrente sono disposti automaticamente dal Common Language Runtime. (Ereditato da Type) |
IsAutoLayout |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsByRef |
Ottiene un valore che indica se l'oggetto Type viene passato per riferimento. (Ereditato da Type) |
IsByRef |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsByRefLike |
Ottiene un valore che indica se il tipo è una struttura simile a byref. |
IsByRefLike |
Ottiene un valore che indica se il tipo è una struttura simile a byref. (Ereditato da Type) |
IsClass |
Ottiene un valore che indica se Type è una classe o un delegato, ovvero se non è un tipo di valore o un'interfaccia. (Ereditato da Type) |
IsClass |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsCollectible |
Ottiene un valore che indica se questo oggetto MemberInfo fa parte di un assembly conservato in un AssemblyLoadContext ritirabile. (Ereditato da MemberInfo) |
IsCOMObject |
Ottiene un valore che indica se Type è un oggetto COM. (Ereditato da Type) |
IsCOMObject |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsConstructedGenericType |
Ottiene un valore che indica se l'oggetto rappresenta un tipo generico costruito. |
IsConstructedGenericType |
Ottiene un valore che indica se l'oggetto rappresenta un tipo generico costruito. È possibile creare istanze di un tipo generico costruito. (Ereditato da Type) |
IsContextful |
Ottiene un valore che indica se è possibile includere Type in un contesto. (Ereditato da Type) |
IsEnum |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. |
IsEnum |
Ottiene un valore che indica se l'oggetto Type è un'enumerazione. (Ereditato da Type) |
IsEnum |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsExplicitLayout |
Ottiene un valore che indica se i campi del tipo corrente sono disposti a offset specificati in modo esplicito. (Ereditato da Type) |
IsExplicitLayout |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsFunctionPointer |
Ottiene un valore che indica se l'oggetto corrente Type è un puntatore a funzione. (Ereditato da Type) |
IsGenericMethodParameter |
Ottiene un valore che indica se l'oggetto Type corrente rappresenta un parametro di tipo nella definizione di un metodo generico. (Ereditato da Type) |
IsGenericParameter |
Ottiene |
IsGenericType |
Restituisce |
IsGenericTypeDefinition |
Ottiene |
IsGenericTypeParameter |
Ottiene un valore che indica se l'oggetto Type corrente rappresenta un parametro di tipo nella definizione di un tipo generico. (Ereditato da Type) |
IsImport |
Ottiene un valore che indica se Type dispone di un attributo ComImportAttribute applicato, che ne indica l'importazione da una libreria di tipi COM. (Ereditato da Type) |
IsImport |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsInterface |
Ottiene un valore che indica se Type è un'interfaccia, ovvero non è una classe né un tipo di valore. (Ereditato da Type) |
IsInterface |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsLayoutSequential |
Ottiene un valore che indica se i campi del tipo corrente sono disposti in sequenza, nell'ordine in cui sono stati definiti o rilasciati ai metadati. (Ereditato da Type) |
IsLayoutSequential |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsMarshalByRef |
Ottiene un valore che indica se l'oggetto Type viene sottoposto a marshalling per riferimento. (Ereditato da Type) |
IsMarshalByRef |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsNested |
Ottiene un valore che indica se l'oggetto Type corrente rappresenta un tipo la cui definizione è annidata all'interno della definizione di un altro tipo. (Ereditato da Type) |
IsNested |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsNestedAssembly |
Ottiene un valore che indica se Type è annidato e visibile soltanto all'interno dell'assembly. (Ereditato da Type) |
IsNestedAssembly |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsNestedFamANDAssem |
Ottiene un valore che indica se Type è annidato e visibile soltanto alle classi della stessa famiglia e dello stesso assembly. (Ereditato da Type) |
IsNestedFamANDAssem |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsNestedFamily |
Ottiene un valore che indica se Type è annidato e visibile solo all'interno della famiglia. (Ereditato da Type) |
IsNestedFamily |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsNestedFamORAssem |
Ottiene un valore che indica se Type è annidato e visibile solo alle classi della stessa famiglia o dello stesso assembly. (Ereditato da Type) |
IsNestedFamORAssem |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsNestedPrivate |
Ottiene un valore che indica se Type è annidato e dichiarato privato. (Ereditato da Type) |
IsNestedPrivate |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsNestedPublic |
Ottiene un valore che indica se una classe è annidata e dichiarata pubblica. (Ereditato da Type) |
IsNestedPublic |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsNotPublic |
Ottiene un valore che indica se l'oggetto Type non è dichiarato pubblico. (Ereditato da Type) |
IsNotPublic |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsPointer |
Ottiene un valore che indica se Type è un puntatore. (Ereditato da Type) |
IsPointer |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsPrimitive |
Ottiene un valore che indica se Type è uno dei tipi primitivi. (Ereditato da Type) |
IsPrimitive |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsPublic |
Ottiene un valore che indica se l'oggetto Type è dichiarato pubblico. (Ereditato da Type) |
IsPublic |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsSealed |
Ottiene un valore che indica se Type è dichiarato sealed. (Ereditato da Type) |
IsSealed |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsSecurityCritical |
Ottiene un valore che indica se il tipo corrente è SecurityCritical o SecuritySafeCritical al livello di attendibilità corrente e può pertanto eseguire operazioni critiche. (Ereditato da Type) |
IsSecuritySafeCritical |
Ottiene un valore che indica se il tipo corrente è SecuritySafeCritical al livello di attendibilità corrente, vale a dire se può eseguire operazioni critiche e se è possibile accedervi tramite codice trasparente. (Ereditato da Type) |
IsSecurityTransparent |
Ottiene un valore che indica se il tipo corrente è trasparente al livello di attendibilità corrente e non può quindi eseguire operazioni critiche. (Ereditato da Type) |
IsSerializable |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. |
IsSerializable |
Obsoleti.
Ottiene un valore che indica se è Type serializzabile binario. (Ereditato da Type) |
IsSerializable |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsSignatureType |
Ottiene un valore che indica se il tipo è un tipo di firma. (Ereditato da Type) |
IsSpecialName |
Ottiene un valore che indica se per il nome del tipo richiede una gestione speciale. (Ereditato da Type) |
IsSpecialName |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsSZArray |
Ottiene un valore che indica se il tipo è un tipo di matrice che può rappresentare solo una matrice unidimensionale con un limite inferiore pari a zero. |
IsSZArray |
Ottiene un valore che indica se il tipo è un tipo di matrice che può rappresentare solo una matrice unidimensionale con un limite inferiore pari a zero. (Ereditato da Type) |
IsTypeDefinition |
Ottiene un valore che indica se il tipo è una definizione di tipo. |
IsTypeDefinition |
Ottiene un valore che indica se il tipo è una definizione di tipo. (Ereditato da Type) |
IsUnicodeClass |
Ottiene un valore che indica se l'attributo di formato della stringa |
IsUnicodeClass |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsUnmanagedFunctionPointer |
Ottiene un valore che indica se l'oggetto corrente Type è un puntatore a funzione non gestito. (Ereditato da Type) |
IsValueType |
Ottiene un valore che indica se Type è un tipo di valore. (Ereditato da Type) |
IsValueType |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsVariableBoundArray |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. |
IsVariableBoundArray |
Ottiene un valore che indica se il tipo è un tipo di matrice che può rappresentare una matrice multidimensionale o una matrice con un limite inferiore arbitrario. (Ereditato da Type) |
IsVisible |
Ottiene un valore che indica se è possibile accedere a Type da codice esterno all'assembly. (Ereditato da Type) |
IsVisible |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
MemberType |
Ottiene un valore MemberTypes che indica che questo membro è un tipo o un tipo annidato. (Ereditato da Type) |
MemberType |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
MetadataToken |
Ottiene un token che identifica il modulo dinamico corrente nei metadati. |
MetadataToken |
Ottiene un valore che identifica un elemento di metadati. (Ereditato da MemberInfo) |
Module |
Ottiene il modulo dinamico che contiene il parametro di tipo generico. |
Name |
Ottiene il nome del parametro di tipo generico. |
Namespace |
Ottiene |
ReflectedType |
Ottiene l'oggetto Type usato per ottenere GenericTypeParameterBuilder. |
ReflectedType |
Ottiene l'oggetto classe utilizzato per ottenere questa istanza di |
StructLayoutAttribute |
Ottiene una classe StructLayoutAttribute che descrive il layout del tipo corrente. (Ereditato da Type) |
StructLayoutAttribute |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
TypeHandle |
Valore non supportato per i parametri di tipo generico incompleti. |
TypeInitializer |
Ottiene l'inizializzatore per il tipo. (Ereditato da Type) |
TypeInitializer |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
UnderlyingSystemType |
Ottiene il parametro di tipo generico corrente. |
UnderlyingSystemType |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
Metodi
AsType() |
Restituisce il tipo corrente come oggetto Type. (Ereditato da TypeInfo) |
Equals(Object) |
Verifica se l'oggetto dato è un'istanza di |
Equals(Type) |
Determina se il tipo di sistema sottostante dell'oggetto Type corrente coincide con il tipo di sistema sottostante dell'oggetto Type specificato. (Ereditato da Type) |
FindInterfaces(TypeFilter, Object) |
Restituisce una matrice di oggetti Type che rappresenta un elenco filtrato di interfacce implementate o ereditate dall'oggetto Type corrente. (Ereditato da Type) |
FindInterfaces(TypeFilter, Object) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object) |
Restituisce una matrice filtrata di oggetti MemberInfo del tipo di membro specificato. (Ereditato da Type) |
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetArrayRank() |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. |
GetArrayRank() |
Ottiene il numero di dimensioni in una matrice. (Ereditato da Type) |
GetArrayRank() |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetAttributeFlagsImpl() |
Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà Attributes e ottiene una combinazione bit per bit di valori di enumerazione che indicano gli attributi associati a Type. |
GetAttributeFlagsImpl() |
Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà Attributes e ottiene una combinazione bit per bit di valori di enumerazione che indicano gli attributi associati a Type. (Ereditato da Type) |
GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[]) |
Cerca il costruttore i cui parametri corrispondono ai tipi di argomenti e ai modificatori specificati, usando i vincoli di associazione e la convenzione di chiamata specificati. (Ereditato da Type) |
GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[]) |
Cerca un costruttore i cui parametri corrispondono ai tipi e ai modificatori dell'argomento specificato, usando i vincoli di associazione specificati. (Ereditato da Type) |
GetConstructor(BindingFlags, Type[]) |
Cerca un costruttore i cui parametri corrispondono ai tipi di argomenti specificati usando i vincoli di associazione specificati. (Ereditato da Type) |
GetConstructor(Type[]) |
Cerca un costruttore di istanza pubblica i cui parametri corrispondono ai tipi nella matrice specificata. (Ereditato da Type) |
GetConstructor(Type[]) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[]) |
Valore non supportato per i parametri di tipo generico incompleti. |
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[]) |
Quando ne viene eseguito l'override in una classe derivata, cerca un costruttore i cui parametri corrispondono ai modificatori e ai tipi di argomento specificati, usando i vincoli di binding e la convenzione di chiamata specificati. (Ereditato da Type) |
GetConstructors() |
Restituisce tutti i costruttori di tipo pubblico definiti per l'oggetto Type corrente. (Ereditato da Type) |
GetConstructors() |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetConstructors(BindingFlags) |
Valore non supportato per i parametri di tipo generico incompleti. |
GetConstructors(BindingFlags) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetCustomAttributes(Boolean) |
Valore non supportato per i parametri di tipo generico incompleti. |
GetCustomAttributes(Boolean) |
Se sottoposto a override in una classe derivata, restituisce una matrice di tutti gli attributi personalizzati applicati a questo membro. (Ereditato da MemberInfo) |
GetCustomAttributes(Type, Boolean) |
Valore non supportato per i parametri di tipo generico incompleti. |
GetCustomAttributes(Type, Boolean) |
Quando viene sottoposto a override in una classe derivata, questo metodo restituisce una matrice di attributi personalizzati applicati a questo membro e identificati da Type. (Ereditato da MemberInfo) |
GetCustomAttributesData() |
Restituisce un elenco di oggetti CustomAttributeData che rappresentano i dati relativi agli attributi applicati al membro di destinazione. (Ereditato da MemberInfo) |
GetDeclaredEvent(String) |
Restituisce un oggetto che rappresenta l'evento specificato dichiarato dal tipo corrente. (Ereditato da TypeInfo) |
GetDeclaredField(String) |
Restituisce un oggetto che rappresenta il campo specificato dichiarato dal tipo corrente. (Ereditato da TypeInfo) |
GetDeclaredMethod(String) |
Restituisce un oggetto che rappresenta il metodo specificato dichiarato dal tipo corrente. (Ereditato da TypeInfo) |
GetDeclaredMethods(String) |
Restituisce una raccolta che contiene tutti i metodi dichiarati nel tipo corrente corrispondente al nome specificato. (Ereditato da TypeInfo) |
GetDeclaredNestedType(String) |
Restituisce un oggetto che rappresenta il tipo annidato specificato dichiarato dal tipo corrente. (Ereditato da TypeInfo) |
GetDeclaredProperty(String) |
Restituisce un oggetto che rappresenta la proprietà specificata dichiarata dal tipo corrente. (Ereditato da TypeInfo) |
GetDefaultMembers() |
Cerca i membri definiti per l'oggetto Type corrente per cui è impostato il DefaultMemberAttribute. (Ereditato da Type) |
GetDefaultMembers() |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetElementType() |
Genera un'eccezione NotSupportedException in tutti i casi. |
GetEnumName(Object) |
Restituisce il nome della costante avente il valore specificato, per il tipo di enumerazione corrente. (Ereditato da Type) |
GetEnumName(Object) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetEnumNames() |
Restituisce i nomi dei membri del tipo di enumerazione corrente. (Ereditato da Type) |
GetEnumNames() |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetEnumUnderlyingType() |
Restituisce il tipo sottostante del tipo di enumerazione corrente. (Ereditato da Type) |
GetEnumUnderlyingType() |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetEnumValues() |
Restituisce una matrice dei valori delle costanti nel tipo di enumerazione corrente. (Ereditato da Type) |
GetEnumValues() |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetEnumValuesAsUnderlyingType() |
Recupera una matrice dei valori delle costanti del tipo sottostante di questo tipo di enumerazione. (Ereditato da Type) |
GetEvent(String) |
Restituisce l'oggetto EventInfo che rappresenta l'evento pubblico specificato. (Ereditato da Type) |
GetEvent(String) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetEvent(String, BindingFlags) |
Valore non supportato per i parametri di tipo generico incompleti. |
GetEvent(String, BindingFlags) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetEvents() |
Valore non supportato per i parametri di tipo generico incompleti. |
GetEvents() |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetEvents(BindingFlags) |
Valore non supportato per i parametri di tipo generico incompleti. |
GetEvents(BindingFlags) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetField(String) |
Cerca il campo pubblico con il nome specificato. (Ereditato da Type) |
GetField(String) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetField(String, BindingFlags) |
Valore non supportato per i parametri di tipo generico incompleti. |
GetField(String, BindingFlags) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetFields() |
Restituisce tutti i campi pubblici dell'oggetto Type corrente. (Ereditato da Type) |
GetFields() |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetFields(BindingFlags) |
Valore non supportato per i parametri di tipo generico incompleti. |
GetFields(BindingFlags) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetFunctionPointerCallingConventions() |
Quando sottoposto a override in una classe derivata, restituisce le convenzioni chiamanti del puntatore Typealla funzione corrente. (Ereditato da Type) |
GetFunctionPointerParameterTypes() |
Quando sottoposto a override in una classe derivata, restituisce i tipi di parametro del puntatore Typealla funzione corrente. (Ereditato da Type) |
GetFunctionPointerReturnType() |
Quando sottoposto a override in una classe derivata, restituisce il tipo restituito del puntatore Typealla funzione corrente. (Ereditato da Type) |
GetGenericArguments() |
Non valido per i parametri di tipo generico. |
GetGenericArguments() |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetGenericParameterConstraints() |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. |
GetGenericParameterConstraints() |
Restituisce una matrice di oggetti Type che rappresentano i vincoli sul parametro di tipo generico corrente. (Ereditato da Type) |
GetGenericParameterConstraints() |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetGenericTypeDefinition() |
Non valido per i parametri di tipo generico. |
GetHashCode() |
Restituisce un codice hash di valori interi a 32 bit per l'istanza corrente. |
GetInterface(String) |
Cerca l'interfaccia con il nome specificato. (Ereditato da Type) |
GetInterface(String) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetInterface(String, Boolean) |
Valore non supportato per i parametri di tipo generico incompleti. |
GetInterface(String, Boolean) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetInterfaceMap(Type) |
Valore non supportato per i parametri di tipo generico incompleti. |
GetInterfaces() |
Valore non supportato per i parametri di tipo generico incompleti. |
GetInterfaces() |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetMember(String) |
Cerca i membri pubblici con il nome specificato. (Ereditato da Type) |
GetMember(String) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetMember(String, BindingFlags) |
Cerca i membri specificati, usando i vincoli di binding specificati. (Ereditato da Type) |
GetMember(String, BindingFlags) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetMember(String, MemberTypes, BindingFlags) |
Valore non supportato per i parametri di tipo generico incompleti. |
GetMember(String, MemberTypes, BindingFlags) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetMembers() |
Restituisce tutti i membri pubblici dell'oggetto Type corrente. (Ereditato da Type) |
GetMembers() |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetMembers(BindingFlags) |
Valore non supportato per i parametri di tipo generico incompleti. |
GetMembers(BindingFlags) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetMemberWithSameMetadataDefinitionAs(MemberInfo) |
Cerca nell'oggetto MemberInfo corrente Type corrispondente all'oggetto specificato MemberInfo. (Ereditato da Type) |
GetMethod(String) |
Cerca il metodo pubblico con il nome specificato. (Ereditato da Type) |
GetMethod(String) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetMethod(String, BindingFlags) |
Cerca il metodo specificato, usando i vincoli di binding specificati. (Ereditato da Type) |
GetMethod(String, BindingFlags) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[]) |
Cerca il metodo specificato i cui parametri corrispondono ai tipi di argomenti e ai modificatori specificati, usando i vincoli di binding e la convenzione di chiamata specificati. (Ereditato da Type) |
GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[]) |
Cerca il metodo specificato i cui parametri corrispondono ai tipi di argomenti e ai modificatori specificati, usando i vincoli di binding specificati. (Ereditato da Type) |
GetMethod(String, BindingFlags, Type[]) |
Cerca il metodo specificato i cui parametri corrispondono ai tipi di argomenti specificati usando i vincoli di associazione specificati. (Ereditato da Type) |
GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[]) |
Cerca il metodo specificato i cui parametri corrispondono al numero di parametri generici, ai tipi di argomenti e ai modificatori specificati, usando i vincoli di binding e la convenzione di chiamata specificati. (Ereditato da Type) |
GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[]) |
Cerca il metodo specificato i cui parametri corrispondono al numero di parametri generici, ai tipi di argomenti e ai modificatori specificati, usando i vincoli di binding specificati. (Ereditato da Type) |
GetMethod(String, Int32, BindingFlags, Type[]) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da Type) |
GetMethod(String, Int32, Type[]) |
Cerca il metodo pubblico specificato i cui parametri corrispondono al numero di parametri generici e ai tipi di argomenti specificati. (Ereditato da Type) |
GetMethod(String, Int32, Type[], ParameterModifier[]) |
Cerca il metodo pubblico specificato i cui parametri corrispondono al numero di parametri generici, ai tipi di argomenti e ai modificatori specificati. (Ereditato da Type) |
GetMethod(String, Type[]) |
Cerca il metodo pubblico specificato i cui parametri corrispondono ai tipi di argomenti specificati. (Ereditato da Type) |
GetMethod(String, Type[]) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetMethod(String, Type[], ParameterModifier[]) |
Cerca il metodo pubblico specificato i cui parametri corrispondono ai modificatori e ai tipi di argomenti specificati. (Ereditato da Type) |
GetMethod(String, Type[], ParameterModifier[]) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[]) |
Valore non supportato per i parametri di tipo generico incompleti. |
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[]) |
Quando ne viene eseguito l'override in una classe derivata, cerca il metodo specificato i cui parametri corrispondono ai modificatori e ai tipi di argomento definiti, usando i vincoli di binding e la convenzione di chiamata specificati. (Ereditato da Type) |
GetMethodImpl(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[]) |
Se sottoposto a override in una classe derivata, cerca il metodo specificato i cui parametri corrispondono al numero di parametri generici, ai tipi di argomenti e ai modificatori specificati, usando i vincoli di binding e la convenzione di chiamata specificati. (Ereditato da Type) |
GetMethods() |
Restituisce tutti i metodi pubblici dell'oggetto Type corrente. (Ereditato da Type) |
GetMethods() |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetMethods(BindingFlags) |
Valore non supportato per i parametri di tipo generico incompleti. |
GetMethods(BindingFlags) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetNestedType(String) |
Cerca il tipo annidato pubblico con il nome specificato. (Ereditato da Type) |
GetNestedType(String) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetNestedType(String, BindingFlags) |
Valore non supportato per i parametri di tipo generico incompleti. |
GetNestedType(String, BindingFlags) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetNestedTypes() |
Restituisce i tipi pubblici annidati all'interno dell'oggetto Type corrente. (Ereditato da Type) |
GetNestedTypes() |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetNestedTypes(BindingFlags) |
Valore non supportato per i parametri di tipo generico incompleti. |
GetNestedTypes(BindingFlags) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetOptionalCustomModifiers() |
Quando sottoposto a override in una classe derivata, restituisce i modificatori personalizzati facoltativi dell'oggetto corrente Type. (Ereditato da Type) |
GetProperties() |
Restituisce tutte le proprietà pubbliche dell'oggetto Type corrente. (Ereditato da Type) |
GetProperties() |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetProperties(BindingFlags) |
Valore non supportato per i parametri di tipo generico incompleti. |
GetProperties(BindingFlags) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetProperty(String) |
Cerca la proprietà pubblica con il nome specificato. (Ereditato da Type) |
GetProperty(String) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetProperty(String, BindingFlags) |
Cerca la proprietà specificata, usando i vincoli di binding specificati. (Ereditato da Type) |
GetProperty(String, BindingFlags) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[]) |
Cerca la proprietà specificata i cui parametri corrispondono ai tipi di argomenti e ai modificatori specificati, usando i vincoli di binding specificati. (Ereditato da Type) |
GetProperty(String, Type) |
Cerca la proprietà pubblica con il nome e il tipo restituito specificati. (Ereditato da Type) |
GetProperty(String, Type) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetProperty(String, Type, Type[]) |
Cerca la proprietà pubblica specificata i cui parametri corrispondono ai tipi di argomenti specificati. (Ereditato da Type) |
GetProperty(String, Type, Type[]) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetProperty(String, Type, Type[], ParameterModifier[]) |
Cerca la proprietà pubblica specificata i cui parametri corrispondono ai tipi di argomenti e ai modificatori specificati. (Ereditato da Type) |
GetProperty(String, Type, Type[], ParameterModifier[]) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetProperty(String, Type[]) |
Cerca la proprietà pubblica specificata i cui parametri corrispondono ai tipi di argomenti specificati. (Ereditato da Type) |
GetProperty(String, Type[]) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[]) |
Valore non supportato per i parametri di tipo generico incompleti. |
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[]) |
Quando viene sottoposto a override in una classe derivata, cerca la proprietà specificata i cui parametri corrispondono ai modificatori e ai tipi di argomenti definiti, usando i vincoli di binding specificati. (Ereditato da Type) |
GetRequiredCustomModifiers() |
In caso di override in una classe derivata, restituisce i modificatori personalizzati obbligatori dell'oggetto corrente Type. (Ereditato da Type) |
GetType() |
Ottiene l'oggetto Type corrente. (Ereditato da Type) |
GetType() |
Individua gli attributi di un membro e consente di accedere ai metadati del membro. (Ereditato da MemberInfo) |
GetTypeCodeImpl() |
Restituisce il codice del tipo sottostante di questa istanza di Type. (Ereditato da Type) |
HasElementTypeImpl() |
Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà HasElementType e determina se l'oggetto Type corrente include o contiene riferimenti a un altro tipo, ovvero se l'oggetto Type corrente è costituito da una matrice o da un puntatore o è passato come riferimento. |
HasElementTypeImpl() |
Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà HasElementType e determina se l'oggetto Type corrente include o contiene riferimenti a un altro tipo, ovvero se l'oggetto Type corrente è costituito da una matrice o da un puntatore o è passato come riferimento. (Ereditato da Type) |
HasSameMetadataDefinitionAs(MemberInfo) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da MemberInfo) |
InvokeMember(String, BindingFlags, Binder, Object, Object[]) |
Chiama il membro specificato, usando i vincoli di associazione specificati e associando l'elenco di argomenti specificato. (Ereditato da Type) |
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo) |
Chiama il membro specificato, usando i vincoli di binding specificati e associando l'elenco di argomenti specificati e le impostazioni cultura. (Ereditato da Type) |
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]) |
Valore non supportato per i parametri di tipo generico incompleti. |
IsArrayImpl() |
Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà IsArray e determina se l'oggetto Type è una matrice. |
IsArrayImpl() |
Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà IsArray e determina se l'oggetto Type è una matrice. (Ereditato da Type) |
IsAssignableFrom(Type) |
Genera un'eccezione NotSupportedException in tutti i casi. |
IsAssignableFrom(Type) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsAssignableFrom(TypeInfo) |
Genera un'eccezione NotSupportedException in tutti i casi. |
IsAssignableTo(Type) |
Determina se il tipo corrente può essere assegnato a una variabile del tipo |
IsByRefImpl() |
Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà IsByRef e determina se l'oggetto Type viene passato per riferimento. |
IsByRefImpl() |
Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà IsByRef e determina se l'oggetto Type viene passato per riferimento. (Ereditato da Type) |
IsCOMObjectImpl() |
Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà IsCOMObject e determina se Type è un oggetto COM. |
IsCOMObjectImpl() |
Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà IsCOMObject e determina se Type è un oggetto COM. (Ereditato da Type) |
IsContextfulImpl() |
Implementa la proprietà IsContextful e determina se Type può essere contenuto in un contesto. (Ereditato da Type) |
IsDefined(Type, Boolean) |
Valore non supportato per i parametri di tipo generico incompleti. |
IsDefined(Type, Boolean) |
Quando se ne effettua l'override in una classe derivata, indica se a questo membro sono applicati uno o più attributi del tipo specificato o dei tipi derivati. (Ereditato da MemberInfo) |
IsEnumDefined(Object) |
Restituisce un valore che indica se il valore specificato esiste nel tipo di enumerazione corrente. (Ereditato da Type) |
IsEnumDefined(Object) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsEquivalentTo(Type) |
Determina se due tipi COM presentano la stessa identità e sono idonei per l'equivalenza di tipo. (Ereditato da Type) |
IsEquivalentTo(Type) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsInstanceOfType(Object) |
Determina se l'oggetto specificato è un'istanza dell'oggetto Type corrente. (Ereditato da Type) |
IsInstanceOfType(Object) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. (Ereditato da TypeInfo) |
IsMarshalByRefImpl() |
Implementa la proprietà IsMarshalByRef e determina se l'oggetto Type viene sottoposto a marshalling per riferimento. (Ereditato da Type) |
IsPointerImpl() |
Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà IsPointer e determina se l'oggetto Type è un puntatore. |
IsPointerImpl() |
Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà IsPointer e determina se l'oggetto Type è un puntatore. (Ereditato da Type) |
IsPrimitiveImpl() |
Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà IsPrimitive e determina se l'oggetto Type corrisponde a uno dei tipi primitivi. |
IsPrimitiveImpl() |
Quando ne viene eseguito l'override in una classe derivata, implementa la proprietà IsPrimitive e determina se l'oggetto Type corrisponde a uno dei tipi primitivi. (Ereditato da Type) |
IsSubclassOf(Type) |
Valore non supportato per i parametri di tipo generico incompleti. |
IsValueTypeImpl() |
Implementa la proprietà IsValueType e determina se l'oggetto Type è un tipo di valore, ovvero, non una classe o un'interfaccia. |
IsValueTypeImpl() |
Implementa la proprietà IsValueType e determina se l'oggetto Type è un tipo di valore, ovvero, non una classe o un'interfaccia. (Ereditato da Type) |
MakeArrayType() |
Restituisce il tipo di una matrice unidimensionale il cui tipo di elemento è il parametro di tipo generico. |
MakeArrayType(Int32) |
Restituisce il tipo di una matrice il cui tipo di elemento è il parametro di tipo generico con il numero di dimensioni specificato. |
MakeByRefType() |
Restituisce un oggetto Type che rappresenta il parametro di tipo generico corrente quando viene passato come parametro per riferimento. |
MakeGenericType(Type[]) |
Non valido per i parametri di tipo generico incompleti. |
MakePointerType() |
Restituisce un oggetto Type che rappresenta un puntatore al parametro di tipo generico corrente. |
MemberwiseClone() |
Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object) |
SetBaseTypeConstraint(Type) |
Imposta il tipo di base che un tipo deve ereditare per essere sostituito con il parametro di tipo. |
SetBaseTypeConstraintCore(Type) |
Quando sottoposto a override in una classe derivata, imposta il tipo di base che un tipo deve ereditare per essere sostituito per il parametro di tipo. |
SetCustomAttribute(ConstructorInfo, Byte[]) |
Imposta un attributo personalizzato usando un BLOB di attributi personalizzati specificato. |
SetCustomAttribute(CustomAttributeBuilder) |
Impostare un attributo personalizzato usando un generatore di attributi personalizzati. |
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>) |
Quando sottoposto a override in una classe derivata, imposta un attributo personalizzato su questo assembly. |
SetGenericParameterAttributes(GenericParameterAttributes) |
Imposta le caratteristiche di varianza e i vincoli speciali del parametro generico, ad esempio il vincolo del costruttore senza parametri. |
SetGenericParameterAttributesCore(GenericParameterAttributes) |
Quando sottoposto a override in una classe derivata, imposta le caratteristiche di varianza e i vincoli speciali del parametro generico, ad esempio il vincolo del costruttore senza parametri. |
SetInterfaceConstraints(Type[]) |
Imposta le interfacce che devono essere implementate da un tipo perché questo venga sostituito per il parametro di tipo. |
SetInterfaceConstraintsCore(Type[]) |
Quando sottoposto a override in una classe derivata, imposta le interfacce che un tipo deve implementare per essere sostituito per il parametro di tipo. |
ToString() |
Restituisce una rappresentazione in formato stringa del parametro di tipo generico corrente. |
Implementazioni dell'interfaccia esplicita
_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) |
Esegue il mapping di un set di nomi a un set corrispondente di ID dispatch. (Ereditato da MemberInfo) |
_MemberInfo.GetType() |
Ottiene un oggetto Type che rappresenta la classe MemberInfo. (Ereditato da MemberInfo) |
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr) |
Recupera le informazioni sul tipo relative a un oggetto che può quindi essere usato per ottenere informazioni sul tipo relative a un'interfaccia. (Ereditato da MemberInfo) |
_MemberInfo.GetTypeInfoCount(UInt32) |
Recupera il numero delle interfacce di informazioni sul tipo fornite da un oggetto (0 o 1). (Ereditato da MemberInfo) |
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) |
Fornisce l'accesso a proprietà e metodi esposti da un oggetto. (Ereditato da MemberInfo) |
_Type.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) |
Esegue il mapping di un set di nomi a un set corrispondente di ID dispatch. (Ereditato da Type) |
_Type.GetTypeInfo(UInt32, UInt32, IntPtr) |
Recupera le informazioni sul tipo relative a un oggetto che può quindi essere usato per ottenere informazioni sul tipo relative a un'interfaccia. (Ereditato da Type) |
_Type.GetTypeInfoCount(UInt32) |
Recupera il numero delle interfacce di informazioni sul tipo fornite da un oggetto (0 o 1). (Ereditato da Type) |
_Type.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) |
Fornisce l'accesso a proprietà e metodi esposti da un oggetto. (Ereditato da Type) |
ICustomAttributeProvider.GetCustomAttributes(Boolean) |
Restituisce una matrice di tutti gli attributi personalizzati definiti in questo membro, esclusi gli attributi denominati, oppure una matrice vuota se non sono presenti attributi personalizzati. (Ereditato da MemberInfo) |
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean) |
Restituisce una matrice di attributi personalizzati definiti in questo membro, identificati dal tipo o da una matrice vuota, se non sono presenti attributi personalizzati di quel tipo. (Ereditato da MemberInfo) |
ICustomAttributeProvider.IsDefined(Type, Boolean) |
Indica se per questo membro sono definite una o più istanze di |
IReflectableType.GetTypeInfo() |
Restituisce una rappresentazione del tipo corrente come oggetto TypeInfo. (Ereditato da TypeInfo) |
Metodi di estensione
GetCustomAttribute(MemberInfo, Type) |
Recupera una attributo personalizzato di un tipo specificato che viene applicato a un membro specificato. |
GetCustomAttribute(MemberInfo, Type, Boolean) |
Recupera un attributo personalizzato di un tipo specificato che viene applicato a un membro specificato e verifica facoltativamente i predecessori di tale membro. |
GetCustomAttribute<T>(MemberInfo) |
Recupera una attributo personalizzato di un tipo specificato che viene applicato a un membro specificato. |
GetCustomAttribute<T>(MemberInfo, Boolean) |
Recupera un attributo personalizzato di un tipo specificato che viene applicato a un membro specificato e verifica facoltativamente i predecessori di tale membro. |
GetCustomAttributes(MemberInfo) |
Recupera una raccolta di attributi personalizzati che vengono applicati a un membro specificato. |
GetCustomAttributes(MemberInfo, Boolean) |
Recupera una raccolta di attributi personalizzati che vengono applicati a un membro specificato e verifica facoltativamente i predecessori di tale membro. |
GetCustomAttributes(MemberInfo, Type) |
Recupera una raccolta di attributi personalizzati di un tipo specificato che vengono applicati a un membro specificato. |
GetCustomAttributes(MemberInfo, Type, Boolean) |
Recupera una raccolta di attributi personalizzati di un tipo specificato che vengono applicati a un membro specificato e verifica facoltativamente i predecessori di tale membro. |
GetCustomAttributes<T>(MemberInfo) |
Recupera una raccolta di attributi personalizzati di un tipo specificato che vengono applicati a un membro specificato. |
GetCustomAttributes<T>(MemberInfo, Boolean) |
Recupera una raccolta di attributi personalizzati di un tipo specificato che vengono applicati a un membro specificato e verifica facoltativamente i predecessori di tale membro. |
IsDefined(MemberInfo, Type) |
Indica se vengono applicati attributi personalizzati del tipo specificato a un membro specificato. |
IsDefined(MemberInfo, Type, Boolean) |
Indica se gli attributi personalizzati di un tipo specificato vengono applicati a un membro specificato e, facoltativamente, ai relativi predecessori. |
GetTypeInfo(Type) |
Restituisce la rappresentazione TypeInfo del tipo specificato. |
GetMetadataToken(MemberInfo) |
Ottiene un token di metadati per il membro specificato, se disponibile. |
HasMetadataToken(MemberInfo) |
Restituisce un valore che indica se un token di metadati è disponibile per il membro specificato. |
GetRuntimeEvent(Type, String) |
Recupera un oggetto che rappresenta l’evento specificato. |
GetRuntimeEvents(Type) |
Recupera una raccolta che rappresenta tutti gli eventi definiti in un tipo specificato. |
GetRuntimeField(Type, String) |
Recupera un oggetto che rappresenta un campo specificato. |
GetRuntimeFields(Type) |
Recupera una raccolta che rappresenta tutti i campi definiti in un tipo specificato. |
GetRuntimeInterfaceMap(TypeInfo, Type) |
Restituisce un mapping di interfaccia per il tipo specificato e per l'interfaccia specificata. |
GetRuntimeMethod(Type, String, Type[]) |
Recupera un oggetto che rappresenta un metodo specificato. |
GetRuntimeMethods(Type) |
Recupera una raccolta che rappresenta tutti i metodi definiti in un tipo specificato. |
GetRuntimeProperties(Type) |
Recupera una raccolta che rappresenta tutte le proprietà definite in un tipo specificato. |
GetRuntimeProperty(Type, String) |
Recupera un oggetto che rappresenta una proprietà specificata. |
GetConstructor(Type, Type[]) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. |
GetConstructors(Type) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. |
GetConstructors(Type, BindingFlags) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. |
GetFields(Type, BindingFlags) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. |
GetGenericArguments(Type) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. |
GetInterfaces(Type) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. |
GetMember(Type, String) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. |
GetMember(Type, String, BindingFlags) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. |
GetMembers(Type) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. |
GetMethods(Type) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. |
GetNestedType(Type, String, BindingFlags) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. |
GetProperties(Type) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. |
GetProperties(Type, BindingFlags) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. |
GetProperty(Type, String, BindingFlags) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. |
GetProperty(Type, String, Type) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. |
GetProperty(Type, String, Type, Type[]) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. |
IsAssignableFrom(Type, Type) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. |
IsInstanceOfType(Type, Object) |
Definisce e crea i parametri di tipo generico per tipi e metodi generici definiti in modo dinamico. La classe non può essere ereditata. |