Même si vous venez juste de vous familiariser avec C#, vous avez probablement déjà rencontré la directive using. Et si vous êtes un utilisateur d'IronPDF, vous serez très familier avec le lancement de votre code avec le namespace using ironpdf.

Cependant, il y a une autre utilisation pour le mot clé using. Dans ce guide, nous examinerons l'instruction using - ce qu'elle est, comment elle fonctionne, et comment elle peut vous aider à créer un code plus efficace. Plongeons dedans !

Qu'est-ce que le using en C# ?

L'instruction using en C# est un moyen pratique de travailler avec des ressources qui implémentent l'interface IDisposable. Les objets IDisposable retiennent généralement des ressources non gérées, comme des descripteurs de fichiers ou des connexions réseau, qui doivent être libérées lorsque vous avez fini de les utiliser. C'est là que l'instruction using intervient - elle vous aide à vous assurer que ces ressources sont correctement détruites après utilisation.

Comment fonctionne l'instruction Using

Quand vous utilisez l'instruction using, C# appellera automatiquement la méthode Dispose sur l'objet lorsqu'il n'est plus nécessaire. Cela signifie que vous n'avez pas besoin d'appeler manuellement la méthode Dispose ou de vous inquiéter d'oublier de le faire. L'instruction using s'occupe de cela pour vous !

Voyons un exemple simple pour voir comment l'instruction using fonctionne en action :

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

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

Dans cet exemple, l'objet StreamReader nommé reader est enveloppé dans un bloc using. Lorsque le bloc using est quitté, la méthode Dispose est automatiquement appelée sur reader, libérant ainsi toutes les ressources qu'il retenait.

Bloc Using vs. Déclaration Using

À partir de C# 8.0, vous pouvez utiliser la déclaration using au lieu du bloc using. La déclaration using est une façon plus courte et plus concise de définir un objet jetable, comme ceci :

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

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

Avec la déclaration using, vous n'avez pas besoin des accolades ou de l'indentation, rendant votre code plus lisible. La méthode Dispose est toujours appelée automatiquement lorsque la variable sort du champ d'application.

Bloc Try, Bloc Finally, et l'instruction Using

Vous vous demandez peut-être comment l'instruction using se rapporte aux blocs try et finally en C#. En fait, l'instruction using est un raccourci pour un bloc try-finally !

Voici le même exemple qu'avant, mais écrit en utilisant un bloc try-finally au lieu d'une instruction 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
        {
            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
        {
            if (reader != null)
            {
                reader.Dispose();
            }
        }
    }
}

Imports System
Imports System.IO

Module Program
    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 Module

Imports System
Imports System.IO

Module Program
    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 Module

Comme vous pouvez le voir, l'instruction using rend le code plus propre et plus facile à lire en supprimant le besoin d'un bloc try-finally et de l'appel explicite à la méthode Dispose.

Gérer plusieurs ressources

L'un des grands atouts de l'instruction using est qu'elle peut gérer plusieurs ressources à la fois. Vous pouvez empiler des instructions using l'une après l'autre, ou utiliser une seule instruction using pour gérer plusieurs ressources dans une liste séparée par des virgules. Voici un exemple qui démontre les deux approches :

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

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

Remarque : C# ne prend pas en charge une seule instruction using avec plusieurs ressources séparées par des virgules. Chaque ressource nécessite sa propre instruction using.

Implémentation de l'interface IDisposable

Parfois, vous pourriez créer vos propres classes personnalisées qui gèrent une ou plusieurs ressources. Si votre classe est responsable de la gestion d'objets jetables ou de ressources non gérées, vous devriez implémenter l'interface IDisposable.

Voici un exemple d'une classe personnalisée qui implémente l'interface 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;
        }
    }
}

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

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

Dans cet exemple, la classe CustomResource gère un objet StreamReader, qui est un objet jetable. En implémentant l'interface IDisposable et en implémentant une méthode Dispose, nous pouvons utiliser l'instruction using avec des instances de cette classe.

Voici comment vous utiliseriez l'instruction using avec la classe CustomResource :

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

Friend Class Program
	Shared Sub Main()
		Using resource As New CustomResource("example.txt")
			resource.ReadContent()
		End Using
	End Sub
End Class

Lorsque le bloc using se termine, la méthode Dispose sera appelée, détruisant l'objet StreamReader qu'elle gère.

Gérer les exceptions avec l'instruction Using

Un autre avantage de l'instruction using est qu'elle aide à gérer les exceptions de manière plus élégante. Si une exception se produit dans le bloc using, la méthode Dispose sera tout de même appelée sur la ressource, assurant un nettoyage approprié.

Par exemple, considérez le code suivant :

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

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

Dans ce cas, si le code lève une FileNotFoundException, l'exception est attrapée et gérée par le bloc catch. Même si l'exception s'est produite dans le bloc using, la méthode Dispose est toujours appelée sur l'objet StreamReader, garantissant qu'aucune ressource n'est perdue.

Travailler avec IronPDF et l'instruction Using

IronPDF est une bibliothèque populaire pour créer, éditer et extraire des fichiers PDF dans les applications C# et .NET. Comme d'autres bibliothèques qui travaillent avec des ressources, IronPDF peut également bénéficier de l'instruction using pour garantir une gestion correcte des ressources.

Explorons comment utiliser l'instruction using avec IronPDF pour créer un document PDF à partir d'une chaîne HTML, démontrant la puissance de l'instruction using dans un scénario de la vie réelle.

Tout d'abord, assurez-vous d'avoir installé le package NuGet IronPDF dans votre projet :

Install-Package IronPdf

Maintenant, extrayons toutes les données du fichier 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);
        }
    }
}

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

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

Dans ce code, nous ouvrons un fichier PDF nommé "PDFData.pdf" en utilisant la méthode PdfDocument.FromFile. Cette méthode retourne une instance de PdfDocument, que nous enveloppons dans une instruction using.

À l'intérieur du bloc using, nous appelons ExtractAllText sur l'instance PdfDocument pour extraire tout le texte du PDF. Lorsque le bloc using est quitté, la méthode Dispose est automatiquement appelée sur le PdfDocument, libérant toutes les ressources qu'il retenait.

En utilisant l'instruction using avec PdfDocument, nous nous assurons que le fichier PDF est correctement fermé après avoir terminé d'extraire du texte, même si une exception se produit pendant le processus. Ceci est un bon exemple de la façon dont l'instruction using peut aider à gérer efficacement les ressources en C#.

Conclusion

Et voilà une visite éclair de l'instruction using ! Nous avons vu comment elle assure la gestion efficace des objets jetables, gérant une ou plusieurs ressources de manière transparente. L'instruction using non seulement aide à maintenir un code plus propre, mais améliore également la lisibilité de votre projet C#.

Nous avons également présenté IronPDF, une bibliothèque robuste pour la manipulation de PDF en C#. Employer l'instruction using en conjonction avec IronPDF démontre l'application pratique de cette fonctionnalité de code, renforçant le concept et son importance.

Prêt à mettre la main sur IronPDF ? Vous pouvez commencer avec notre essai gratuit de 30 jours de IronPDF et de la suite Iron Software. C'est aussi totalement gratuit à utiliser à des fins de développement afin que vous puissiez vraiment voir ce dont il est fait. Et si vous aimez ce que vous voyez, IronPDF commence aussi bas que $999 pour les options de licence. Pour des économies encore plus importantes, consultez le package complet de logiciels Iron Suite où vous pouvez obtenir les neuf outils Iron Software pour le prix de deux. Bonne programmation !