AIDE .NET

Utilisation de C# (Comment ça marche pour les développeurs)

Publié août 15, 2024

Même si vous commencez à peine à vous familiariser avec le langage C#, vous aurez probablement déjà rencontré la directive using. Et si vous êtes un utilisateur d'IronPDF, vous serez très familier avec le fait de commencer votre code avec l'espace de noms using ironpdf.

Cependant, il existe une autre utilisation pour le mot-clé using. Dans ce guide, nous examinerons l'instruction using - ce que c'est, comment cela fonctionne et comment cela peut vous aider à créer un code plus efficace. Plongeons dans le vif du sujet!

Qu'est-ce que l'utilisation en C# ?

La déclaration using en C# est un moyen pratique de travailler avec des ressources qui implémentent l'interface IDisposable. Les objets IDisposable détiennent 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 entre en jeu - elle vous aide à vous assurer que ces ressources sont correctement libérées après utilisation.

Fonctionnement du relevé d'emploi

Lorsque 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 fonctionne l'instruction using en action :

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#

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

Utilisation d'un bloc ou d'une déclaration

À partir de C# 8.0, vous pouvez utiliser la déclaration using au lieu du bloc using. La déclaration using est un moyen plus court et plus concis de définir un objet disposable, comme ceci :

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#

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

Le bloc Try, le bloc Finally et la déclaration d'utilisation

Vous vous demandez peut-être comment l'instruction using est liée aux blocs try et finally en C#. Eh bien, l'instruction using est en réalité une abréviation pour un bloc try-finally.!

Voici le même exemple qu'auparavant, mais écrit en utilisant un bloc try-finally au lieu d'une instruction using :

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#

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

Gestion de ressources multiples

L'un des grands avantages de l'instruction using est qu'elle peut gérer plusieurs ressources à la fois. Vous pouvez empiler des instructions using les unes après les autres, 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.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#

Les deux approches garantiront que la méthode Dispose est appelée sur chaque objet StreamReader lorsque le bloc using est quitté, libérant ainsi toutes les ressources qu'ils détenaient.

Implémentation de l'interface IDisposable

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

Voici un exemple de 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

VB C#

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

Voici comment utiliser 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

VB C#

À la fin du bloc using, la méthode Dispose sera appelée, ce qui entraînera la suppression de l'objet StreamReader qu'il gère.

Gestion des exceptions avec l'instruction Using

Un autre avantage de l'instruction using est qu'elle permet de gérer les exceptions plus élégamment. Si une exception se produit dans le bloc using, la méthode Dispose sera toujours appelée sur la ressource, garantissant ainsi un nettoyage approprié.

Prenons l'exemple du 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

VB C#

Dans ce cas, si le code génère une FileNotFoundException, l'exception est capturé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 fuitée.

Travailler avec IronPDF et la déclaration d'utilisation

IronPDF est une bibliothèque populaire pour créer, éditer et extraire des fichiers PDF dans des 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 assurer une bonne gestion des ressources.

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

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 (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#

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

Dans le 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 ainsi toutes les ressources qu'il détenait.

En utilisant l'instruction using avec PdfDocument, nous nous assurons que le fichier PDF est correctement fermé après avoir terminé l'extraction 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 les ressources efficacement en C#.

Csharp Using 1 related to Travailler avec IronPDF et la déclaration d'utilisation

Conclusion

Et voilà un tour d'horizon de l'instruction using! Nous avons vu comment cela garantit la gestion efficace des objets jetables, en gérant une ou plusieurs ressources sans problème. L'instruction using non seulement aide à maintenir un code plus propre, mais elle améliore également la lisibilité de votre projet C#.

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

Prêt à mettre la main sur IronPDF ? Vous pouvez commencer avec notreessai gratuit de 30 jours d'IronPDF et de la Suite d'Iron Software. C'est également totalement gratuit à utiliser à des fins de développement, ce qui vous permet de vraiment voir de quoi il est fait. Et si vous aimez ce que vous voyez, IronPDF commence à partir de749 $ pour les options de licence. Pour des économies encore plus importantes, consultez leLogiciel complet Iron Suiteoù vous pouvez obtenir les neuf outils Iron Software pour le prix de deux. Bon codage!

Csharp Using 2 related to Conclusion