Partage via

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.

La documentation de référence du langage C# décrit la version la plus récente du langage C#. Il contient également la documentation initiale des fonctionnalités dans les préversions publiques pour la prochaine version du langage.

La documentation identifie toute fonctionnalité introduite en premier dans les trois dernières versions de la langue ou dans les préversions publiques actuelles.

Conseil / Astuce

Pour savoir quand une fonctionnalité a été introduite en C#, consultez l’article sur l’historique des versions du langage C#.

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. Cette condition 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

Utilisez l’opérateur as pour convertir explicitement le résultat d’une expression en type de valeur nullable ou référence donnée. 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 effectuer une conversion définie par l’utilisateur, utilisez une expression de 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
}

Note

Comme l’illustre l’exemple précédent, vous devez comparer le résultat de l’expression as pour null vérifier si la conversion a réussi. Vous pouvez utiliser l’opérateuris pour tester si la conversion réussit et, si elle réussit, affecter son résultat à une nouvelle variable.

Expression Cast

Une expression de cast du formulaire (T)E convertit explicitement le résultat de l’expression E en type T. Si aucune conversion explicite n’existe du type de E type en type T, le compilateur émet une erreur. 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 consiste à ajuster l’ordre dans lequel C# évalue 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 d’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 peut pas être un type qui nécessite des annotations de métadonnées. Voici quelques exemples de ces types :

  • 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, utilisez object. Au lieu de string?, utilisez 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 à l’aide de l’opérateur typeof et de 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

Vous ne pouvez pas surcharger les opérateurs et typeofasles isopérateurs.

Un type défini par l’utilisateur ne peut pas surcharger l’opérateur () , mais il peut définir des conversions de type personnalisées qu’une expression de cast effectue. 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# :

Voir aussi

  • Last updated on