C# Casting (Cómo Funciona para Desarrolladores)

Casting implícito frente a explícito

En C#, la conversión se puede categorizar ampliamente en dos tipos: conversión implícita y conversión explícita.

• Conversión implícita: esto ocurre cuando el compilador realiza una conversión automáticamente. Es segura y no conduce a la pérdida de datos. Por ejemplo, convertir un tipo de dato más pequeño (como una variable entera) a un tipo más grande (como una variable doble) es 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

  Este proceso a menudo se denomina conversión automática, ya que el compilador de C# lo maneja sin ninguna instrucción explícita del desarrollador.

• Conversión explícita: esto requiere una operación de conversión y es necesario cuando se convierte de un tipo más grande a un tipo más pequeño, ya que puede provocar pérdida de datos. Por ejemplo:

  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

  En este caso, el desarrollador debe indicar su intención de convertir el tipo de dato a otro tipo, de ahí el término conversión de tipo explícita.

Escenarios comunes de fundición

La conversión se utiliza comúnmente en escenarios que involucran clases base y derivadas. Por ejemplo, al trabajar con una jerarquía de clases, puede convertir un objeto de clase derivada a su tipo de clase 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

Al usar IronPDF, la conversión es esencial al tratar con varias clases relacionadas con PDF, como cuando desea convertir un objeto PDF genérico a un tipo más específico para acceder a ciertas propiedades o métodos.

Instalación de IronPDF

Install-Package IronPdf

using IronPdf;

using IronPdf;

Imports IronPdf

Trabajar con objetos de documentos PDF

IronPDF proporciona varias clases para manipular documentos PDF, tales como PdfDocument, ChromePdfRenderer y PdfPage. Entender cómo estos tipos interactúan a través de la conversión es crucial para una manipulación efectiva de PDF.

Por ejemplo, puede tener una colección de objetos PdfDocument genéricos y necesitar trabajar con un objeto PdfPage específico. Puede lograr esto mediante la conversión:

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

Esta conversión le permite acceder a las propiedades y métodos específicos de PdfPage, mejorando su control sobre el contenido PDF.

Ejemplo: Casting en acción

Veamos el siguiente ejemplo, donde necesitamos extraer texto de un PDF y convertir objetos apropiadamente:

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

PDF de Entrada:

Salida de Consola:

En este ejemplo, cargamos un documento PDF, iteramos a través de sus páginas y convertimos cada página a PdfPage para extraer contenido textual. Esto destaca cómo la conversión le permite trabajar con las propiedades y métodos específicos de las clases de IronPDF.

Evitar InvalidCastException

Al convertir, es importante asegurarse de que la conversión sea válida para evitar una InvalidCastException en tiempo de ejecución. Aquí hay algunas mejores prácticas:

1. Utilice la palabra clave as: esta palabra clave le permite intentar una conversión sin generar una excepción si falla. En su lugar, devuelve null.

   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. Comprobación de tipo con is: antes de la conversión, puede comprobar el tipo del objeto utilizando la palabra clave 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. Conversiones definidas por el usuario: C# permite a los desarrolladores definir sus propias reglas de conversión para clases personalizadas a través de conversiones definidas por el usuario. Esto puede ser particularmente útil cuando desea facilitar una forma más intuitiva de convertir entre diferentes tipos definidos por el usuario.

   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

Consideraciones sobre el rendimiento

Mientras que la conversión es generalmente eficiente, la conversión excesiva o innecesaria puede llevar a problemas de rendimiento, especialmente en escenarios que involucran colecciones grandes o objetos complejos. Para optimizar el rendimiento:

• Minimize la conversión trabajando con los tipos más específicos siempre que sea posible.
• Evite la conversión en bucles críticos para el rendimiento, y en su lugar, almacene en caché los resultados donde sea factible.
• Aproveche los métodos integrados para la conversión de tipos cuando sea posible, ya que a menudo pueden proporcionar un rendimiento más optimizado.