C# AS (Cómo funciona para los desarrolladores)

La programación en C# implica a menudo trabajar con distintos tipos de datos. A veces, necesitamos verificar si un object es de un cierto tipo o intentar convertirlo a ese tipo. Es ahí donde la as operator keyword resulta útil. Junto con su pariente cercano, el is operator ayuda en las pruebas de tipo y conversiones. En este tutorial, exploraremos los entresijos de este operador y sus casos de uso.

Comprender el operador as

Conceptos básicos del operador as

La palabra clave del operador as en C# es un operador binario utilizado para realizar ciertas conversiones entre tipos de referencia compatibles o tipos anulables. El siguiente código proporciona una demostración sencilla:

object myObj = "Hello, World!";
string myStr = myObj as string;

object myObj = "Hello, World!";
string myStr = myObj as string;

Dim myObj As Object = "Hello, World!"
Dim myStr As String = TryCast(myObj, String)

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

¿En qué se diferencia del reparto explícito?

Si bien tanto el operador as como el casteo explícito sirven para propósitos similares, hay una distinción clave. Si una conversión explícita falla, lanza una excepción. Por otro lado, si el intento de conversión del operador as de un tipo a otro falla, el operador devuelve un valor nulo en lugar de lanzar una excepción. Vamos a entenderlo con el siguiente ejemplo de código:

object someValue = 12345;

// Using explicit cast
string castResult;
try {
    castResult = (string)someValue; // This will throw an exception since the cast fails.
}
catch(Exception ex) {
    castResult = null;
}

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

object someValue = 12345;

// Using explicit cast
string castResult;
try {
    castResult = (string)someValue; // This will throw an exception since the cast fails.
}
catch(Exception ex) {
    castResult = null;
}

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

Dim someValue As Object = 12345

' Using explicit cast
Dim castResult As String
Try
	castResult = DirectCast(someValue, String) ' This will throw an exception since the cast fails.
Catch ex As Exception
	castResult = Nothing
End Try

' Using the as operator
Dim asResult As String = TryCast(someValue, String) ' No exception, but asResult will be null since the cast fails.

Como es evidente, usar el operador as puede ser más seguro ya que evitas posibles errores en tiempo de ejecución.

Conexión con el operador is

A menudo, el operador as se utiliza junto con el operador is para realizar pruebas de tipo antes de intentar una conversión. El is operator comprueba si el objeto proporcionado es del tipo dado y devuelve verdadero si lo es, de lo contrario, devuelve falso.

El siguiente ejemplo de código lo ilustra:

object testObject = "This is a string";

if(testObject is string) {
    string result = testObject as string;
    Console.WriteLine(result);
} else {
    Console.WriteLine("Not a string");
}

object testObject = "This is a string";

if(testObject is string) {
    string result = testObject as string;
    Console.WriteLine(result);
} else {
    Console.WriteLine("Not a string");
}

Dim testObject As Object = "This is a string"

If TypeOf testObject Is String Then
	Dim result As String = TryCast(testObject, String)
	Console.WriteLine(result)
Else
	Console.WriteLine("Not a string")
End If

Con la introducción de la coincidencia de patrones en versiones posteriores de C#, el operador is también puede realizar ciertas acciones si la prueba de tipo es exitosa. Esto a menudo reduce la necesidad de usar el operador as.

Casos especiales y consideraciones más profundas

Conversiones de tipo de valor anulable

Uno de los casos especiales donde el operador as es invaluable es con los tipos de valor anulables. Los tipos de valor (como int, double, etc.) no pueden asignarse un valor nulo. Sin embargo, al hacerlos anulables, puedes asignarles null. El operador as se puede usar para intentar la conversión a un tipo de valor anulable:

int? nullableInt = 10;
object objInt = nullableInt;
int? resultInt = objInt as int?;

int? nullableInt = 10;
object objInt = nullableInt;
int? resultInt = objInt as int?;

Dim nullableInt? As Integer = 10
Dim objInt As Object = nullableInt
Dim resultInt? As Integer = CType(objInt, Integer?)

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 utilizando métodos de conversión especiales en sus clases.

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

class Sample {
    public static implicit operator string(Sample s) {
        return "Converted to String";
    }
}

Sample sampleObject = new Sample();
string conversionResult = sampleObject as string;

class Sample {
    public static implicit operator string(Sample s) {
        return "Converted to String";
    }
}

Sample sampleObject = new Sample();
string conversionResult = sampleObject as string;

Friend Class Sample
	Public Shared Widening Operator CType(ByVal s As Sample) As String
		Return "Converted to String"
	End Operator
End Class

Private sampleObject As New Sample()
Private conversionResult As String = TryCast(sampleObject, String)

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

Cuando no se aplica as

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

Escenarios avanzados con el operador as

Boxeo y unboxing con as

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

Considere el siguiente código para las conversiones de cajas:

int intValue = 42;
object boxedValue = intValue;

int intValue = 42;
object boxedValue = intValue;

Dim intValue As Integer = 42
Dim boxedValue As Object = intValue

Aquí, el intValue se encapsula en un object.

Desempaquetar es el proceso inverso de empaquetar, es decir, extraer el tipo de valor del object. El operador as se puede usar para desboxear valores de forma segura, especialmente cuando no estás seguro de si el objeto contiene el tipo de valor que esperas. Si el unboxing no tiene éxito, el resultado de la expresión será null.

Considere el siguiente ejemplo para las conversiones unboxing:

object obj = 42;
int? result = obj as int?;

object obj = 42;
int? result = obj as int?;

Dim obj As Object = 42
Dim result? As Integer = CType(obj, Integer?)

Trabajar con matrices

Las matrices son tipos de referencia en C#. A veces, puede 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" };
string[] stringArray = arrayObject as string[];

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

Dim arrayObject() As Object = New String() { "one", "two", "three" }
Dim stringArray() As String = TryCast(arrayObject, String())

En el código anterior, arrayObject es un arreglo de objetos pero en realidad contiene cadenas. Usando el operador as, puedes intentar tratarlo de manera segura como un array de cadenas.

Combinando as con LINQ

Language Integrated Query (LINQ - Documentación de Microsoft) es una característica potente en C# que te permite consultar colecciones de una manera similar a SQL. A veces, puedes recuperar objetos de tipos mixtos en una colección y querer filtrar tipos específicos. Aquí, el operador as puede ser muy útil.

Por ejemplo, considere una lista de objetos que contenga tanto cadenas como números enteros. Si quería recuperar solo las cadenas, podría usar el operador as junto con LINQ:

var mixedList = new List<object> { "Hello", 42, "World", 100 };
var stringValues = mixedList
    .Select(item => item as string)
    .Where(item => item != null)
    .ToList();

var mixedList = new List<object> { "Hello", 42, "World", 100 };
var stringValues = mixedList
    .Select(item => item as string)
    .Where(item => item != null)
    .ToList();

Dim mixedList = New List(Of Object) From {"Hello", 42, "World", 100}
Dim stringValues = mixedList.Select(Function(item) TryCast(item, String)).Where(Function(item) item IsNot Nothing).ToList()

Integración con Iron Suite

Soluciones Iron Suite para Desarrolladores de C# es un conjunto de herramientas de alta calidad que permiten a los desarrolladores de C# integrar sin problemas funcionalidades como la manipulación de PDF, el manejo de Excel, el Reconocimiento Óptico de Caracteres (OCR) y la generación y lectura de códigos de barras. Estas herramientas, al igual que nuestra discusión anterior sobre los operadores as y is, son fundamentales para amplificar la eficiencia de un desarrollador al construir aplicaciones robustas.

IronPDF

IronPDF permite a los desarrolladores generar, manipular y leer archivos PDF dentro de sus aplicaciones C#. Teniendo en cuenta la relevancia para nuestro tema, supongamos que tienes un tipo de referencia que contiene algunos datos, y quieres 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 tipo, 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 proporciona a los desarrolladores la capacidad de leer, editar y crear hojas de cálculo de Excel sin necesitar depender de Office Interop. En el contexto de nuestra discusión sobre conversiones de tipos, piense en IronXL como una herramienta que le permite convertir estructuras de datos o entradas de bases de datos en C# en 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. Vinculando esto a nuestro tutorial, es similar a convertir un objeto (en este caso, una imagen) a un tipo más específico (string o datos textuales) utilizando capacidades avanzadas de reconocimiento.

IronBarcode

En muchas aplicaciones comerciales, el manejo de códigos de barras es indispensable. Herramienta IronBarcode para el Procesamiento de Códigos de Barras ayuda a los desarrolladores a generar, leer y decodificar códigos de barras en aplicaciones C#. Con respecto a nuestra discusión sobre conversiones de tipos, IronBarcode puede verse como una herramienta que traduce datos visuales de código de barras (una forma de objeto) en tipos de datos más específicos y utilizables, como cadenas o detalles de productos.

Conclusión

Cada producto dentro de las Ofertas de Iron Suite es un testimonio de la flexibilidad y el poder que C# ofrece, especialmente cuando se integra en nuestra discusión sobre conversiones de tipos y verificación de tipos. Estas herramientas, como los operadores as y is, proporcionan a los desarrolladores la capacidad de convertir y procesar datos de manera eficiente.

Si estás considerando integrar cualquiera de estas herramientas en tus proyectos, vale la pena mencionar que cada licencia de producto comienza desde $749 y cada producto ofrece una prueba gratuita de Iron Suite Tools. Para aquellos que buscan una solución completa, Iron Suite ofrece una propuesta atractiva: puede adquirir la licencia de Iron Suite por el precio de solo dos productos.