Partager via

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

  • Article

Ces opérateurs et expressions effectuent un contrôle ou une conversion de type. L’isopérateur vérifie si le type à l’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 à l’exécution est compatible avec ce type. Les expressions cast effectuent une conversion explicite en un type cible. L’typeofopérateur obtient l’instance System.Type pour un type.

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 un 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 :

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

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.

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 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 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
}

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. Vous pouvez utiliser l’opérateur is pour tester si la conversion réussit et, si tel est le cas, pour affecter 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

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

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 les contrôles de type effectués avec l’opérateur typeof et l’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 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 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