C# AS (Cómo funciona para desarrolladores)

Conceptos básicos del operador as

La palabra clave as en C# es un operador binario que se utiliza para realizar ciertas conversiones entre tipos de referencia compatibles o tipos que aceptan valores NULL. El siguiente código ofrece una demostración sencilla:

// Declare an object that holds a string
object myObj = "Hello, World!";

// Use the 'as' operator to attempt to convert 'myObj' to a string
string myStr = myObj as string;

// myStr will hold the string value "Hello, World!" if the conversion is successful;
// otherwise, it will be null.

// Declare an object that holds a string
object myObj = "Hello, World!";

// Use the 'as' operator to attempt to convert 'myObj' to a string
string myStr = myObj as string;

// myStr will hold the string value "Hello, World!" if the conversion is successful;
// otherwise, it will be null.

En el código anterior, myObj es un objeto de tipo object (el tipo base para todos los tipos en C#). No se conoce con certeza su tipo subyacente en tiempo de compilación. El operador as se utiliza para intentar tratar myObj como string. Si tiene éxito, myStr contendrá el valor de la cadena. De lo contrario, contendrá un valor null.

¿En qué se diferencia de la fundición explícita?

Si bien tanto el operador as como la conversión explícita cumplen propósitos similares, existe una distinción clave. Si una conversión explícita falla, lanza una excepción. Por otro lado, si el intento del operador as de realizar una conversión de un tipo a otro falla, el operador devuelve un valor null en lugar de generar una excepción. Entendamos esto con el siguiente ejemplo de código:

object someValue = 12345;
string castResult;

// Using explicit cast
try {
    castResult = (string)someValue; // This will throw an exception since the cast fails.
}
catch(Exception ex) {
    castResult = null; // The result is set to null if an exception is caught.
}

// Using the 'as' operator
string asResult = someValue as string; // No exception, but 'asResult' will be null since the cast fails.

object someValue = 12345;
string castResult;

// Using explicit cast
try {
    castResult = (string)someValue; // This will throw an exception since the cast fails.
}
catch(Exception ex) {
    castResult = null; // The result is set to null if an exception is caught.
}

// Using the 'as' operator
string asResult = someValue as string; // No exception, but 'asResult' will be null since the cast fails.

Como es evidente, utilizar el operador as a menudo puede ser más seguro ya que evita posibles errores de tiempo de ejecución.

Conversiones de tipos de valores anulables

Un caso especial en el que el operador as resulta invaluable es con tipos de valor que aceptan valores NULL. A los tipos de valor (como int, double, etc.) no se les puede asignar un valor null. Sin embargo, si los hacemos anulables, se les puede asignar null. El operador as se puede utilizar para intentar la conversión a un tipo de valor que acepte valores NULL:

// Declare a nullable integer
int? nullableInt = 10;

// Box the nullable int
object objInt = nullableInt;

// Attempt to unbox using 'as' to a nullable int type
int? resultInt = objInt as int?;

// Declare a nullable integer
int? nullableInt = 10;

// Box the nullable int
object objInt = nullableInt;

// Attempt to unbox using 'as' to a nullable int type
int? resultInt = objInt as int?;

Conversiones de referencia y conversiones definidas por el usuario

El operador as admite tanto conversiones de referencia (entre tipos de referencia relacionados) como conversiones definidas por el usuario. Las conversiones definidas por el usuario son aquellas conversiones que se definen mediante métodos de conversión especiales en tus clases.

Considere el siguiente código de una conversión definida por el usuario:

class Sample {
    // Define an implicit conversion from Sample to string
    public static implicit operator string(Sample s) {
        return "Converted to String";
    }
}

Sample sampleObject = new Sample();

// Use 'as' to convert 'sampleObject' to string
string conversionResult = sampleObject as string;

// conversionResult will hold "Converted to String"

class Sample {
    // Define an implicit conversion from Sample to string
    public static implicit operator string(Sample s) {
        return "Converted to String";
    }
}

Sample sampleObject = new Sample();

// Use 'as' to convert 'sampleObject' to string
string conversionResult = sampleObject as string;

// conversionResult will hold "Converted to String"

Aquí, el método de conversión definido por el usuario permite que un objeto de tipo Sample sea tratado como un string.

Cuando como no se aplica

Recuerde que el operador as no se puede utilizar con tipos de valor (a menos que se trate de tipos de valor que acepten valores nulos) o con conversiones definidas por el usuario que involucren un método explícito.

Boxing y unboxing con as

El encapsulado es el proceso de convertir una instancia de tipo-valor a una referencia de objeto. Esto es posible porque cada tipo de valor hereda implícitamente de un object. Cuando encierras un tipo de valor, lo envuelves dentro de un object.

Considere el siguiente código para conversiones de encapsulado:

int intValue = 42;

// Box the value type to an object
object boxedValue = intValue;

int intValue = 42;

// Box the value type to an object
object boxedValue = intValue;

Aquí, el intValue está encajonado en un object.

El desempaquetado es el proceso inverso del empaquetado, es decir, extraer el tipo de valor de object. El operador as se puede utilizar para desempaquetar valores de forma segura, en particular cuando no está seguro de si object contiene el tipo de valor que espera. Si el desempaquetado es infructuoso, el resultado de la expresión será null.

Considere el siguiente ejemplo para conversiones de desempaquetado:

object obj = 42;

// Attempt to unbox using 'as' to a nullable int type
int? result = obj as int?;

object obj = 42;

// Attempt to unbox using 'as' to a nullable int type
int? result = obj as int?;

Trabajar con matrices

Los arreglos son tipos de referencia en C#. A veces, es posible que necesites determinar si un object es un tipo específico de matriz y luego trabajar con él. El operador as también puede ayudar aquí.

Considere el siguiente código:

object[] arrayObject = new string[] { "one", "two", "three" };

// Attempt to cast to a string array using 'as'
string[] stringArray = arrayObject as string[];

// stringArray will hold the array of strings if successful

object[] arrayObject = new string[] { "one", "two", "three" };

// Attempt to cast to a string array using 'as'
string[] stringArray = arrayObject as string[];

// stringArray will hold the array of strings if successful

En el código anterior, arrayObject es una matriz de objetos pero en realidad contiene cadenas. Usando el operador as, puedes intentar tratarlo con seguridad como una matriz de cadenas.

Combinando as con LINQ

El Lenguaje Integrado de Consultas (LINQ - Documentación de Microsoft) es una característica poderosa en C# que te permite consultar colecciones de una manera similar a SQL. A veces, es posible recuperar objetos de tipos mixtos en una colección y querer filtrar tipos específicos. En este caso, el operador as puede ser muy útil.

Por ejemplo, considera una lista de objetos que contienen tanto cadenas como enteros. Si desea recuperar solo las cadenas, puede utilizar el operador as junto con LINQ:

var mixedList = new List<object> { "Hello", 42, "World", 100 };

// Use LINQ to select only strings from mixedList
var stringValues = mixedList
    .Select(item => item as string)
    .Where(item => item != null)
    .ToList();

// stringValues will contain "Hello" and "World"

var mixedList = new List<object> { "Hello", 42, "World", 100 };

// Use LINQ to select only strings from mixedList
var stringValues = mixedList
    .Select(item => item as string)
    .Where(item => item != null)
    .ToList();

// stringValues will contain "Hello" and "World"

IronPDF

IronPDF permite a los desarrolladores generar, manipular y leer archivos PDF dentro de sus aplicaciones C#. Considerando la relevancia para nuestro tema, supongamos que tenías un tipo de referencia que contenía algunos datos, y querías convertir estos datos en un informe o documento. IronPDF puede tomar la salida de su aplicación y, de manera similar a la conversión de tipos, traducirla en un documento PDF bien formateado.

IronXL

El manejo de archivos Excel es un requisito frecuente en muchas aplicaciones de software. IronXL for Excel Operations ofrece a los desarrolladores la capacidad de leer, editar y crear hojas de cálculo de Excel sin necesidad de usar Office Interop. En el contexto de nuestra discusión sobre conversiones de tipos, considere IronXL como una herramienta que permite convertir estructuras de datos o entradas de bases de datos en C# a formatos de Excel sin problemas.

IronOCR

Optical Character Recognition with IronOCR es una herramienta de reconocimiento óptico de caracteres que permite a los desarrolladores leer e interpretar texto de imágenes. Aplicando esto a nuestro tutorial, es similar a convertir un object (en este caso, una imagen) a un tipo más específico (string o datos textuales) usando capacidades de reconocimiento avanzadas.

IronBarcode

En muchas aplicaciones comerciales, el manejo de códigos de barras es indispensable. IronBarcode Tool for Barcode Processing ayuda a los desarrolladores a generar, leer y decodificar códigos de barras en aplicaciones C#. En relación con nuestra discusión sobre las conversiones de tipos, IronBarcode puede verse como una herramienta que traduce datos de códigos de barras visuales (una forma de object) en tipos de datos más específicos y utilizables, como cadenas o detalles de productos.