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

Selbst wenn Sie sich gerade erst mit C# vertraut machen, werden Sie wahrscheinlich schon auf die using-Direktive gestoßen sein. Und wenn Sie ein IronPDF-Benutzer sind, werden Sie sehr vertraut damit sein, Ihren Code mit dem Namensraum using ironpdf zu beginnen.

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);
           }
       }
   }

IRON VB CONVERTER ERROR developers@ironsoftware.com

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);
       }
   }

IRON VB CONVERTER ERROR developers@ironsoftware.com

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();
               }
           }
       }
   }

IRON VB CONVERTER ERROR developers@ironsoftware.com

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()t
       {
           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{conten1}\nContent from example2.txt:\n{content2}");
           }
       }
   }

   using System.IO;

   class Program
   {
       static void Main()t
       {
           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{conten1}\nContent from example2.txt:\n{content2}");
           }
       }
   }

IRON VB CONVERTER ERROR developers@ironsoftware.com

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;
           }
       }
   }

IRON VB CONVERTER ERROR developers@ironsoftware.com

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();
       }
   }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

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}");
       }
   }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

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);
       }
   }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

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

Innerhalb des using-Blocks rufen wir ExtractAllText auf der 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.

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 unserem 30 Tage kostenloser Test. 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. Noch größere Einsparungen können Sie mit dem Iron Suite wo Sie alle neun Iron Software Tools zum Preis von zwei erhalten. Fröhliches Kodieren!