Compartir a través de

Operadores de prueba de tipos y expresión de conversión: is, as, typeof y conversiones

Estos operadores y expresiones realizan la comprobación de tipos o la conversión de tipos. El isoperador comprueba si el tipo en tiempo de ejecución de una expresión es compatible con un tipo determinado. El asoperador convierte explícitamente una expresión a un tipo determinado si su tipo en tiempo de ejecución es compatible con ese tipo. Las expresiones de conversión realizan una conversión explícita a un tipo de destino. El typeofoperador obtiene la instancia System.Type para un tipo.

La documentación de referencia del lenguaje C# cubre la versión más reciente publicada del lenguaje C#. También contiene documentación inicial sobre las características de las versiones preliminares públicas de la próxima versión del lenguaje.

La documentación identifica cualquier característica introducida por primera vez en las últimas tres versiones del idioma o en las versiones preliminares públicas actuales.

Sugerencia

Para buscar cuándo se introdujo por primera vez una característica en C#, consulte el artículo sobre el historial de versiones del lenguaje C#.

El operador is

El operador is comprueba si el tipo en tiempo de ejecución del resultado de una expresión es compatible con un tipo determinado. El operador is también prueba el resultado de una expresión en relación con un patrón.

La expresión con el operador is de prueba de tipos tiene el formato siguiente:

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. E no puede ser un método anónimo ni una expresión lambda.

El operador is devuelve true cuando el resultado de una expresión es distinto de NULL y se cumple cualquiera de las condiciones siguientes:

  • El tipo en tiempo de ejecución de un resultado de expresión tiene una conversión de identidad a T.

  • El tipo en tiempo de ejecución del resultado de una expresión deriva del tipo T, implementa una interfaz T, o bien otra conversión de referencia implícita existe en T. Esta condición cubre las relaciones de herencia y las implementaciones de interfaz.

  • El tipo en tiempo de ejecución del resultado de una expresión es un tipo de valor que admite un valor NULL con el tipo subyacente T y Nullable<T>.HasValue es true.

  • Existe una conversión boxing o unboxing del tipo en tiempo de ejecución de un resultado de expresión al tipo T cuando la expresión no es una instancia de ref struct.

El is operador no tiene en cuenta las conversiones definidas por el usuario ni las conversiones de intervalo implícita.

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:

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:

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

Prueba de tipos con coincidencia de patrones

El operador is también prueba el resultado de una expresión en relación con un patrón. En el ejemplo siguiente se muestra cómo usar un patrón de declaración para comprobar el tipo en tiempo de ejecución de una expresión:

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 información sobre los patrones admitidos, consulte Patrones.

El operador as

Use el as operador para convertir explícitamente el resultado de una expresión en una referencia determinada o un tipo de valor que acepta valores NULL. Si la conversión no es posible, el operador as devuelve null. A diferencia de la expresión Cast, el operador as no genera nunca una excepción.

La expresión con el formato

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, genera el mismo resultado que

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

Excepto que E solo se evalúe una vez.

El operador as solo considera las conversiones de referencia, las que aceptan valores NULL, boxing y unboxing. No puede usar el operador as para realizar una conversión definida por el usuario. Para realizar una conversión definida por el usuario, use una expresión de conversión.

En el siguiente ejemplo se muestra el uso del operador 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
}

Nota

Como se muestra en el ejemplo anterior, debe comparar el resultado de la as expresión con null para comprobar si la conversión se realizó correctamente. Puede usar el is operador para probar si la conversión se realiza correctamente y, si se realiza correctamente, asigne su resultado a una nueva variable.

Expresión Cast

Una expresión de conversión del formulario (T)E convierte explícitamente el resultado de la expresión E en el tipo T. Si no existe ninguna conversión explícita del tipo de E al tipo T, el compilador emite un error. 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.

El ejemplo siguiente muestra las conversiones explícitas numérica y de referencia:

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

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

Otros usos de ()

También puede utilizar paréntesis para llamar a un método o invocar un delegado.

Otro uso de paréntesis es ajustar el orden en el que C# evalúa las operaciones en una expresión. Para obtener más información, vea Operadores de C# (referencia de C#).

El operador typeof

El typeof operador obtiene la System.Type instancia de un tipo. 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:

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]

El argumento no puede ser un tipo que requiera anotaciones de metadatos. Entre los ejemplos de estos tipos se incluyen los siguientes:

  • dynamic
  • string? (o cualquier tipo de referencia que acepte valores NULL)

Estos tipos no se representan directamente en los metadatos. Los tipos incluyen atributos que describen el tipo subyacente. En ambos casos se puede usar el tipo subyacente. En vez de dynamic, use object. En vez de string?, use string.

También se puede usar el operador typeof con tipos genéricos sin enlazar. 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. En el siguiente ejemplo se muestra el uso del operador typeof con un tipo genérico sin enlazar:

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

Una expresión no puede ser un argumento del operador typeof. Para obtener la instancia de System.Type para el tipo en tiempo de ejecución del resultado de una expresión, use el método Object.GetType.

Prueba de tipos con el operador typeof

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. En el ejemplo siguiente se muestra la diferencia entre la comprobación de tipos realizada mediante el typeof operador y el is operador :

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 operador

No se pueden sobrecargar los isoperadores , asy typeof .

Un tipo definido por el usuario no puede sobrecargar el () operador, pero puede definir conversiones de tipos personalizados que realiza una expresión de conversión. Para obtener más información, vea Operadores de conversión definidos por el usuario.

Especificación del lenguaje C#

Para más información, vea las secciones siguientes de la Especificación del lenguaje C#:

Consulte también

  • Last updated on