Nawet jeśli dopiero zaczynasz przygodę z C#, prawdopodobnie już spotkałeś się z dyrektywą using. A jeśli jesteś użytkownikiem IronPDF, doskonale znasz rozpoczynanie swojego kodu za pomocą przestrzeni nazw using ironpdf.
Istnieje jednak inne zastosowanie słowa kluczowego "using". W tym przewodniku przyjrzymy się instrukcji using — czym jest, jak działa i jak może pomóc w tworzeniu bardziej wydajnego kodu. Zaczynamy!
Instrukcja using w języku C# to wygodny sposób pracy z zasobami, które implementują interfejs IDisposable. Obiekty typu IDisposable zazwyczaj przechowują zasoby niezarządzane, takie jak uchwyty plików lub połączenia sieciowe, które należy zwolnić po zakończeniu ich używania. W tym miejscu do gry wkracza instrukcja using – pomaga ona zapewnić, że zasoby te zostaną prawidłowo usunięte po użyciu.
Gdy używasz instrukcji using, C# automatycznie wywoła metodę Dispose na obiekcie, gdy nie będzie on już potrzebny. Oznacza to, że nie musisz ręcznie wywoływać metody Dispose ani martwić się, że o tym zapomnisz. Instrukcja using zajmie się tym za Ciebie!
Przyjrzyjmy się prostemu przykładowi, aby zobaczyć, jak działa instrukcja using w praktyce:
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 ClassW tym przykładzie obiekt StreamReader o nazwie reader jest zawarty w bloku using. Po wyjściu z bloku using automatycznie wywoływana jest metoda Dispose czytnika, co zwalnia wszelkie zasoby, które były przez niego zajmowane.
Począwszy od C# 8.0, można używać deklaracji using zamiast bloku using. Deklaracja using to krótszy i bardziej zwięzły sposób definiowania obiektu jednorazowego użytku, na przykład:
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 ClassDzięki deklaracji using nie potrzebujesz nawiasów klamrowych ani wcięć, co sprawia, że kod jest bardziej czytelny. Metoda Dispose jest nadal wywoływana automatycznie, gdy zmienna wychodzi poza zakres.
Być może zastanawiasz się, jaki związek ma instrukcja using z blokami try i finally w języku C#. Cóż, instrukcja using jest w rzeczywistości skrótem dla bloku try-finally!
Oto ten sam przykład co poprzednio, ale napisany przy użyciu bloku try-finally zamiast instrukcji using:
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 ClassJak widać, instrukcja using sprawia, że kod jest bardziej przejrzysty i łatwiejszy do odczytania, eliminując potrzebę stosowania bloku try-finally oraz jawnego wywołania metody Dispose.
Jedną z największych zalet instrukcji using jest to, że może ona obsługiwać wiele zasobów jednocześnie. Można stosować instrukcje using jedna po drugiej lub użyć pojedynczej instrukcji using do obsługi wielu zasobów w postaci listy rozdzielonej przecinkami. Oto przykład ilustrujący oba podejścia:
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 ClassUwaga: C# nie obsługuje pojedynczej instrukcji using z wieloma zasobami oddzielonymi przecinkami. Każdy zasób wymaga własnej instrukcji using.
Czasami możesz tworzyć własne klasy niestandardowe, które zarządzają jednym lub kilkoma zasobami. Jeśli Twoja klasa odpowiada za obsługę obiektów jednorazowego użytku lub zasobów niezarządzanych, powinieneś zaimplementować interfejs IDisposable.
Oto przykład klasy niestandardowej, która implementuje interfejs IDisposable:
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 ClassW tym przykładzie klasa CustomResource zarządza obiektem StreamReader, który jest obiektem jednorazowego użytku. Dzięki zaimplementowaniu interfejsu IDisposable i metody Dispose możemy używać instrukcji using z instancjami tej klasy.
Oto jak użyć instrukcji using z klasą CustomResource:
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 ClassPo zakończeniu bloku using zostanie wywołana metoda Dispose, która usunie zarządzany przez nią obiekt StreamReader.
Kolejną zaletą instrukcji using jest to, że pomaga ona w bardziej płynnym obsłudze wyjątków. Jeśli w bloku using wystąpi wyjątek, metoda Dispose nadal zostanie wywołana dla zasobu, zapewniając prawidłowe wyczyszczenie.
Weźmy na przykład następujący kod:
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 ClassW tym przypadku, jeśli kod wygeneruje wyjątek FileNotFoundException, zostanie on przechwycony i obsłużony przez blok catch. Mimo że wyjątek wystąpił w bloku using, metoda Dispose jest nadal wywoływana na obiekcie StreamReader, co gwarantuje, że nie dochodzi do wycieku zasobów.
IronPDF to popularna biblioteka służąca do tworzenia, edycji i wyodrębniania plików PDF w aplikacjach napisanych w języku C# i platformie .NET. Podobnie jak inne biblioteki obsługujące zasoby, IronPDF może również korzystać z instrukcji using w celu zapewnienia prawidłowego zarządzania zasobami.
Zobaczmy, jak używać instrukcji using z IronPDF do tworzenia dokumentu PDF z ciągu znaków HTML, pokazując moc instrukcji using w rzeczywistym scenariuszu.
Najpierw upewnij się, że zainstalowałeś pakiet IronPDF NuGet w swoim projekcie:
Teraz wyciągnijmy wszystkie dane z pliku PDF:
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 ClassW tym kodzie otwieramy plik PDF o nazwie "PDFData.pdf" za pomocą metody PdfDocument.FromFile. Ta metoda zwraca instancję PdfDocument, którą umieszczamy w instrukcji using.
Wewnątrz bloku using wywołujemy ExtractAllText na instancji PdfDocument, aby wyodrębnić cały tekst z PDF. Po wyjściu z bloku using automatycznie wywoływana jest metoda Dispose na obiekcie PdfDocument, co powoduje zwolnienie wszystkich zasobów, które były przez niego zajmowane.
Używając instrukcji using z PdfDocument, zapewniamy, że plik PDF zostanie prawidłowo zamknięty po zakończeniu wyodrębniania z niego tekstu, nawet jeśli podczas tego procesu wystąpi wyjątek. To dobry przykład tego, jak instrukcja using może pomóc w efektywnym zarządzaniu zasobami w języku C#.
I to już krótkie wprowadzenie do instrukcji using! Widzieliśmy, jak zapewnia to wydajną obsługę obiektów jednorazowego użytku, płynnie zarządzając jednym lub kilkoma zasobami. Instrukcja using nie tylko pomaga w utrzymaniu przejrzystości kodu, ale także poprawia czytelność projektu C#.
Wprowadziliśmy również IronPDF, solidną bibliotekę do manipulacji plikami PDF w języku C#. Zastosowanie instrukcji using w połączeniu z IronPDF pokazuje praktyczne zastosowanie tej funkcji kodu, wzmacniając koncepcję i jej znaczenie.
Chcesz wypróbować IronPDF? Możesz zacząć od 30-dniowego okresu próbnego IronPDF i Iron Suite. Można z niego korzystać całkowicie za darmo do celów programistycznych, więc naprawdę możesz sprawdzić, na czym to polega. A jeśli podoba Ci się to, co widzisz, IronPDF jest dostępny już od $999 dla opcji licencjonowania. Aby uzyskać jeszcze większe oszczędności, sprawdź kompletny pakiet oprogramowania Iron Suite, w którym możesz otrzymać wszystkie dziewięć narzędzi Iron Software w cenie dwóch. Miłego kodowania!
Jacob Mellor jest Chief Technology Officer w Iron Software i wizjonerskim inżynierem, pionierem technologii C# PDF. Jako pierwotny deweloper głównej bazy kodowej Iron Software, kształtuje architekturę produktów firmy od jej początku, przekształcając ją wspólnie z CEO Cameron Rimington w firmę liczącą ponad 50 osób, obsługującą NASA, Teslę i światowe agencje rządowe.
IronPDF jest częścią IRONSUITE
10 produktów API .NET dla twoich dokumentów biurowych
Kiedy potrzebujesz, aby twój PDF wyglądał jak HTML, szybko.
