Cette page vous a-t-elle été utile ?
Votre avis sur ce contenu est important. N'hésitez pas à nous faire part de vos commentaires.
Vous avez d'autres commentaires ?
1500 caractères restants
Exporter (0) Imprimer
Développer tout
Développer Réduire
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

Type.ContainsGenericParameters, propriété

Obtient une valeur indiquant si l'objet Type actif a des paramètres de type qui n'ont pas été remplacés par des types spécifiques.

Espace de noms :  System
Assembly :  mscorlib (dans mscorlib.dll)

public virtual bool ContainsGenericParameters { get; }

Valeur de propriété

Type : System.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.

Pour créer une instance d'un type, il ne doit pas y avoir de définition de type générique ni de types construits ouverts dans les arguments de type du type lui-même, dans aucun type générique englobant, ni dans aucun élément du type. En d'autres termes, lorsqu'il est examiné itérativement, le type ne doit contenir aucun paramètre de type générique.

Comme les types peuvent être arbitrairement complexes, cette détermination est difficile. Par commodité et pour réduire les possibilités d'erreur, la propriété ContainsGenericParameters offre un moyen standard de distinguer les types construits fermés, qui peuvent être instanciés, des types construits ouverts qui ne le peuvent pas. Si la propriété ContainsGenericParameters retourne true, le type ne peut pas être instancié.

La propriété ContainsGenericParameters recherche itérativement des paramètres de type. Par exemple, elle retourne la valeur true pour un tableau dont les éléments sont du type A<T> (A(Of T) en Visual Basic), bien que le tableau ne soit pas lui-même générique. Comparez cela avec le comportement de la propriété IsGenericType qui retourne la valeur false pour les tableaux.

Pour obtenir un ensemble de classes d'exemple et un tableau affichant les valeurs de la propriété ContainsGenericParameters, consultez IsGenericType.

L'exemple suivant définit une classe générique avec deux paramètres de type, puis une deuxième classe générique qui en dérive. La classe de base de la classe dérivée a deux arguments de type : le premier est Int32 et le deuxième 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 rapportées par la propriété GenericParameterPosition.


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


.NET Framework

Pris en charge dans : 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Bibliothèque de classes portable

Pris en charge dans : Bibliothèque de classes portable

.NET pour les applications Windows Phone

Pris en charge dans : Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Ajouts de la communauté

AJOUTER
Afficher:
© 2015 Microsoft