Opérateurs de test de type et expressions de cast : is, astypeof et casts

Ces opérateurs et expressions effectuent un contrôle ou une conversion de type. L’isopérateur vérifie si le type d’exécution d’une expression est compatible avec un type donné. L’asopérateur convertit explicitement une expression en un type donné si son type d’exécution est compatible avec ce type. Les expressions de cast effectuent une conversion explicite en un type cible. L’typeof obtient l’instance System.Type pour un type.

L’opérateur is

L’opérateur is vérifie si le type d’un résultat d’expression est compatible avec un type donné. L’opérateur is teste également un résultat d’expression par rapport à un modèle.

L’expression avec l’opérateur de test de type is a la forme suivante

E is T

Où E est une expression qui retourne une valeur et T est le nom d’un type ou d’un paramètre de type. E ne peut pas être une méthode anonyme ou une expression lambda.

L’opérateur is renvoie true lorsqu’un résultat d’expression n’est pas nul et que l’une des conditions suivantes est remplie :

• Le type d’exécution d’un résultat d’expression a un conversion d'identité vers T.

• Le type d’exécution d’un résultat d’expression dérive du type T, implémente l’interface T, ou une autre conversion de référence implicite en T existe à partir de celui-ci. Cela couvre les relations d’héritage et les implémentations d’interface.

• Le type d’exécution d’un résultat d’expression est un type valeur pouvant accepter la valeur Null avec le type sous-jacent T, et Nullable<T>.HasValue est true.

• Il existe une conversion boxing ou unboxing du type d’exécution du résultat d’une expression vers le type T lorsque l'expression n'est pas une instance d'une ref struct.

L’opérateur is ne prend pas en compte les conversions définies par l’utilisateur ou les conversions d’étendue implicites.

L’exemple suivant montre que l’opérateur is renvoie true si le type d’exécution d’un résultat d’expression dérive d’un type donné, autrement dit, s’il existe une conversion de référence entre les types :

public class Base { }

public class Derived : Base { }

public static class IsOperatorExample
{
    public static void Main()
    {
        object b = new Base();
        Console.WriteLine(b is Base);  // output: True
        Console.WriteLine(b is Derived);  // output: False

        object d = new Derived();
        Console.WriteLine(d is Base);  // output: True
        Console.WriteLine(d is Derived); // output: True
    }
}

L’exemple suivant montre que l’opérateur is prend en compte les conversions boxing et unboxing mais ne tient pas compte des conversions numériques :

int i = 27;
Console.WriteLine(i is System.IFormattable);  // output: True

object iBoxed = i;
Console.WriteLine(iBoxed is int);  // output: True
Console.WriteLine(iBoxed is long);  // output: False

Pour plus d’informations sur les conversions C#, consultez le chapitre Conversions de la Spécification du langage C#.

Test de type avec des critères spéciaux

L’opérateur is teste également un résultat d’expression par rapport à un modèle. L’exemple suivant montre comment utiliser un modèle de déclaration pour vérifier le type d’exécution d’une expression :

int i = 23;
object iBoxed = i;
int? jNullable = 7;
if (iBoxed is int a && jNullable is int b)
{
    Console.WriteLine(a + b);  // output 30
}

Pour plus d’informations sur les modèles pris en charge, consultez Modèles.

L’opérateur as

L’opérateur as convertit explicitement le résultat d’une expression en un type de valeur de référence ou nullable. Si la conversion est impossible, l’opérateur as renvoie null. Contrairement à une expression cast, l’opérateur as ne lève jamais d’exception.

L’expression de la forme

E as T

Où E est une expression qui retourne une valeur et T est le nom d’un type ou d’un paramètre de type, produit le même résultat que

E is T ? (T)(E) : (T)null

Sauf que E est évalué une seule fois.

L’opérateur as envisage uniquement les conversions de référence, nullable, boxing et unboxing. Vous ne pouvez pas utiliser l’opérateur as pour effectuer une conversion définie par l’utilisateur. Pour ce faire, utilisez une expression cast.

L’exemple suivant illustre l’utilisation de l’opérateur as :

IEnumerable<int> numbers = new List<int>(){10, 20, 30};
IList<int> indexable = numbers as IList<int>;
if (indexable != null)
{
    Console.WriteLine(indexable[0] + indexable[indexable.Count - 1]);  // output: 40
}

Expression Cast

Une expression cast de la forme (T)E effectue une conversion explicite du résultat de l’expression E en type T. S’il n’existe aucune conversion explicite du type de E en type T, une erreur de compilation se produit. Au moment de l’exécution, une conversion explicite peut ne pas réussir, et une expression cast peut lever une exception.

L’exemple suivant montre des conversions numériques et de référence explicites :

double x = 1234.7;
int a = (int)x;
Console.WriteLine(a);   // output: 1234

int[] ints = [10, 20, 30];
IEnumerable<int> numbers = ints;
IList<int> list = (IList<int>)numbers;
Console.WriteLine(list.Count);  // output: 3
Console.WriteLine(list[1]);  // output: 20

Pour plus d’informations sur les conversions explicites prises en charge, consultez la section Conversions explicites de la Spécification du langage C#. Pour plus d’informations sur la façon de définir une conversion de type explicite ou implicite personnalisée, consultez Opérateurs de conversion définie par l’utilisateur.

Autres utilisations de ()

Vous pouvez aussi utiliser des parenthèses pour appeler une méthode ou un délégué.

Une autre utilisation des parenthèses est d’ajuster l’ordre dans lequel évaluer les opérations dans une expression. Pour plus d’informations, consultez Opérateurs C#.

L’opérateur typeof

L’opérateur typeof obtient l’instance System.Type pour un type. L’argument de l’opérateur typeof doit avoir le nom d’un type ou d’un paramètre de type, comme le montre l’exemple suivant :

void PrintType<T>() => Console.WriteLine(typeof(T));

Console.WriteLine(typeof(List<string>));
PrintType<int>();
PrintType<System.Int32>();
PrintType<Dictionary<int, char>>();
// Output:
// System.Collections.Generic.List`1[System.String]
// System.Int32
// System.Int32
// System.Collections.Generic.Dictionary`2[System.Int32,System.Char]

L’argument ne doit pas être un type qui nécessite des annotations de métadonnées. Les types suivants en sont des exemples :

• dynamic
• string? (ou tout type référence Nullable)

Ces types ne sont pas directement représentés dans les métadonnées. Les types comprennent des attributs qui décrivent le type sous-jacent. Dans les deux cas, vous pouvez utiliser le type sous-jacent. Au lieu de dynamic, vous pouvez utiliser object. Au lieu de string?, vous pouvez utiliser string.

Vous pouvez également utiliser l’opérateur typeof avec des types génériques indépendants. Le nom d’un type générique indépendant doit contenir le nombre approprié de virgules, à savoir une de moins que le nombre de paramètres de type. L’exemple suivant illustre l’utilisation de l’opérateur typeof avec un type générique indépendant :

Console.WriteLine(typeof(Dictionary<,>));
// Output:
// System.Collections.Generic.Dictionary`2[TKey,TValue]

Une expression ne peut pas être un argument de l’opérateur typeof. Pour obtenir l’instance System.Type du type d’exécution d’un résultat d’expression, utilisez la méthode Object.GetType.

Test de type avec l’opérateur typeof

Utilisez l’opérateur typeof pour vérifier si le type d’exécution du résultat de l’expression correspond exactement à un type donné. L’exemple suivant illustre la différence entre la vérification de type effectuée avec l’opérateur typeof et l’opérateuris :

public class Animal { }

public class Giraffe : Animal { }

public static class TypeOfExample
{
    public static void Main()
    {
        object b = new Giraffe();
        Console.WriteLine(b is Animal);  // output: True
        Console.WriteLine(b.GetType() == typeof(Animal));  // output: False

        Console.WriteLine(b is Giraffe);  // output: True
        Console.WriteLine(b.GetType() == typeof(Giraffe));  // output: True
    }
}

Capacité de surcharge de l’opérateur

Les opérateurs is, as et typeof ne peuvent pas être surchargés.

Un type défini par l’utilisateur ne peut pas surcharger l’opérateur () , mais peut définir des conversions de types personnalisées effectuées par une expression de cast. Pour plus d’informations, consultez Opérateurs de conversion définie par l’utilisateur.

spécification du langage C#

Pour plus d’informations, consultez les sections suivantes de la spécification du langage C# :

• L'opérateur is
• L'opérateur as
• Expressions de cast
• L'opérateur typeof

Voir aussi

• Opérateurs et expressions C#
• Guide pratique pour effectuer des casts de manière sécurisée avec les critères spéciaux, ainsi que les opérateurs is et as
• Génériques en .NET