C# Casting (Comment ça fonctionne pour les développeurs)

Conversion implicite vs. explicite

En C#, la conversion peut être globalement catégorisée en deux types : conversion implicite et conversion explicite.

• Conversion Implicite : Cela se produit lorsqu'une conversion est effectuée automatiquement par le compilateur. Elle est sûre et ne mène pas à une perte de données. Par exemple, convertir un type de données plus petit (comme une variable entière) en un type plus grand (comme une variable double) est implicite :

  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

  Ce processus est souvent appelé conversion automatique, car le compilateur C# le gère sans instruction explicite du développeur.

• Conversion Explicite : Cela nécessite une opération de conversion et est nécessaire lors de la conversion d'un type plus grand vers un type plus petit, car cela peut entraîner une perte de données. Par exemple :

  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

  Dans ce cas, le développeur doit indiquer son intention de convertir le type de données en un autre type, d'où le terme conversion de type explicite.

Scénarios de conversion courants

La conversion est couramment utilisée dans des scénarios impliquant des classes de base et dérivées. Par exemple, lorsque vous travaillez avec une hiérarchie de classes, vous pouvez convertir un objet de classe dérivée vers le type de sa classe de 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

Lors de l'utilisation d'IronPDF, la conversion est essentielle lorsque vous traitez avec diverses classes liées aux PDF, par exemple lorsque vous souhaitez convertir un objet PDF générique en un type plus spécifique pour accéder à certaines propriétés ou méthodes.

Installer IronPDF

Install-Package IronPdf

using IronPdf;

using IronPdf;

Imports IronPdf

Travailler avec des objets de document PDF

IronPDF provides several classes to manipulate PDF documents, such as PdfDocument, ChromePdfRenderer, and PdfPage. Comprendre comment ces types interagissent par la conversion est crucial pour une manipulation efficace des PDF.

Par exemple, vous pouvez avoir une collection d'objets PdfDocument génériques et avoir besoin de travailler avec un objet PdfPage spécifique. Vous pouvez y parvenir par la conversion :

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

Cette conversion vous permet d'accéder aux propriétés et méthodes spécifiques à PdfPage, améliorant votre contrôle sur le contenu PDF.

Exemple : Conversion en action

Jetons un œil à l'exemple suivant, où nous devons extraire du texte d'un PDF et convertir correctement les objets :

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 d'entrée :

Sortie de la console :

Dans cet exemple, nous chargeons un document PDF, parcourons ses pages et convertissons chaque page en PdfPage pour extraire le contenu textuel. Cela montre comment la conversion vous permet de travailler avec les propriétés et méthodes spécifiques des classes IronPDF.

Éviter InvalidCastException

Lors de la conversion, il est important de s'assurer que la conversion est valide pour éviter une InvalidCastException à l'exécution. Voici quelques meilleures pratiques :

1. Utilisez le mot-clé as : Ce mot-clé vous permet d'essayer une conversion sans déclencher d'exception en cas d'échec. Au lieu de cela, il renvoie 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. Vérification du type avec is : Avant de convertir, vous pouvez vérifier le type de l'objet en utilisant le mot-clé 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. Conversions définies par l'utilisateur : C# permet aux développeurs de définir leurs propres règles de conversion pour les classes personnalisées par le biais de conversions définies par l'utilisateur. Cela peut être particulièrement utile lorsque vous souhaitez faciliter un moyen plus intuitif de convertir entre différents types définis par l'utilisateur.

   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

Considérations de performance

Bien que la conversion soit généralement efficace, des conversions excessives ou inutiles peuvent entraîner des problèmes de performance, en particulier dans des scénarios impliquant de grandes collections ou des objets complexes. Pour optimiser les performances :

• Minimisez les conversions en travaillant avec les types les plus spécifiques possible.
• Évitez les conversions dans les boucles critiques pour les performances, et au lieu de cela, mettez en cache les résultats lorsque c'est possible.
• Profitez des méthodes intégrées pour la conversion de type lorsque c'est possible, car elles peuvent souvent offrir de meilleures performances optimisées.