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

Grundlagen des Parsens von Ganzzahlen

In C# wird das Konvertieren eines Zeichenfolgenwerts (wie "123") in eine Ganzzahl häufig mit int.Parse() oder Convert.ToInt32() durchgeführt. Diese Methoden helfen Entwicklern, textuelle Daten in verwendbare numerische Werte für Berechnungen und Validierungen umzuwandeln.

• int.Parse(string s): Konvertiert eine Zeichenfolge in eine Ganzzahl. Löst eine Ausnahme aus, wenn die Zeichenfolge keine gültige Ganzzahl ist.
• Convert.ToInt32(string s): Konvertiert eine Zeichenfolge in eine Ganzzahl und behandelt Null-Eingaben anders.

Hier ist ein Beispiel für das Konvertieren von Zeichenfolgen mit 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

Alternativ mit der Convert-Klasse:

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

Die Convert-Klasse ermöglicht es Ihnen, Zeichenfolgen und andere Datentypen sicher zu konvertieren. Dies ist besonders nützlich, wenn die Zeichenfolgenvariable möglicherweise einen Null- oder ungültigen Wert darstellt, da Convert.ToInt32() einen Standardwert (0 in diesem Fall) zurückgibt, anstatt eine Ausnahme auszulösen.

Standardwert und Umgang mit Fehlern

Ein Problem, mit dem Entwickler häufig konfrontiert sind, wenn sie Zeichenfolgen in Ganzzahlen umwandeln, ist der Umgang mit ungültigen oder nicht numerischen Eingaben. Wenn die Zeichenfolgendarstellung der Zahl nicht im richtigen Format ist, lösen Methoden wie int.Parse() eine Ausnahme aus. Jedoch verfügt Convert.ToInt32() über einen integrierten Rückfallmechanismus für ungültige Zeichenfolgen.

Hier ist ein Beispiel, das zeigt, wie man mit Standardwerten beim Parsen umgeht:

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

Wenn Sie Zeichenfolgen mit mehr Kontrolle konvertieren möchten, können Sie int.TryParse() verwenden, das einen booleschen Wert zurückgibt, der angibt, ob die Konvertierung erfolgreich war oder nicht:

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

In diesem Fall verwendet TryParse() einen Out-Parameter, um die konvertierte Ganzzahl zu speichern, wodurch die Methode einen Wert zurückgeben kann, ohne eine Ausnahme auszulösen. Falls die Konvertierung fehlschlägt, wird die else-Anweisung ausgeführt, anstatt Ihr Programm einfach zum Absturz zu bringen. Andernfalls zeigt das Programm das Ergebnis der erfolgreich geparsten Zahl aus der Eingabezeichenfolge an. Die Verwendung von int.TryParse kann in Fällen hilfreich sein, in denen Konvertierungsfehler erwartet werden und Sie den Absturz des Programms vermeiden möchten.

Warum IronPDF für das Parsen von Daten verwenden?

Bei der Arbeit mit PDFs stößt man möglicherweise auf Tabellen oder unstrukturierten Text, der numerische Daten in Zeichenfolgen enthält. Um diese Daten zu extrahieren und zu verarbeiten, müssen Zeichenfolgen in Ganzzahlen konvertiert werden. IronPDF macht diesen Prozess einfach und bietet sowohl die Flexibilität als auch die Leistung, um PDF-Inhalte zu lesen und Operationen wie das Konvertieren von Zeichenfolgen in numerische Werte durchzuführen.

Hier sind einige der Hauptmerkmale, die IronPDF bietet:

• HTML-zu-PDF-Konvertierung: IronPDF kann HTML-Inhalte (einschließlich CSS, Bilder und JavaScript) in vollständig formatierte PDFs umwandeln. Dies ist besonders nützlich, um dynamische Webseiten oder Berichte als PDFs zu rendern.
• PDF-Bearbeitung: Mit IronPDF können Sie bestehende PDF-Dokumente manipulieren, indem Sie Text, Bilder und Grafiken hinzufügen sowie den Inhalt vorhandener Seiten bearbeiten.
• Text- und Bildextraktion: Die Bibliothek ermöglicht es Ihnen, Text und Bilder aus PDFs zu extrahieren, wodurch das Parsen und Analysieren von PDF-Inhalten erleichtert wird.
• Wasserzeichen: Es ist auch möglich, Wasserzeichen zu PDF-Dokumenten für Branding oder Urheberrechtsschutz hinzuzufügen.

Erste Schritte mit IronPDF

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

using IronPdf;

using IronPdf;

Imports IronPdf

Beispiel: Extrahieren und Parsen von Zahlen aus einer PDF-Datei

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

Erklärung des Codes

1. Text aus PDF extrahieren:

   Der Code beginnt mit dem Laden einer PDF-Datei mithilfe von IronPDF. Dann extrahiert er den gesamten Text aus dem PDF.

2. Reguläre Ausdrücke verwenden, um Zahlen zu finden:

   Der Code verwendet einen Regulären Ausdruck (ein Muster zur Textsuche), um im extrahierten Text nach Zahlen zu suchen. Der reguläre Ausdruck sucht sowohl nach ganzen Zahlen (z. B. 12345) als auch nach Dezimalzahlen (z. B. 50,75).

3. Zahlen parsen und ausgeben:

   Sobald die Zahlen gefunden sind, gibt das Programm jede einzelne in der Konsole aus. Dies umfasst Ganzzahlen und Dezimalzahlen.

4. Warum reguläre Ausdrücke:

   Reguläre Ausdrücke werden verwendet, weil sie leistungsstarke Werkzeuge sind, um Muster im Text zu finden, wie Zahlen. Sie können Zahlen mit Symbolen (wie Währungssymbolen $) verarbeiten und machen den Prozess somit flexibler.

Fehlerhafte Formate in PDFs

PDFs enthalten oft als Text formatierte Zahlen (z. B. "1,234.56" oder "12,345 USD"). Um diese korrekt zu verarbeiten, müssen Sie sicherstellen, dass die Zeichenfolgendarstellung der Zahl im korrekten Format für das Parsen vorliegt. IronPDF ermöglicht es Ihnen, den Text sauber zu extrahieren, und Sie können Zeichenfolgenmanipulationsmethoden (wie Replace()) verwenden, um das Format vor der Konvertierung anzupassen.

Beispiel:

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

Behandlung mehrerer numerischer Werte in einem Text

In einem komplexen PDF können numerische Werte in unterschiedlichen Formaten oder über verschiedene Bereiche verstreut auftreten. Mit IronPDF können Sie den gesamten Text extrahieren und dann reguläre Ausdrücke verwenden, um Zeichenfolgen effizient in Ganzzahlen zu konvertieren.