Simplifiez-vous la vie avec les scripts C# — Visual Studio Magazine

.NET pratique

Simplifiez-vous la vie avec les scripts C#

Les projets de test vous permettent d’exercer votre code pour voir s’il fonctionne, mais ils font également partie de “l’enregistrement permanent” de votre projet. Si tout ce que vous voulez faire est d’essayer quelque chose avec du code jetable, le script C# dans Visual Studio peut être un meilleur choix.

C# Scripting (ci-après, CS-Script) vous permet d’écrire et d’exécuter des lignes individuelles de code C# sans avoir à définir des classes ou des espaces de noms. Cette déclaration, à elle seule, est un script CS-Script parfaitement bon (et, dans le bon environnement, affichera même “Hello, World”) :

Console.WriteLine("Hello, World");

Et, si vous avez installé Visual Studio, vous disposez déjà d’un environnement CS-Script parfaitement correct : CSI.EXE (j’ai trouvé ma copie dans C:UsersSourceExchangeControl.WebServicebinroslyn ). Vous pouvez créer un environnement de commande CS-Script en ouvrant simplement l’invite de commande du développeur pour Visual Studio et en tapant CSI. Une fois que la fenêtre a réaffiché l’invite de commande, vous pouvez commencer à saisir et à exécuter CS-Script.

Vous n’êtes pas limité à des instructions C# uniques avec l’invite CSI : les instructions que vous entrez dans l’environnement CSI s’appuient sur les instructions précédentes que vous avez entrées. Les instructions suivantes, saisies l’une après l’autre, fonctionneront ensemble pour créer une classe Customer, par exemple (l’environnement CSI détecte le moment où vous terminez une ligne et continue d’étendre la classe Customer avec laquelle je commence dans cet exemple jusqu’à ce que j’arrive à la clôture finale accolade):

> class Customer {
. public string firstName {get; set;}
. public string lastName {get; set; }
. public string fullName() {
. return firstName + " " + lastName;
. }
. }

Maintenant, je peux tirer parti de cet objet Customer avec quelques instructions CS-Script supplémentaires :

> Customer cust = new Customer();
> cust.firstName = "Peter";
> cust.lastName = "Vogel";
> string fname = cust.fullName();

Si vous n’entrez qu’une expression (une combinaison d’opérateurs, de membres, de variables et de valeurs qui se réduisent à une seule valeur), l’environnement me renvoie cette valeur :

> fname
"Peter Vogel"

Bien sûr, les chances que vous saisissiez tout ce code sans erreur sont extrêmement faibles (bien que vous puissiez utiliser les touches fléchées pour revenir aux lignes autonomes précédentes et les corriger). La chose intelligente, alors, est de mettre tout votre code dans un fichier avec l’extension .csx et d’exécuter ce fichier. Vous pouvez également utiliser la commande csi pour exécuter ce fichier de script, comme ceci :

csi .csx

Malheureusement, l’invite de commande CSI ne prend en charge aucune commande de navigation et de gestion de dossier (par exemple, cd, dir, etc.), il n’y a donc aucun moyen intégré de naviguer vers le dossier contenant votre fichier.csx. Mark Michealis a fourni un ensemble d’extensions pour l’environnement CSI qui vous permettront de récupérer certaines de ces fonctionnalités.

Voici une autre option : Associez l’extension de fichier .csx à CSI.EXE. Vous pouvez maintenant exécuter un fichier .csx simplement en double-cliquant dessus dans l’Explorateur de fichiers.

Script C# et Visual Studio
Et tout cela est très intéressant, mais c’est l’intégration avec Visual Studio qui pourrait simplifier certaines parties de votre processus de développement de code. L’exemple le plus évident de cette intégration apparaît lorsque vous cliquez avec le bouton droit sur l’instruction C# dans votre code et que vous sélectionnez Exécuter en mode interactif dans le menu contextuel : Visual Studio traite l’instruction comme s’il s’agissait de CS-Script et l’exécute.

Bien sûr, cela ne fonctionnera probablement pas car la ligne de code sur laquelle vous avez cliqué dépend presque certainement du travail effectué par les lignes de code précédentes. En règle générale, vous sélectionnez plusieurs lignes de code et cliquez avec le bouton droit sur l’ensemble du bloc avant de sélectionner Exécuter en mode interactif. Un bloc de code comme celui-ci s’exécutera très bien, par exemple :

CustomerRepo cr = new CustomerRepo();
Customer cust = cr.GetCustomer("A123");
string fName = cust.GetFirstName();

Encore plus utile est la fenêtre CS-Script REPL (Read-Evaluate-Print-Loop) que vous pouvez ouvrir en accédant à Visual Studio’s View | Autre choix de menu Windows et sélection de C# Interactive. Dans cette fenêtre, vous pouvez maintenant entrer le code CS-Script et appuyer simplement sur la touche pour l’exécuter.

Il y a quelques déceptions ici, cependant. Il peut être judicieux d’essayer les classes et leurs membres à partir de la fenêtre interactive. Cependant, ce n’est pas parce que la fenêtre s’est ouverte dans Visual Studio alors que votre solution est ouverte que la fenêtre sait quoi que ce soit sur les classes définies dans la solution actuelle. En fait, le dossier par défaut de la fenêtre n’est même pas le dossier de votre solution actuelle (du moins dans Visual Studio 2019).

Vous n’êtes pas complètement sans ressources : il y a des DLL .NET de base chargées pour vous et des directives système (à l’aide d’instructions) exécutées pour vous lorsque la fenêtre s’ouvre. Cela signifie que Console.WriteLine fonctionne dès la sortie de la boîte, par exemple. Mais pour tout ce qui va au-delà de certaines bibliothèques de classes de base, vous devrez ajouter vous-même des références à ces bibliothèques.

Création de scripts de test
Cela signifie que si vous voulez essayer les objets de votre solution, vous devrez (a) avoir compilé votre code au moins une fois, et (b) avoir ajouté une référence à un ou plusieurs DDL de vos projets. La directive CS-Script #r vous permettra de référencer une DLL, à condition que vous transmettiez à la directive #r le chemin d’accès complet à la DLL souhaitée ou que vous référenciez votre dossier bin/debug via la collection ReferencePaths.

Je trouve que l’ajout du chemin du fichier DLL aux dossiers bin/debug de mes projets à ReferencePaths est la solution la plus simple. Ce n’est peut-être pas évident car le code pour le faire ressemble à ceci pour un projet typique :

ReferencePaths.Add(@"C:UsersSourceReposbindebug");

Je suis d’accord: ce n’est pas quelque chose que vous voulez taper plus d’une fois (ou pas du tout, d’ailleurs). Pour faciliter l’exercice des objets de mon projet à partir de la fenêtre C# Interactive, j’ajoute d’abord un fichier appelé utilities.csx à mon projet, puis j’ajoute cette instruction ReferencePaths au fichier (je peux obtenir le nom du chemin de mon dossier Debug en cliquant avec le bouton droit de la souris sur le dossier dans l’Explorateur de solutions et en sélectionnant Copier le chemin complet). Lorsque j’ai besoin d’ajouter mon chemin de référence, j’ouvre simplement mon fichier utilities.csx, je clique avec le bouton droit sur cette ligne ReferencePaths et je sélectionne Execute in interactive.

Cela fait, je peux maintenant charger les DLL dans mon dossier Debug par nom (et définir leurs espaces de noms pour économiser de la frappe) avec un code comme celui-ci dans la fenêtre interactive :

> #r ".dll"
> using ;

Cependant, vous vous retrouverez probablement à exécuter les mêmes ensembles de code encore et encore au fur et à mesure que votre code fonctionnera. Une fois que vous avez du code de script à utiliser dans la fenêtre interactive C#, la chose la plus intelligente à faire est de copier ce code dans un autre fichier .csx de votre projet et d’exécuter ce fichier pour exercer vos cours.

Pour exécuter ce fichier .csx, vous utilisez la directive #load de CS-Script. Malheureusement, la directive #load nécessite également un chemin complet, cette fois vers le fichier .csx. Encore une fois, je peux obtenir ce nom de fichier complet en cliquant avec le bouton droit sur mon fichier .csx et en sélectionnant Copier le chemin complet. J’ajoute ensuite une instruction #load avec ce chemin de fichier à mon fichier utilities.csx et j’utilise Execute in interactive pour l’exécuter. Une commande #load typique dans mon fichier utilities.csx pour exécuter un script ressemble à ceci :

#load "C:UserspeterSourceReposSampleClassLibrarySampleClassLibraryExerciseAddCustomer.csx"

Garder ce script dans des fichiers .csx me permet d’économiser beaucoup de frappe lorsque je reviens à ce projet et que je souhaite réutiliser ce code.

Pièges et mises en garde
La fenêtre interactive C #, comme toute bonne fenêtre REPL, vous permet de faire défiler les commandes précédentes, de les modifier et de les réexécuter. Ce qui m’amène à ceci : il y a quelques endroits où les habitudes de votre doigt dans d’autres fenêtres REPL peuvent vous induire en erreur.

Dans la fenêtre C# Interactive REPL, l’utilisation de la ne vous permettra pas de revenir en arrière dans les commandes précédentes : vous devrez utiliser +. Appuyer sur la touche au milieu d’une instruction n’exécutera pas l’instruction mais ajoutera à la place un saut de ligne dans l’instruction : + exécute toujours l’instruction en cours.

Vous pouvez effacer la fenêtre interactive avec l’icône d’effacement de la fenêtre dans la barre de menus de la fenêtre interactive C# ou en utilisant les directives #cls ou #clear dans la fenêtre elle-même. Vous pouvez démarrer une nouvelle session soit en cliquant sur l’icône de réinitialisation dans le menu de la fenêtre, soit en utilisant la directive #reset à l’intérieur de la fenêtre. Si vous travaillez avec .NET Core, vous voudrez utiliser la directive #reset avec le paramètre core afin que CS-Script comprenne le format de vos DLL, comme ceci :

#reset core

Ainsi, avec un peu de configuration (et un fichier utilities.csx d’instructions utiles), CS-Script peut vous donner un moyen facile d’essayer un nouveau code et d’exercer le code existant sans avoir à polluer vos classes de test avec des essais temporaires. Et nous sommes tous opposés à la pollution.