GenericTypeParameterBuilder 類別
定義
重要
部分資訊涉及發行前產品，在發行之前可能會有大幅修改。 Microsoft 對此處提供的資訊，不做任何明確或隱含的瑕疵擔保。
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。
public ref class GenericTypeParameterBuilder sealed : Typepublic ref class GenericTypeParameterBuilder sealed : System::Reflection::TypeInfopublic ref class GenericTypeParameterBuilder abstract : System::Reflection::TypeInfopublic sealed class GenericTypeParameterBuilder : Typepublic sealed class GenericTypeParameterBuilder : System.Reflection.TypeInfopublic 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.TypeInfotype GenericTypeParameterBuilder = class
inherit Typetype GenericTypeParameterBuilder = class
inherit TypeInfo[<System.Runtime.InteropServices.ComVisible(true)>]
type GenericTypeParameterBuilder = class
inherit Type[<System.Runtime.InteropServices.ComVisible(true)>]
type GenericTypeParameterBuilder = class
inherit TypeInfoPublic NotInheritable Class GenericTypeParameterBuilder
Inherits TypePublic NotInheritable Class GenericTypeParameterBuilder
Inherits TypeInfoPublic MustInherit Class GenericTypeParameterBuilder
Inherits TypeInfo- 繼承
- 繼承
- 繼承
- 屬性
範例
下列程式代碼範例會建立具有兩個型別參數的泛型型別，並將其儲存在元件 GenericEmitExample1.dll中。 您可以使用 Ildasm.exe （IL 反組譯器） 來檢視產生的類型。 如需定義動態泛型類型相關步驟的更詳細說明，請參閱 如何：使用反映發出定義泛型型別。
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
備註
您可以使用 TypeBuilder.DefineGenericParameters 方法，將型別參數新增至動態型別、使其成為泛型型別，或使用 MethodBuilder.DefineGenericParameters 方法將型別參數新增至動態方法，以取得 GenericTypeParameterBuilder 對象的陣列。 使用 GenericTypeParameterBuilder 物件，將條件約束新增至型別參數。 條件約束有三種類型：
基底類型條件約束會指定指派給泛型型別參數的任何類型都必須衍生自特定的基底類型。 使用 SetBaseTypeConstraint 方法來設定此條件約束。
介面條件約束指定指派給泛型型別參數的任何類型都必須實作特定的介面。 使用 SetInterfaceConstraints 方法來設定介面條件約束。
特殊條件約束指定指派給泛型型別參數的任何類型都必須具有無參數建構函式、必須是參考型別，或必須是實值型別。 使用 SetGenericParameterAttributes 方法設定類型參數的特殊條件約束。
介面條件約束和特殊條件約束無法使用 GenericTypeParameterBuilder 類別的方法擷取。 建立包含型別參數的泛型型別之後，您可以使用其 Type 物件來反映條件約束。 使用 Type.GetGenericArguments 方法來取得類型參數，而且針對每個類型參數，請使用 Type.GetGenericParameterConstraints 方法來取得基底類型條件約束和介面條件約束，以及取得特殊條件約束的 Type.GenericParameterAttributes 屬性。
建構函式
| GenericTypeParameterBuilder() |
初始化 GenericTypeParameterBuilder 類別的新實例。 |
屬性
| Assembly |
取得 Assembly 物件，表示包含目前型別參數所屬之泛型型別定義的動態元件。 |
| AssemblyQualifiedName |
在所有情況下取得 |
| Attributes |
取得與 Type相關聯的屬性。 |
| Attributes |
取得與 Type相關聯的屬性。 (繼承來源 Type) |
| Attributes |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| BaseType |
取得目前泛型型別參數的基底型別條件約束。 |
| ContainsGenericParameters |
在所有情況下取得 |
| CustomAttributes |
取得集合，其中包含這個成員的自定義屬性。 (繼承來源 MemberInfo) |
| DeclaredConstructors |
取得目前型別所宣告之建構函式的集合。 (繼承來源 TypeInfo) |
| DeclaredEvents |
取得目前型別所定義之事件的集合。 (繼承來源 TypeInfo) |
| DeclaredFields |
取得目前型別所定義的欄位集合。 (繼承來源 TypeInfo) |
| DeclaredMembers |
取得目前型別所定義之成員的集合。 (繼承來源 TypeInfo) |
| DeclaredMethods |
取得目前型別所定義之方法的集合。 (繼承來源 TypeInfo) |
| DeclaredNestedTypes |
取得目前型別所定義的巢狀型別集合。 (繼承來源 TypeInfo) |
| DeclaredProperties |
取得目前型別所定義之屬性的集合。 (繼承來源 TypeInfo) |
| DeclaringMethod |
取得表示宣告方法的 MethodInfo，如果目前的 GenericTypeParameterBuilder 代表泛型方法的類型參數。 |
| DeclaringType |
取得泛型型別定義或泛型型別參數所屬的泛型方法定義。 |
| FullName |
在所有情況下取得 |
| GenericParameterAttributes |
取得 GenericParameterAttributes 旗標的組合，描述目前泛型型別參數的共變數和特殊條件約束。 |
| GenericParameterAttributes |
取得 GenericParameterAttributes 旗標的組合，描述目前泛型型別參數的共變數和特殊條件約束。 (繼承來源 Type) |
| GenericParameterPosition |
取得類型參數在宣告參數之泛型型別或方法的類型參數清單中的位置。 |
| GenericTypeArguments |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 |
| GenericTypeArguments |
取得這個型別之泛型型別自變數的陣列。 (繼承來源 Type) |
| GenericTypeArguments |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| GenericTypeParameters |
取得目前實例之泛型型別參數的陣列。 (繼承來源 TypeInfo) |
| GUID |
不支援不完整的泛型型別參數。 |
| HasElementType |
取得值，指出目前的 Type 是否包含或參考另一種型別;也就是說，目前 Type 是陣列、指標或以傳址方式傳遞。 (繼承來源 Type) |
| HasElementType |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| ImplementedInterfaces |
取得目前型別所實作之介面的集合。 (繼承來源 TypeInfo) |
| IsAbstract |
取得值，指出 Type 是否為抽象且必須覆寫。 (繼承來源 Type) |
| IsAbstract |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsAnsiClass |
取得值，指出是否已為 Type選取字串格式屬性 |
| IsAnsiClass |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsArray |
取得值，這個值表示型別是否為陣列。 (繼承來源 Type) |
| IsArray |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsAutoClass |
取得值，指出是否已為 Type選取字串格式屬性 |
| IsAutoClass |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsAutoLayout |
取得值，指出目前類型的字段是否由 Common Language Runtime 自動配置。 (繼承來源 Type) |
| IsAutoLayout |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsByRef |
取得值，指出是否以傳址方式傳遞 Type。 (繼承來源 Type) |
| IsByRef |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsByRefLike |
取得值，這個值表示型別是否為類似 byref 的結構。 |
| IsByRefLike |
取得值，這個值表示型別是否為類似 byref 的結構。 (繼承來源 Type) |
| IsClass |
取得值，指出 Type 是類別還是委派;也就是說，不是實值型別或介面。 (繼承來源 Type) |
| IsClass |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsCollectible |
取得值，這個值表示這個 MemberInfo 物件是否為可收集 AssemblyLoadContext中保存的元件。 (繼承來源 MemberInfo) |
| IsCOMObject |
取得值，指出 Type 是否為 COM 物件。 (繼承來源 Type) |
| IsCOMObject |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsConstructedGenericType |
取得值，這個值表示這個物件是否代表建構的泛型型別。 |
| IsConstructedGenericType |
取得值，這個值表示這個物件是否代表建構的泛型型別。 您可以建立已建構泛型類型的實例。 (繼承來源 Type) |
| IsContextful |
取得值，指出是否可以在內容中裝載 Type。 (繼承來源 Type) |
| IsEnum |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 |
| IsEnum |
取得值，指出目前的 Type 是否代表列舉。 (繼承來源 Type) |
| IsEnum |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsExplicitLayout |
取得值，指出目前型別的欄位是否在明確指定的位移中配置。 (繼承來源 Type) |
| IsExplicitLayout |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsFunctionPointer |
取得值，這個值表示目前 Type 是否為函式指標。 (繼承來源 Type) |
| IsGenericMethodParameter |
取得值，這個值表示目前 Type 是否代表泛型方法定義中的型別參數。 (繼承來源 Type) |
| IsGenericParameter |
在所有情況下取得 |
| IsGenericType |
在所有情況下都會傳回 |
| IsGenericTypeDefinition |
在所有情況下取得 |
| IsGenericTypeParameter |
取得值，這個值表示目前 Type 是否代表泛型型別定義中的型別參數。 (繼承來源 Type) |
| IsImport |
取得值，指出 Type 是否已套用 ComImportAttribute 屬性，指出它已從 COM 類型庫匯入。 (繼承來源 Type) |
| IsImport |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsInterface |
取得值，指出 Type 是否為介面;也就是說，不是類別或實值型別。 (繼承來源 Type) |
| IsInterface |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsLayoutSequential |
取得值，指出目前類型的欄位是否依定義或發出至元數據的順序循序配置。 (繼承來源 Type) |
| IsLayoutSequential |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsMarshalByRef |
取得值，指出是否以傳址方式封送處理 Type。 (繼承來源 Type) |
| IsMarshalByRef |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsNested |
取得值，指出目前的 Type 物件是否代表定義巢狀於另一個型別定義內的型別。 (繼承來源 Type) |
| IsNested |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsNestedAssembly |
取得值，指出 Type 是否為巢狀結構，且只顯示在它自己的元件內。 (繼承來源 Type) |
| IsNestedAssembly |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsNestedFamANDAssem |
取得值，指出 Type 是否為巢狀結構，且只對屬於其本身系列和本身元件的類別可見。 (繼承來源 Type) |
| IsNestedFamANDAssem |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsNestedFamily |
取得值，指出 Type 是否為巢狀，且只在其自己的系列內可見。 (繼承來源 Type) |
| IsNestedFamily |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsNestedFamORAssem |
取得值，指出 Type 是巢狀的，而且只對屬於其自有系列或本身元件之類別可見。 (繼承來源 Type) |
| IsNestedFamORAssem |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsNestedPrivate |
取得值，指出 Type 是否為巢狀且宣告為私用。 (繼承來源 Type) |
| IsNestedPrivate |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsNestedPublic |
取得值，指出類別是否為巢狀和宣告為公用。 (繼承來源 Type) |
| IsNestedPublic |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsNotPublic |
取得值，指出 Type 是否未宣告為公用。 (繼承來源 Type) |
| IsNotPublic |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsPointer |
取得值，指出 Type 是否為指標。 (繼承來源 Type) |
| IsPointer |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsPrimitive |
取得值，指出 Type 是否為其中一個基本型別。 (繼承來源 Type) |
| IsPrimitive |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsPublic |
取得值，指出 Type 是否宣告為公用。 (繼承來源 Type) |
| IsPublic |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsSealed |
取得值，指出是否宣告 Type 密封。 (繼承來源 Type) |
| IsSealed |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsSecurityCritical |
取得值，這個值表示目前類型在目前信任層級是安全性關鍵或安全性安全關鍵，因此可以執行重大作業。 (繼承來源 Type) |
| IsSecuritySafeCritical |
取得值，這個值表示目前類型在目前信任層級上是否為安全性安全關鍵;也就是說，它是否可以執行關鍵作業，而且可由透明程式代碼存取。 (繼承來源 Type) |
| IsSecurityTransparent |
取得值，這個值表示目前類型在目前信任層級上是否透明，因此無法執行關鍵作業。 (繼承來源 Type) |
| IsSerializable |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 |
| IsSerializable |
已淘汰.
取得值，指出 Type 是否可串行化二進位。 (繼承來源 Type) |
| IsSerializable |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsSignatureType |
取得值，這個值表示型別是否為簽章型別。 (繼承來源 Type) |
| IsSpecialName |
取得值，指出型別是否有需要特殊處理的名稱。 (繼承來源 Type) |
| IsSpecialName |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsSZArray |
取得值，這個值表示型別是否為數位型別，只能代表具有零下限的單一維度數位。 |
| IsSZArray |
取得值，這個值表示型別是否為數位型別，只能代表具有零下限的單一維度數位。 (繼承來源 Type) |
| IsTypeDefinition |
取得值，這個值表示型別是否為型別定義。 |
| IsTypeDefinition |
取得值，這個值表示型別是否為型別定義。 (繼承來源 Type) |
| IsUnicodeClass |
取得值，指出是否已為 Type選取字串格式屬性 |
| IsUnicodeClass |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsUnmanagedFunctionPointer |
取得值，這個值表示目前 Type 是否為 Unmanaged 函式指標。 (繼承來源 Type) |
| IsValueType |
取得值，指出 Type 是否為實值型別。 (繼承來源 Type) |
| IsValueType |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| IsVariableBoundArray |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 |
| IsVariableBoundArray |
取得值，這個值表示型別是否為數位類型，可代表多維度陣列或具有任意下限的陣列。 (繼承來源 Type) |
| IsVisible |
取得值，指出元件外部的程式代碼是否可以存取 Type。 (繼承來源 Type) |
| IsVisible |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| MemberType |
取得 MemberTypes 值，指出這個成員是型別或巢狀型別。 (繼承來源 Type) |
| MemberType |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| MetadataToken |
取得識別元數據中目前動態模組的令牌。 |
| MetadataToken |
取得識別元數據專案的值。 (繼承來源 MemberInfo) |
| Module |
取得包含泛型型別參數的動態模組。 |
| Name |
取得泛型型別參數的名稱。 |
| Namespace |
在所有情況下取得 |
| ReflectedType |
取得用來取得 GenericTypeParameterBuilder的 Type 物件。 |
| ReflectedType |
取得用來取得這個實例 |
| StructLayoutAttribute |
取得描述目前型別配置 StructLayoutAttribute。 (繼承來源 Type) |
| StructLayoutAttribute |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| TypeHandle |
不支援不完整的泛型型別參數。 |
| TypeInitializer |
取得型別的初始化表達式。 (繼承來源 Type) |
| TypeInitializer |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
| UnderlyingSystemType |
取得目前的泛型型別參數。 |
| UnderlyingSystemType |
定義並建立動態定義泛型型別和方法的泛型型別參數。 無法繼承這個類別。 (繼承來源 TypeInfo) |
