Conversão de tipos em C# (Como funciona para desenvolvedores)

Conversão implícita vs. conversão explícita

Em C#, a conversão de tipos pode ser amplamente categorizada em dois tipos: conversão implícita e conversão explícita .

• Conversão implícita: ocorre quando uma conversão é realizada automaticamente pelo compilador. É seguro e não causa perda de dados. Por exemplo, converter um tipo de dado menor (como uma variável inteira) para um tipo maior (como uma variável do tipo double) é implícito:

  int myInt = 10; // Integer variable
  double myDouble = myInt; // Implicit casting from int to double

  int myInt = 10; // Integer variable
  double myDouble = myInt; // Implicit casting from int to double

  Dim myInt As Integer = 10 ' Integer variable
  Dim myDouble As Double = myInt ' Implicit casting from int to double

  $vbLabelText   $csharpLabel

  Esse processo é frequentemente chamado de conversão automática, pois o compilador C# o realiza sem qualquer instrução explícita do desenvolvedor.

• Conversão explícita: Isso requer uma operação de conversão de tipo e é necessário ao converter de um tipo maior para um tipo menor, pois pode levar à perda de dados. Por exemplo:

  double myDouble = 9.78;
  int myInt = (int)myDouble; // Explicit casting from double to int

  double myDouble = 9.78;
  int myInt = (int)myDouble; // Explicit casting from double to int

  Imports System
  
  Dim myDouble As Double = 9.78
  Dim myInt As Integer = CInt(Math.Truncate(myDouble)) ' Explicit casting from double to int

  $vbLabelText   $csharpLabel

  Nesse caso, o desenvolvedor deve indicar sua intenção de converter o tipo de dados para outro tipo, daí o termo conversão explícita de tipo.

Cenários comuns de conversão de tipos

A conversão de tipos (casting) é comumente usada em cenários que envolvem classes base e derivadas. Por exemplo, ao trabalhar com uma hierarquia de classes, você pode converter um objeto de classe derivada para o tipo de sua classe base:

class Base { }
class Derived : Base { }
Derived derived = new Derived();
Base baseRef = derived; // Implicit casting to base class

class Base { }
class Derived : Base { }
Derived derived = new Derived();
Base baseRef = derived; // Implicit casting to base class

Friend Class Base
End Class
Friend Class Derived
	Inherits Base

End Class
Private derived As New Derived()
Private baseRef As Base = derived ' Implicit casting to base class

Ao usar o IronPDF, a conversão de tipos é essencial ao lidar com várias classes relacionadas a PDF, como quando você deseja converter um objeto PDF genérico em um tipo mais específico para acessar determinadas propriedades ou métodos.

Instalando o IronPDF

Install-Package IronPdf

using IronPdf;

using IronPdf;

Imports IronPdf

Trabalhando com objetos em documentos PDF

O IronPDF fornece diversas classes para manipular documentos PDF, como PdfDocument , ChromePdfRenderer e PdfPage . Compreender como esses tipos interagem por meio da conversão de tipos é crucial para a manipulação eficaz de PDFs.

Por exemplo, você pode ter uma coleção de objetos PdfDocument genéricos e precisar trabalhar com um objeto PdfPage específico. Você pode conseguir isso por meio de conversão de tipos:

PdfDocument pdfDoc = new PdfDocument(210, 297);
PdfPage page = (PdfPage)pdfDoc.Pages[0]; // Casting a generic PDF page to a specific type

PdfDocument pdfDoc = new PdfDocument(210, 297);
PdfPage page = (PdfPage)pdfDoc.Pages[0]; // Casting a generic PDF page to a specific type

Dim pdfDoc As New PdfDocument(210, 297)
Dim page As PdfPage = CType(pdfDoc.Pages(0), PdfPage) ' Casting a generic PDF page to a specific type

Essa conversão permite acessar propriedades e métodos específicos do PdfPage , aumentando o controle sobre o conteúdo do PDF.

Exemplo: Conversão de tipos em ação

Vejamos o seguinte exemplo, onde precisamos extrair texto de um PDF e converter os objetos adequadamente:

using IronPdf;
using IronPdf.Pages;
using System;

public static void Main(string[] args)
{
    PdfDocument pdf = PdfDocument.FromFile("example.pdf");
    foreach (PdfPage page in pdf.Pages)
    {
        PdfPage pdfPage = (PdfPage)page;
        string text = pdfPage.Text;
        Console.WriteLine($"Text from Page {pdfPage.PageIndex}: {text}");
    }
}

using IronPdf;
using IronPdf.Pages;
using System;

public static void Main(string[] args)
{
    PdfDocument pdf = PdfDocument.FromFile("example.pdf");
    foreach (PdfPage page in pdf.Pages)
    {
        PdfPage pdfPage = (PdfPage)page;
        string text = pdfPage.Text;
        Console.WriteLine($"Text from Page {pdfPage.PageIndex}: {text}");
    }
}

Imports IronPdf
Imports IronPdf.Pages
Imports System

Public Shared Sub Main(ByVal args() As String)
	Dim pdf As PdfDocument = PdfDocument.FromFile("example.pdf")
	For Each page As PdfPage In pdf.Pages
		Dim pdfPage As PdfPage = CType(page, PdfPage)
		Dim text As String = pdfPage.Text
		Console.WriteLine($"Text from Page {pdfPage.PageIndex}: {text}")
	Next page
End Sub

Entrada PDF:

Saída do console:

Neste exemplo, carregamos um documento PDF, percorremos suas páginas e convertemos cada página para um objeto PdfPage para extrair o conteúdo de texto. Isso demonstra como a conversão de tipos permite trabalhar com as propriedades e métodos específicos das classes do IronPDF .

Evitando InvalidCastException

Ao realizar conversões de tipo, é importante garantir que a conversão seja válida para evitar uma exceção InvalidCastException em tempo de execução. Aqui estão algumas boas práticas:

1. Use a palavra-chave as: Esta palavra-chave permite que você tente uma conversão sem lançar uma exceção caso ela falhe. Em vez disso, retorna nulo.

   PdfPage pdfPage = page as PdfPage; // Safe cast
   if (pdfPage != null)
   {
       // Proceed with pdfPage
   }

   PdfPage pdfPage = page as PdfPage; // Safe cast
   if (pdfPage != null)
   {
       // Proceed with pdfPage
   }

   Dim pdfPage As PdfPage = TryCast(page, PdfPage) ' Safe cast
   If pdfPage IsNot Nothing Then
   	' Proceed with pdfPage
   End If

   $vbLabelText   $csharpLabel

2. Verificação de tipo com is: Antes da conversão, você pode verificar o tipo do objeto usando a palavra-chave is.

   if (page is PdfPage)
   {
       PdfPage pdfPage = (PdfPage)page; // Safe cast after type check
   }

   if (page is PdfPage)
   {
       PdfPage pdfPage = (PdfPage)page; // Safe cast after type check
   }

   If TypeOf page Is PdfPage Then
   	Dim pdfPage As PdfPage = CType(page, PdfPage) ' Safe cast after type check
   End If

   $vbLabelText   $csharpLabel

3. Conversões definidas pelo usuário: O C# permite que os desenvolvedores definam suas próprias regras de conversão para classes personalizadas por meio de conversões definidas pelo usuário. Isso pode ser particularmente útil quando se deseja facilitar uma forma mais intuitiva de conversão entre diferentes tipos definidos pelo usuário.

   public class MyCustomType
   {
       public static explicit operator MyCustomType(int value)
       {
           return new MyCustomType(/* conversion logic */);
       }
   }
   
   int myInt = 5;
   MyCustomType myCustomType = (MyCustomType)myInt; // Using explicit user-defined conversion

   public class MyCustomType
   {
       public static explicit operator MyCustomType(int value)
       {
           return new MyCustomType(/* conversion logic */);
       }
   }
   
   int myInt = 5;
   MyCustomType myCustomType = (MyCustomType)myInt; // Using explicit user-defined conversion

   Public Class MyCustomType
   	Public Shared Narrowing Operator CType(ByVal value As Integer) As MyCustomType
   		Return New MyCustomType()
   	End Operator
   End Class
   
   Private myInt As Integer = 5
   Private myCustomType As MyCustomType = CType(myInt, MyCustomType) ' Using explicit user-defined conversion

   $vbLabelText   $csharpLabel

Considerações sobre o desempenho

Embora a conversão de tipos seja geralmente eficiente, o uso excessivo ou desnecessário de conversões pode levar a problemas de desempenho, especialmente em cenários que envolvem grandes coleções ou objetos complexos. Para otimizar o desempenho:

• Minimize as conversões de tipo trabalhando com os tipos mais específicos sempre que possível.
• Evite conversões de tipo em loops críticos para o desempenho e, em vez disso, armazene os resultados em cache sempre que possível.
• Utilize os métodos integrados para conversão de tipos sempre que possível, pois eles geralmente oferecem um desempenho mais otimizado.