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

Les bases du parsing des entiers

En C#, convertir une valeur de chaîne (comme "123") en entier se fait couramment en utilisant int.Parse() ou Convert.ToInt32(). Ces méthodes aident les développeurs à transformer des données textuelles en valeurs numériques utilisables pour les calculs et les validations.

• int.Parse(string s) : Convertit une chaîne de caractères en un entier. Lève une exception si la chaîne de caractères n'est pas un entier valide.
• Convert.ToInt32(string s) : Convertit une chaîne de caractères en un entier, en gérant différemment les entrées nulles.

Voici un exemple de conversion de chaînes en utilisant int.Parse() :

string numberString = "123";
// Convert the string to an integer using int.Parse
int num = int.Parse(numberString);
Console.WriteLine(num); // Output: 123

string numberString = "123";
// Convert the string to an integer using int.Parse
int num = int.Parse(numberString);
Console.WriteLine(num); // Output: 123

Dim numberString As String = "123"
' Convert the string to an integer using int.Parse
Dim num As Integer = Integer.Parse(numberString)
Console.WriteLine(num) ' Output: 123

Alternativement, en utilisant la classe Convert :

string numericString = "123";
// Convert the string to an integer using Convert.ToInt32
int result = Convert.ToInt32(numericString);
Console.WriteLine(result); // Outputs: 123

string numericString = "123";
// Convert the string to an integer using Convert.ToInt32
int result = Convert.ToInt32(numericString);
Console.WriteLine(result); // Outputs: 123

Dim numericString As String = "123"
' Convert the string to an integer using Convert.ToInt32
Dim result As Integer = Convert.ToInt32(numericString)
Console.WriteLine(result) ' Outputs: 123

La classe Convert vous permet de convertir des chaînes et d'autres types de données en toute sécurité. Elle est particulièrement utile lorsque la variable de chaîne pourrait représenter une valeur nulle ou invalide, car Convert.ToInt32() retourne une valeur par défaut (0 dans ce cas) au lieu de lancer une exception.

Valeur par défaut et gestion des erreurs

Un problème auquel les développeurs font souvent face lors de la conversion de chaînes en entiers est la gestion des entrées invalides ou non numériques. Si la représentation textuelle du nombre n'est pas dans le bon format, des méthodes comme int.Parse() lanceront une exception. Toutefois, Convert.ToInt32() dispose d'un mécanisme de secours intégré pour les chaînes invalides.

Voici un exemple démontrant comment gérer les valeurs par défaut lors du parsing :

string invalidString = "abc";
// Convert will return 0 instead of throwing an exception for invalid input
int result = Convert.ToInt32(invalidString);
Console.WriteLine(result); // Outputs: 0

string invalidString = "abc";
// Convert will return 0 instead of throwing an exception for invalid input
int result = Convert.ToInt32(invalidString);
Console.WriteLine(result); // Outputs: 0

Dim invalidString As String = "abc"
' Convert will return 0 instead of throwing an exception for invalid input
Dim result As Integer = Convert.ToInt32(invalidString)
Console.WriteLine(result) ' Outputs: 0

Si vous souhaitez convertir des chaînes avec plus de contrôle, vous pouvez utiliser int.TryParse(), qui retourne une valeur booléenne indiquant si la conversion a réussi ou échoué :

string invalidInput = "abc";
// Attempt to parse using TryParse, which avoids exceptions for invalid input
if (int.TryParse(invalidInput, out int result))
{
    Console.WriteLine(result);
}
else
{
    Console.WriteLine("Parsing failed.");
}

string invalidInput = "abc";
// Attempt to parse using TryParse, which avoids exceptions for invalid input
if (int.TryParse(invalidInput, out int result))
{
    Console.WriteLine(result);
}
else
{
    Console.WriteLine("Parsing failed.");
}

Dim invalidInput As String = "abc"
' Attempt to parse using TryParse, which avoids exceptions for invalid input
Dim result As Integer
If Integer.TryParse(invalidInput, result) Then
	Console.WriteLine(result)
Else
	Console.WriteLine("Parsing failed.")
End If

Dans ce cas, TryParse() utilise un paramètre out pour stocker l'entier converti, ce qui permet à la méthode de retourner une valeur sans lancer d'exception. Si la conversion échoue, l'instruction else s'exécutera au lieu de simplement planter le programme. Sinon, le programme affichera le résultat du nombre correctement parsé à partir de la chaîne d'entrée. L'utilisation de int.TryParse peut être utile dans les cas où des échecs de conversion sont attendus et où vous souhaitez éviter que le programme ne plante.

Pourquoi utiliser IronPDF pour le parsing des données ?

Lorsqu'on travaille avec des PDFs, on peut rencontrer des tableaux ou du texte non structuré contenant des données numériques sous forme de chaînes. Pour extraire et traiter ces données, il est crucial de convertir ces chaînes en entiers. IronPDF rend ce processus simple, offrant à la fois la flexibilité et la puissance de lire les contenus des PDFs et d'effectuer des opérations comme convertir des chaînes en valeurs numériques.

Voici quelques-unes des principales fonctionnalités qu'IronPDF offre :

• Conversion de HTML en PDF : IronPDF peut convertir des contenus HTML (y compris CSS, images et JavaScript) en PDFs entièrement formatés. Ceci est particulièrement utile pour rendre des pages web dynamiques ou des rapports sous forme de PDFs.
• Édition de PDF : Avec IronPDF, vous pouvez manipuler des documents PDF existants en ajoutant du texte, des images, et des graphiques, ainsi qu'en modifiant le contenu des pages existantes.
• Extraction de texte et d'images : La bibliothèque vous permet d'extraire le texte et les images à partir de PDFs, facilitant ainsi l'analyse du contenu des PDFs.
• Ajout de filigranes : Il est également possible d'ajouter des filigranes aux documents PDF pour le branding ou la protection des droits d'auteur.

Commencer avec IronPDF

// Command to install IronPDF package via the Package Manager Console
Install-Package IronPdf

using IronPdf;

using IronPdf;

Imports IronPdf

Exemple : Extraire et analyser des nombres à partir d'un PDF

using IronPdf;
using System.Text.RegularExpressions;

public class Program
{
    public static void Main(string[] args)
    {
        // Load a PDF file
        PdfDocument pdf = PdfDocument.FromFile("example.pdf");

        // Extract all text from the PDF
        string text = pdf.ExtractAllText();

        // Print the extracted text (for reference)
        Console.WriteLine("Extracted Text: ");
        Console.WriteLine(text);

        // Parse and print all numbers found in the extracted text
        Console.WriteLine("\nParsed Numbers:");

        // Use regular expression to find all number patterns, including integers and decimals
        var numberMatches = Regex.Matches(text, @"\d+(\.\d+)?");

        // Iterate through all matched numbers and print them
        foreach (Match match in numberMatches)
        {
            // Print each matched number
            Console.WriteLine($"{match.Value}");
        }
    }
}

using IronPdf;
using System.Text.RegularExpressions;

public class Program
{
    public static void Main(string[] args)
    {
        // Load a PDF file
        PdfDocument pdf = PdfDocument.FromFile("example.pdf");

        // Extract all text from the PDF
        string text = pdf.ExtractAllText();

        // Print the extracted text (for reference)
        Console.WriteLine("Extracted Text: ");
        Console.WriteLine(text);

        // Parse and print all numbers found in the extracted text
        Console.WriteLine("\nParsed Numbers:");

        // Use regular expression to find all number patterns, including integers and decimals
        var numberMatches = Regex.Matches(text, @"\d+(\.\d+)?");

        // Iterate through all matched numbers and print them
        foreach (Match match in numberMatches)
        {
            // Print each matched number
            Console.WriteLine($"{match.Value}");
        }
    }
}

Imports Microsoft.VisualBasic
Imports IronPdf
Imports System.Text.RegularExpressions

Public Class Program
	Public Shared Sub Main(ByVal args() As String)
		' Load a PDF file
		Dim pdf As PdfDocument = PdfDocument.FromFile("example.pdf")

		' Extract all text from the PDF
		Dim text As String = pdf.ExtractAllText()

		' Print the extracted text (for reference)
		Console.WriteLine("Extracted Text: ")
		Console.WriteLine(text)

		' Parse and print all numbers found in the extracted text
		Console.WriteLine(vbLf & "Parsed Numbers:")

		' Use regular expression to find all number patterns, including integers and decimals
		Dim numberMatches = Regex.Matches(text, "\d+(\.\d+)?")

		' Iterate through all matched numbers and print them
		For Each match As Match In numberMatches
			' Print each matched number
			Console.WriteLine($"{match.Value}")
		Next match
	End Sub
End Class

Explication du code

1. Extraire le texte du PDF :

   Le code commence par charger un fichier PDF en utilisant IronPDF. Il extrait ensuite tout le texte du PDF.

2. Utiliser des expressions régulières pour trouver les nombres :

   Le code utilise une expression régulière (un motif pour faire correspondre le texte) pour rechercher dans le texte extrait et trouver tous les nombres. L'expression régulière cherche à la fois les nombres entiers (ex : 12345) et les nombres décimaux (ex : 50.75).

3. Analyser et imprimer les nombres :

   Une fois les nombres trouvés, le programme les imprime chacun sur la console. Cela inclut les entiers et les décimaux.

4. Pourquoi les expressions régulières :

   Les expressions régulières sont utilisées car elles sont des outils puissants pour trouver des motifs dans le texte, comme les nombres. Elles peuvent gérer les nombres avec des symboles (comme les symboles monétaires $), rendant le processus plus flexible.

Formats incorrects dans les PDFs

Les PDFs contiennent souvent des nombres formatés en texte (ex : "1,234.56" ou "12,345 USD"). Pour traiter ces formats correctement, vous devez vous assurer que la représentation textuelle du nombre est dans le bon format pour le parsing. IronPDF vous permet d'extraire proprement le texte, et vous pouvez utiliser des méthodes de manipulation de chaînes (par ex. Replace()) pour ajuster le format avant la conversion.

Exemple :

string formattedNumber = "1,234.56"; // String value with commas
// Remove commas from the string to clean it
string cleanNumber = formattedNumber.Replace(",", "");
// Convert the cleaned string to an integer by first converting to double then to integer
int result = Convert.ToInt32(Convert.ToDouble(cleanNumber));
Console.WriteLine(result); // Outputs: 1234

string formattedNumber = "1,234.56"; // String value with commas
// Remove commas from the string to clean it
string cleanNumber = formattedNumber.Replace(",", "");
// Convert the cleaned string to an integer by first converting to double then to integer
int result = Convert.ToInt32(Convert.ToDouble(cleanNumber));
Console.WriteLine(result); // Outputs: 1234

Dim formattedNumber As String = "1,234.56" ' String value with commas
' Remove commas from the string to clean it
Dim cleanNumber As String = formattedNumber.Replace(",", "")
' Convert the cleaned string to an integer by first converting to double then to integer
Dim result As Integer = Convert.ToInt32(Convert.ToDouble(cleanNumber))
Console.WriteLine(result) ' Outputs: 1234

Gérer plusieurs valeurs numériques dans du texte

Dans un PDF complexe, les valeurs numériques peuvent apparaître dans différents formats ou être dispersées à différents endroits. Avec IronPDF, vous pouvez extraire tout le texte, puis utiliser des expressions régulières pour trouver et convertir les chaînes en entiers de manière efficace.