Opérateurs de test de type et expression de cast (référence C#)

Vous pouvez utiliser les opérateurs et expressions suivants pour effectuer une vérification de type ou une conversion de type :

  • is, opérateur: pour vérifier si le type au moment de l’exécution d’une expression est compatible avec un type donné
  • opérateur as: pour convertir explicitement une expression en un type donné si son type au moment de l’exécution est compatible avec ce type
  • expression de cast: pour effectuer une conversion explicite
  • Opérateur typeof : pour obtenir l’instance de System.Type pour un type

Opérateur is

L' is opérateur vérifie si le type au moment de l’exécution d’un résultat d’expression est compatible avec un type donné. À compter de C# 7,0, l' is opérateur 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

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

L' is opérateur retourne true lorsqu’un résultat d’expression n’a pas la valeur null et que l’une des conditions suivantes est vraie :

  • Le type au moment de l’exécution d’un résultat d’expression est T .

  • Le type au moment de l’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 existe à T .

  • Le type au moment de l’exécution d’un résultat d’expression est un type valeur Nullable avec le type sous-jacent T et Nullable<T>.HasValue est true .

  • Une conversion boxing ou unboxing existe du type au moment de l’exécution d’un résultat d’expression en type T .

L’opérateur is ne considère pas les conversions définies par l’utilisateur.

L’exemple suivant montre que l' is opérateur retourne true si le type au moment de l’exécution d’un résultat d’expression dérive d’un type donné, autrement dit, 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' is opérateur prend en compte les conversions boxing et unboxing, mais ne prend pas en compte les 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

À compter de C# 7,0, l' is opérateur 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 patterns.

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 n’est pas possible, l’opérateur as retourne null. Contrairement à une expression de cast, l' as opérateur ne lève jamais d’exception.

L’expression de la forme

E as T

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

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

sauf que E n’est évalué qu’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 de cast.

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

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

Notes

Comme le montre l’exemple précédent, vous devez comparer le résultat de l’expression as avec null pour vérifier si la conversion a réussi. À compter de C# 7,0, vous pouvez utiliser l' opérateur is pour tester si la conversion aboutit et, si elle aboutit, assigner son résultat à une nouvelle variable.

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

IEnumerable<int> numbers = new int[] { 10, 20, 30 };
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#.

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]

Vous pouvez également utiliser l' typeof opérateur 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' System.Type instance du type au moment de l’exécution d’un résultat d’expression, utilisez la Object.GetType méthode.

Test de type avec l’opérateur typeof

Utilisez l' typeof opérateur 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 des types effectuée avec l’opérateur typeofl’opérateur is :

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 is as opérateurs, et typeof ne peuvent pas être surchargés.

Un type défini par l’utilisateur ne peut pas surcharger l’opérateur (), mais vous pouvez définir des conversions de type personnalisées qui peuvent être effectuées par une expression 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# :

Voir aussi