Ajout d’une extension du protocole de serveur de langageAdding a Language Server Protocol extension

Le protocole de serveur de langage (LSP) est un protocole commun, sous la forme de JSON RPC v2.0, utilisée pour fournir des fonctionnalités de service à différents éditeurs de code de langue.The Language Server Protocol (LSP) is a common protocol, in the form of JSON RPC v2.0, used to provide language service features to various code editors. À l’aide du protocole, les développeurs peuvent écrire un serveur unilingue fournissent des fonctionnalités telles qu’IntelliSense, les diagnostics d’erreur du service de langage, rechercher toutes les références, etc. pour différents éditeurs de code qui prennent en charge le LSP.Using the protocol, developers can write a single language server to provide language service features like IntelliSense, error diagnostics, find all references, etc. to various code editors that support the LSP. En règle générale, les services de langage dans Visual Studio peuvent être ajoutés par une à l’aide de fichiers de grammaire TextMate pour fournir des fonctionnalités de base telles que la mise en surbrillance de syntaxe, ou en écrivant des services de langage personnalisé à l’aide de l’ensemble des API d’extensibilité de Visual Studio pour fournir des données plus riches.Traditionally, language services in Visual Studio can be added by either using TextMate grammar files to provide basic functionalities such as syntax highlighting, or by writing custom language services using the full set of Visual Studio extensibility APIs to provide richer data. À présent, prise en charge le LSP offre une troisième option.Now, support for the LSP offers a third option.

service de protocole de serveur de langage dans Visual Studio

Protocole de serveur de langageLanguage Server Protocol

Pour plus d’informations sur le protocole lui-même, consultez la documentation ici.For more information on the protocol itself, see the documentation here. Implémentation de Visual Studio du protocole de serveur de langage est en version préliminaire et prise en charge doit être considérée comme expérimentale.Visual Studio’s implementation of Language Server Protocol is in preview, and support should be considered experimental. La version préliminaire est sous la forme d’une extension (Language Server protocole Client Preview), , mais cette extension ne peut être installée sur le canal de version préliminaire de Visual Studio.The preview release is in the form of an extension (Language Server Protocol Client Preview), but this extension can only be installed on the preview channel of Visual Studio. Une version ultérieure de Visual Studio inclut la prise en charge intégrée pour le protocole de serveur langue, moment auquel l’indicateur de version préliminaire est supprimées.A later release of Visual Studio will include built-in support for Language Server Protocol, at which time the Preview flag will be dropped. Vous ne devez pas utiliser la version d’évaluation à des fins de production.You should not use the preview for production purposes.

Pour plus d’informations sur la création d’un exemple de serveur de langue ou de l’intégration d’un serveur de langue existant dans Visual Studio Code, consultez la documentation ici.For more information on how to create a sample language server or how to integrate an existing language server into Visual Studio Code, see the documentation here.

implémentation de protocole de serveur de langage

Cet article décrit comment créer une extension de Visual Studio qui utilise un serveur de langage LSP.This article describes how to create a Visual Studio extension that uses an LSP-based language server. Il part du principe que vous avez déjà créé un serveur de langage LSP et que vous souhaitez intégrer à Visual Studio.It assumes that you have already developed an LSP-based language server and just want to integrate it into Visual Studio.

Pour la prise en charge dans Visual Studio, les serveurs de langage peuvent communiquer avec le client (Visual Studio) via les mécanismes suivants :For support within Visual Studio, language servers can communicate with the client (Visual Studio) via the following mechanisms:

  • Flux d’entrée/sortie standardStandard input/output streams
  • Canaux nommésNamed pipes
  • socketsSockets

Le but des LSP et sa prise en charge dans Visual Studio est aux services de langage intégré qui ne font pas partie du produit Visual Studio.The intent of the LSP and support for it in Visual Studio is to onboard language services that are not part of Visual Studio product. Il n’est pas destinée à étendre existantes des services de langage (tels que c#) dans Visual Studio.It is not intended to extend existing language services (like C#) in Visual Studio. Pour étendre les langages existants, reportez-vous au guide d’extensibilité du service de langage (par exemple, le plateforme des compilateurs .NET « Roslyn »).To extend existing languages, refer to the language service’s extensibility guide (for example, the "Roslyn" .NET Compiler Platform).

Fonctionnalités de protocole serveur langage pris en chargeLanguage Server Protocol features supported

Les fonctionnalités LSP suivantes sont prises en charge dans Visual Studio jusqu'à présent :The following LSP features are supported in Visual Studio so far:

MessageMessage Prend en charge dans Visual StudioHas Support in Visual Studio
initialiserinitialize ouiyes
initialiséinitialized ouiyes
arrêtshutdown ouiyes
quitterexit ouiyes
$/ cancelRequest$/cancelRequest ouiyes
fenêtre/showMessagewindow/showMessage ouiyes
fenêtre/showMessageRequestwindow/showMessageRequest ouiyes
fenêtre/logMessagewindow/logMessage ouiyes
événement de télémétrie /telemetry/event
client/registerCapabilityclient/registerCapability
client/unregisterCapabilityclient/unregisterCapability
espace de travail/didChangeConfigurationworkspace/didChangeConfiguration ouiyes
espace de travail/didChangeWatchedFilesworkspace/didChangeWatchedFiles ouiyes
espace de travail/symbolesworkspace/symbol ouiyes
espace de travail/executeCommandworkspace/executeCommand ouiyes
espace de travail/applyEditworkspace/applyEdit ouiyes
textDocument/publishDiagnosticstextDocument/publishDiagnostics ouiyes
textDocument/didOpentextDocument/didOpen ouiyes
textDocument/didChangetextDocument/didChange ouiyes
textDocument/willSavetextDocument/willSave
textDocument/willSaveWaitUntiltextDocument/willSaveWaitUntil
textDocument/didSavetextDocument/didSave ouiyes
textDocument/didClosetextDocument/didClose ouiyes
textDocument/fintextDocument/completion ouiyes
Saisie semi-automatique/résolutioncompletion/resolve ouiyes
textDocument/pointagetextDocument/hover ouiyes
textDocument/signatureHelptextDocument/signatureHelp ouiyes
textDocument/référencestextDocument/references ouiyes
textDocument/documentHighlighttextDocument/documentHighlight
textDocument/documentSymboltextDocument/documentSymbol ouiyes
textDocument/la mise en formetextDocument/formatting ouiyes
textDocument/rangeFormattingtextDocument/rangeFormatting ouiyes
textDocument/onTypeFormattingtextDocument/onTypeFormatting
définition/textDocumenttextDocument/definition ouiyes
textDocument/codeActiontextDocument/codeAction ouiyes
textDocument/codeLenstextDocument/codeLens
codeLens/résolutioncodeLens/resolve
textDocument/documentLinktextDocument/documentLink
documentLink/résolutiondocumentLink/resolve
textDocument/changement de nomtextDocument/rename ouiyes

Prise en mainGetting Started

Créez un projet VSIXCreate a VSIX project

Pour créer une extension de service de langage à l’aide d’un serveur de langage LSP, commencez par vérifier que vous avez le le développement d’extensions Visual Studio la charge de travail installé pour votre instance de Visual Studio.To create a language service extension using an LSP-based language server, first make sure you have the Visual Studio extension development Workload installed for your instance of VS.

Ensuite créer un nouveau VSIXProject vide en accédant à fichier > nouveau projet > Visual C# > Extensibilité > projet VSIX:Next create a new blank VSIXProject by navigating to File > New Project > Visual C# > Extensibility > VSIX Project:

créer le projet vsix

Pour la version préliminaire, prise en charge de Visual Studio pour le LSP sera sous la forme d’une extension VSIX (Microsoft.VisualStudio.LanguageServer.Client.Preview).For the preview release, VS support for the LSP will be in the form of a VSIX (Microsoft.VisualStudio.LanguageServer.Client.Preview). Les développeurs d’extensions qui souhaitent créer une extension à l’aide de serveurs de langue LSP doivent prendre une dépendance sur ce VSIX.Extension developers who wish to create an extension using LSP language servers must take a dependency on this VSIX. Par conséquent, les clients qui souhaitent installer une extension du langage doit tout d’abord installer la langue serveur protocole Client Preview extension VSIX.Therefore, customers wishing to install a language server extension must first install the Language Server Protocol Client Preview VSIX.

Pour définir la dépendance VSIX, ouvrez le Concepteur de manifeste VSIX pour votre extension VSIX (en double-cliquant sur le fichier source.extension.vsixmanifest dans votre projet) et accédez à dépendances:To define the VSIX dependency, open the VSIX manifest designer for your VSIX (by double-clicking the source.extension.vsixmanifest file in your project) and navigate to Dependencies:

Ajouter une référence à un client de protocole de serveur de langage

Créer une nouvelle dépendance comme suit :Create a new dependency like the following:

définir la dépendance de client de protocole de serveur language

Note

Le URL de téléchargement doit être renseigné afin que les utilisateurs de l’installation de votre extension sachent comment installer la dépendance requise.The Download URL must be filled in so users installing your extension know how to install the required dependency.

Installation de serveur et d’exécution de langageLanguage server and runtime installation

Par défaut, les extensions créées pour prendre en charge des serveurs de langage LSP dans Visual Studio ne contiendra pas les serveurs de la langue ou les runtimes nécessaires à leur exécution.By default, the extensions created to support LSP-based language servers in Visual Studio will not contain the language servers themselves or the runtimes needed to execute them. Les développeurs d’extensions sont responsables de distribution les serveurs de langage et les runtimes si nécessaires.Extension developers are responsible for distributing the language servers and the runtimes needed. Il existe plusieurs façons de le faire :There are several ways to do so:

  • Serveurs de langue peuvent être incorporées dans le projet VSIX en tant que fichiers de contenu.Language servers can be embedded in the VSIX as content files.
  • Créer un fichier MSI pour installer le serveur de langage et/ou nécessaire runtimes.Create an MSI to install the language server and/or needed runtimes.
  • Fournissent des instructions sur les utilisateurs information Marketplace comment obtenir les runtimes et langage de serveurs.Provide instructions on Marketplace informing users how to obtain runtimes and language servers.

Fichiers de grammaire TextMateTextMate grammar files

LSP n’inclut pas de spécification sur la façon de fournir la colorisation de texte pour les langues.The LSP does not include specification on how to provide text colorization for languages. Pour fournir la colorisation personnalisée pour les langues dans Visual Studio, les développeurs d’extensions peuvent utiliser un fichier de grammaire TextMate.To provide custom colorization for languages in Visual Studio, extension developers can use a TextMate grammar file. Pour ajouter des fichiers thème ou de grammaire TextMate personnalisés, procédez comme suit :To add custom TextMate grammar or theme files, follow these steps:

  1. Créez un dossier nommé « Grammaires » à l’intérieur de votre extension (ou il peut être le nom de votre choix).Create a folder called "Grammars" inside your extension (or it can be whatever name you choose).

  2. Dans le dossier « Grammaires », inclure des *.tmlanguage, *.plist, *.tmtheme ou les fichiers *.json que vous aimeriez qui fournit la colorisation personnalisée.Inside the "Grammars" folder, include any *.tmlanguage, *.plist, *.tmtheme, or *.json files you’d like which provides custom colorization.

  3. Avec le bouton droit sur les fichiers et sélectionnez propriétés.Right-click on the files and select Properties. Modifier l’action de génération pour contenu et inclure dans VSIX true à la propriété.Change the Build action to Content and the Include in VSIX property to true.

  4. Créer un fichier .pkgdef et ajoutez une ligne semblable à celle-ci :Create a .pkgdef file and add a line similar to this:

    [$RootKey$\TextMate\Repositories]
    "MyLang"="$PackageFolder$\Grammars"
    
  5. Avec le bouton droit sur les fichiers et sélectionnez propriétés.Right-click on the files and select Properties. Modifier l’action de génération pour contenu et inclure dans VSIX true à la propriété.Change the Build action to Content and the Include in VSIX property to true.

Après avoir effectué les étapes précédentes, un dossier « Grammaires » est ajouté pour l’installation du package active en tant que référentiel source nommé 'MyLang' ('MyLang' est simplement un nom de lever l’ambiguïté et peut être toute chaîne unique).After completing the previous steps, a "Grammars" folder is added to the package’s install directory as a repository source named 'MyLang' ('MyLang' is just a name for disambiguation and can be any unique string). Toutes les grammaires (fichiers .tmlanguage) et le thème (fichiers .tmtheme) dans ce répertoire sont prélevés comme potentiels et remplacent les grammaires intégrés fournis avec TextMate.All of the grammars (.tmlanguage files) and theme files (.tmtheme files) in this directory are picked up as potentials and they supersede the built-in grammars provided with TextMate. Si les extensions du fichier de grammaire déclaré correspond à l’extension du fichier en cours d’ouverture, TextMate pas.If the grammar file's declared extensions match the extension of the file being opened, TextMate will step in.

Création d’un client de langage simpleCreating a simple language client

Interface principale - ILanguageClientMain Interface - ILanguageClient

Après avoir créé votre projet VSIX, ajoutez les packages NuGet suivants à votre projet :After creating your VSIX project, add the following NuGet package(s) to your project:

Note

Lorsque vous prenez une dépendance sur le package NuGet après avoir effectué les étapes précédentes, les packages Newtonsoft.Json et StreamJsonRpc sont ajoutés à votre projet.When you take a dependency on the NuGet package after you complete the previous steps, the Newtonsoft.Json and StreamJsonRpc packages are added to your project as well. Ne mettez pas à jour ces packages, sauf si vous êtes certain que les nouvelles versions seront installées sur la version de Visual Studio qui les cibles de l’extension.Do not update these packages unless you are certain that those new versions will be installed on the version of Visual Studio that your extension targets. Les assemblys ne sera pas inclus dans votre projet VSIX--au lieu de cela, ils sont récupérés à partir du répertoire d’installation de Visual Studio.The assemblies will not be included in your VSIX -- instead, they will be picked up from the Visual Studio installation directory. Si vous référencez une version plus récente des assemblys que celle qui est installée sur l’ordinateur d’un utilisateur, votre extension ne fonctionne pas.If you are referencing a newer version of the assemblies than what is installed on a user's machine, your extension will not work.

Vous pouvez créer ensuite une nouvelle classe qui implémente le ILanguageClient interface, l’interface principale nécessaire pour les clients de langue qui se connectent à un serveur de langage LSP.You can then create a new class that implements the ILanguageClient interface, the main interface needed for language clients connecting to an LSP-based language server.

Voici un exemple :The following is a sample:

namespace MockLanguageExtension
{
    [ContentType("bar")]
    [Export(typeof(ILanguageClient))]
    public class BarLanguageClient : ILanguageClient
    {
        public string Name => "Bar Language Extension";

        public IEnumerable<string> ConfigurationSections => null;

        public object InitializationOptions => null;

        public IEnumerable<string> FilesToWatch => null;

        public event AsyncEventHandler<EventArgs> StartAsync;
        public event AsyncEventHandler<EventArgs> StopAsync;

        public async Task<Connection> ActivateAsync(CancellationToken token)
        {
            await Task.Yield();

            ProcessStartInfo info = new ProcessStartInfo();
            info.FileName = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Server", @"MockLanguageServer.exe");
            info.Arguments = "bar";
            info.RedirectStandardInput = true;
            info.RedirectStandardOutput = true;
            info.UseShellExecute = false;
            info.CreateNoWindow = true;

            Process process = new Process();
            process.StartInfo = info;

            if (process.Start())
            {
                return new Connection(process.StandardOutput.BaseStream, process.StandardInput.BaseStream);
            }

            return null;
        }

        public async Task OnLoadedAsync()
        {
            await StartAsync?.InvokeAsync(this, EventArgs.Empty);
        }

        public async Task OnServerInitializeFailedAsync(Exception e)
        {
            return Task.CompletedTask;
        }

        public async Task OnServerInitializedAsync()
        {
            return Task.CompletedTask;
        }
    }
}

Les principales méthodes qui doivent être implémentés sont OnLoadedAsync et ActivateAsync.The main methods that need to be implemented are OnLoadedAsync and ActivateAsync. OnLoadedAsync est appelée lors du chargement de votre extension de Visual Studio et votre serveur est prêt à démarrer.OnLoadedAsync is called when Visual Studio has loaded your extension and your language server is ready to be started. Dans cette méthode, vous pouvez appeler la StartAsync délégué immédiatement pour signaler que le serveur doit être démarré, ou vous pouvez effectuer une logique supplémentaire et appeler StartAsync plus tard.In this method, you can invoke the StartAsync delegate immediately to signal that the language server should be started, or you can do additional logic and invoke StartAsync later. Pour activer votre serveur de langue, vous devez appeler StartAsync à un moment donné.To activate your language server, you must call StartAsync at some point.

ActivateAsync est la méthode appelée par la suite en appelant le StartAsync délégué ; il contient la logique permettant de démarrer le serveur de langage et d’établir la connexion à celui-ci.ActivateAsync is the method eventually invoked by calling the StartAsync delegate; it contains the logic to start the language server and establish connection to it. Un objet de connexion qui contient le flux de données pour l’écriture sur le serveur et la lecture à partir du serveur doit être retourné.A connection object that contains streams for writing to the server and reading from the server must be returned. Toutes les exceptions levées ici sont interceptées et affichées à l’utilisateur via un message de la barre d’informations dans Visual Studio.Any exceptions thrown here are caught and displayed to user via an InfoBar message in Visual Studio.

ActivationActivation

Une fois que votre classe de client de langage est implémenté, vous devez définir deux attributs pour pouvoir définir la façon dont il sera chargé dans Visual Studio et activé :Once your language client class is implemented, you'll need to define two attributes for it to define how it will be loaded into Visual Studio and activated:

  [Export(typeof(ILanguageClient))]
  [ContentType("bar")]

MEFMEF

Visual Studio utilise MEF (Managed Extensibility Framework) pour gérer ses points d’extensibilité.Visual Studio uses MEF (Managed Extensibility Framework) to manage its extensibility points. Le exporter attribut indique à Visual Studio que cette classe doit être récupérée en tant qu’un point d’extension et chargée au moment opportun.The Export attribute indicates to Visual Studio that this class should be picked up as an extension point and loaded at the appropriate time.

Pour utiliser MEF, vous devez également définir MEF comme un élément multimédia dans le manifeste VSIX.To use MEF, you must also define MEF as an Asset in the VSIX manifest.

Ouvrez le Concepteur de manifeste VSIX et accédez à la actifs onglet :Open up your VSIX manifest designer and navigate to the Assets tab:

ajouter des ressources MEF

Cliquez sur Nouveau pour créer un nouvel élément multimédia :Click new to create a new Asset:

définir l’élément multimédia MEF

  • Type: Microsoft.VisualStudio.MefComponentType: Microsoft.VisualStudio.MefComponent
  • Source: un projet dans la solution actuelleSource: A project in the current solution
  • Projet: [nom de votre projet]Project: [Your project]

Définition de Type de contenuContent Type Definition

Actuellement, la seule façon de charger votre extension de serveur de langage LSP est par type de contenu de fichier.Currently the only way to load your LSP-based language server extension is by file content type. Autrement dit, lorsque vous définissez votre classe de client de langage (qui implémente ILanguageClient), vous devez définir les types de fichiers qui, quand elle est ouverte, entraîne votre extension à charger.That is, when defining your language client class (which implements ILanguageClient), you will need to define the types of files that, when opened, will cause your extension to load. Si aucun fichier ne correspond à votre type de contenu défini n’est ouverte, puis votre extension ne sera pas chargée.If no files that match your defined content type are opened, then your extension will not be loaded.

Cela est effectué à partir de la définition d’une ou plusieurs classes ContentTypeDefinition :This is done through defining one or more ContentTypeDefinition classes:

namespace MockLanguageExtension
{
    public class BarContentDefinition
    {
        [Export]
        [Name("bar")]
        [BaseDefinition(CodeRemoteContentDefinition.CodeRemoteContentTypeName)]
        internal static ContentTypeDefinition BarContentTypeDefinition;


        [Export]
        [FileExtension(".bar")]
        [ContentType("bar")]
        internal static FileExtensionToContentTypeDefinition BarFileExtensionDefinition;
    }
}

Dans l’exemple précédent, une définition de type de contenu est créée pour les fichiers qui se terminent par .bar extension de fichier.In the previous example, a content type definition is created for files that end in .bar file extension. La définition de type de contenu est fonction de la barre « nom » et doit dérivent CodeRemoteContentTypeName.The content type definition is given the name "bar" and must derive from CodeRemoteContentTypeName.

Après avoir ajouté une définition de type de contenu, vous pouvez définir votre extension de client de langage dans la classe de client de langage de chargement :After adding a content type definition, you can then define when to load your language client extension in the language client class:

    [ContentType("bar")]
    [Export(typeof(ILanguageClient))]
    public class BarLanguageClient : ILanguageClient
    {
    }

Ajout de la prise en charge pour les serveurs de langage LSP ne nécessite pas d’implémenter votre propre système de projet dans Visual Studio.Adding support for LSP language servers does not require you to implement your own project system in Visual Studio. Les clients peuvent ouvrir un seul fichier ou un dossier dans Visual Studio pour démarrer à l’aide de votre service de langage.Customers can open a single file or a folder in Visual Studio to start using your language service. En fait, prise en charge des serveurs de langue LSP est conçu pour fonctionner uniquement dans les scénarios de dossier/fichier ouvert.In fact, support for LSP language servers is designed to work only in open folder/file scenarios. Si un système de projet personnalisé est implémenté, certaines fonctionnalités (telles que les paramètres) ne fonctionneront pas.If a custom project system is implemented, some features (such as settings) will not work.

Fonctionnalités avancéesAdvanced Features

ParamètresSettings

Prise en charge des paramètres de serveur-spécifiques au langage personnalisés ne sont pas disponibles pour la version préliminaire de la prise en charge LSP dans Visual Studio, mais il est toujours en cours d’améliorées.Support for custom language-server-specific settings is available for Preview release of LSP support in Visual Studio, but it is still in the process of being improved. Paramètres sont spécifiques à ce que le serveur prend en charge et généralement contrôler comment le serveur émet des données.Settings are specific to what the language server supports and usually control how the language server emits data. Par exemple, un serveur de langue peut avoir un paramètre pour le nombre maximal d’erreurs signalées.For example, a language server might have a setting for the maximum number of errors reported. Auteurs d’extensions définissez une valeur par défaut, qui peut être modifiée par les utilisateurs pour des projets spécifiques.Extension authors would define a default value, which can be changed by users for specific projects.

Suivez ces étapes ci-dessous pour ajouter la prise en charge des paramètres pour votre extension de service de langage LSP :Follow these steps below to add support for settings to your LSP language service extension:

  1. Ajouter un fichier JSON (par exemple, « MockLanguageExtensionSettings.json ») dans votre projet qui contient les paramètres et leurs valeurs par défaut.Add a JSON file (for example, "MockLanguageExtensionSettings.json") in your project that contains the settings and their default values. Par exemple :For example:

    {
     "foo.maxNumberOfProblems": -1
    }
    
  2. Cliquez avec le bouton droit sur le fichier JSON et sélectionnez propriétés.Right click on the JSON file and select Properties. Modifier la générer action pour « Contenu » et le « inclure dans VSIX' true à la propriété.Change the Build action to "Content" and the "Include in VSIX' property to true.

  3. Implémenter ConfigurationSections et retourner la liste des préfixes pour les paramètres définis dans le fichier JSON (dans Visual Studio Code, il serait correspondre au nom de la section de configuration dans package.json) :Implement ConfigurationSections and return the list of prefixes for the settings defined in the JSON file (In Visual Studio Code, this would map to the configuration section name in package.json):

    public IEnumerable<string> ConfigurationSections
    {
       get
       {
           yield return "foo";
       }
    }
    
  4. Ajoutez un fichier .pkgdef au projet (ajouter le nouveau fichier texte et remplacez l’extension de fichier .pkgdef).Add a .pkgdef file to the project (add new text file and change the file extension to .pkgdef). Le fichier pkgdef doit contenir ces informations :The pkgdef file should contain this info:

     [$RootKey$\OpenFolder\Settings\VSWorkspaceSettings\[settings-name]]
     @="$PackageFolder$\[settings-file-name].json"
    
  5. Cliquez avec le bouton droit sur le fichier .pkgdef et sélectionnez propriétés.Right click on the .pkgdef file and select Properties. Modifier la générer l’action « Contenu » et la valeur true à la propriété « Inclure dans VSIX ».Change the Build action to "Content" and the "Include in VSIX" property to true.

  6. Ouvrez le source.extension.vsixmanifest et ajoutez un élément multimédia dans le Asset onglet :Open up the source.extension.vsixmanifest file and add an asset in the Asset tab:

    modifier le vspackage actif

    • Type: Microsoft.VisualStudio.VsPackageType: Microsoft.VisualStudio.VsPackage
    • Source: fichier sur le système de fichiersSource: File on filesystem
    • Chemin d’accès: [chemin d’accès à votre fichier pkgdef]Path: [Path to your pkgdef file]

Modification des paramètres pour un espace de travail d’utilisateurUser editing of settings for a workspace

  1. Utilisateur ouvre un espace de travail contenant le propriétaire de votre serveur de fichiers.User opens a workspace containing files your server owns.
  2. Utilisateur ajoute un fichier dans le dossier « .vs » appelé « VSWorkspaceSettings.json ».User adds a file in the ".vs" folder called "VSWorkspaceSettings.json".
  3. Utilisateur ajoute une ligne dans le fichier VSWorkspaceSettings.json pour un paramètre que fournit par le serveur.User adds a line to the VSWorkspaceSettings.json file for a setting the server provides. Par exemple :For example:

    {
     "foo.maxNumberOfProblems": 10
    }
    

    L’activation du traçage de diagnosticEnabling diagnostics tracing

    Traçage de diagnostic peut être activé pour tous les messages entre le client et le serveur, ce qui peut être utile lors du débogage des problèmes de sortie.Diagnostics tracing can be enabled to output all messages between the client and server, which can be useful when debugging issues. Pour activer le suivi de diagnostic, procédez comme suit :To enable diagnostic tracing, do the following:

  4. Ouvrez ou créez le fichier de paramètres d’espace de travail « VSWorkspaceSettings.json » (voir « Utilisateur modification des paramètres pour un espace de travail »).Open or create the workspace settings file "VSWorkspaceSettings.json" (see "User editing of settings for a workspace").

  5. Ajoutez la ligne suivante dans le fichier json de paramètres :Add the following line in the settings json file:
{
    "foo.server.trace": "Off"
}

Il existe trois valeurs possibles pour les commentaires de trace :There are three possible values for trace verbosity:

  • « Désactivé » : le suivi complètement mise hors tension"Off": tracing turned off completely
  • « Messages » : le traçage activé mais l’ID de nom et de réponse seule méthode est suivi."Messages": tracing turned on but only method name and response ID are traced.
  • « Commentaires » : le suivi activé ; le message rpc entière est suivi."Verbose": tracing turned on; the entire rpc message is traced.

Quand le traçage est activé sur le contenu est écrit dans un fichier dans le répertoire « temp%\VisualStudio\LSP % ».When tracing is turned on the content is written to a file in the "%temp%\VisualStudio\LSP" directory. Le journal suit le format d’affectation de noms [LanguageClientName]-[Datetime Stamp].log.The log follows the naming format [LanguageClientName]-[Datetime Stamp].log. Actuellement, le suivi ne peut être activé que pour les scénarios d’ouvrir le dossier.Currently, tracing can only be enabled for open folder scenarios. Ouverture d’un fichier unique pour activer un serveur de langue n’est pas prise en charge de suivi de diagnostic.Opening a single file to activate a language server does not have diagnostics tracing support.

Messages personnalisésCustom messages

Il existe des API en place afin de faciliter le passage des messages à et réception de messages à partir du serveur de langage qui ne font pas partie du protocole du serveur de langage standard.There are APIs in place to facilitate passing messages to and receiving messages from the language server that are not part of the standard language server protocol. Pour gérer des messages personnalisés, vous devez implémenter ILanguageClientCustomMessage interface dans votre classe de client de langage.To handle custom messages, implement ILanguageClientCustomMessage interface in your language client class. VS-StreamJsonRpc bibliothèque est utilisée pour transmettre des messages personnalisés entre votre client de langage et le serveur.VS-StreamJsonRpc library is used to transmit custom messages between your language client and language server. Étant donné que votre extension de client de langage LSP est identique à une autre extension de Visual Studio, vous pouvez décider d’ajouter des fonctionnalités supplémentaires (qui ne sont pas pris en charge par le LSP) pour Visual Studio (à l’aide d’autres API de Studio Visual) dans votre extension par le biais des messages personnalisés.Since your LSP language client extension is just like any other Visual Studio extension, you can decide to add additional features (that are not supported by the LSP) to Visual Studio (using other Visual Studio APIs) in your extension through custom messages.

Réception de messages personnalisésReceiving custom messages

Pour recevoir des messages personnalisés à partir du serveur de la langue, vous devez implémenter la CustomMessageTarget propriété sur ILanguageClientCustomMessage et retourner un objet qui sait comment gérer vos messages personnalisés .To receive custom messages from the language server, implement the CustomMessageTarget property on ILanguageClientCustomMessage and return an object that knows how to handle your custom messages. Exemple ci-dessous :Example below:

internal class MockCustomLanguageClient : MockLanguageClient, ILanguageClientCustomMessage
{
    private JsonRpc customMessageRpc;

    public MockCustomLanguageClient() : base()
    {
        CustomMessageTarget = new CustomTarget();
    }

    public object CustomMessageTarget
    {
        get;
        set;
    }

    public class CustomTarget
    {
        public void OnCustomNotification(JToken arg)
        {
            // Provide logic on what happens OnCustomNotification is called from the language server
        }

        public string OnCustomRequest(string test)
        {
            // Provide logic on what happens OnCustomRequest is called from the language server
        }
    }
}

Envoi de messages personnalisésSending custom messages

Pour envoyer des messages personnalisés sur le serveur de la langue, vous devez implémenter la AttachForCustomMessageAsync méthode sur ILanguageClientCustomMessage.To send custom messages to the language server, implement the AttachForCustomMessageAsync method on ILanguageClientCustomMessage. Cette méthode est appelée lorsque votre serveur est démarré et prêt à recevoir des messages.This method is invoked when your language server is started and ready to receive messages. A JsonRpc objet est passé en tant que paramètre, que vous pouvez ensuite mettre à envoyer des messages vers le serveur de langue à l’aide de VS-StreamJsonRpc API.A JsonRpc object is passed as a parameter, which you can then keep to send messages to the language server using VS-StreamJsonRpc APIs. Exemple ci-dessous :Example below:

internal class MockCustomLanguageClient : MockLanguageClient, ILanguageClientCustomMessage
{
    private JsonRpc customMessageRpc;

    public MockCustomLanguageClient() : base()
    {
        CustomMessageTarget = new CustomTarget();
    }

    public async Task AttachForCustomMessageAsync(JsonRpc rpc)
    {
        await Task.Yield();

        this.customMessageRpc = rpc;
    }

    public async Task SendServerCustomNotification(object arg)
    {
        await this.customMessageRpc.NotifyWithParameterObjectAsync("OnCustomNotification", arg);
    }

    public async Task<string> SendServerCustomMessage(string test)
    {
        return await this.customMessageRpc.InvokeAsync<string>("OnCustomRequest", test);
    }
}

Couche intermédiaireMiddle Layer

Un développeur d’extension peut souhaiter intercepter des messages LSP envoyées à / reçues à partir du serveur de langue.Sometimes an extension developer may want to intercept LSP messages sent to and received from the language server. Par exemple, un développeur d’extension peut à modifier le paramètre de message envoyé d’un message LSP particulier, ou modifier les résultats retournés à partir du serveur de langue pour une fonctionnalité LSP (par exemple les achèvements).For example, an extension developer may want to alter the message parameter sent for a particular LSP message, or modify the results returned from the language server for an LSP feature (for example completions). Lorsque cela est nécessaire, développeurs d’extensions peuvent utiliser l’API MiddleLayer pour intercepter les messages LSP.When this is necessary, extension developers can use the MiddleLayer API to intercept LSP messages.

Chaque message LSP possède sa propre interface de couche intermédiaire pour l’interception.Each LSP message has its own middle layer interface for interception. Pour intercepter un message particulier, créez une classe qui implémente l’interface de couche intermédiaire pour le message.To intercept a particular message, create a class that implements the middle layer interface for that message. Ensuite, implémentez la ILanguageClientCustomMessage interface dans votre classe de client de langue et de retourner une instance de l’objet dans le MiddleLayer propriété.Then, implement the ILanguageClientCustomMessage interface in your language client class and return an instance of your object in the MiddleLayer property. Exemple ci-dessous :Example below:

public class MockLanguageClient: ILanguageClient, ILanguageClientCustomMessage
{
    public object MiddleLayer => MiddleLayerProvider.Instance;

    private class MiddleLayerProvider : ILanguageClientWorkspaceSymbolProvider
    {
        internal readonly static MiddleLayerProvider Instance = new MiddleLayerProvider();

        private MiddleLayerProvider()
        {
        }

        public async Task<SymbolInformation[]> RequestWorkspaceSymbols(WorkspaceSymbolParams param, Func<WorkspaceSymbolParams, Task<SymbolInformation[]>> sendRequest)
        {
            // Send along the request as given
            SymbolInformation[] symbols = await sendRequest(param);

            // Only return symbols that are "files"
            return symbols.Where(sym => string.Equals(new Uri(sym.Location.Uri).Scheme, "file", StringComparison.OrdinalIgnoreCase)).ToArray();
        }
    }
}

La fonctionnalité de couche intermédiaire est en cours de développement et pas encore complète.The middle layer feature is still under development and not yet comprehensive.

Exemple d’extension de serveur LSP languageSample LSP language server extension

Pour afficher le code source d’un exemple d’extension à l’aide de l’API du client LSP dans Visual Studio, consultez les exemples d’extensibilité d’extensibilité Visual Studio exemple LSP.To see the source code of a sample extension using the LSP client API in Visual Studio, see VSSDK-Extensibility-Samples LSP sample.

FAQFAQ

Je souhaite créer un système de projet personnalisés pour compléter l’action mon serveur LSP pour fournir la prise en charge des fonctionnalités plus riche dans Visual Studio, comment faire pour y parvenir ?I would like to build a custom project system to supplement my LSP language server to provide richer feature support in Visual Studio, how do I go about doing that?

Prise en charge pour les serveurs de langage LSP dans Visual Studio s’appuie sur le fonctionnalité Ouvrir le dossier et est spécifiquement conçu pour ne pas exiger un système de projet personnalisé.Support for LSP-based language servers in Visual Studio relies on the open folder feature and is specifically designed to not require a custom project system. Vous pouvez créer votre propre système de projet personnalisé suivant instructions ici, mais certaines fonctionnalités, telles que les paramètres peuvent ne pas fonctionnent.You can build your own custom project system following instructions here, but some features, such as settings, may not work. La logique d’initialisation par défaut pour les serveurs de langage LSP consiste à passer dans l’emplacement du dossier racine du dossier actuellement ouvert, donc si vous utilisez un système de projet personnalisé, vous devrez peut-être fournir une logique personnalisée lors de l’initialisation pour vous assurer de votre serveur de langage peut démarrer correctement.The default initialization logic for LSP language servers is to pass in the root folder location of the folder currently being opened, so if you use a custom project system, you may need to provide custom logic during initialization to ensure your language server can start properly.

Comment ajouter la prise en charge du débogueur ?How do I add debugger support?

Nous vous fournirons prise en charge pour le courants de débogage de protocole dans une version ultérieure.We will be providing support for the common debugging protocol in a future release.

S’il existe déjà un service de langage pris en charge Visual Studio installé (par exemple, JavaScript), puis-je toujours installer une extension de serveur de langage LSP qui offre des fonctionnalités supplémentaires (telles que pelucheux) ?If there is already a VS supported language service installed (for example, JavaScript), can I still install an LSP language server extension that offers additional features (such as linting)?

Oui, mais certaines fonctionnalités ne fonctionneront correctement.Yes, but not all features will work properly. Le but ultime pour les extensions serveur LSP language est pour activer les services de langage natif pris en charge par Visual Studio.The ultimate goal for LSP language server extensions is to enable language services not natively supported by Visual Studio. Vous pouvez créer des extensions qui offrent la prise en charge supplémentaire à l’aide de serveurs de langue LSP, mais certaines fonctionnalités (telles qu’IntelliSense) ne sera pas une meilleure expérience.You can create extensions that offer additional support using LSP language servers, but some features (such as IntelliSense) will not be a smooth experience. En règle générale, il est recommandé que les extensions serveur LSP langage être utilisé pour fournir de nouvelles expériences de langage, ne pas étendre les objets existants.In general, it is advised that LSP language server extensions be used for providing new language experiences, not extending existing ones.

Où publier mon serveur de langage LSP VSIX terminé ?Where do I publish my completed LSP language server VSIX?

Consultez les instructions de Marketplace ici.See the Marketplace instructions here.