Programar en C# a menudo implica trabajar con diferentes tipos de datos. A veces, necesitamos verificar si un object es de un cierto tipo o intentar convertirlo a ese tipo. Es aquí donde la palabra clave del operador as resulta muy útil. Junto con su pariente cercano, el operador is ayuda en las pruebas de tipo y conversiones. En este tutorial, exploraremos las complejidades de este operador y sus casos de uso.

Entender 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:

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

' Declare an object that holds a string
Dim myObj As Object = "Hello, World!"

' Use the 'as' operator to attempt to convert 'myObj' to a string
Dim myStr As String = TryCast(myObj, 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
Dim myObj As Object = "Hello, World!"

' Use the 'as' operator to attempt to convert 'myObj' to a string
Dim myStr As String = TryCast(myObj, 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 estamos seguros de su tipo subyacente en tiempo de compilación. Se utiliza el operador as para intentar tratar myObj como un string. Si tiene éxito, myStr contendrá el valor de 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 tienen 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 null en lugar de lanzar 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.

Dim someValue As Object = 12345
Dim castResult As String

' Using explicit cast
Try
	castResult = DirectCast(someValue, String) ' This will throw an exception since the cast fails.
Catch ex As Exception
	castResult = Nothing ' The result is set to null if an exception is caught.
End Try

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

Dim someValue As Object = 12345
Dim castResult As String

' Using explicit cast
Try
	castResult = DirectCast(someValue, String) ' This will throw an exception since the cast fails.
Catch ex As Exception
	castResult = Nothing ' The result is set to null if an exception is caught.
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, a menudo, más seguro ya que evitas posibles errores en tiempo de ejecución.

La conexión con el operador is

A menudo, el operador as se usa junto con el operador is para pruebas de tipo antes de intentar una conversión. El operador is verifica si el objeto proporcionado es del tipo dado y devuelve true si lo es, de lo contrario, devuelve false.

El siguiente ejemplo de código ilustra esto:

object testObject = "This is a string";

// Check if testObject is of type string
if (testObject is string) {
    // If true, convert testObject to string using 'as'
    string result = testObject as string;
    Console.WriteLine(result); // Outputs: This is a string
} else {
    Console.WriteLine("Not a string");
}

object testObject = "This is a string";

// Check if testObject is of type string
if (testObject is string) {
    // If true, convert testObject to string using 'as'
    string result = testObject as string;
    Console.WriteLine(result); // Outputs: This is a string
} else {
    Console.WriteLine("Not a string");
}

Dim testObject As Object = "This is a string"

' Check if testObject is of type string
If TypeOf testObject Is String Then
	' If true, convert testObject to string using 'as'
	Dim result As String = TryCast(testObject, String)
	Console.WriteLine(result) ' Outputs: This is a string
Else
	Console.WriteLine("Not a string")
End If

Dim testObject As Object = "This is a string"

' Check if testObject is of type string
If TypeOf testObject Is String Then
	' If true, convert testObject to string using 'as'
	Dim result As String = TryCast(testObject, String)
	Console.WriteLine(result) ' Outputs: This is a string
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.

Aprofundizando: Casos especiales y consideraciones

Conversiones de tipos de valores anulables

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 a un valor null. Sin embargo, si los hacemos anulables, se les puede asignar null. El operador as puede usarse para intentar la conversión a un tipo de valor anulable:

// 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?;

' Declare a nullable integer
Dim nullableInt? As Integer = 10

' Box the nullable int
Dim objInt As Object = nullableInt

' Attempt to unbox using 'as' to a nullable int type
Dim resultInt? As Integer = CType(objInt, Integer?)

' Declare a nullable integer
Dim nullableInt? As Integer = 10

' Box the nullable int
Dim objInt As Object = nullableInt

' Attempt to unbox using 'as' to a nullable int type
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 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"

Friend Class Sample
	' Define an implicit conversion from Sample to string
	Public Shared Widening Operator CType(ByVal s As Sample) As String
		Return "Converted to String"
	End Operator
End Class

Private sampleObject As New Sample()

' Use 'as' to convert 'sampleObject' to string
Private conversionResult As String = TryCast(sampleObject, String)

' conversionResult will hold "Converted to String"

Friend Class Sample
	' Define an implicit conversion from Sample to string
	Public Shared Widening Operator CType(ByVal s As Sample) As String
		Return "Converted to String"
	End Operator
End Class

Private sampleObject As New Sample()

' Use 'as' to convert 'sampleObject' to string
Private conversionResult As String = TryCast(sampleObject, 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 usar 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

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 encapsula 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;

Dim intValue As Integer = 42

' Box the value type to an object
Dim boxedValue As Object = intValue

Dim intValue As Integer = 42

' Box the value type to an object
Dim boxedValue As Object = intValue

Aquí, el intValue se empaqueta en un object.

El desempaquetado es el proceso inverso de empaquetado, es decir, extraer el tipo de valor del object. El operador as se puede usar para desempaquetar valores de manera segura, especialmente cuando no estás seguro de si el object contiene el tipo de valor que esperas. 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?;

Dim obj As Object = 42

' Attempt to unbox using 'as' to a nullable int type
Dim result? As Integer = CType(obj, Integer?)

Dim obj As Object = 42

' Attempt to unbox using 'as' to a nullable int type
Dim result? As Integer = CType(obj, Integer?)

Trabajar con matrices

Los arreglos 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" };

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

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

' Attempt to cast to a string array using 'as'
Dim stringArray() As String = TryCast(arrayObject, String())

' stringArray will hold the array of strings if successful

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

' Attempt to cast to a string array using 'as'
Dim stringArray() As String = TryCast(arrayObject, 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 con seguridad tratarlo 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, podrías 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, considera una lista de objetos que contienen tanto cadenas como enteros. Si quisieras recuperar solo las cadenas, podrías 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"

Dim mixedList = New List(Of Object) From {"Hello", 42, "World", 100}

' Use LINQ to select only strings from mixedList
Dim stringValues = mixedList.Select(Function(item) TryCast(item, String)).Where(Function(item) item IsNot Nothing).ToList()

' stringValues will contain "Hello" and "World"

Dim mixedList = New List(Of Object) From {"Hello", 42, "World", 100}

' Use LINQ to select only strings from mixedList
Dim stringValues = mixedList.Select(Function(item) TryCast(item, String)).Where(Function(item) item IsNot Nothing).ToList()

' stringValues will contain "Hello" and "World"

Integración con Iron Suite

Soluciones Iron Suite para Desarrolladores de C# es un conjunto de herramientas de alta calidad que permite a los desarrolladores de C# integrar sin problemas funcionalidades como la manipulación de PDF, manejo de Excel, Reconocimiento Óptico de Caracteres (OCR) y generación y lectura de códigos de barras. Estas herramientas, como 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#. 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 una 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 permite a los desarrolladores leer, editar y crear hojas de cálculo de Excel sin necesidad de depender de Office Interop. En el contexto de nuestra discusión sobre conversiones de tipo, piense en IronXL como una herramienta que le permite convertir estructuras de datos o entradas de base 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. Vinculándolo con nuestro tutorial, es similar a convertir un object (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. IronBarcode Tool for Barcode Processing ayuda a los desarrolladores a generar, leer y decodificar códigos de barras en aplicaciones C#. Relacionándolo con nuestra discusión sobre conversiones de tipo, IronBarcode puede ser visto como una herramienta que traduce datos visuales del código de barras (una forma de object) 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 ofrece C#, especialmente cuando se vincula a nuestra discusión sobre conversiones de tipo y verificación de tipo. Estas herramientas, como los operadores as y is, proporcionan a los desarrolladores la capacidad de convertir y procesar datos eficientemente.

Si está considerando integrar alguna de estas herramientas en sus proyectos, cabe destacar que cada licencia de producto comienza a partir de $999 y cada producto ofrece una prueba gratuita de Iron Suite Tools. Para aquellos que buscan una solución integral, Iron Suite ofrece una oferta atractiva: puede adquirir la licencia de Iron Suite por el precio de solo dos productos.