Syntaxe:
L'instruction C# « using » est utilisée pour gérer les ressources qui doivent être explicitement éliminées de manière pratique et sûre. Il suit une syntaxe spécifique comme suit :
en utilisant ( Ressource ResourceType = nouveau type de ressource ( ) ) { //Code }- Le mot clé « using » est utilisé pour déclarer l’instruction « using ».
- Après le mot-clé « using », vous spécifiez le type de ressource avec lequel vous souhaitez travailler, suivi d'un nom de variable qui représente la ressource dans le bloc. Tout objet qui exécute l’interface IDisposable est éligible. Vous pouvez opérer sur la ressource dans le bloc si nécessaire.
- Ensuite, un signe égal (=) est utilisé pour attribuer une nouvelle instance du type de ressource à la variable.
- Ici, le mot-clé « new » est utilisé pour générer un nouvel objet du type ressource.
- Toute initialisation ou configuration supplémentaire peut être effectuée entre parenthèses après le nouveau mot-clé.
- Enfin, vous placez le code qui utilise la ressource entre les accolades {}.
Exemple 1:
Commençons par les exemples de code C# pour démontrer l’utilisation de l’instruction « using » C# dans cet article. Le code donné couvre un programme C# qui lit le contenu d'un fichier texte à l'aide de la classe « StreamReader » dans une instruction « using ».
Le programme commence par importer les espaces de noms nécessaires, System et System.IO, qui fournissent des classes pour les opérations d'entrée/sortie et la gestion des fichiers. Le programme définit une classe appelée « Dummy ». À l'intérieur de la classe « Dummy », il existe une méthode Main() qui doit toujours être traitée comme l'entrée de tout programme C# pour exécuter le programme global du début à la fin.
La méthode Main() commence par déclarer la variable chaîne « fp » et lui attribuer la valeur « test.txt ». Ceci représente le chemin du fichier texte à lire. Pour faire face à toutes les erreurs possibles pouvant survenir lors de la lecture de fichiers, un bloc try-catch est utilisé.
Dans le bloc try, une instruction « using » est utilisée pour créer une instance de la classe « StreamReader ». La tâche de comprendre le contenu d’un fichier incombe au « StreamReader ». Le chemin du fichier stocké dans la variable « fp » est transmis au constructeur « StreamReader » et indique le fichier à lire.
À l’intérieur du bloc « using », le contenu du fichier est examiné ligne par ligne à l’aide d’une boucle « while », sauf si la dernière ligne du document apparaît. La boucle lit une ligne en utilisant la méthode ReadLine() du « StreamReader » et l'affecte à la variable chaîne « l ». Si la ligne n’est pas nulle, elle est imprimée sur la console à l’aide de Console.WriteLine(l).
Une fois la fin du fichier atteinte et qu'il n'y a plus de lignes à lire, le bloc « using » est quitté et l'objet « StreamReader » est automatiquement supprimé en raison de l'instruction « using ». Le bloc catch est activé chaque fois qu'une IOException survient lors de la lecture d'un document. Le message d'exception est obtenu à l'aide de e.Message et un message d'erreur est affiché sur la console à l'aide de Console.WriteLine().
L'exécution du programme se termine et la sortie de la console s'affiche. En supposant que le fichier « test.txt » existe et contient plusieurs lignes de texte, la sortie de ce code est le contenu du fichier qui est imprimé sur la console comme affiché dans l'image ci-jointe suivante. Chaque ligne est affichée séparément dans le résultat :
en utilisant le système ;en utilisant le système. IO ;
mannequin de classe {
statique vide Principal ( ) {
chaîne fp = 'test.txt' ;
essayer {
en utilisant ( Lecteur StreamReader = nouveau StreamReader ( fp ) )
{
chaîne l ;
alors que ( ( je = lecteur. Lire la ligne ( ) ) != nul )
{
Console. Écrire une ligne ( je ) ;
}
}
}
attraper ( IOExceptione ) {
Console. Écrire une ligne ( 'Erreur est survenue: ' + C'est. Message ) ;
}
}
}
Note: Si le fichier « test.txt » n'existe pas ou s'il y a un problème d'accès ou de lecture au fichier, le bloc catch est exécuté et un message d'erreur s'affiche sur la console indiquant l'exception spécifique qui s'est produite.
Exemple 2 :
Voici un autre exemple simple qui démontre l'utilisation de l'instruction C# « using » avec un StreamWriter pour écrire les données dans un fichier. Voici une explication du code ainsi que son résultat attendu. Le code commence par la déclaration de la classe « Dummy » et de la méthode « Main » qui finiront par démarrer et terminer le programme.
Dans la méthode « Main », la variable chaîne « fp » est déclarée et initialisée avec le chemin du fichier « test.txt ». Le document sur lequel les informations sont écrites est représenté par ceci. Pour gérer toute éventuelle IOException pouvant survenir tout au long du processus d'écriture du document, le programme est enfermé dans un bloc try-catch.
À l'intérieur du bloc try, un objet StreamWriter nommé «writer» est créé et initialisé à l'aide de l'instruction «using». Le StreamWriter est responsable de l'écriture des caractères dans un fichier. Deux lignes de contenu distinctes sont ajoutées à un document dans la section « using » via la fonction WriteLine de l'objet écrivain. Une fois le bloc quitté, la méthode Dispose() de StreamWriter est automatiquement appelée, ce qui garantit que toutes les données en attente sont écrites dans le fichier et que les ressources nécessaires sont libérées.
Enfin, en dehors du bloc « using », le message « Données écrites avec succès ». Un message s'affiche sur la console qui démontre que l'opération d'écriture du document a réussi et sans erreur. Le bloc catch est activé si une IOException se produit pendant le processus d’écriture du document. Dans ce cas, un message d'erreur ainsi que le message d'exception spécifique s'affichent sur la console.
en utilisant le système ;en utilisant le système. IO ;
mannequin de classe {
statique vide Principal ( ) {
chaîne fp = 'test.txt' ;
essayer {
en utilisant ( Écrivain StreamWriter = nouveau StreamWriter ( fp ) )
{
écrivain. Écrire une ligne ( 'Bonjour, C-Sharp !' ) ;
écrivain. Écrire une ligne ( 'Ceci est un texte de test.' ) ;
}
Console. Écrire une ligne ( 'Données écrites avec succès.' ) ;
}
attraper ( IOExceptione ) {
Console. Écrire une ligne ( 'Erreur est survenue: ' + C'est. Message ) ;
}
}
}
En résumé, le code crée un objet StreamWriter à l'aide de l'instruction « using », écrit deux lignes de texte dans un fichier, puis supprime automatiquement StreamWriter. Si l'opération d'écriture réussit, le logiciel génère un message de réussite. Sinon, il émet un message d'échec si une IOException se produit.
Conclusion
L'instruction C# « using » offre une méthode pratique et sécurisée de gestion des ressources qui nécessitent une élimination explicite. Vous pouvez garantir que les procédures de nettoyage nécessaires sont effectuées automatiquement et réduire le risque de fuite de ressources en enfermant la consommation de ressources dans un bloc « utilisation ». Cela augmente la fiabilité de votre code.