Type.ContainsGenericParameters Propriété

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Assembly:

netstandard.dll

Assembly:

mscorlib.dll

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.

C#

public virtual bool ContainsGenericParameters { get; }

Valeur de propriété

Boolean

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é.

C#

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)
 */

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 .

S’applique à

Voir aussi

• ContainsGenericParameters
• IsGenericTypeDefinition
• MakeGenericType(Type[])
• Réflexion et types génériques
• Guide pratique pour examiner et instancier des types génériques avec la réflexion