Type.ContainsGenericParameters Właściwość
Definicja
Ważne
Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.
Pobiera wartość wskazującą, czy bieżący obiekt ma parametry typu, które nie Type zostały zastąpione przez określone typy.
public:
virtual property bool ContainsGenericParameters { bool get(); };public virtual bool ContainsGenericParameters { get; }member this.ContainsGenericParameters : boolPublic Overridable ReadOnly Property ContainsGenericParameters As BooleanWartość właściwości
true Jeśli obiekt jest sam parametrem typu ogólnego lub ma parametry typu, dla których nie podano określonych Type typów; w przeciwnym razie false .
Przykłady
W poniższym przykładzie zdefiniowano ogólną klasę z dwoma parametrami typu, a następnie zdefiniowano drugą klasę ogólną pochodzącą od pierwszej klasy. Klasa bazowa klasy pochodnej ma dwa argumenty typu: pierwszy to, a drugi to parametr typu Int32 typu pochodnego. W przykładzie są wyświetlane informacje o tych klasach ogólnych, w tym pozycje zgłoszone przez GenericParameterPosition właściwość .
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)
'
Uwagi
Aby utworzyć wystąpienie typu, nie może być żadnych definicji typów ogólnych ani otwartych skonstruowanych typów w argumentach typu samego typu, w jakichkolwiek otaczających typach ogólnych lub we wszystkich elementach typu. Innym sposobem jest stwierdzenie, że w przypadku badania rekursywnie typ nie może zawierać parametrów typu ogólnego.
Ponieważ typy mogą być dowolnie złożone, utrudnia to określenie. Aby zwiększyć wygodę i zmniejszyć prawdopodobieństwo wystąpienia błędu, właściwość zapewnia standardowy sposób rozróżniania zamkniętych typów skonstruowanych, które mogą być konstruowane, a typami skonstruowanymi jako otwarte, a których nie ContainsGenericParameters można utworzyć. Jeśli właściwość ContainsGenericParameters zwróci wartość , nie można utworzyć wystąpienia true typu.
Właściwość ContainsGenericParameters rekursywnie wyszukuje parametry typu. Na przykład zwraca wartość dla tablicy, której elementy są typu ( w true A<T> A(Of T) Visual Basic), nawet jeśli tablica nie jest sama w sobie ogólną. Porównaj to z zachowaniem IsGenericType właściwości , która zwraca wartość dla false tablic.
Aby uzyskać zestaw przykładowych klas i tabelę pokazującą wartości ContainsGenericParameters właściwości, zobacz IsGenericType .