Type.ContainsGenericParameters Propriété
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Obtient une valeur indiquant si l'objet Type actuel a des paramètres de type qui n'ont pas été remplacés par des types spécifiques.
public:
virtual property bool ContainsGenericParameters { bool get(); };public virtual bool ContainsGenericParameters { get; }member this.ContainsGenericParameters : boolPublic Overridable ReadOnly Property ContainsGenericParameters As BooleanValeur de propriété
true si l'objet Type est lui-même un paramètre de type générique ou a des paramètres de type pour lesquels les types spécifiques n'ont pas été fournis ; sinon, false.
Exemples
L’exemple suivant définit une classe générique avec deux paramètres de type, puis définit une deuxième classe générique qui dérive de la première classe. La classe de base de la classe dérivée a deux arguments de type : le premier est Int32 et le second est un paramètre de type du type dérivé. L’exemple affiche des informations sur ces classes génériques, y compris les positions signalées par la GenericParameterPosition propriété.
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)
'
Remarques
Pour créer une instance d’un type, il ne doit y avoir aucune définition de type générique ni aucun type construit ouvert dans les arguments de type du type lui-même, dans les types génériques englobants ou dans tous les éléments du type. Une autre façon de dire que, lorsqu’il est examiné de manière récursive, le type ne doit pas contenir de paramètres de type générique.
Étant donné que les types peuvent être arbitrairement complexes, cette détermination est difficile. Pour des raisons pratiques et pour réduire le risque d’erreur, la ContainsGenericParameters propriété fournit un moyen standard de distinguer les types construits fermés, qui peuvent être instanciés, et les types construits ouverts, qui ne le peuvent pas. Si la ContainsGenericParameters propriété retourne true , le type ne peut pas être instancié.
La ContainsGenericParameters propriété effectue une recherche de manière récursive pour les paramètres de type. par exemple, elle retourne true pour un tableau dont les éléments sont de type A<T> ( A(Of T) dans Visual Basic), même si le tableau n’est pas lui-même générique. Comparez ceci avec le comportement de la IsGenericType propriété, qui retourne false pour les tableaux.
Pour obtenir un ensemble d’exemples de classes et un tableau contenant les valeurs de la ContainsGenericParameters propriété, consultez IsGenericType .