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 la vérification de type ou la conversion de type :

Opérateur is

L’opérateur is vérifie si le type d’exécution 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

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 retourne true lorsqu’un résultat d’expression n’est pas null et que l’une des conditions suivantes est vraie :

  • Le type d’exécution d’un résultat d’expression est T.

  • Le type d’exécution d’un résultat d’expression dérive du type T, implémente l’interface Tou une autre conversion de référence implicite existe de celui-ci en T.

  • Le type d’exécution d’un résultat d’expression est un type valeur nullable avec le type T sous-jacent et l’est Nullable<T>.HasValuetrue.

  • Une conversion boxing ou unboxing existe du type d’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’opérateur is retourne true si le type d’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’opérateur is 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

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 n’est pas possible, l’opérateur as retourne null. Contrairement à une expression de cast, l’opérateur as 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 pour effectuer une conversion définie par l’utilisateur as . 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. Vous pouvez utiliser l’opérateur is à la fois pour tester si la conversion réussit et, si elle réussit, 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

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]

L’argument ne doit pas être un type qui nécessite des annotations de métadonnées. Voici quelques 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 incluent des attributs qui décrivent le type sous-jacent. Dans les deux cas, vous pouvez utiliser le type sous-jacent. Au lieu de dynamiccela, vous pouvez utiliser object. Au lieu de string?cela, 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 Object.GetType méthode.

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é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 isopérateurs , aset typeof les opérateurs 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 type personnalisées qui peuvent être 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# :

Voir aussi