is (Referencia de C#)is (C# Reference)

Comprueba si un objeto es compatible con un tipo determinado o, a partir de C# 7.0, prueba una expresión en un patrón.Checks if an object is compatible with a given type, or (starting with C# 7.0) tests an expression against a pattern.

Probar la compatibilidad de tiposTesting for type compatibility

La palabra clave is evalúa la compatibilidad de tipos en tiempo de ejecución.The is keyword evaluates type compatibility at runtime. Determina si una instancia de objeto o el resultado de una expresión se puede convertir en un tipo especificado.It determines whether an object instance or the result of an expression can be converted to a specified type. Tiene la sintaxisIt has the syntax

   expr is type

en la que expr es una expresión que se evalúa como una instancia de un tipo y type es el nombre del tipo en el que se va a convertir el resultado de expr.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. La instrucción is es true si expr no es NULL y el objeto resultado de la evaluación de la expresión se pueden convertir en type. En caso contrario, devuelve 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.

Por ejemplo, el código siguiente determina si obj se puede convertir en una instancia del tipo 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.
}

La instrucción is es verdadera si:The is statement is true if:

  • expr es una instancia del mismo tipo que type.expr is an instance of the same type as type.

  • expr es una instancia de un tipo que deriva de type.expr is an instance of a type that derives from type. En otras palabras, el resultado de expr puede convertirse en una instancia de type.In other words, the result of expr can be upcast to an instance of type.

  • expr tiene un tipo en tiempo de compilación que es una clase base de type y expr tiene un tipo en tiempo de ejecución que es type o se deriva 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. El tipo en tiempo de compilación de una variable es el tipo de la variable tal como se define en su declaración.The compile-time type of a variable is the variable's type as defined in its declaration. El tipo en tiempo de ejecución de una variable es el tipo de la instancia que se asigna a esa variable.The runtime type of a variable is the type of the instance that is assigned to that variable.

  • expr es una instancia de un tipo que implementa la interfaz type.expr is an instance of a type that implements the type interface.

En el ejemplo siguiente se muestra que la expresión is se evalúa como true para cada una de estas conversiones.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

La palabra clave is genera una advertencia en tiempo de compilación si se sabe que la expresión es siempre true o false.The is keyword generates a compile-time warning if the expression is known to always be either true or false. Solo considera las conversiones de referencias, las conversiones boxing y las conversiones unboxing. No tiene en cuenta las conversiones definidas por el usuario o las conversiones definidas por los operadores implicit y explicit de un tipo.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. En el ejemplo siguiente se generan advertencias porque el resultado de la conversión se conoce en tiempo de compilación.The following example generates warnings because the result of the conversion is known at compile time. La expresión is para conversiones de int en long y double devuelve false, ya que estas conversiones se controlan mediante el operador implicit.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 no puede ser un método anónimo ni una expresión lambda.expr cannot be an anonymous method or lambda expression. Puede ser cualquier otra expresión que devuelva un valor.It can be any other expression that returns a value. En el ejemplo siguiente se usa is para evaluar el valor devuelto de una llamada de método.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.

A partir de C# 7.0, puede usar la coincidencia de patrones con el patrón de tipo para escribir código más conciso que use la instrucción 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.

Coincidencia de patrones con isPattern matching with is

A partir de C# 7.0, las instrucciones is y switch admiten la coincidencia de patrones.Starting with C# 7.0, the is and switch statements support pattern matching. La palabra clave is admite los patrones siguientes:The is keyword supports the following patterns:

  • Patrón de tipo, que comprueba si una expresión se puede convertir en un tipo especificado y, en caso afirmativo, la convierte en una variable de ese tipo.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.

  • Patrón de constante, que comprueba si una expresión se evalúa como un valor constante especificado.Constant pattern, which tests whether an expression evaluates to a specified constant value.

  • Patrón var, una coincidencia que siempre se realiza correctamente y enlaza el valor de una expresión a una variable local nueva.var pattern, a match that always succeeds and binds the value of an expression to a new local variable.

Patrón de tipoType pattern

Cuando se usa el patrón de tipo para realizar la coincidencia de patrones, is comprueba si una expresión se puede convertir en un tipo especificado y, en caso afirmativo, la convierte en una variable de ese tipo.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. Es una extensión sencilla de la instrucción is que habilita la evaluación y la conversión de tipos concisa.It's a straightforward extension of the is statement that enables concise type evaluation and conversion. La forma general del patrón de tipos is es:The general form of the is type pattern is:

   expr is type varname 

donde expr es una expresión que se evalúa como una instancia de un tipo, type es el nombre del tipo al que se va a convertir el resultado de expr y varname es el objeto al que se va a convertir el resultado de expr si la prueba is es 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.

La expresión is es true si expr no es null y se cumple alguna de las siguientes condiciones:The is expression is true if expr isn't null, and any of the following is true:

  • expr es una instancia del mismo tipo que type.expr is an instance of the same type as type.

  • expr es una instancia de un tipo que deriva de type.expr is an instance of a type that derives from type. En otras palabras, el resultado de expr puede convertirse en una instancia de type.In other words, the result of expr can be upcast to an instance of type.

  • expr tiene un tipo en tiempo de compilación que es una clase base de type y expr tiene un tipo en tiempo de ejecución que es type o se deriva 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. El tipo en tiempo de compilación de una variable es el tipo de la variable tal como se define en su declaración.The compile-time type of a variable is the variable's type as defined in its declaration. El tipo en tiempo de ejecución de una variable es el tipo de la instancia que se asigna a esa variable.The runtime type of a variable is the type of the instance that is assigned to that variable.

  • type es una instancia de un tipo que implementa la interfaz type.expr is an instance of a type that implements the type interface.

A partir de C# 7.1, expr puede tener un tipo de tiempo de compilación definido por un parámetro y sus restricciones.Beginning with C# 7.1, expr may have a compile-time type defined by a generic type parameter and its constraints.

Si expr es true y is se usa con una instrucción if, solo se asigna varname dentro de la instrucción if.If expr is true and is is used with an if statement, varname is assigned within the if statement only. El ámbito de varname abarca de la expresión is al final del bloque que incluye la instrucción if.The scope of varname is from the is expression to the end of the block enclosing the if statement. El uso de varname en cualquier otra ubicación genera un error en tiempo de compilación por el uso de una variable que no se ha asignado.Using varname in any other location generates a compile-time error for use of a variable that has not been assigned.

En el ejemplo siguiente se usa el patrón de tipo is para proporcionar la implementación de un método IComparable.CompareTo(Object) de tipo.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.");
    }
}

Sin coincidencia de patrones, este código podría escribirse del modo siguiente.Without pattern matching, this code might be written as follows. El uso de la coincidencia de patrones de tipo genera código más compacto y legible al eliminar la necesidad de comprobar si el resultado de una conversión es 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);
    }
}

El patrón de tipo is también genera código más compacto al determinar el tipo de un tipo de valor.The is type pattern also produces more compact code when determining the type of a value type. En el ejemplo siguiente se usa el patrón de tipo is para determinar si un objeto es una instancia de Person o Dog antes de mostrar el valor de una propiedad adecuada.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

El código equivalente sin coincidencia de patrones requiere una asignación independiente que incluya una conversión explícita.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

Patrón de constante Constant pattern

Al realizar la coincidencia de patrones con el patrón constante, is comprueba si una expresión es igual a una constante especificada.When performing pattern matching with the constant pattern, is tests whether an expression equals a specified constant. En C# 6 y versiones anteriores, la instrucción switch admite el patrón de constante.In C# 6 and earlier versions, the constant pattern is supported by the switch statement. A partir de C# 7.0, la instrucción is también lo admite.Starting with C# 7.0, it's supported by the is statement as well. Su sintaxis es:Its syntax is:

   expr is constant

donde expr es la expresión que se va a evaluar y constant es el valor que se va a comprobar.where expr is the expression to evaluate, and constant is the value to test for. constant puede ser cualquiera de las expresiones de constante siguientes:constant can be any of the following constant expressions:

  • Un valor literal.A literal value.

  • El nombre de una variable const declarada.The name of a declared const variable.

  • Una constante de enumeración.An enumeration constant.

La expresión de constante se evalúa de la siguiente forma:The constant expression is evaluated as follows:

  • Si expr y constant son tipos enteros, el operador de igualdad de C# determina si la expresión devuelve true (es decir, 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).

  • De lo contrario, el valor de la expresión se determina mediante una llamada al método estático Object.Equals(expr, constant).Otherwise, the value of the expression is determined by a call to the static Object.Equals(expr, constant) method.

En el ejemplo siguiente se combinan los patrones de tipo y de constante para probar si un objeto es una instancia de Dice y, si es así, para determinar si el valor de una tirada de dados es 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!

La búsqueda de null puede realizarse con el patrón de constante.Checking for null can be performed using the constant pattern. La palabra clave null es compatible con la instrucción is.The null keyword is supported by the is statement. Su sintaxis es:Its syntax is:

   expr is null

En el ejemplo siguiente se muestra una comparación de comprobaciones null:The following example shows a comparison of null checks:

using System;

class Program
{
    static void Main(string[] args)
    {
        object o = null;

        if (o is null)
        {
            Console.WriteLine("o does not have a value");
        }
        else
        {
            Console.WriteLine($"o is {o}");
        }
        
        int? x = 10;

        if (x is null)
        {
            Console.WriteLine("x does not have a value");
        }
        else
        {
            Console.WriteLine($"x is {x.Value}");
        }
        
        // 'null' check comparison
        Console.WriteLine($"'is' constant pattern 'null' check result : { o is null }");
        Console.WriteLine($"object.ReferenceEquals 'null' check result : { object.ReferenceEquals(o, null) }");
        Console.WriteLine($"Equality operator (==) 'null' check result : { o == null }");
    }

    // The example displays the following output:
    // o does not have a value
    // x is 10
    // 'is' constant pattern 'null' check result : True
    // object.ReferenceEquals 'null' check result : True
    // Equality operator (==) 'null' check result : True
}

Patrón var var pattern

El patrón var es un comodín para cualquier tipo o valor.The var pattern is a catch-all for any type or value. El valor de expr siempre se asigna a una variable local del mismo tipo que el tipo de tiempo de compilación de expr.The value of expr is always assigned to a local variable the same type as the compile time type of expr. El resultado de la expresión is es siempre true.The result of the is expression is always true. Su sintaxis es:Its syntax is:

   expr is var varname

En el ejemplo siguiente se usa el patrón var para asignar una expresión a una variable denominada obj.The following example uses the var pattern to assign an expression to a variable named obj. Después, se muestra el valor y el tipo 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

Especificación del lenguaje C#C# Language Specification

Para obtener más información, consulte la Especificación del lenguaje C#.For more information, see the C# Language Specification. La especificación del lenguaje es la fuente definitiva de la sintaxis y el uso de C#.The language specification is the definitive source for C# syntax and usage.

Vea tambiénSee also