is (référence C#)is (C# Reference)

Vérifie si un objet est compatible avec un type donné, ou (avec C# 7.0) teste une expression par rapport à un modèle.Checks if an object is compatible with a given type, or (starting with C# 7.0) tests an expression against a pattern.

Test de compatibilité de typeTesting for type compatibility

Le mot clé is évalue la compatibilité de type au moment de l’exécution.The is keyword evaluates type compatibility at runtime. Il détermine si une instance d’objet ou le résultat d’une expression peuvent être convertis en un type spécifié.It determines whether an object instance or the result of an expression can be converted to a specified type. Sa syntaxe estIt has the syntax

   expr is type

expr est une expression qui correspond à une instance d’un type, et où type est le nom du type dans lequel le résultat de expr doit être converti.where expr is an expression that evaluates to an instance of some type, and type is the name of the type to which the result of expr is to be converted. L’instruction is est true si expr est non-Null et si l’objet qui résulte de l’évaluation de l’expression peut être converti en type ; sinon, elle retourne false.The is statement is true if expr is non-null and the object that results from evaluating the expression can be converted to type; otherwise, it returns false.

Par exemple, le code suivant détermine si obj peut être casté en une instance de type Person :For example, the following code determines if obj can be cast to an instance of the Person type:

if (obj is Person) {
   // Do something if obj is a Person.
}

L’instruction is a la valeur true si :The is statement is true if:

  • expr est une instance du même type que type.expr is an instance of the same type as type.

  • expr est une instance d’un type qui dérive de type.expr is an instance of a type that derives from type. En d’autres termes, le résultat de expr peut être upcasté en une instance de type.In other words, the result of expr can be upcast to an instance of type.

  • expr a un type au moment de la compilation qui est une classe de base de type et expr a un type au moment de l’exécution égal à type ou dérivé de type.expr has a compile-time type that is a base class of type, and expr has a runtime type that is type or is derived from type. Le type au moment de la compilation d’une variable est le type de la variable, tel qu’il est défini dans sa déclaration.The compile-time type of a variable is the variable's type as defined in its declaration. Le type au moment de l’exécution d’une variable est le type de l’instance qui est assignée à cette variable.The runtime type of a variable is the type of the instance that is assigned to that variable.

  • expr est une instance d’un type qui implémente l’interface type.expr is an instance of a type that implements the type interface.

L’exemple suivant montre que l’expression is a la valeur true pour chacune de ces conversions.The following example shows that the is expression evaluates to true for each of these conversions.

using System;

public class Class1 : IFormatProvider
{
   public object GetFormat(Type t)
   {
      if (t.Equals(this.GetType()))      
         return this;
      return null;
   }
}

public class Class2 : Class1
{
   public int Value { get; set; }
}

public class Example
{
   public static void Main()
   {
      var cl1 = new Class1();
      Console.WriteLine(cl1 is IFormatProvider);
      Console.WriteLine(cl1 is Object);
      Console.WriteLine(cl1 is Class1);
      Console.WriteLine(cl1 is Class2); 
      Console.WriteLine();
 
      var cl2 = new Class2();
      Console.WriteLine(cl2 is IFormatProvider);
      Console.WriteLine(cl2 is Class2);
      Console.WriteLine(cl2 is Class1);
      Console.WriteLine();
      
      Class1 cl = cl2;
      Console.WriteLine(cl is Class1);
      Console.WriteLine(cl is Class2);
   }
}
// The example displays the following output:
//     True
//     True
//     True
//     False
//     
//     True
//     True
//     True
//     
//     True
//     True

Le mot clé is génère un avertissement au moment de la compilation si l’expression est connue pour être toujours soit true, soit false.The is keyword generates a compile-time warning if the expression is known to always be either true or false. Il tient compte uniquement des conversions de référence, des conversions boxing et des conversions unboxing. Il ne tient pas compte des conversions définies par l’utilisateur ni des conversions définies par les opérateurs implicit et explicit d’un type.It only considers reference conversions, boxing conversions, and unboxing conversions; it does not consider user-defined conversions or conversions defined by a type's implicit and explicit operators. L’exemple suivant génère des avertissements, car le résultat de la conversion est connu au moment de la compilation.The following example generates warnings because the result of the conversion is known at compile-time. Notez que l’expression is pour les conversions de int à long et double retourne la valeur false, puisque ces conversions sont gérées par l’opérateur implicit.Note that the is expression for conversions from int to long and double return false, since these conversions are handled by the implicit operator.

Console.WriteLine(3 is int);
Console.WriteLine();

int value = 6;
Console.WriteLine(value is long);
Console.WriteLine(value is double);
Console.WriteLine(value is object);
Console.WriteLine(value is ValueType);
Console.WriteLine(value is int);
// Compilation generates the following compiler warnings:
//   is2.cs(8,25): warning CS0183: The given expression is always of the provided ('int') type
//   is2.cs(12,25): warning CS0184: The given expression is never of the provided ('long') type
//   is2.cs(13,25): warning CS0184: The given expression is never of the provided ('double') type
//   is2.cs(14,25): warning CS0183: The given expression is always of the provided ('object') type
//   is2.cs(15,25): warning CS0183: The given expression is always of the provided ('ValueType') type
//   is2.cs(16,25): warning CS0183: The given expression is always of the provided ('int') type

expr peut correspondre à toute expression qui retourne une valeur, à l’exception des méthodes anonymes et des expressions lambda.expr can be any expression that returns a value, with the exception of anonymous methods and lambda expressions. L’exemple suivant utilise is pour évaluer la valeur de retour d’un appel de méthode.The following example uses is to evaluate the return value of a method call.

using System;

public class Example
{
   public static void Main()
   {
      double number1 = 12.63; 
      if (Math.Ceiling(number1) is double)
         Console.WriteLine("The expression returns a double.");
      else if (Math.Ceiling(number1) is decimal)    
         Console.WriteLine("The expression returns a decimal.");

      decimal number2 = 12.63m; 
      if (Math.Ceiling(number2) is double)
         Console.WriteLine("The expression returns a double.");
      else if (Math.Ceiling(number2) is decimal)    
         Console.WriteLine("The expression returns a decimal.");

   }
}
// The example displays the following output:
//     The expression returns a double.
//     The expression returns a decimal.

Avec C# 7.0, vous pouvez utiliser les critères spéciaux avec le modèle de type pour écrire du code plus concis qui utilise l’instruction is.Starting with C# 7.0, you can use pattern matching with the type pattern to write more concise code that uses the is statement.

Utilisation des critères spéciaux avec isPattern matching with is

À compter de C# 7.0, les instructions is et switch prennent en charge les critères spéciaux.Starting with C# 7.0, the is and switch statements support pattern matching. Le mot clé is prend en charge les modèles suivants :The is keyword supports the following patterns:

  • Modèle de type : permet de tester si une expression peut être convertie en un type spécifié et, si tel est le cas, caste l’expression en une variable de ce type.Type pattern, which tests whether an expression can be converted to a specified type and, if it can be, casts it to a variable of that type.

  • Modèle de constante : teste si une expression correspond à une valeur de constante spécifiée.Constant pattern, which tests whether an expression evaluates to a specified constant value.

  • Modèle de variable : correspondance qui réussit toujours et lie la valeur d’une expression à une variable locale.var pattern, a match that always succeeds and binds the value of an expression to a new local variable.

Modèle de type Type pattern

Lorsque vous utilisez le modèle de type pour rechercher des critères spéciaux, is permet de tester si une expression peut être convertie en un type spécifié et, si tel est le cas, effectuer un cast de l’expression en une variable de ce type.When using the type pattern to perform pattern matching, is tests whether an expression can be converted to a specified type and, if it can be, casts it to a variable of that type. Il s’agit d’une extension simple de l’instruction is qui permet une évaluation et une conversion de type concises.It is a straightforward extension of the is statement that enables concise type evaluation and conversion. La forme générale du modèle de type is est la suivante :The general form of the is type pattern is:

   expr is type varname 

expr est une expression qui correspond à une instance d’un type, où type est le nom du type dans lequel le résultat de expr doit être converti, et où varname est l’objet dans lequel le résultat de expr est converti si le test is a la valeur true.where expr is an expression that evaluates to an instance of some type, type is the name of the type to which the result of expr is to be converted, and varname is the object to which the result of expr is converted if the is test is true.

L’expression is est true si expr n’est pas null et que l’un des énoncés suivants est vrai :The is expression is true if expr is not null, and any of the following is true:

  • expr est une instance du même type que type.expr is an instance of the same type as type.

  • expr est une instance d’un type qui dérive de type.expr is an instance of a type that derives from type. En d’autres termes, le résultat de expr peut être upcasté en une instance de type.In other words, the result of expr can be upcast to an instance of type.

  • expr a un type au moment de la compilation qui est une classe de base de type et expr a un type au moment de l’exécution égal à type ou dérivé de type.expr has a compile-time type that is a base class of type, and expr has a runtime type that is type or is derived from type. Le type au moment de la compilation d’une variable est le type de la variable, tel qu’il est défini dans sa déclaration.The compile-time type of a variable is the variable's type as defined in its declaration. Le type au moment de l’exécution d’une variable est le type de l’instance qui est assignée à cette variable.The runtime type of a variable is the type of the instance that is assigned to that variable.

  • expr est une instance d’un type qui implémente l’interface type.expr is an instance of a type that implements the type interface.

Si exp est true et que is est utilisé avec une instruction if, varname est assigné et sa portée locale se limite à l’instruction if.If expr is true and is is used with an if statement, varname is assigned and has local scope within the if statement only.

L’exemple suivant utilise le modèle de type is pour fournir l’implémentation de la méthode IComparable.CompareTo(Object) d’un type.The following example uses the is type pattern to provide the implementation of a type's IComparable.CompareTo(Object) method.

using System;

public class Employee : IComparable
{
    public String Name { get; set; }
    public int Id { get; set; }

    public int CompareTo(Object o)
    {
        if (o is Employee e)
        {
            return Name.CompareTo(e.Name);
        }
        throw new ArgumentException("o is not an Employee object.");
    }
}

Sans critères spéciaux, ce code peut être écrit comme suit.Without pattern matching, this code might be written as follows. L’utilisation de critères spéciaux de type génère un code lisible plus compact en éliminant la nécessité de tester si le résultat d’une conversion est un null.The use of type pattern matching produces more compact, readable code by eliminating the need to test whether the result of a conversion is a null.

using System;

public class Employee : IComparable
{
    public String Name { get; set; }
    public int Id { get; set; }

    public int CompareTo(Object o)
    {
        var e = o as Employee;
        if (e == null)
        {
           throw new ArgumentException("o is not an Employee object.");
        }
        return Name.CompareTo(e.Name);
    }
}

Le modèle de type is génère également du code plus compact lorsqu’il détermine le type d’un type valeur.The is type pattern also produces more compact code when determining the type of a value type. L’exemple suivant utilise le modèle de type is pour déterminer si un objet est une instance Person ou Dog avant d’afficher la valeur d’une propriété appropriée.The following example uses the is type pattern to determine whether an object is a Person or a Dog instance before displaying the value of an appropriate property.

using System;

public class Example
{
   public static void Main()
   {
      Object o = new Person("Jane");
      ShowValue(o);
      
      o = new Dog("Alaskan Malamute");
      ShowValue(o);
   }

   public static void ShowValue(object o)
   {
      if (o is Person p) {
         Console.WriteLine(p.Name);
      }   
      else if (o is Dog d) {
         Console.WriteLine(d.Breed);
      }             
   }
}

public struct Person
{  
   public string Name { get; set; }
   
   public Person(string name) : this()
   {
      Name = name;
   }
}

public struct Dog
{
   public string Breed { get; set; }

   public Dog(string breedName) : this()
   {
      Breed = breedName;
   }
}
// The example displays the following output:
//	Jane
//	Alaskan Malamute

Le code équivalent sans critères spéciaux nécessite une attribution distincte comprenant un cast explicite.The equivalent code without pattern matching requires a separate assignment that includes an explicit cast.

using System;

public class Example
{
   public static void Main()
   {
      Object o = new Person("Jane");
      ShowValue(o);
      
      o = new Dog("Alaskan Malamute");
      ShowValue(o);
   }

   public static void ShowValue(object o)
   {
      if (o is Person) {
         Person p = (Person) o;
         Console.WriteLine(p.Name);
      }   
      else if (o is Dog) {
         Dog d = (Dog) o;
         Console.WriteLine(d.Breed);
      }             
   }
}

public struct Person
{  
   public string Name { get; set; }
   
   public Person(string name) : this()
   {
      Name = name;
   }
}

public struct Dog
{
   public string Breed { get; set; }

   public Dog(string breedName) : this()
   {
      Breed = breedName;
   }
}
// The example displays the following output:
//       Jane
//       Alaskan Malamute

Modèle de constante Constant pattern

Lorsque vous utilisez des critères spéciaux avec le modèle de constante, is teste si une expression est égale à une constante spécifiée.When performing pattern matching with the constant pattern, is tests whether an expression equals a specified constant. Avec C# 6 et les versions antérieures, le modèle de constante est pris en charge par l’instruction switch.In C# 6 and earlier versions, the constant pattern is supported by the switch statement. À compter de C# 7.0, ce modèle est également pris en charge par l’instruction is.Starting with C# 7.0, it is supported by the is statement as well. Sa syntaxe est la suivante :Its syntax is:

   expr is constant

expr est l’expression à évaluer, et où constant est la valeur à tester.where expr is the expression to evaluate, and constant is the value to test for. constant peut correspondre à l’une des expressions constantes suivantes :constant can be any of the following constant expressions:

  • Une valeur littéraleA literal value.

  • Le nom d’une variable const déclaréeThe name of a declared const variable.

  • Une constante d’énumérationAn enumeration constant.

L’expression constante est évaluée de la manière suivante :The constant expression is evaluated as follows:

  • Si expr et constant sont des types intégraux, l’opérateur d’égalité C# détermine si l’expression retourne true (autrement dit, si expr == constant).If expr and constant are integral types, the C# equality operator determines whether the expression returns true (that is, whether expr == constant).

  • Sinon, la valeur de l’expression est déterminée par un appel à la méthode statique Object.Equals(expr, constant).Otherwise, the value of the expression is determined by a call to the static Object.Equals(expr, constant) method.

L’exemple suivant combine le modèle de type et le modèle de constante pour tester si un objet est une instance Dice et, si c’est le cas, pour déterminer si la valeur obtenue après un lancer de dés est de 6.The following example combines the type and constant patterns to test whether an object is a Dice instance and, if it is, to determine whether the value of a dice roll is 6.

using System;

public class Dice
{
    Random rnd = new Random();
    public Dice()
    {

    }
    public int Roll()
    {
        return rnd.Next(1, 7); 
    }
}

class Program
{
    static void Main(string[] args)
    {
        var d1 = new Dice();
        ShowValue(d1);
    }

    private static void ShowValue(object o)
    {
        const int HIGH_ROLL = 6;

        if (o is Dice d && d.Roll() is HIGH_ROLL)
            Console.WriteLine($"The value is {HIGH_ROLL}!");
        else
            Console.WriteLine($"The dice roll is not a {HIGH_ROLL}!");
     }
}
// The example displays output like the following:
//      The value is 6!

Modèle de variable var pattern

Une recherche de critères spéciaux qui utilise le modèle de variable réussit toujours.A pattern match with the var pattern always succeeds. Sa syntaxe est la suivante :Its syntax is

   expr is var varname

où la valeur de expr est toujours assignée à une variable locale nommée varname.where the value of expr is always assigned to a local variable named varname. varname est une variable statique du même type que expr.varname is a static variable of the same type as expr. L’exemple suivant utilise le modèle de variable pour assigner une expression à une variable nommée obj.The following example uses the var pattern to assign an expression to a variable named obj. Il affiche ensuite la valeur et le type de obj.It then displays the value and the type of obj.

using System;

class Program
{
    static void Main()
   {
      object[] items = { new Book("The Tempest"), new Person("John") };
      foreach (var item in items) {
        if (item is var obj)
          Console.WriteLine($"Type: {obj.GetType().Name}, Value: {obj}"); 
      }
   }
}

class Book
{
    public Book(string title) 
    {
       Title = title;    
    }

    public string Title { get; set; }

    public override string ToString()
    {
       return Title;
    }
}

class Person
{
   public Person(string name)
   {
      Name = name;
   }

   public string Name 
   { get; set; }

   public override string ToString()
   {
      return Name;
   }
}
// The example displays the following output:
//       Type: Book, Value: The Tempest
//       Type: Person, Value: John

Notez que si expr est null, l’expression is a toujours la valeur true et attribue null à varname.Note that if expr is null, the is expression still is true and assigns null to varname.

Spécification du langage C#C# Language Specification

Pour plus d'informations, voir la spécification du langage C#.For more information, see the C# Language Specification. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.The language specification is the definitive source for C# syntax and usage.

Voir aussiSee also

Référence C#C# Reference
Mots clés C#C# Keywords
typeoftypeof
asas
Mots clés des opérateursOperator Keywords