Selbst wenn Sie gerade erst anfangen, sich mit C# vertraut zu machen, werden Sie wahrscheinlich bereits die using-Direktive kennengelernt haben. Und wenn Sie IronPDF-Benutzer sind, werden Sie sehr vertraut damit sein, Ihren Code mit dem Namespace using ironpdf zu beginnen.
Es gibt jedoch eine weitere Verwendung für das Schlüsselwort using. In diesem Leitfaden werden wir uns die Using-Anweisung ansehen - was sie ist, wie sie funktioniert und wie sie Ihnen helfen kann, effizienteren Code zu erstellen. Lassen Sie uns starten!
Die Using-Anweisung in C# ist eine bequeme Möglichkeit, mit Ressourcen zu arbeiten, die das IDisposable-Interface implementieren. IDisposable-Objekte halten typischerweise nicht verwaltete Ressourcen, wie Datei-Handles oder Netzwerkverbindungen, die freigegeben werden müssen, wenn Sie sie nicht mehr verwenden. Hier kommt die Using-Anweisung ins Spiel - sie hilft Ihnen sicherzustellen, dass diese Ressourcen nach der Nutzung ordnungsgemäß freigegeben werden.
Wenn Sie die Using-Anweisung verwenden, wird C# automatisch die Dispose-Methode für das Objekt aufrufen, wenn es nicht mehr benötigt wird. Das bedeutet, dass Sie die Dispose-Methode nicht manuell aufrufen oder sich Sorgen machen müssen, dass Sie es vergessen könnten. Die Using-Anweisung nimmt Ihnen diese Aufgabe ab!
Lassen Sie uns ein einfaches Beispiel betrachten, um zu sehen, wie die Using-Anweisung in der Praxis funktioniert:
using System;
using System.IO;
class Program
{
static void Main()
{
// Using a using statement to ensure StreamReader is disposed of
using (StreamReader reader = new StreamReader("example.txt"))
{
string content = reader.ReadToEnd();
Console.WriteLine(content);
}
}
}Imports System
Imports System.IO
Friend Class Program
Shared Sub Main()
' Using a using statement to ensure StreamReader is disposed of
Using reader As New StreamReader("example.txt")
Dim content As String = reader.ReadToEnd()
Console.WriteLine(content)
End Using
End Sub
End ClassIn diesem Beispiel wird das StreamReader-Objekt namens reader in einem Using-Block eingeschlossen. Wenn der Using-Block verlassen wird, wird die Dispose-Methode automatisch für den reader aufgerufen, wodurch alle Ressourcen freigegeben werden, die es gehalten hat.
Ab C# 8.0 können Sie anstelle des Using-Blocks die Using-Deklaration verwenden. Die Using-Deklaration ist eine kürzere und präzisere Möglichkeit, ein disposable Objekt zu definieren, wie folgt:
using System;
using System.IO;
class Program
{
static void Main()
{
// Using the using declaration simplifies the code
using var reader = new StreamReader("example.txt");
string content = reader.ReadToEnd();
Console.WriteLine(content);
}
}Imports System
Imports System.IO
Friend Class Program
Shared Sub Main()
' Using the using declaration simplifies the code
Dim reader = New StreamReader("example.txt")
Dim content As String = reader.ReadToEnd()
Console.WriteLine(content)
End Sub
End ClassMit der Using-Deklaration benötigen Sie keine geschweiften Klammern oder Einrückungen, was Ihren Code lesbarer macht. Die Dispose-Methode wird dennoch automatisch aufgerufen, wenn die Variable den Gültigkeitsbereich verlässt.
Sie könnten sich fragen, wie die Using-Anweisung sich auf die Try- und Finally-Blöcke in C# bezieht. Nun, die Using-Anweisung ist tatsächlich eine Abkürzung für einen Try-Finally-Block!
Hier ist dasselbe Beispiel wie zuvor, jedoch mit einem Try-Finally-Block statt einer Using-Anweisung geschrieben:
using System;
using System.IO;
class Program
{
static void Main()
{
StreamReader reader = null;
try
{
reader = new StreamReader("example.txt");
string content = reader.ReadToEnd();
Console.WriteLine(content);
}
finally\static-assets\pdf\blog\csharp-using\csharp-using-2.webp
{
if (reader != null)
{
reader.Dispose();
}
}
}
}Imports System
Imports System.IO
Friend Class Program
Shared Sub Main()
Dim reader As StreamReader = Nothing
Try
reader = New StreamReader("example.txt")
Dim content As String = reader.ReadToEnd()
Console.WriteLine(content)
Finally
\static-assets\pdf\blog\csharp-using\csharp-using-2.webp
If reader IsNot Nothing Then
reader.Dispose()
End If
End Try
End Sub
End ClassWie Sie sehen können, macht die Using-Anweisung den Code sauberer und leichter lesbar, indem sie den Bedarf für den Try-Finally-Block und den expliziten Aufruf der Dispose-Methode beseitigt.
Eine der großartigen Eigenschaften der Using-Anweisung ist, dass sie mehrere Ressourcen gleichzeitig handhaben kann. Sie können Using-Anweisungen eine nach der anderen stapeln oder eine einzelne Using-Anweisung verwenden, um mehrere Ressourcen in einer kommagetrennten Liste zu handhaben. Hier ist ein Beispiel, das beide Ansätze veranschaulicht:
using System;
using System.IO;
class Program
{
static void Main()
{
// Stacking using statements for multiple disposable resources
using (StreamReader reader1 = new StreamReader("example1.txt"))
using (StreamReader reader2 = new StreamReader("example2.txt"))
{
string content1 = reader1.ReadToEnd();
string content2 = reader2.ReadToEnd();
Console.WriteLine($"Content from example1.txt:\n{content1}\nContent from example2.txt:\n{content2}");
}
// Attempting to use a single using statement with multiple resources (not valid)
// Note: This method using comma-separated resources is not supported in C#
}
}Imports Microsoft.VisualBasic
Imports System
Imports System.IO
Friend Class Program
Shared Sub Main()
' Stacking using statements for multiple disposable resources
Using reader1 As New StreamReader("example1.txt")
Using reader2 As New StreamReader("example2.txt")
Dim content1 As String = reader1.ReadToEnd()
Dim content2 As String = reader2.ReadToEnd()
Console.WriteLine($"Content from example1.txt:" & vbLf & "{content1}" & vbLf & "Content from example2.txt:" & vbLf & "{content2}")
End Using
End Using
' Attempting to use a single using statement with multiple resources (not valid)
' Note: This method using comma-separated resources is not supported in C#
End Sub
End ClassHinweis: C# unterstützt keine einzelne Using-Anweisung mit mehreren durch Kommata getrennten Ressourcen. Jede Ressource benötigt ihre eigene Using-Anweisung.
Manchmal könnten Sie Ihre eigenen benutzerdefinierten Klassen erstellen, die eine oder mehrere Ressourcen verwalten. Wenn Ihre Klasse für die Verwaltung von disposable Objekten oder nicht verwalteten Ressourcen verantwortlich ist, sollten Sie das IDisposable-Interface implementieren.
Hier ist ein Beispiel für eine benutzerdefinierte Klasse, die das IDisposable-Interface implementiert:
using System;
using System.IO;
public class CustomResource : IDisposable
{
private StreamReader _reader;
public CustomResource(string filePath)
{
_reader = new StreamReader(filePath);
}
public void ReadContent()
{
string content = _reader.ReadToEnd();
Console.WriteLine(content);
}
public void Dispose()
{
if (_reader != null)
{
_reader.Dispose();
_reader = null;
}
}
}Imports System
Imports System.IO
Public Class CustomResource
Implements IDisposable
Private _reader As StreamReader
Public Sub New(ByVal filePath As String)
_reader = New StreamReader(filePath)
End Sub
Public Sub ReadContent()
Dim content As String = _reader.ReadToEnd()
Console.WriteLine(content)
End Sub
Public Sub Dispose() Implements IDisposable.Dispose
If _reader IsNot Nothing Then
_reader.Dispose()
_reader = Nothing
End If
End Sub
End ClassIn diesem Beispiel verwaltet die CustomResource-Klasse ein StreamReader-Objekt, das ein disposable Objekt ist. Durch die Implementierung des IDisposable-Interfaces und die Implementierung einer Dispose-Methode können wir die Using-Anweisung mit Instanzen dieser Klasse verwenden.
So würden Sie die Using-Anweisung mit der CustomResource-Klasse verwenden:
class Program
{
static void Main()
{
using (CustomResource resource = new CustomResource("example.txt"))
{
resource.ReadContent();
}
}
}Friend Class Program
Shared Sub Main()
Using resource As New CustomResource("example.txt")
resource.ReadContent()
End Using
End Sub
End ClassWenn der Using-Block beendet wird, wird die Dispose-Methode aufgerufen, wobei das StreamReader-Objekt, das es verwaltet, freigegeben wird.
Ein weiterer Vorteil der Using-Anweisung ist, dass sie hilft, Ausnahmen eleganter zu behandeln. Wenn innerhalb des Using-Blocks eine Ausnahme auftritt, wird die Dispose-Methode dennoch auf der Ressource aufgerufen, um eine ordnungsgemäße Bereinigung zu gewährleisten.
Betrachten Sie zum Beispiel den folgenden Code:
using System;
using System.IO;
class Program
{
static void Main()
{
try
{
using (StreamReader reader = new StreamReader("nonexistentfile.txt"))
{
string content = reader.ReadToEnd();
Console.WriteLine(content);
}
}
catch (FileNotFoundException ex)
{
Console.WriteLine($"Error: {ex.Message}");
}
}
}Imports System
Imports System.IO
Friend Class Program
Shared Sub Main()
Try
Using reader As New StreamReader("nonexistentfile.txt")
Dim content As String = reader.ReadToEnd()
Console.WriteLine(content)
End Using
Catch ex As FileNotFoundException
Console.WriteLine($"Error: {ex.Message}")
End Try
End Sub
End ClassIn diesem Fall, wenn der Code eine FileNotFoundException auslöst, wird die Ausnahme vom Catch-Block abgefangen und behandelt. Obwohl die Ausnahme im Using-Block auftrat, wird die Dispose-Methode dennoch auf das StreamReader-Objekt aufgerufen, um zu gewährleisten, dass keine Ressourcen undicht werden.
IronPDF ist eine beliebte Bibliothek zur Erstellung, Bearbeitung und Extraktion von PDF-Dateien in C# und .NET-Anwendungen. Wie andere Bibliotheken, die mit Ressourcen arbeiten, kann IronPDF auch von der Using-Anweisung profitieren, um ein ordnungsgemäßes Ressourcenmanagement zu gewährleisten.
Erforschen wir, wie man die Using-Anweisung mit IronPDF verwendet, um ein PDF-Dokument aus einem HTML-String zu erstellen und die Leistungsfähigkeit der Using-Anweisung in einem realen Szenario zu demonstrieren.
Zuerst stellen Sie sicher, dass Sie das IronPDF-NuGet-Paket in Ihrem Projekt installiert haben:
Jetzt lass uns alle Daten aus der PDF-Datei extrahieren:
using IronPdf;
class Program
{
static void Main()
{
// Using a using statement with IronPDF to ensure resources are managed
using (PdfDocument pdfDocument = PdfDocument.FromFile("PDFData.pdf"))
{
string extractedText = pdfDocument.ExtractAllText();
Console.WriteLine(extractedText);
}
}
}Imports IronPdf
Friend Class Program
Shared Sub Main()
' Using a using statement with IronPDF to ensure resources are managed
Using pdfDocument As PdfDocument = PdfDocument.FromFile("PDFData.pdf")
Dim extractedText As String = pdfDocument.ExtractAllText()
Console.WriteLine(extractedText)
End Using
End Sub
End ClassIn diesem Code öffnen wir eine PDF-Datei namens "PDFData.pdf" mit der PdfDocument.FromFile Methode. Diese Methode gibt eine PdfDocument-Instanz zurück, die wir in einer Using-Anweisung einschließen.
Innerhalb des using-Blocks rufen wir ExtractAllText in der PdfDocument-Instanz auf, um allen Text aus dem PDF zu extrahieren. Wenn der Using-Block verlassen wird, wird die Dispose-Methode automatisch auf die PdfDocument aufgerufen und gibt alle Ressourcen frei, die es gehalten hat.
Durch die Verwendung der Using-Anweisung mit PdfDocument stellen wir sicher, dass die PDF-Datei ordnungsgemäß geschlossen wird, nachdem wir den Text daraus extrahiert haben, selbst wenn während des Prozesses eine Ausnahme auftritt. Dies ist ein gutes Beispiel dafür, wie die Using-Anweisung helfen kann, Ressourcen effektiv in C# zu verwalten.
Und das war ein kurzer Überblick über die Using-Anweisung! Wir haben gesehen, wie sie die effiziente Handhabung von disposable Objekten gewährleistet und eine oder mehrere Ressourcen nahtlos verwaltet. Die Using-Anweisung hilft nicht nur, den Code sauberer zu halten, sondern verbessert auch die Lesbarkeit Ihres C#-Projekts.
Wir haben auch IronPDF eingeführt, eine robuste Bibliothek zur PDF-Bearbeitung in C#. Die Verwendung der Using-Anweisung in Verbindung mit IronPDF demonstriert die praktische Anwendung dieser Code-Funktion und verstärkt das Konzept und seine Bedeutung.
Bereit, IronPDF selbst auszuprobieren? Sie können mit unserer 30-tägigen kostenlosen Testversion von IronPDF und der Iron Software's Suite beginnen. Es ist auch völlig kostenlos für Entwicklungszwecke, sodass Sie wirklich sehen können, woraus es besteht. Und wenn Sie mögen, was Sie sehen, beginnt IronPDF schon ab $999 für Lizenzierungsoptionen. Für noch größere Einsparungen werfen Sie einen Blick auf das Iron Suite komplette Softwarepaket, bei dem Sie alle neun Iron Software-Tools zum Preis von zwei erhalten. Viel Spaß beim Coden!
Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
