Partager via

Janvier 2016

Volume 31, numéro 1

Cet article a fait l'objet d'une traduction automatique.

L’essentiel de .NET : génération de scripts C#

Par Mark Michaelis | Janvier 2016

Mark MichaelisAvec l'arrivée de Visual Studio 2015 Update 1, désormais Update 1, est une nouvelle c# en lecture-évaluation-impression-boucle (REPL), disponible sous la forme d'une nouvelle fenêtre interactive dans Visual Studio 2015 ou une nouvelle interface de ligne de commande (CLI) appelée CSI. En plus de la commercialisation de la ligne de commande du langage c#, mise à jour 1 introduit également un nouveau c# scripting language, généralement enregistré dans un fichier CSX.

Avant de plonger dans les détails du nouveau langage c# scripting, il est important de comprendre les scénarios cible. Script c# est un outil pour tester vos extraits de code c# et .NET sans les efforts de création d'unité plusieurs projets de test ou de la console. Il fournit une option légère pour rapidement coder un appel de méthode d'agrégation LINQ sur la ligne de commande, la vérification de l'API .NET pour décompresser les fichiers ou appeler une API REST pour déterminer ce qu'elle retourne ou son fonctionnement. Il fournit un moyen facile d'Explorer et comprendre une API sans la surcharge d'un fichier CSPROJ encore un autre dans votre répertoire % temp%.

La réplication de ligne de commande Interface c# (CSI. (EXE)

En tant que formation c# lui-même, le meilleur moyen de vous familiariser avec la boucle REPL c# d'apprentissage interface consiste à exécuter et commencer l'exécution de commandes. Pour le lancer, exécutez la commande csi.exe à partir de l'invite de commandes développeur Visual Studio 2015 ou utilisez le chemin d'accès complet, C:\Program Files (x86)\MSBuild\14.0\bin\csi.exe. À partir de là, commencez à exécuter les instructions c# telles que celles illustrées dans Figure 1.

Figure 1 CSI REPL exemple

C:\Program Files (x86)\Microsoft Visual Studio 14.0>csi
Microsoft (R) Visual C# Interactive Compiler version 1.1.0.51014
Copyright (C) Microsoft Corporation. All rights reserved.
Type "#help" for more information.
> System.Console.WriteLine("Hello! My name is Inigo Montoya");
Hello! My name is Inigo Montoya
> 
> ConsoleColor originalConsoleColor  = Console.ForegroundColor;
> try{
.  Console.ForegroundColor = ConsoleColor.Red;
.  Console.WriteLine("You killed my father. Prepare to die.");
. }
. finally
. {
.  Console.ForegroundColor = originalConsoleColor;
. }
You killed my father. Prepare to die.
> IEnumerable<Process> processes = Process.GetProcesses();
> using System.Collections.Generic;
> processes.Where(process => process.ProcessName.StartsWith("c") ).
.  Select(process => process.ProcessName ).Distinct()
DistinctIterator { "chrome", "csi", "cmd", "conhost", "csrss" }
> processes.First(process => process.ProcessName == "csi" ).MainModule.FileName
"C:\\Program Files (x86)\\MSBuild\\14.0\\bin\\csi.exe"
> $"The current directory is { Environment.CurrentDirectory }."
"The current directory is C:\\Program Files (x86)\\Microsoft Visual Studio 14.0."
>

La première chose à noter est l'évident, c'est comme c#, mais un nouveau dialecte du langage c# (mais sans la cérémonie est admises dans un programme de production complet et inutile dans un prototype brièvement). Par conséquent, évidemment, si vous souhaitez appeler une méthode statique écrire le nom de méthode qualifié et passer des arguments entre parenthèses. Comme dans c#, vous déclarez une variable en lui attribuant le type et, éventuellement, l'affectation d'une nouvelle valeur au moment de la déclaration. Là encore, évidemment, toute syntaxe du corps de méthode valide : blocs try/catch/finally, de déclaration de variable, les expressions lambda et LINQ, fonctionne de façon transparente.

Et même sur la ligne de commande, autres fonctionnalités c#, tels que chaîne construit (respect de la casse, les littéraux de chaîne et l'interpolation de chaîne), sont conservées. Par conséquent, lorsque vous utilisez ou en affichant les chemins d'accès, barres obliques inverses doivent être échappé à l'aide d'un caractère d'échappement c# (« \ ») ou un littéral de chaîne, comme des barres obliques inverses doubles dans la sortie d'un chemin d'accès similaire à celle de csi.exe. Chaîne fonctionne interpolation, trop, comme « répertoire actuel » exemple de ligne de Figure 1 montre.

Script c# permet de bien plus que des instructions et des expressions, toutefois. Vous pouvez déclarer des types personnalisés, incorporer les métadonnées des types via des attributs et même simplifier les commentaires à l'aide de declaratives spécifiques à un script c#. Prenons l'exemple de vérification orthographique dans Figure 2.

Figure 2 classe orthographique (Spell.csx) de script c#

#r ".\Newtonsoft.Json.7.0.1\lib\net45\Newtonsoft.Json.dll"
#load "Mashape.csx"  // Sets a value for the string Mashape.Key
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Threading.Tasks;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
public class Spell
{
  [JsonProperty("original")]
  public string Original { get; set; }
  [JsonProperty("suggestion")]
  public string Suggestion { get; set; }
  [JsonProperty(PropertyName ="corrections")]
  private JObject InternalCorrections { get; set; }
  public IEnumerable<string> Corrections
  {
    get
    {
      if (!IsCorrect)
      {
        return InternalCorrections?[Original].Select(
          x => x.ToString()) ?? Enumerable.Empty<string>();
      }
      else return Enumerable.Empty<string>();
    }
  }
  public bool IsCorrect
  {
    get { return Original == Suggestion; }
  }
  static public bool Check(string word, out IEnumerable<string> corrections)
  {
    Task <Spell> taskCorrections = CheckAsync(word);
    corrections = taskCorrections.Result.Corrections;
    return taskCorrections.Result.IsCorrect;
  }
  static public async Task<Spell> CheckAsync(string word)
  {
    HttpWebRequest request = (HttpWebRequest)WebRequest.Create(
      $"https://montanaflynn-spellcheck.p.mashape.com/check/?text={ word }");
    request.Method = "POST";
    request.ContentType = "application/json";
    request.Headers = new WebHeaderCollection();
    // Mashape.Key is the string key available for
    // Mashape for the montaflynn API.
    request.Headers.Add("X-Mashape-Key", Mashape.Key);
    using (HttpWebResponse response =
      await request.GetResponseAsync() as HttpWebResponse)
    {
      if (response.StatusCode != HttpStatusCode.OK)
        throw new Exception(String.Format(
        "Server error (HTTP {0}: {1}).",
        response.StatusCode,
        response.StatusDescription));
      using(Stream stream = response.GetResponseStream())
      using(StreamReader streamReader = new StreamReader(stream))
      {
        string strsb = await streamReader.ReadToEndAsync();
        Spell spell = Newtonsoft.Json.JsonConvert.DeserializeObject<Spell>(strsb);
        // Assume spelling was only requested on first word.
        return spell;
      }
    }
  }
}

La plupart du temps, il s'agit simplement une norme c# déclaration de classe. Toutefois, il existe plusieurs c# script des fonctionnalités spécifiques. Tout d'abord, la directive #r sert à référencer un assembly externe. Dans ce cas, la référence est à Newtonsoft.Json.dll, qui vous aide à analyser les données JSON. Notez, toutefois, il s'agit une directive conçue pour faire référence à des fichiers dans le système de fichiers. Par conséquent, il ne nécessite pas la cérémonie inutile d'une séquence d'échappement barre oblique inverse.

Ensuite, vous pouvez prendre la liste complète et enregistrez-le en tant que fichier CSX, puis « importation » ou « inline » du fichier dans la fenêtre REPL c# à l'aide de #load Spell.csx. La directive #load vous permet d'inclure des fichiers de script supplémentaires comme si tous les fichiers #load ont été inclus dans le même « projet » ou « compilation ». Placer le code dans un fichier de script c# distinct permet à un type de fichier de refactorisation et, plus important encore, la possibilité de rendre persistant le script c# au fil du temps.

À l'aide de déclarations sont une autre fonctionnalité de langage c# autorisée en c#, langage de script, un qui Figure 2 exploite plusieurs fois. Notez que, comme dans c#, un à l'aide de déclaration est étendue pour le fichier. Par conséquent, si vous avez appelé #load Spell.csx dans la fenêtre REPL, ne conserve l'utilisation déclarative en dehors de la Spell.csx Newtonsoft.Json. En d'autres termes, à l'aide de Newtonsoft.Json à partir de Spell.csx n'aurait pas rendre persistantes dans la fenêtre REPL à nouveau être déclaré explicitement dans la fenêtre REPL (et inversement). Notez que c# 6.0 à l'aide de static déclarative est également pris en charge. Par conséquent, un « à l'aide de System.Console statique » déclarative évite de préfixe des membres System.Console avec le type, permettant de commandes REPL tels que « WriteLine ("Hello ! Mon nom est Inigo Montoya »). »

Autres constructions de note dans le script c# incluent l'utilisation d'attributs, à l'aide des instructions de déclaration de propriété et la fonction et prise en charge d'async/await. Étant donné la prise en charge de ce dernier, il même est possible d'utiliser await dans la fenêtre de réplication :

 

(await Spell.CheckAsync("entrepreneur")).IsCorrect

Voici quelques remarques supplémentaires sur l'interface c# REPL :

  • Vous ne pouvez pas exécuter csi.exe à partir de Windows PowerShell Scripting environnement intégré (ISE) car elle nécessite une entrée direct à la console, ce qui n'est pas pris en charge dans les fenêtres de console « simulé » de Windows PowerShell ISE. (Pour cette raison, envisagez d'ajouter à la liste non pris en charge des applications de console, $psUnsupportedConsoleApplications.)
  • Il n'existe aucun « exit » ou la commande de « quitter » pour quitter le programme CSI. Au lieu de cela, vous utilisez Ctrl + C pour quitter le programme.
  • Historique des commandes est conservé entre les sessions csi.exe démarrées à partir de la même cmd.exe ou PowerShell.exe session. Par exemple, si vous démarrez csi.exe, appelez Console.WriteLine("HelloWorld"), utilisez Ctrl + C pour quitter, puis relancez csi.exe, la flèche vers le haut affiche la commande Console.WriteLine("HelloWorld") précédente. Quitter la fenêtre cmd.exe et relancer efface l'historique.
  • CSI.exe prend en charge la commande REPL #help, qui affiche la sortie présentée dans Figure 3.
  • CSI.exe prend en charge plusieurs options de ligne de commande, comme indiqué dans Figure 4.

Figure 3 le REPL #help sortie de la commande

> #help
Keyboard shortcuts:
  Enter         If the current submission appears to be complete, evaluate it.
                Otherwise, insert a new line.
  Escape        Clear the current submission.
  UpArrow       Replace the current submission with a previous submission.
  DownArrow     Replace the current submission with a subsequent
                submission (after having previously navigated backward).
REPL commands:
  #help         Display help on available commands and key bindings.

Options de ligne de commande de la figure 4 Csi.exe

Microsoft (R) Visual C# Interactive Compiler version 1.1.0.51014
Copyright (C) Microsoft Corporation. All rights reserved.
Usage: csi [option] ... [script-file.csx] [script-argument] ...
Executes script-file.csx if specified, otherwise launches an interactive REPL (Read Eval Print Loop).
Options:
  /help       Display this usage message (alternative form: /?)
  /i          Drop to REPL after executing the specified script
  /r:<file>   Reference metadata from the specified assembly file
              (alternative form: /reference)
  /r:<file list> Reference metadata from the specified assembly files
                 (alternative form: /reference)
  /lib:<path list> List of directories where to look for libraries specified
                   by #r directive (alternative forms: /libPath /libPaths)
  /u:<namespace>   Define global namespace using
                   (alternative forms: /using, /usings, /import, /imports)
  @<file>     Read response file for more options
  --          Indicates that the remaining arguments should not be
              treated as options

Comme indiqué, csi.exe vous permet de spécifier un fichier de « profil » par défaut qui personnalise votre fenêtre de commande :

  • Pour effacer la console CSI, appelez Console.Clear. (Utilisez un System.Console statique déclarative pour ajouter la prise en charge de simplement appeler clairement.)
  • Si vous entrez une commande sur plusieurs lignes et que vous faites une erreur sur une ligne précédente, vous pouvez utiliser Ctrl + Z, puis appuyez sur ENTREE pour annuler et revenir à une invite de commandes vide sans exécuter (Notez que le ^ Z s'affiche dans la console).

La fenêtre Interactive Visual Studio c#

Comme je l'ai mentionné, il existe également une nouvelle fenêtre de Visual Studio c# interactif dans Update 1, comme dans Figure 5. La fenêtre Interactive c# est lancée à partir de la vue | Autres fenêtres | Menu Interactive c#, qui ouvre une autre fenêtre ancrée. Comme la fenêtre csi.exe, il est une fenêtre REPL c#, mais avec quelques fonctionnalités supplémentaires. Tout d'abord, il inclut le codage de couleur de syntaxe et IntelliSense. De même, compilation se produit en temps réel, comme vous le modifiez, les erreurs de syntaxe et les autres seront automatiquement souligné de trait de soulignement ondulé rouge.

Déclaration d'une fonction de Script c# en dehors d'une classe à l'aide de la fenêtre Interactive Visual Studio c#
Figure 5 déclaration c# de Script en dehors d'une classe à l'aide de la fenêtre Interactive Visual Studio c# (fonction)

Une association avec la fenêtre Interactive c# commune est, bien sûr, les fenêtres de Visual Studio exécution et commande. Bien qu'il existe des chevauchements — après tout, elles sont les deux fenêtres REPL par rapport à laquelle vous pouvez exécuter des instructions de .NET, ils ont des besoins très différents. La fenêtre exécution c# est liée directement dans le contexte de débogage de votre application, ce qui vous permet d'injecter des instructions supplémentaires dans le contexte, examiner les données dans la session de débogage et même de manipuler et mettre à jour les données et contexte de débogage. De même, la fenêtre de commande fournit une interface CLI pour la manipulation de Visual Studio, notamment exécuter les différents menus, mais à partir de la fenêtre de commande, plutôt que dans les menus eux-mêmes. (L'exécution de la commande View.C#Interactive, par exemple, ouvre la fenêtre Interactive c#.) En revanche, la fenêtre Interactive c# vous permet d'exécuter c#, y compris toutes les fonctionnalités relatives à l'interface c# REPL abordée dans la section précédente. Toutefois, la fenêtre Interactive c# n'a pas accès au contexte de débogage. Il existe une session c# entièrement indépendante sans poignées soit le contexte de débogage ou même Visual Studio. Comme csi.exe, il est un environnement qui vous permet de tester rapides extraits de code c# et .NET pour vérifier votre présentation sans avoir à démarrer un autre projet Visual Studio console ou l'unité de test. Au lieu de lancer un programme distinct, toutefois, la fenêtre Interactive c# est hébergée dans Visual Studio, où le développeur est vraisemblablement résidents en mémoire.

Voici quelques remarques à propos de la fenêtre Interactive c# :

  • La fenêtre Interactive c# prend en charge un nombre de commandes REPL supplémentaires introuvable dans csi.exe, y compris :
    • #cls / #clear pour effacer le contenu de la fenêtre de l'éditeur
    • #reset pour restaurer l'environnement d'exécution à son état initial, tout en conservant l'historique des commandes
  • Les raccourcis clavier sont un peu inattendus, comme l'indique la #help Figure 6 montre.

Figure 6 raccourcis clavier pour la fenêtre Interactive c#

Entrer Si la soumission en cours est terminée, l'évaluer. Sinon, insérez une nouvelle ligne.
CTRL + ENTRÉE Dans la présentation en cours, évaluer la soumission en cours.
MAJ + ENTRÉE Insérer une nouvelle ligne.
Séquence d'échappement Désactivez la soumission en cours.
ALT + flèche haut Remplacez la soumission en cours d'une soumission précédente.
ALT + bas Remplacer la soumission actuelle avec un envoi suivant (après avoir été accédé en arrière).
Ctrl + Alt + flèche haut Remplacer la soumission actuelle avec un début de soumission précédente avec le même texte.
Ctrl + Alt + bas Remplacer la soumission actuelle avec un début de soumission avec le même texte (après avoir été accédé en arrière).
Flèche haut

À la fin de l'envoi en cours, remplacez la soumission en cours avec une soumission précédente.

Par ailleurs, déplacez le curseur d'une ligne.
Bas

À la fin de l'envoi en cours, remplacez la soumission en cours avec une soumission suivante (après avoir été accédé en arrière).

Par ailleurs, déplacez le curseur vers le bas d'une ligne.
CTRL + K, Ctrl + Entrée Coller la sélection à la fin de la mémoire tampon interactif, laissez le signe insertion à la fin de l'entrée.
CTRL + E, Ctrl + Entrée Coller et exécuter la sélection avant toute entrée en attente dans la mémoire tampon interactive.
Ctrl+A Appuyez d'abord sur, sélectionnez la présentation contenant le curseur. Appuyez ensuite sur la touche, sélectionnez tout le texte dans la fenêtre.

Il est important de noter que Alt + haut/bas sont les raccourcis clavier pour rappeler l'historique des commandes. Microsoft sélectionné ces sur la flèche haut/bas plus simple car elle voulait que l'expérience de la fenêtre Interactive correspond à celle d'une fenêtre de code de Visual Studio standard.

  • Étant donné que la fenêtre Interactive c# est hébergée dans Visual Studio, il n'existe pas de la même opportunité pour passer des références, à l'aide des importations via la ligne de commande ou declaratives qu'avec csi.exe. Au lieu de cela, la fenêtre Interactive c# charge son contexte d'exécution par défaut dans C:\Program Files (x 86) \Microsoft Visual Studio 14.0\Common7\IDE\PrivateAssemblies\CSharpInteractive.rsp, qui identifie les assemblys à référencer par défaut :
# This file contains command-line options that the C# REPL
# will process as part of every compilation, unless
# \"/noconfig\" option is specified in the reset command.
/r:System
/r:System.Core
/r:Microsoft.CSharp
/r:System.Data
/r:System.Data.DataSetExtensions
/r:System.Xml
/r:System.Xml.Linq
SeedUsings.csx

En outre, le fichier CSharpInteractive.rsp fait référence à un fichier par défaut C:\Program Files (x 86) \Microsoft Visual Studio 14.0\Common7\IDE\PrivateAssemblies\SeedUsings.csx :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

La combinaison de ces deux fichiers est la raison pour laquelle vous pouvez utiliser Console.WriteLine et Environment.CurrentDirectory plutôt que complet System.Console.WriteLine et System.Environ-ment.CurrentDirectory, respectivement. En outre, faisant référence à des assemblys tels que Microsoft.CSharp permet l'utilisation de fonctionnalités de langage comme dynamique sans rien d'autre. (Modification de ces fichiers est façon de modifier votre « profil » ou les « préférences » afin que les modifications sont conservées entre les sessions).

Plus d'informations sur la syntaxe du Script c#

Une chose à garder à l'esprit que la syntaxe du script c# est que la plupart de la cérémonie importante standard c# deviennent convenablement facultatif dans un script c#. Par exemple, les éléments tels que les corps de méthode n'avez pas besoin d'apparaître dans une fonction et les fonctions de script c# peuvent être déclarées en dehors des limites d'une classe. Vous pouvez, par exemple, définir une fonction d'installation NuGet directement dans la fenêtre REPL, comme indiqué dans Figure 5. En outre, peut-être un peu surprenant script c# ne gère pas déclarer des espaces de noms. Par exemple, vous ne pouvez ajuster la classe de l'orthographe dans un espace de noms grammaire : grammaire de l'espace de noms {{}} de l'orthographe de la classe.

Il est important de noter que vous pouvez déclarer que la construction (variable, classe, fonction, etc.) et à nouveau. La dernière déclaration occulte toute déclaration antérieure.

Un autre élément important à être attentif est le comportement du point-virgule de fin de commande. Instructions (affectations de variables, par exemple) requièrent un point-virgule. Sans le point-virgule la fenêtre REPL continuera à inviter (via un point) pour plus d'entrée jusqu'à ce que le point-virgule est entré. En revanche, les expressions, exécutera sans le point-virgule. Par conséquent, System.Diagnostics.Process.Start("notepad") lancera le bloc-notes même sans le point-virgule de fin. En outre, étant donné que l'appel de méthode de démarrage renvoie un processus, sortie de chaîne de l'expression s'affiche sur la ligne de commande: [System.Diagnostics.Process (bloc-notes)]. Fermeture d'une expression par un point-virgule, masque, toutefois, la sortie. Appel de démarrer avec un point-virgule de fin, par conséquent, ne génère aucune sortie, bien que toujours lance le bloc-notes. Bien entendu, Console.WriteLine ("il faudrait un miracle.") ; affiche toujours le texte, même avec le point-virgule, étant donné que la méthode elle-même est affichant la sortie (pas le retour de la méthode).

La distinction entre les expressions et des instructions peut entraîner des différences subtiles dans certains cas. Par exemple, le texte de chaîne d'instruction = « une pénurie de b parfait... » ; ne génère aucune sortie, texte = « Arrêter ce qui rime et que je veux » renvoie la chaîne assignée (car l'assignation renvoie la valeur affectée et il n'existe aucun point-virgule pour supprimer la sortie).

Les directives de script c# pour référencer des assemblys supplémentaires (#r) et l'importation de scripts c# existants (#load) sont des ajouts merveilleux. (On peut l'imaginer des solutions complexes tels que les fichiers project.json pour parvenir au même résultat ne serait pas aussi élégant). Malheureusement, au moment de la rédaction de cet article, les packages NuGet ne sont pas pris en charge. Pour faire référence à un fichier à partir de NuGet nécessite l'installation du package dans un répertoire et puis de référencer la DLL via la directive #r. (Microsoft garantit me que cela arrive.)

Notez que les directives de référence à des fichiers spécifiques à ce stade. Vous ne pouvez pas, par exemple, spécifier une variable dans la directive. Pendant que vous attendez cela avec une directive, elle empêche la possibilité de charger dynamiquement un assembly. Par exemple, vous pouvez appeler dynamiquement « installer nuget.exe » pour extraire un assembly (consultez à nouveau Figure 5). Ce faisant, toutefois, ne permet pas votre fichier CSX lier de manière dynamique pour le package NuGet extrait, car il n'existe aucun moyen pour passer dynamiquement le chemin d'accès de l'assembly de la directive #r.

UNE INTERFACE CLI C#

J'avoue que j'ai une relation d'amour-détestent avec Windows PowerShell. C'est l'avantage d'avoir Microsoft .NET Framework sur la ligne de commande et la possibilité de passer .NET d'objets sur le canal, plutôt que le texte de la CLI qui précédait si nombreux traditionnel. Ceci dit, lorsqu'il s'agit du langage c#, je suis partisan, j'adore son élégance et la puissance. (À ce jour, je suis toujours impressionné par les extensions de langage qui rendues possibles par LINQ.) Par conséquent, l'idée que j'aurais également l'éventail de Windows PowerShell .NET combinée avec l'élégance du langage c# signifiait que j'avais géré la boucle REPL c# comme un remplacement pour Windows PowerShell. Après avoir lancé csi.exe, j'ai essayé immédiatement cd, dir, ls, pwd, cls, alias et autres commandes. Je me contenterais de dire, je suis désolé, car aucun d'eux a fonctionné. Après avoir est l'expérience et discuter avec l'équipe c#, j'ai réalisé que Windows PowerShell de remplacement n'a pas ce que l'équipe a consacré dans la version 1. En outre, il est le .NET Framework et, par conséquent, il prend en charge d'extensibilité à la fois en ajoutant vos propres fonctions pour les commandes précédentes et même en mettant à jour de l'implémentation de script c# sur Roslyn. Définir sur la définition des fonctions pour ces commandes immédiatement. Le début de ce type de bibliothèque est disponible pour téléchargement sur GitHub à l'adresse github.com/CSScriptEx.

Pour ceux qui recherchent une CLI c# plus fonctionnel qui prend en charge de la liste précédente de la commande dès maintenant, vous devez prendre en compte ScriptCS à scriptcs.net (également sur GitHub à l'adresse github.com/scriptcs). Lui aussi tire parti de Roslyn et inclut des alias, cd, effacer, répertoire de travail actuel, quitter, aide, installer, références, réinitialisation, scriptpacks, les instructions Using et var. Notez que, avec ScriptCS, le préfixe de commande est aujourd'hui un signe deux-points (comme dans : Réinitialiser) au lieu d'un signe dièse (par exemple, #reset). En bonus, ScriptCS ajoute également la prise en charge pour les fichiers CSX, sous la forme de colorisation et IntelliSense, pour Visual Studio Code.

Synthèse

Au moins pour le moment, de l'interface c# REPL vise ne pas à remplacer Windows PowerShell ou même cmd.exe. Pour tenter une approche en tant que tel au début entraîne déception. Au lieu de cela, je vous recommande de script approche c# et la CLI REPL en remplacement légère pour Visual Studio | Nouveau projet : UnitTestProject105 ou le dotnetfiddle.net même envisagée. Il s'agit de c# et méthodes .NET ciblé pour augmenter votre compréhension de la langue et l'API .NET. La boucle REPL c# fournit un moyen de codage des extraits de code courts ou unités de programme que vous pouvez noodle sur avant qu'ils aient prêts à être coupé et collé dans des programmes plus volumineux. Il vous permet d'écrire des scripts plus étendues dont la syntaxe est validée (même pour les petites choses telles que les différences de casse) lorsque vous écrivez le code, plutôt que de vous forcer à exécuter le script vous découvrez mal tapé quelque chose. Une fois que vous avez compris que sa place, le script c# et son windows interactives deviennent un plaisir, l'outil vous recherchez depuis la version 1.0.

Aussi intéressantes que c# REPL et script c# sont eux-mêmes, considérez qu'elles fournissent également un point de départ est une infrastructure d'extensions pour votre propre application — à la Visual Basic pour Applications (VBA). Avec une fenêtre interactive et prise en charge de script c#, vous pouvez l'imaginer un monde — pas trop éloignée, dans laquelle vous pouvez ajouter « macros » de .NET dans vos applications à nouveau, sans inventer un langage personnalisé, un analyseur et un éditeur. Ce serait une fonctionnalité COM héritée lancer sur le monde moderne none trop tôt.

Mark Michaelisest le fondateur de IntelliTect, où il sert de son poste d'architecte en chef technique et un formateur. Depuis près de deux décennies, il a été MVP Microsoft et un directeur régional Microsoft depuis 2007. Michaelis fait plusieurs logiciels conception révision équipes Microsoft, notamment c#, Microsoft Azure, SharePoint et Visual Studio ALM. Il participe à des conférences de développeurs et a écrit de nombreux ouvrages, y compris sa plus récente, « Essential c# 6.0 (5e édition) » (itl.tc/EssentialCSharp). Contactez-le sur Facebook à facebook.com/Mark.Michaelis, sur son blog à l'adresse IntelliTect.com/Mark, sur Twitter : @markmichaelis ou par courrier électronique à mark@IntelliTect.com.

Merci à l'experte technique Microsoft suivante d'avoir relu cet article : Kevin Bost et Kasey Uhlenhuth