C# Casting (Wie es für Entwickler funktioniert)

Implicit vs. Explicit Casting

In C#, casting can be broadly categorized into two types: implicit conversion and explicit conversion.

• Implicit Conversion: This occurs when a conversion is performed automatically by the compiler. It is safe and does not lead to data loss. For instance, converting a smaller data type (like an integer variable) to a larger type (like a double variable) is implicit:

  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

  This process is often referred to as automatic conversion, as the C# compiler handles it without any explicit instruction from the developer.

• Explicit Conversion: This requires a cast operation and is necessary when converting from a larger type to a smaller type, as it may lead to data loss. For example:

  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

  In this case, the developer must indicate their intention to convert the data type to another type, hence the term explicit type casting.

Common Casting Scenarios

Casting is commonly used in scenarios involving base and derived classes. For example, when working with a class hierarchy, you can cast a derived class object to its base class type:

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

When using IronPDF, casting is essential when dealing with various PDF-related classes, such as when you want to convert a generic PDF object to a more specific type to access certain properties or methods.

Installing IronPDF

Install-Package IronPdf

using IronPdf;

using IronPdf;

Imports IronPdf

Working with PDF Document Objects

IronPDF provides several classes to manipulate PDF documents, such as PdfDocument, ChromePdfRenderer, and PdfPage. Understanding how these types interact through casting is crucial for effective PDF manipulation.

For instance, you may have a collection of generic PdfDocument objects and need to work with a specific PdfPage object. You can achieve this through casting:

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

This casting allows you to access properties and methods specific to PdfPage, enhancing your control over the PDF content.

Example: Casting in Action

Let's look at the following example, where we need to extract text from a PDF and cast objects appropriately:

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

Input PDF:

Console Output:

In this example, we load a PDF document, iterate through its pages, and cast each page to PdfPage to extract text content. This highlights how casting enables you to work with the specific properties and methods of IronPDF classes.

Avoiding InvalidCastException

When casting, it's important to ensure that the conversion is valid to avoid an InvalidCastException at runtime. Here are some best practices:

1. Use the as Keyword: This keyword allows you to attempt a cast without throwing an exception if it fails. Instead, it returns 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. Type Checking with is: Before casting, you can check the type of the object using the is keyword.

   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. User-Defined Conversions: C# allows developers to define their own casting rules for custom classes through user-defined conversions. This can be particularly useful when you want to facilitate a more intuitive way of converting between different user-defined types.

   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

Performance Considerations

While casting is generally efficient, excessive or unnecessary casting can lead to performance issues, especially in scenarios involving large collections or complex objects. To optimize performance:

• Minimize casting by working with the most specific types whenever possible.
• Avoid casting in performance-critical loops, and instead, cache results where feasible.
• Leverage built-in methods for type conversion when possible, as they can often provide more optimized performance.