.NET-HILFE

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

Veröffentlicht 15. August 2024

Teilen Sie:

Selbst wenn Sie sich gerade erst mit C# vertraut machen, werden Sie wahrscheinlich schon mit der using-Direktive in Berührung gekommen sein. Und wenn Sie IronPDF verwenden, werden Sie mit dem Beginn Ihres Codes mit dem Namespace using ironpdf sehr vertraut sein.

Es gibt jedoch noch eine andere Verwendung für das Schlüsselwort using. In diesem Handbuch werden wir uns die using-Anweisung ansehen - was sie ist, wie sie funktioniert und wie sie Ihnen helfen kann, effizienteren Code zu erstellen. Tauchen wir ein!

Was bedeutet Verwenden in C#?

Die using-Anweisung in C# ist ein bequemer Weg, um mit Ressourcen zu arbeiten, die die IDisposable-Schnittstelle implementieren. IDisposable-Objekte enthalten in der Regel nicht verwaltete Ressourcen, wie z. B. Datei-Handles oder Netzwerkverbindungen, die freigegeben werden müssen, wenn Sie sie nicht mehr benötigen. Hier kommt der Verwendungsnachweis ins Spiel - er hilft Ihnen, sicherzustellen, dass diese Ressourcen nach ihrer Verwendung ordnungsgemäß entsorgt werden.

Wie die Verwendungserklärung funktioniert

Wenn Sie die using-Anweisung verwenden, ruft C# automatisch die Dispose-Methode für das Objekt auf, wenn es nicht mehr benötigt wird. Das bedeutet, dass Sie die Dispose-Methode nicht manuell aufrufen müssen und auch nicht befürchten müssen, dies zu vergessen. Die using-Anweisung übernimmt diese Aufgabe für Sie!

Schauen wir uns ein einfaches Beispiel an, um zu sehen, wie die using-Anweisung in der Praxis funktioniert:

using System.IO;

class Program
{
    static void Main()
    {
        using (StreamReader reader = new StreamReader("example.txt"))
        {
            string content = reader.ReadToEnd();
            Console.WriteLine(content);
        }
    }
}

using System.IO;

class Program
{
    static void Main()
    {
        using (StreamReader reader = new StreamReader("example.txt"))
        {
            string content = reader.ReadToEnd();
            Console.WriteLine(content);
        }
    }
}

Imports System.IO

Friend Class Program
	Shared Sub Main()
		Using reader As New StreamReader("example.txt")
			Dim content As String = reader.ReadToEnd()
			Console.WriteLine(content)
		End Using
	End Sub
End Class

VB C#

In diesem Beispiel wird das StreamReader-Objekt namens reader in einen using-Block eingeschlossen. Beim Verlassen des using-Blocks wird automatisch die Dispose-Methode für das Lesegerät aufgerufen, so dass alle Ressourcen freigegeben werden, an denen es gehangen hat.

Block verwenden vs. Deklaration verwenden

Ab C# 8.0 können Sie die using-Deklaration anstelle des using-Blocks verwenden. Die using-Deklaration ist ein kürzerer und prägnanterer Weg, ein Wegwerfobjekt zu definieren, etwa so:

using System.IO;

class Program
{
    static void Main()
    {
        using var reader = new StreamReader("example.txt");
        string content = reader.ReadToEnd();
        Console.WriteLine(content);
    }
}

using System.IO;

class Program
{
    static void Main()
    {
        using var reader = new StreamReader("example.txt");
        string content = reader.ReadToEnd();
        Console.WriteLine(content);
    }
}

Imports System.IO

Friend Class Program
	Shared Sub Main()
		Dim reader = New StreamReader("example.txt")
		Dim content As String = reader.ReadToEnd()
		Console.WriteLine(content)
	End Sub
End Class

VB C#

Mit der using-Deklaration entfallen die geschweiften Klammern und die Einrückung, wodurch Ihr Code besser lesbar wird. Die Dispose-Methode wird immer noch automatisch aufgerufen, wenn die Variable den Anwendungsbereich verlässt.

Try-Block, Finally-Block und die Using-Anweisung

Sie fragen sich vielleicht, wie sich die using-Anweisung zu den try- und finally-Blöcken in C# verhält. Nun, die using-Anweisung ist eigentlich eine Kurzform für einen try-finally-Block!

Hier ist das gleiche Beispiel wie zuvor, aber mit einem try-finally-Block anstelle einer using-Anweisung geschrieben:

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
        {
            if (reader != null)
            {
                reader.Dispose();
            }
        }
    }
}

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
        {
            if (reader != null)
            {
                reader.Dispose();
            }
        }
    }
}

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
			If reader IsNot Nothing Then
				reader.Dispose()
			End If
		End Try
	End Sub
End Class

VB C#

Wie Sie sehen können, macht die using-Anweisung den Code sauberer und leichter lesbar, da der try-finally-Block und der explizite Aufruf der Dispose-Methode entfallen.

Mehrere Ressourcen verwalten

Einer der großen Vorteile der using-Anweisung ist, dass sie mehrere Ressourcen gleichzeitig verarbeiten kann. Sie können using-Anweisungen nacheinander stapeln oder eine einzige using-Anweisung verwenden, um mehrere Ressourcen in einer kommagetrennten Liste zu behandeln. Hier ist ein Beispiel, das beide Ansätze demonstriert:

using System.IO;

class Program
{
    static void Main()
    {
        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}");
        }

        // Alternatively, you can use a single using statement with multiple resources:

        using (StreamReader reader1 = new StreamReader("example1.txt"), 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}");
        }
    }
}

using System.IO;

class Program
{
    static void Main()
    {
        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}");
        }

        // Alternatively, you can use a single using statement with multiple resources:

        using (StreamReader reader1 = new StreamReader("example1.txt"), 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}");
        }
    }
}

Imports Microsoft.VisualBasic
Imports System.IO

Friend Class Program
	Shared Sub Main()
		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

		' Alternatively, you can use a single using statement with multiple resources:

		Using reader1 As New StreamReader("example1.txt"), 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 Sub
End Class

VB C#

Beide Ansätze stellen sicher, dass die Dispose-Methode auf jedem StreamReader-Objekt aufgerufen wird, wenn der using-Block verlassen wird, und geben alle Ressourcen frei, an denen sie festgehalten wurden.

Implementierung der IDisposable-Schnittstelle

In manchen Fällen können Sie Ihre eigenen benutzerdefinierten Klassen erstellen, die eine oder mehrere Ressourcen verwalten. Wenn Ihre Klasse für die Handhabung von Wegwerfobjekten oder nicht verwalteten Ressourcen verantwortlich ist, sollten Sie die Schnittstelle IDisposable implementieren.

Hier ist ein Beispiel für eine benutzerdefinierte Klasse, die die Schnittstelle IDisposable 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

VB C#

In diesem Beispiel verwaltet die Klasse CustomResource ein StreamReader-Objekt, das ein Einwegobjekt ist. Indem wir die Schnittstelle IDisposable implementieren und eine Dispose-Methode implementieren, können wir die using-Anweisung mit Instanzen dieser Klasse verwenden.

So würden Sie die using-Anweisung mit der Klasse CustomResource 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

VB C#

Wenn der using-Block beendet ist, wird die Dispose-Methode aufgerufen, die das von ihr verwaltete StreamReader-Objekt entsorgt.

Behandlung von Ausnahmen mit der Using-Anweisung

Ein weiterer Vorteil der using-Anweisung ist, dass sie dazu beiträgt, Ausnahmen besser zu behandeln. Tritt innerhalb des using-Blocks eine Ausnahme auf, wird die Dispose-Methode dennoch für die 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

VB C#

Wenn der Code in diesem Fall eine FileNotFoundException auslöst, wird die Ausnahme durch den Catch-Block abgefangen und behandelt. Auch wenn die Ausnahme innerhalb des using-Blocks aufgetreten ist, wird die Dispose-Methode für das StreamReader-Objekt aufgerufen, um sicherzustellen, dass keine Ressourcen verloren gehen.

Arbeiten mit IronPDF und der Using-Anweisung

IronPDF ist eine beliebte Bibliothek zum Erstellen, Bearbeiten und Extrahieren von PDF-Dateien in C#- und .NET-Anwendungen. Wie andere Bibliotheken, die mit Ressourcen arbeiten, kann auch IronPDF von der using-Anweisung profitieren, um eine angemessene Ressourcenverwaltung zu gewährleisten.

Wir wollen nun untersuchen, wie die using-Anweisung mit IronPDF verwendet werden kann, um ein PDF-Dokument aus einer HTML-Zeichenfolge zu erstellen, um die Leistungsfähigkeit der using-Anweisung in einem realen Szenario zu demonstrieren.

Stellen Sie zunächst sicher, dass Sie das IronPDF NuGet-Paket in Ihrem Projekt installiert haben:

Installations-Paket IronPDF

Lassen Sie uns nun alle Daten aus der PDF-Datei extrahieren:

using IronPdf;

class Program
{
    static void Main()
    {
        using (PdfDocument pdfDocument = PdfDocument.FromFile("PDFData.pdf"))
        {
            string extractedText = pdfDocument.ExtractAllText();
            Console.WriteLine(extractedText);
        }
    }
}

using IronPdf;

class Program
{
    static void Main()
    {
        using (PdfDocument pdfDocument = PdfDocument.FromFile("PDFData.pdf"))
        {
            string extractedText = pdfDocument.ExtractAllText();
            Console.WriteLine(extractedText);
        }
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main()
		Using pdfDocument As PdfDocument = PdfDocument.FromFile("PDFData.pdf")
			Dim extractedText As String = pdfDocument.ExtractAllText()
			Console.WriteLine(extractedText)
		End Using
	End Sub
End Class

VB C#

In diesem Code wird eine PDF-Datei mit dem Namen "PDFData.pdf" mit der Methode "PdfDocument.FromFile" geöffnet. Diese Methode gibt eine PdfDocument-Instanz zurück, die wir in eine using-Anweisung verpacken.

Innerhalb des using-Blocks rufen wir ExtractAllText für die PdfDocument-Instanz auf, um den gesamten Text aus der PDF-Datei zu extrahieren. Beim Beenden des using-Blocks wird automatisch die Dispose-Methode für das PdfDocument aufgerufen, die alle Ressourcen freigibt, an denen es festgehalten wurde.

Durch die Verwendung der using-Anweisung mit PdfDocument wird sichergestellt, dass die PDF-Datei nach dem Extrahieren von Text ordnungsgemäß geschlossen wird, selbst wenn während des Prozesses eine Ausnahme auftritt. Dies ist ein gutes Beispiel dafür, wie die using-Anweisung helfen kann, Ressourcen in C# effektiv zu verwalten.

Csharp Using 1 related to Arbeiten mit IronPDF und der Using-Anweisung

Einpacken

Und das ist ein kurzer Rundgang durch die Verwendung der Erklärung! Wir haben gesehen, wie es die effiziente Handhabung von Einwegobjekten sicherstellt und eine oder mehrere Ressourcen nahtlos verwaltet. Die using-Anweisung hilft nicht nur bei der Aufrechterhaltung eines sauberen Codes, sondern verbessert auch die Lesbarkeit Ihres C#-Projekts.

Wir haben auch IronPDF vorgestellt, eine robuste Bibliothek für die PDF-Bearbeitung in C#. Die Verwendung der using-Anweisung in Verbindung mit IronPDF demonstriert die praktische Anwendung dieses Code-Features und unterstreicht das Konzept und seine Bedeutung.

Sind Sie bereit, IronPDF in die Hand zu nehmen? Sie können mit unserem30-tägige kostenlose Testversion von IronPDF und Iron Software's Suite. Außerdem ist die Nutzung für Entwicklungszwecke völlig kostenlos, so dass Sie wirklich sehen können, was in ihm steckt. Und wenn Ihnen gefällt, was Sie sehen, beginnt IronPDF bereits ab einem Preis von$749 für Lizenzierungsoptionen. Noch größere Einsparungen können Sie mit demIron Suite - komplettes Software-Paket wo Sie alle neun Iron Software Tools zum Preis von zwei erhalten. Fröhliches Kodieren!

Csharp Using 2 related to Einpacken