Type.GenericParameterPosition Properti
Definisi
Penting
Beberapa informasi terkait produk prarilis yang dapat diubah secara signifikan sebelum dirilis. Microsoft tidak memberikan jaminan, tersirat maupun tersurat, sehubungan dengan informasi yang diberikan di sini.
Mendapatkan posisi parameter jenis dalam daftar parameter jenis jenis atau metode generik yang mendeklarasikan parameter, ketika Type objek mewakili parameter jenis jenis generik atau metode generik.
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 : intPublic MustOverride ReadOnly Property GenericParameterPosition As IntegerPublic Overridable ReadOnly Property GenericParameterPosition As IntegerNilai Properti
Posisi parameter jenis dalam daftar parameter jenis jenis atau metode generik yang menentukan parameter . Nomor posisi dimulai pada 0.
Pengecualian
Jenis saat ini tidak mewakili parameter jenis. Artinya, IsGenericParameter mengembalikan false.
Contoh
Contoh berikut mendefinisikan kelas generik dengan dua parameter jenis dan mendefinisikan kelas generik kedua yang berasal dari kelas pertama. Kelas dasar kelas turunan memiliki dua jenis argumen: yang pertama adalah Int32, dan yang kedua adalah parameter jenis dari jenis turunan. Contoh menampilkan informasi tentang kelas generik ini, termasuk posisi yang dilaporkan oleh GenericParameterPosition properti .
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)
*/
open System
open System.Reflection
open System.Collections.Generic
// Define a base class with two type parameters.
type Base<'T, 'U>() = class end
// 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.
type Derived<'V>() = inherit Base<int, 'V>()
let displayGenericTypeInfo (t: Type) =
printfn $"\n{t}"
printfn $"\tIs this a generic type definition? {t.IsGenericTypeDefinition}"
printfn $"\tIs it a generic type? {t.IsGenericType}"
printfn $"\tDoes it have unassigned generic parameters? {t.ContainsGenericParameters}"
if t.IsGenericType then
// If this is a generic type, display the type arguments.
let typeArguments = t.GetGenericArguments()
printfn $"\tList type arguments ({typeArguments.Length}):"
for tParam in typeArguments do
// IsGenericParameter is true only for generic type
// parameters.
if tParam.IsGenericParameter then
printfn $"\t\t{tParam} (unassigned - parameter position {tParam.GenericParameterPosition})"
else
printfn $"\t\t{tParam}"
printfn $"\r\n--- Display a generic type and the open constructed"
printfn $" 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.)
//
let derivedType = (typeof<Derived<_>>).GetGenericTypeDefinition()
displayGenericTypeInfo derivedType
// Display its open constructed base type.
displayGenericTypeInfo derivedType.BaseType
(* 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)
'
Keterangan
Properti GenericParameterPosition mengembalikan posisi parameter jenis dalam daftar parameter definisi jenis generik atau definisi metode generik tempat parameter jenis awalnya ditentukan. Properti DeclaringType dan DeclaringMethod mengidentifikasi jenis generik atau definisi metode:
DeclaringMethod Jika properti mengembalikan MethodInfo, yang MethodInfo mewakili definisi metode generik, dan objek saat ini Type mewakili parameter jenis dari definisi metode generik tersebut.
DeclaringMethod Jika properti mengembalikan
null, maka DeclaringType properti selalu mengembalikan objek yang Type mewakili definisi jenis generik, dan objek saat ini Type mewakili parameter jenis definisi jenis generik tersebut.
Untuk memberikan konteks yang benar untuk nilai GenericParameterPosition properti, perlu untuk mengidentifikasi jenis generik atau metode yang dimiliki parameter jenis. Misalnya, pertimbangkan nilai pengembalian metode GetSomething generik dalam kode berikut:
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>();
}
}
type B<'T, 'U>() = class end
type A<'V>() =
member _.GetSomething<'X>() =
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
Jenis yang dikembalikan oleh GetSomething tergantung pada argumen jenis yang disediakan ke kelas A dan ke GetSomething dirinya sendiri. Anda dapat memperoleh MethodInfo untuk GetSomething, dan dari itu Anda dapat memperoleh jenis pengembalian. Saat Anda memeriksa parameter jenis jenis pengembalian, GenericParameterPosition mengembalikan 0 untuk keduanya. Posisi V adalah 0 karena V merupakan parameter jenis pertama dalam daftar parameter jenis untuk kelas A. Posisi X adalah 0 karena X merupakan parameter jenis pertama dalam daftar parameter jenis untuk GetSomething.
Catatan
GenericParameterPosition Memanggil properti menyebabkan pengecualian jika saat ini Type tidak mewakili parameter jenis. Saat Anda memeriksa argumen jenis dari jenis yang dibangun terbuka, gunakan IsGenericParameter properti untuk mengetahui parameter jenis dan mana yang merupakan jenis. Properti IsGenericParameter mengembalikan true parameter jenis; Anda kemudian dapat menggunakan GenericParameterPosition metode untuk mendapatkan posisinya dan menggunakan DeclaringMethod properti dan DeclaringType untuk menentukan metode generik atau definisi jenis yang mendefinisikannya.
