Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. C# Using
.NET AIDE

Using en C# (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

Même si vous débutez avec C#, vous aurez probablement déjà rencontré la directive using. Et si vous êtes un utilisateur de IronPDF, vous serez très familier avec le démarrage de votre code avec l'espace de noms 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 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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

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\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

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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

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 de 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#.

Instruction Using 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 à partir de $799 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 !

Instruction Using avec IronPDF

Questions Fréquemment Posées

Quel est le but de l'instruction using en C# ?

L'instruction using en C# est utilisée pour gérer les ressources qui implémentent l'interface IDisposable, telles que les descripteurs de fichiers ou les connexions réseau, en veillant à ce qu'elles soient correctement éliminées après utilisation.

Comment l'instruction using en C# peut-elle aider à prévenir les fuites de ressources ?

L'instruction using appelle automatiquement la méthode Dispose sur les objets lorsqu'ils ne sont plus nécessaires, ce qui aide à prévenir les fuites de ressources en veillant à ce que les ressources soient libérées, même si des exceptions se produisent.

Quelles sont les différences entre le bloc using et la déclaration using en C# ?

Le bloc using entoure le code entre des accolades et garantit la destruction à la fin du bloc, tandis que la déclaration using, introduite dans C# 8.0, est plus concise et élimine automatiquement les ressources lorsqu'elles sortent du champ d'application.

Comment puis-je implémenter IDisposable dans mes classes personnalisées C# ?

Pour implémenter IDisposable dans des classes personnalisées, définissez une méthode Dispose pour libérer les ressources non gérées, permettant l'utilisation de l'instruction using pour une gestion automatique des ressources.

L'instruction using peut-elle gérer plusieurs ressources en C# ?

Oui, vous pouvez gérer plusieurs ressources en empilant plusieurs instructions using, bien qu'une seule instruction using avec plusieurs ressources séparées par des virgules ne soit pas prise en charge.

Pourquoi l'instruction using est-elle préférée aux blocs try-finally en C# ?

L'instruction using est préférée pour sa syntaxe plus propre et sa gestion automatique des ressources, ce qui simplifie le code par rapport à l'implémentation manuelle de blocs try-finally pour garantir la destruction des ressources.

Comment puis-je gérer efficacement les documents PDF en C# ?

Vous pouvez gérer efficacement les documents PDF à l'aide de IronPDF, qui s'intègre à l'instruction using pour garantir que les ressources telles que les instances de documents sont correctement fermées après des opérations telles que l'extraction de texte.

Existe-t-il un essai gratuit pour les bibliothèques PDF pour le développement en C# ?

Oui, certaines bibliothèques PDF offrent un essai gratuit de 30 jours et sont gratuites pour une utilisation à des fins de développement, vous permettant d'explorer leurs capacités avant d'acheter.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit