Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF-Blog
  3. .NET-Hilfe
  4. C# Using-Anleitungen
.NET HILFE

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

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

Selbst wenn Sie gerade erst C# kennenlernen, sind Sie wahrscheinlich bereits auf die using-Direktive gestoßen. Und wenn Sie ein IronPDF-Benutzer sind, sind Sie sehr vertraut damit, 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!

Was bedeutet Verwenden in C#?

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.

Wie das Using Statement funktioniert

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);
        }
    }
}
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 Class
$vbLabelText   $csharpLabel

In 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.

Verwendung eines Blocks vs. Verwendung einer Deklaration

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);
    }
}
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 Class
$vbLabelText   $csharpLabel

Mit 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.

Try Block, Finally Block und die Using-Anweisung

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();
            }
        }
    }
}
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 Class
$vbLabelText   $csharpLabel

Wie 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.

Verwaltung mehrerer Ressourcen

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#
    }
}
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 Class
$vbLabelText   $csharpLabel

Hinweis: C# unterstützt keine einzelne Using-Anweisung mit mehreren durch Kommata getrennten Ressourcen. Jede Ressource benötigt ihre eigene Using-Anweisung.

Implementierung der IDisposable-Schnittstelle

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;
        }
    }
}
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 Class
$vbLabelText   $csharpLabel

In 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();
        }
    }
}
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 Class
$vbLabelText   $csharpLabel

Wenn der Using-Block beendet wird, wird die Dispose-Methode aufgerufen, wobei das StreamReader-Objekt, das es verwaltet, freigegeben wird.

Handhabung von Ausnahmen mit der Using-Anweisung

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}");
        }
    }
}
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 Class
$vbLabelText   $csharpLabel

In 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.

Arbeiten mit IronPDF und dem Using Statement

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:

Install-Package IronPdf

Jetzt lassen Sie 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);
        }
    }
}
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 Class
$vbLabelText   $csharpLabel

In 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 auf der PdfDocument-Instanz auf, um allen Text aus der 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.

C# Using Statement

Zusammenfassung

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 es Ihnen gefällt, beginnen die Lizenzoptionen von IronPDF bereits ab $799 für Lizenzoptionen. 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!

IronPDF Using Statement

Häufig gestellte Fragen

Was ist der Zweck der using-Anweisung in C#?

Die using-Anweisung in C# wird verwendet, um Ressourcen zu verwalten, die die IDisposable-Schnittstelle implementieren, wie z.B. Datei-Handles oder Netzwerkverbindungen, und stellt sicher, dass sie nach der Nutzung ordnungsgemäß freigegeben werden.

Wie kann die using-Anweisung in C# helfen, Ressourcenlecks zu verhindern?

Die using-Anweisung ruft automatisch die Dispose-Methode auf Objekten auf, wenn sie nicht mehr benötigt werden. Dies hilft, Ressourcenlecks zu verhindern, indem Ressouren freigegeben werden, selbst wenn Ausnahmen auftreten.

Was sind die Unterschiede zwischen dem using-Block und der using-Deklaration in C#?

Der using-Block umschließt Code in geschweiften Klammern und sorgt für die Freigabe am Ende des Blocks, während die using-Deklaration, eingeführt in C# 8.0, prägnanter ist und Ressourcen automatisch freigibt, wenn sie außer Rahmen sind.

Wie implementiere ich IDisposable in meinen C#-Klassen?

Um IDisposable in benutzerdefinierten Klassen zu implementieren, definieren Sie eine Dispose-Methode, um nicht verwaltete Ressourcen freizugeben, was die Verwendung der using-Anweisung für automatisches Ressourcenmanagement ermöglicht.

Kann die using-Anweisung mehrere Ressourcen in C# verwalten?

Ja, Sie können mehrere Ressourcen verwalten, indem Sie mehrere using-Anweisungen stapeln, obwohl eine einzelne using-Anweisung mit mehreren durch Kommas getrennten Ressourcen nicht unterstützt wird.

Warum wird die using-Anweisung gegenüber try-finally-Blöcken in C# bevorzugt?

Die using-Anweisung wird bevorzugt wegen ihrer saubereren Syntax und des automatischen Ressourcenmanagements, was den Code im Vergleich zur manuellen Implementierung von try-finally-Blöcken zur Sicherstellung der Ressourenfreigabe vereinfacht.

Wie kann ich effektiv PDF-Dokumente in C# verwalten?

Sie können PDF-Dokumente effektiv mit IronPDF verwalten, das sich mit der using-Anweisung integriert, um sicherzustellen, dass Ressourcen wie Dokumentinstanzen nach Vorgängen wie Textextraktion ordnungsgemäß geschlossen werden.

Gibt es eine Testversion für PDF-Bibliotheken zur C#-Entwicklung?

Ja, bestimmte PDF-Bibliotheken bieten eine 30-tägige kostenlose Testversion und sind kostenlos für die Entwicklungszwecke nutzbar, sodass Sie ihre Fähigkeiten vor dem Kauf erkunden können.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der führend in der C# PDF-Technologie ist. Als ursprünglicher Entwickler der Iron Software-Kerncodebasis hat er die Produktarchitektur des Unternehmens seit seiner Gründung gestaltet und zusammen mit CEO Cameron Rimington in ein Unternehmen ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen