Operadores de conversión y prueba de tipos (Referencia de C#)Type-testing and cast operators (C# reference)

Puede usar los siguientes operadores para realizar la comprobación de tipos o la conversión de tipos:You can use the following operators to perform type checking or type conversion:

  • operador is: para comprobar si el tipo en tiempo de ejecución de una expresión es compatible con un tipo determinado.is operator: to check if the runtime type of an expression is compatible with a given type
  • operador as: para convertir explícitamente una expresión a un tipo determinado si su tipo en tiempo de ejecución es compatible con ese tipo.as operator: to explicitly convert an expression to a given type if its runtime type is compatible with that type
  • operador de conversión (): para realizar una conversión explícita.cast operator (): to perform an explicit conversion
  • operador typeof: para obtener la instancia System.Type para un tipo.typeof operator: to obtain the System.Type instance for a type

Operador isis operator

El operador is comprueba si el tipo en tiempo de ejecución del resultado de una expresión es compatible con un tipo determinado.The is operator checks if the runtime type of an expression result is compatible with a given type. A partir de C# 7.0, el operador is también prueba el resultado de una expresión en relación con un patrón.Starting with C# 7.0, the is operator also tests an expression result against a pattern.

La expresión con el operador is de prueba de tipos tiene el formato siguiente:The expression with the type-testing is operator has the following form

E is T

donde E es una expresión que devuelve un valor y T es el nombre de un tipo o un parámetro de tipo.where E is an expression that returns a value and T is the name of a type or a type parameter. E no puede ser un método anónimo ni una expresión lambda.E cannot be an anonymous method or a lambda expression.

La expresión E is T devuelve true si el resultado de E es distinto de NULL y se puede convertir al tipo T por una conversión de referencia, una conversión boxing o una conversión unboxing; de lo contrario, devuelve false.The E is T expression returns true if the result of E is non-null and can be converted to type T by a reference conversion, a boxing conversion, or an unboxing conversion; otherwise, it returns false. El operador is no toma en consideración las conversiones definidas por el usuario.The is operator doesn't consider user-defined conversions.

En el ejemplo siguiente se muestra que el operador is devuelve true si el tipo en tiempo de ejecución del resultado de una expresión se deriva de un tipo determinado, es decir, existe una conversión de referencia entre tipos:The following example demonstrates that the is operator returns true if the runtime type of an expression result derives from a given type, that is, there exists a reference conversion between 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
    }
}

En el ejemplo siguiente se muestra que el operador is tiene en cuenta las conversiones boxing y unboxing pero no considera las conversiones numéricas:The next example shows that the is operator takes into account boxing and unboxing conversions but doesn't consider numeric conversions:

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

Para obtener información acerca de las conversiones de C#, vea el capítulo Conversiones de la especificación del lenguaje C#.For information about C# conversions, see the Conversions chapter of the C# language specification.

Prueba de tipos con coincidencia de patronesType testing with pattern matching

A partir de C# 7.0, el operador is también prueba el resultado de una expresión en relación con un patrón.Starting with C# 7.0, the is operator also tests an expression result against a pattern. En concreto, admite el patrón de tipo de la forma siguiente:In particular, it supports the type pattern in the following form:

E is T v

donde E es una expresión que devuelve un valor, T es el nombre de un tipo o un parámetro de tipo y v es una nueva variable local de tipo T.where E is an expression that returns a value, T is the name of a type or a type parameter, and v is a new local variable of type T. Si el resultado de E no es NULL y puede convertirse en T mediante una conversión de referencia, boxing o unboxing, la expresión E is T v devuelve true y el valor convertido del resultado de E se asigna a la variable v.If the result of E is non-null and can be converted to T by a reference, boxing, or unboxing conversion, the E is T v expression returns true and the converted value of the result of E is assigned to variable v.

En el siguiente ejemplo se muestra el uso del operador is con un patrón de tipo:The following example demonstrates the usage of the is operator with the type pattern:

int i = 23;
object iBoxed = i;
int? jNullable = 7;
if (iBoxed is int a && jNullable is int b)
{
    Console.WriteLine(a + b);  // output 30
}

Para obtener más información sobre el patrón de tipo y otros patrones admitidos, consulte Coincidencia de patrones con is.For more information about the type pattern and other supported patterns, see Pattern matching with is.

Operador asas operator

El operador as convierte explícitamente el resultado de una expresión en una referencia determinada o un tipo de valor que acepta valores NULL.The as operator explicitly converts the result of an expression to a given reference or nullable value type. Si la conversión no es posible, el operador as devuelve null.If the conversion is not possible, the as operator returns null. A diferencia del operador de conversión (), el operador as no genera nunca una excepción.Unlike the cast operator (), the as operator never throws an exception.

La expresión con el formatoThe expression of the form

E as T

donde E es una expresión que devuelve un valor y T es el nombre de un tipo o un parámetro de tipo produce el mismo resultado quewhere E is an expression that returns a value and T is the name of a type or a type parameter, produces the same result as

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

salvo que E solo se evalúa una vez.except that E is only evaluated once.

El operador as solo considera las conversiones de referencia, las que aceptan valores NULL, boxing y unboxing.The as operator considers only reference, nullable, boxing, and unboxing conversions. No puede usar el operador as para realizar una conversión definida por el usuario.You cannot use the as operator to perform a user-defined conversion. Para hacerlo, utilice el operador de conversión ().To do that, use the cast operator ().

En el siguiente ejemplo se muestra el uso del operador as:The following example demonstrates the usage of the as operator:

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
}

Nota

Como se muestra en el ejemplo anterior, se necesita comparar el resultado de la expresión as con null para comprobar si una conversión es correcta.As the preceding example shows, you need to compare the result of the as expression with null to check if the conversion is successful. A partir de C# 7.0, puede usar el operador is para probar si la conversión es correcta y, si es así, asignar su resultado a una nueva variable.Starting with C# 7.0, you can use the is operator both to test if the conversion succeeds and, if it succeeds, assign its result to a new variable.

Operador de conversión ()Cast operator ()

Una expresión de conversión con el formato (T)E realiza una conversión explícita del resultado de la expresión E al tipo T.A cast expression of the form (T)E performs an explicit conversion of the result of expression E to type T. Si no existe ninguna conversión explícita del tipo de E al tipo T, se producirá un error en tiempo de compilación.If no explicit conversion exists from the type of E to type T, a compile-time error occurs. En el tiempo de ejecución, una conversión explícita podría no completarse correctamente y una expresión de conversión podría generar una excepción.At run time, an explicit conversion might not succeed and a cast expression might throw an exception.

El ejemplo siguiente muestra las conversiones explícitas numérica y de referencia:The following example demonstrates explicit numeric and reference conversions:

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

Para obtener más información sobre las conversiones explícitas, vea la sección Conversiones explícitas de la especificación del lenguaje C#.For information about supported explicit conversions, see the Explicit conversions section of the C# language specification. Para obtener información sobre cómo definir una conversión personalizada de tipo explícito o implícito, vea Operadores de conversión definidos por el usuario.For information about how to define a custom explicit or implicit type conversion, see User-defined conversion operators.

Otros usos de ()Other usages of ()

También puede utilizar paréntesis para llamar a un método o invocar un delegado.You also use parentheses to call a method or invoke a delegate.

Sirven además para ajustar el orden en el que se van a evaluar operaciones en una expresión.Other use of parentheses is to adjust the order in which to evaluate operations in an expression. Para obtener más información, vea Operadores de C# (referencia de C#).For more information, see C# operators.

Operador typeoftypeof operator

El operador typeof obtiene la instancia System.Type para un tipo.The typeof operator obtains the System.Type instance for a type. El argumento del operador typeof debe ser el nombre de un tipo o un parámetro de tipo, como se muestra en el ejemplo siguiente:The argument to the typeof operator must be the name of a type or a type parameter, as the following example shows:

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]

También puede usar el operador typeof con tipos genéricos sin enlazar.You also can use the typeof operator with unbound generic types. El nombre de un tipo genérico sin enlazar debe contener el número apropiado de comas, que es inferior en una unidad al número de parámetros de tipo.The name of an unbound generic type must contain the appropriate number of commas, which is one less than the number of type parameters. En el siguiente ejemplo se muestra el uso del operador typeof con un tipo genérico sin enlazar:The following example shows the usage of the typeof operator with an unbound generic type:

Console.WriteLine(typeof(Dictionary<,>));
// Output:
// System.Collections.Generic.Dictionary`2[TKey,TValue]

Una expresión no puede ser un argumento del operador typeof.An expression cannot be an argument of the typeof operator. Para obtener la instancia System.Type para el tipo en tiempo de ejecución del resultado de la expresión, use el método Object.GetType.To get the System.Type instance for the runtime type of the expression result, use the Object.GetType method.

Prueba de tipos con el operador typeofType testing with the typeof operator

Use el operador typeof para comprobar si el tipo en tiempo de ejecución del resultado de la expresión coincide exactamente con un tipo determinado.Use the typeof operator to check if the runtime type of the expression result exactly matches a given type. En el ejemplo siguiente se muestra la diferencia entre la comprobación de tipos realizada con el operador typeof y el operador is:The following example demonstrates the difference between type checking performed with the typeof operator and the is operator:

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

Posibilidad de sobrecarga del operadorOperator overloadability

Los operadores is, as y typeof no son sobrecargables.The is, as, and typeof operators are not overloadable.

Un tipo definido por el usuario no se puede sobrecargar el operador (), pero puede definir conversiones de tipos personalizadas que pueden realizarse mediante una expresión de conversión.A user-defined type cannot overload the () operator, but can define custom type conversions that can be performed by a cast expression. Para obtener más información, vea Operadores de conversión definidos por el usuario.For more information, see User-defined conversion operators.

Especificación del lenguaje C#C# language specification

Para más información, vea las secciones siguientes de la Especificación del lenguaje C#:For more information, see the following sections of the C# language specification:

Vea tambiénSee also