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 comprobar si un objeto es de un tipo determinado o intentar convertirlo a ese tipo. Ahí es donde elPalabra clave del operador `as es muy útil. Junto con su pariente cercano, el operador is ayuda en la comprobación de tipos 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 ofrece 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#). En tiempo de compilación no conocemos el tipo subyacente. El operador as se utiliza para intentar tratar myObj como una string. Si tiene éxito, myStr contendrá el valor de la cadena. En caso contrario, contendrá un "valor nulo".

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

Aunque tanto el reparto como operador como el explícito sirven para fines similares, hay una distinción clave. Si una conversión explícita falla, lanza una excepción. Por otra parte, si el intento de conversión de un tipo a otro del operador as 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, utilizar el operador as a menudo puede ser más seguro, ya que se evitan 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 comprobar el tipo antes de intentar una conversión. El operador is comprueba si el objeto proporcionado es del tipo dado y devuelve true si lo es, en caso contrario, devuelve false.

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 concordancia de patrones en versiones posteriores de C#, el operador is también puede realizar ciertas acciones si se supera la prueba de tipo. Esto reduce a menudo la necesidad de utilizar el operador as.

Casos especiales y consideraciones más profundas

Conversiones de tipo de valor anulable

Uno de los casos especiales en los que el operador as es inapreciable es con los tipos de valor anulables. Tipos de valor(como int, double, etc.) no se le puede asignar un "valor nulo". Sin embargo, al hacerlos anulables, puedes asignarles null. El operador as puede utilizarse 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 ambas conversiones de referencia(entre tipos de referencia relacionados) y 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 tratar un objeto de tipo Muestra como una cadena.

Cuando no se aplica as

Recuerde que el operador as no puede utilizarse con tipos de valor(a menos que se trate de tipos de valores 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 objeto. Cuando encajonas un tipo de valor, lo envuelves dentro de un objeto.

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 encasilla en un object.

Unboxing es el proceso inverso al boxing, es decir, extraer el tipo de valor del objeto. El operador as puede utilizarse para descomprimir valores de forma segura, especialmente cuando no se está seguro de si el object contiene el tipo de valor que se espera. 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 objeto es un tipo específico de array y luego trabajar con él. El operador as también puede ayudar en este caso.

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 una matriz de objetos, pero en realidad contiene cadenas. Utilizando el operador as, puedes intentar tratarlo como un array de cadenas.

Combinación de as con LINQ

Idioma Consulta integrada(LINQ - Documentación de Microsoft) es una potente función de C# que permite consultar colecciones de forma similar a SQL. A veces, puede que recuperes objetos de tipos mixtos en una colección y quieras filtrar tipos específicos. En este caso, el operador as puede ser muy útil.

Por ejemplo, considere una lista de objetos que contenga tanto cadenas como números enteros. Si quisiera recuperar sólo las cadenas, podría utilizar 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 a la perfección funcionalidades como la manipulación de PDF, el manejo de Excel, el reconocimiento óptico de caracteres(OCR)y generación y lectura de códigos de barras. Estas herramientas, al igual que los operadores "como" y "es", son fundamentales para aumentar la eficacia de los desarrolladores a la hora de crear 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 forma similar a la conversión tipográfica, convertirla en un documento PDF bien formateado.

IronXL

El manejo de archivos Excel es un requisito frecuente en muchas aplicaciones de software. ironXL para operaciones en Excel proporciona a los desarrolladores la capacidad de leer, editar y crear hojas de cálculo 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 bases de datos en C# a formatos de Excel sin problemas.

IronOCR

reconocimiento óptico de caracteres con IronOCR es una herramienta de reconocimiento óptico de caracteres que permite leer e interpretar texto a partir de imágenes. Enlazando esto con 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 funciones 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 descodificar códigos de barras en aplicaciones C#. En relación con nuestro debate sobre las conversiones de tipos, IronBarcode puede considerarse como una herramienta que traduce datos visuales de códigos 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 de laOfertas de Iron Suite es un testimonio de la flexibilidad y potencia que ofrece C#, especialmente cuando se vincula a nuestra discusión sobre conversiones de tipos y comprobación de tipos. Estas herramientas, como los operadores as y is, proporcionan a los desarrolladores la capacidad de convertir y procesar datos de forma eficaz.

Si está considerando integrar alguna de estas herramientas en sus proyectos, vale la pena señalar que la licencia de cada producto comienza a partir de $749 y cada producto ofrece unprueba gratuita de Iron Suite Tools. Para los que buscan una solución completa, Iron Suite ofrece una tentadora oferta: puedeadquirir la licencia de Iron Suite por el precio de sólo dos productos.