A programação em C# frequentemente envolve o trabalho com diferentes tipos de dados. Às vezes, precisamos verificar se um object é de um certo tipo ou tentar convertê-lo para esse tipo. É aí que a palavra-chave do operador as se torna útil. Junto com seu parente próximo, o operador is auxilia em testes de tipo e conversões. Neste tutorial, exploraremos as complexidades desse operador e seus casos de uso.

Entendendo o operador

Fundamentos do operador as

A palavra-chave do operador 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.

' 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 bem-sucedido, myStr manterá o valor da string. Caso contrário, ele conterá um valor null.

Qual a diferença entre isso e o elenco explícito?

Embora ambos os operadores as e cast explícito tenham objetivos semelhantes, há uma diferença chave. Se uma conversão explícita falhar, uma exceção será lançada. Por outro lado, se a tentativa de conversão do operador as de um tipo para outro falhar, o operador retorna um valor null em vez de lançar 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.

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 é evidente, usar o operador as pode ser mais seguro, pois evita possíveis erros de tempo de execução.

A conexão com o operador é

Frequentemente, o operador as é usado em conjunto com o operador is para teste de tipo antes de tentar uma conversão. O operador is verifica se o objeto fornecido é do tipo dado e retorna true se for, caso contrário, retorna false.

O exemplo de código a seguir ilustra isso:

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

Com a introdução da correspondência de padrões em versões posteriores de C#, o operador is também pode realizar certas ações se o teste de tipo for aprovado. Isso geralmente reduz a necessidade de usar o operador as.

Aprofundando o assunto: casos especiais e considerações

Conversões de tipo de valor anulável

Um dos casos especiais em que o operador as é inestimável é com tipos de valor anuláveis. Tipos de valor (como int, double, etc.) não podem ser atribuídos a 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?)

' 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"

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 "como" não se aplica

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

Cenários avançados com o operador

Boxe 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

Dim intValue As Integer = 42

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

Aqui, o intValue é encapsulado em um object.

A desmontagem é o processo inverso da encapsulagem, ou seja, extrair o tipo de valor do object. O operador as pode ser usado para desmontar valores com segurança, especialmente quando você não tem certeza se o object contém o tipo de valor que você espera. 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?)

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 array e então trabalhar com ele. O operador as pode ajudar aqui também.

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

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 com segurança tratá-lo como um array 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. Aqui, 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, você poderia usar o operador as em conjunto com 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"

Integração com o Iron Suite

O Iron Suite Solutions para desenvolvedores C# é um conjunto de ferramentas de alta qualidade que permite aos desenvolvedores C# integrar funcionalidades como manipulação de PDF, processamento de Excel, reconhecimento óptico de caracteres (OCR) e geração e leitura de códigos de barras de forma integrada. Essas ferramentas, como nossa discussão anterior sobre os operadores as e is, são fundamentais para aumentar a eficiência de um desenvolvedor na construção de aplicações robustas.

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 forma 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 proporciona aos desenvolvedores a capacidade de ler, editar e criar planilhas do Excel sem necessitar de depender do Office Interop. No contexto de 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# em formatos do Excel sem complicações.

IronOCR

Optical Character Recognition with IronOCR é uma ferramenta de reconhecimento óptico de caracteres que permite aos desenvolvedores ler e interpretar texto a partir de imagens. Ligando isso ao nosso tutorial, é semelhante a converter um object (neste caso, uma imagem) para um tipo mais específico (string ou dados textuais) usando capacidades avançadas de reconhecimento.

Código de barras IronBarcode

Em muitas aplicações comerciais, o manuseio de códigos de barras é indispensável. IronBarcode Tool for Barcode Processing auxilia os desenvolvedores na geração, leitura e decodificação de códigos de barras em aplicações C#. Relatando à 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 de produtos.

Conclusão

Cada produto dentro do pacote Iron Suite é uma prova da flexibilidade e do poder que o C# oferece, especialmente quando relacionado à nossa discussão sobre conversões de tipo e verificação de tipos. Essas ferramentas, como os operadores as e is, oferecem aos desenvolvedores a capacidade de converter e processar dados de forma eficiente.

Se você está considerando integrar alguma dessas ferramentas em seus projetos, vale a pena notar que cada licença de produto começa a partir de $999 e cada produto oferece uma avaliação gratuita das Ferramentas Iron Suite. Para aqueles que procuram uma solução abrangente, Iron Suite oferece uma proposta atraente: você pode adquirir a licença Iron Suite pelo preço de apenas dois produtos.