Type.GenericParameterPosition 属性
定义
public:
abstract property int GenericParameterPosition { int get(); };
public:
virtual property int GenericParameterPosition { int get(); };
public abstract int GenericParameterPosition { get; }
public virtual int GenericParameterPosition { get; }
member this.GenericParameterPosition : int
Public MustOverride ReadOnly Property GenericParameterPosition As Integer
Public Overridable ReadOnly Property GenericParameterPosition As Integer
属性值
类型参数在定义它的泛型类型或方法的类型参数列表中的位置。The position of a type parameter in the type parameter list of the generic type or method that defines the parameter. 位置编号从 0 开始。Position numbers begin at 0.
例外
当前的类型不表示类型参数。The current type does not represent a type parameter. 也就是说,IsGenericParameter 返回 false。That is, IsGenericParameter returns false.
示例
下面的示例定义了一个具有两个类型参数的泛型类,并定义了第一个派生自第一个类的泛型类。The following example defines a generic class with two type parameters and defines a second generic class that derives from the first class. 派生类的基类具有两个类型参数:第一个是 Int32 ,第二个是派生类型的类型参数。The derived class's base class has two type arguments: the first is Int32, and the second is a type parameter of the derived type. 该示例显示有关这些泛型类的信息,包括属性报告的位置 GenericParameterPosition 。The example displays information about these generic classes, including the positions reported by the GenericParameterPosition property.
using namespace System;
using namespace System::Reflection;
using namespace System::Collections::Generic;
// Define a base class with two type parameters.
generic< class T,class U >
public ref class Base {};
// Define a derived class. The derived class inherits from a constructed
// class that meets the following criteria:
// (1) Its generic type definition is Base<T, U>.
// (2) It specifies int for the first type parameter.
// (3) For the second type parameter, it uses the same type that is used
// for the type parameter of the derived class.
// Thus, the derived class is a generic type with one type parameter, but
// its base class is an open constructed type with one type argument and
// one type parameter.
generic<class V>
public ref class Derived : Base<int,V> {};
public ref class Test
{
public:
static void Main()
{
Console::WriteLine(
L"\r\n--- Display a generic type and the open constructed");
Console::WriteLine(L" type from which it is derived.");
// Create a Type object representing the generic type definition
// for the Derived type. Note the absence of type arguments.
//
Type^ derivedType = Derived::typeid;
DisplayGenericTypeInfo(derivedType);
// Display its open constructed base type.
DisplayGenericTypeInfo(derivedType->BaseType);
}
private:
static void DisplayGenericTypeInfo(Type^ t)
{
Console::WriteLine(L"\r\n{0}", t);
Console::WriteLine(L"\tIs this a generic type definition? {0}",
t->IsGenericTypeDefinition);
Console::WriteLine(L"\tIs it a generic type? {0}", t->IsGenericType);
Console::WriteLine(L"\tDoes it have unassigned generic parameters? {0}",
t->ContainsGenericParameters);
if (t->IsGenericType)
{
// If this is a generic type, display the type arguments.
//
array<Type^>^typeArguments = t->GetGenericArguments();
Console::WriteLine(L"\tList type arguments ({0}):",
typeArguments->Length);
System::Collections::IEnumerator^ myEnum =
typeArguments->GetEnumerator();
while (myEnum->MoveNext())
{
Type^ tParam = safe_cast<Type^>(myEnum->Current);
// IsGenericParameter is true only for generic type
// parameters.
//
if (tParam->IsGenericParameter)
{
Console::WriteLine(
L"\t\t{0} (unassigned - parameter position {1})",
tParam, tParam->GenericParameterPosition);
}
else
{
Console::WriteLine(L"\t\t{0}", tParam);
}
}
}
}
};
int main()
{
Test::Main();
}
/* This example produces the following output:
--- Display a generic type and the open constructed
type from which it is derived.
Derived`1[V]
Is this a generic type definition? True
Is it a generic type? True
Does it have unassigned generic parameters? True
List type arguments (1):
V (unassigned - parameter position 0)
Base`2[System.Int32,V]
Is this a generic type definition? False
Is it a generic type? True
Does it have unassigned generic parameters? True
List type arguments (2):
System.Int32
V (unassigned - parameter position 0)
*/
using System;
using System.Reflection;
using System.Collections.Generic;
// Define a base class with two type parameters.
public class Base<T, U> { }
// Define a derived class. The derived class inherits from a constructed
// class that meets the following criteria:
// (1) Its generic type definition is Base<T, U>.
// (2) It specifies int for the first type parameter.
// (3) For the second type parameter, it uses the same type that is used
// for the type parameter of the derived class.
// Thus, the derived class is a generic type with one type parameter, but
// its base class is an open constructed type with one type argument and
// one type parameter.
public class Derived<V> : Base<int, V> { }
public class Test
{
public static void Main()
{
Console.WriteLine(
"\r\n--- Display a generic type and the open constructed");
Console.WriteLine(" type from which it is derived.");
// Create a Type object representing the generic type definition
// for the Derived type, by omitting the type argument. (For
// types with multiple type parameters, supply the commas but
// omit the type arguments.)
//
Type derivedType = typeof(Derived<>);
DisplayGenericTypeInfo(derivedType);
// Display its open constructed base type.
DisplayGenericTypeInfo(derivedType.BaseType);
}
private static void DisplayGenericTypeInfo(Type t)
{
Console.WriteLine("\r\n{0}", t);
Console.WriteLine("\tIs this a generic type definition? {0}",
t.IsGenericTypeDefinition);
Console.WriteLine("\tIs it a generic type? {0}",
t.IsGenericType);
Console.WriteLine("\tDoes it have unassigned generic parameters? {0}",
t.ContainsGenericParameters);
if (t.IsGenericType)
{
// If this is a generic type, display the type arguments.
//
Type[] typeArguments = t.GetGenericArguments();
Console.WriteLine("\tList type arguments ({0}):",
typeArguments.Length);
foreach (Type tParam in typeArguments)
{
// IsGenericParameter is true only for generic type
// parameters.
//
if (tParam.IsGenericParameter)
{
Console.WriteLine(
"\t\t{0} (unassigned - parameter position {1})",
tParam,
tParam.GenericParameterPosition);
}
else
{
Console.WriteLine("\t\t{0}", tParam);
}
}
}
}
}
/* This example produces the following output:
--- Display a generic type and the open constructed
type from which it is derived.
Derived`1[V]
Is this a generic type definition? True
Is it a generic type? True
Does it have unassigned generic parameters? True
List type arguments (1):
V (unassigned - parameter position 0)
Base`2[System.Int32,V]
Is this a generic type definition? False
Is it a generic type? True
Does it have unassigned generic parameters? True
List type arguments (2):
System.Int32
V (unassigned - parameter position 0)
*/
Imports System.Reflection
Imports System.Collections.Generic
' Define a base class with two type parameters.
Public Class Base(Of T, U)
End Class
' Define a derived class. The derived class inherits from a constructed
' class that meets the following criteria:
' (1) Its generic type definition is Base<T, U>.
' (2) It uses int for the first type parameter.
' (3) For the second type parameter, it uses the same type that is used
' for the type parameter of the derived class.
' Thus, the derived class is a generic type with one type parameter, but
' its base class is an open constructed type with one assigned type
' parameter and one unassigned type parameter.
Public Class Derived(Of V)
Inherits Base(Of Integer, V)
End Class
Public Class Test
Public Shared Sub Main()
Console.WriteLine(vbCrLf _
& "--- Display a generic type and the open constructed")
Console.WriteLine(" type from which it is derived.")
' Create a Type object representing the generic type definition
' for the Derived type, by omitting the type argument. (For
' types with multiple type parameters, supply the commas but
' omit the type arguments.)
'
Dim derivedType As Type = GetType(Derived(Of ))
DisplayGenericTypeInfo(derivedType)
' Display its open constructed base type.
DisplayGenericTypeInfo(derivedType.BaseType)
End Sub
Private Shared Sub DisplayGenericTypeInfo(ByVal t As Type)
Console.WriteLine(vbCrLf & "{0}", t)
Console.WriteLine(vbTab & "Is this a generic type definition? " _
& t.IsGenericTypeDefinition)
Console.WriteLine(vbTab & "Is it a generic type? " _
& t.IsGenericType)
Console.WriteLine(vbTab _
& "Does it have unassigned generic parameters? " _
& t.ContainsGenericParameters)
If t.IsGenericType Then
' If this is a generic type, display the type arguments.
'
Dim typeArguments As Type() = t.GetGenericArguments()
Console.WriteLine(vbTab & "List type arguments (" _
& typeArguments.Length & "):")
For Each tParam As Type In typeArguments
' IsGenericParameter is true only for generic type
' parameters.
'
If tParam.IsGenericParameter Then
Console.WriteLine(vbTab & vbTab & tParam.ToString() _
& " (unassigned - parameter position " _
& tParam.GenericParameterPosition & ")")
Else
Console.WriteLine(vbTab & vbTab & tParam.ToString())
End If
Next tParam
End If
End Sub
End Class
' This example produces the following output:
'
'--- Display a generic type and the open constructed
' type from which it is derived.
'
'Derived`1[V]
' Is this a generic type definition? True
' Is it a generic type? True
' Does it have unassigned generic parameters? True
' List type arguments (1):
' V (unassigned - parameter position 0)
'
'Base`2[System.Int32,V]
' Is this a generic type definition? False
' Is it a generic type? True
' Does it have unassigned generic parameters? True
' List type parameters (2):
' System.Int32
' V (unassigned - parameter position 0)
'
注解
GenericParameterPosition属性返回类型参数在最初定义该类型参数的泛型类型定义或泛型方法定义的参数列表中的位置。The GenericParameterPosition property returns the position of a type parameter in the parameter list of the generic type definition or generic method definition where the type parameter was originally defined. DeclaringType和 DeclaringMethod 属性标识泛型类型或方法定义:The DeclaringType and DeclaringMethod properties identify the generic type or method definition:
如果 DeclaringMethod 属性返回,则 MethodInfo MethodInfo 表示泛型方法定义,而当前 Type 对象表示泛型方法定义的类型参数。If the DeclaringMethod property returns a MethodInfo, that MethodInfo represents a generic method definition, and the current Type object represents a type parameter of that generic method definition.
如果 DeclaringMethod 属性返回
null,则 DeclaringType 属性始终返回 Type 表示泛型类型定义的对象,而当前 Type 对象表示该泛型类型定义的类型参数。If the DeclaringMethod property returnsnull, then the DeclaringType property always returns a Type object representing a generic type definition, and the current Type object represents a type parameter of that generic type definition.
若要为属性的值提供正确的上下文 GenericParameterPosition ,必须标识类型参数所属的泛型类型或方法。To provide the correct context for the value of the GenericParameterPosition property, it is necessary to identify the generic type or method a type parameter belongs to. 例如,请考虑以下代码中泛型方法的返回值 GetSomething :For example, consider the return value of the generic method GetSomething in the following code:
generic<typename T, typename U> public ref class B { };
generic<typename V> public ref class A
{
public:
generic<typename X> B<V, X>^ GetSomething()
{
return gcnew B<V, X>();
}
};
public class B<T, U> { }
public class A<V>
{
public B<V, X> GetSomething<X>()
{
return new B<V, X>();
}
}
Public Class B(Of T, U)
End Class
Public Class A(Of V)
Public Function GetSomething(Of X)() As B(Of V, X)
Return New B(Of V, X)()
End Function
End Class
返回的类型 GetSomething 取决于提供给类和自身的类型参数 A GetSomething 。The type returned by GetSomething depends on the type arguments supplied to class A and to GetSomething itself. 你可以获取的 MethodInfo GetSomething ,以及可以获取返回类型的。You can obtain a MethodInfo for GetSomething, and from that you can obtain the return type. 检查返回类型的类型参数时, GenericParameterPosition 对两者都返回0。When you examine the type parameters of the return type, GenericParameterPosition returns 0 for both. 的位置 V 为0,因为 V 是类的类型参数列表中的第一个类型参数 A 。The position of V is 0 because V is the first type parameter in the type parameter list for class A. 的位置 X 为0,因为 X 是的类型参数列表中的第一个类型参数 GetSomething 。The position of X is 0 because X is the first type parameter in the type parameter list for GetSomething.
备注
GenericParameterPosition如果当前不表示类型参数,则调用属性会导致异常 Type 。Calling the GenericParameterPosition property causes an exception if the current Type does not represent a type parameter. 检查开放式构造类型的类型参数时,请使用 IsGenericParameter 属性告诉它们是类型参数和类型。When you examine the type arguments of an open constructed type, use the IsGenericParameter property to tell which are type parameters and which are types. IsGenericParameter属性为 true 类型参数返回; 您可以使用 GenericParameterPosition 方法获取其位置,并使用 DeclaringMethod 和 DeclaringType 属性来确定定义它的泛型方法或类型定义。The IsGenericParameter property returns true for a type parameter; you can then use the GenericParameterPosition method to obtain its position and use the DeclaringMethod and DeclaringType properties to determine the generic method or type definition that defines it.