C# AS (Como funciona para desenvolvedores)

Noções básicas do operador as

A palavra-chave as em C# é um operador binário usado para realizar certas conversões entre tipos de referência compatíveis ou tipos anuláveis. O código a seguir fornece uma demonstração simples:

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

No código acima, myObj é um objeto do tipo object (o tipo base para todos os tipos em C#). Não temos certeza de seu tipo subjacente em tempo de compilação. O operador as é usado para tentar tratar myObj como um string. Se a operação for bem-sucedida, myStr conterá o valor da string. Caso contrário, conterá o valor null.

Qual a diferença entre isso e a conversão explícita (cast)?

Embora o operador as e a conversão explícita sirvam a propósitos semelhantes, existe uma distinção fundamental. Se uma conversão explícita falhar, uma exceção será lançada. Por outro lado, se a tentativa do operador as de conversão de um tipo para outro falhar, o operador retorna um valor null em vez de gerar uma exceção. Vamos entender isso com o seguinte exemplo 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.

Como se pode ver, usar o operador as geralmente é mais seguro, pois evita possíveis erros de tempo de execução.

Conversões de tipo de valor anulável

Um dos casos especiais em que o operador as é indispensável é com tipos de valor anuláveis. Tipos de valor (como int, double, etc.) não podem receber um valor null. No entanto, ao torná-los anuláveis, você pode atribuir o valor nulo a eles. O operador as pode ser usado para tentar a conversão para um tipo de valor anulável:

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

Conversões de referência e conversões definidas pelo usuário

O operador as suporta conversões de referência (entre tipos de referência relacionados) e conversões definidas pelo usuário. As conversões definidas pelo usuário são aquelas definidas usando métodos de conversão especiais em suas classes.

Considere o seguinte código de uma conversão definida pelo usuário:

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"

Aqui, o método de conversão definido pelo usuário permite que um objeto do tipo Sample seja tratado como um string.

Quando as não se aplica

Lembre-se de que o operador as não pode ser usado com tipos de valor (a menos que se trate de tipos de valor anuláveis) ou com conversões definidas pelo usuário que envolvam um método explícito.

Boxing e Unboxing com as

Boxing é o processo de converter uma instância de um tipo de valor em uma referência de objeto. Isso é possível porque todo tipo de valor herda implicitamente de um object. Quando você encapsula um tipo de valor, você o envolve dentro de um object.

Considere o seguinte código para conversões de boxing:

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

Aqui, o intValue está dentro de um object.

O unboxing é o processo inverso do boxing, ou seja, extrair o tipo de valor do object. O operador as pode ser usado para extrair valores com segurança, especialmente quando você não tem certeza se o object contém o tipo de valor que você está esperando. Se a operação de desempacotamento falhar, o resultado da expressão será nulo.

Considere o seguinte exemplo de conversões de unboxing:

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?)

Trabalhando com Matrizes

Em C#, arrays são tipos de referência. Às vezes, você pode precisar determinar se um object é um tipo específico de matriz e então trabalhar com ela. O operador as também pode ajudar aqui.

Considere o seguinte 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

No código acima, arrayObject é um array de objetos, mas na verdade contém strings. Usando o operador as, você pode tentar tratá-lo com segurança como uma matriz de strings.

Combinando as com LINQ

A Consulta Integrada à Linguagem ( LINQ - Documentação da Microsoft ) é um recurso poderoso em C# que permite consultar coleções de maneira semelhante ao SQL. Às vezes, você pode recuperar objetos de tipos mistos em uma coleção e querer filtrar tipos específicos. Nesse caso, o operador as pode ser muito útil.

Por exemplo, considere uma lista de objetos que contenha tanto strings quanto números inteiros. Se você quisesse recuperar apenas as strings, poderia usar o operador as em conjunto com o 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"

IronPDF

O IronPDF permite que os desenvolvedores gerem, manipulem e leiam arquivos PDF em seus aplicativos C#. Considerando a relevância para o nosso tópico, suponha que você tenha um tipo de referência que contenha alguns dados e queira converter esses dados em um relatório ou documento. IronPDF pode pegar a saída do seu aplicativo e, de maneira semelhante à conversão de tipo, traduzi-la em um documento PDF bem formatado.

IronXL

O manuseio de arquivos do Excel é um requisito frequente em muitos aplicativos de software. IronXL for Excel Operations oferece aos desenvolvedores a capacidade de ler, editar e criar planilhas do Excel sem precisar depender do Office Interop. No contexto da nossa discussão sobre conversões de tipo, pense em IronXL como uma ferramenta que permite converter estruturas de dados ou entradas de banco de dados em C# para formatos do Excel de forma integrada.

IronOCR

Optical Character Recognition with IronOCR é uma ferramenta de reconhecimento óptico de caracteres que permite aos desenvolvedores ler e interpretar textos a partir de imagens. Fazendo a ligação com o nosso tutorial, é semelhante a converter um object (neste caso, uma imagem) para um tipo mais específico (string ou dados textuais) usando recursos avançados de reconhecimento.

IronBarcode

Em muitas aplicações comerciais, o manuseio de códigos de barras é indispensável. IronBarcode Tool for Barcode Processing auxilia desenvolvedores na geração, leitura e decodificação de códigos de barras em aplicações C#. Relacionando-nos com nossa discussão sobre conversões de tipo, IronBarcode pode ser visto como uma ferramenta que traduz dados visuais de código de barras (uma forma de object) em tipos de dados mais específicos e utilizáveis, como strings ou detalhes do produto.