Ajouter une extension du protocole de serveur de langageAdd 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é 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. En utilisant le protocole, les développeurs peuvent écrire un serveur unilingue fournissent des fonctionnalités comme IntelliSense, des diagnostics d’erreur du service de langage, de trouver 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 à l’aide à l’aide de fichiers de grammaire TextMate pour fournir des fonctionnalités de base telles que la coloration syntaxique, ou en écrivant des services de langage personnalisés à 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, prend en charge pour le partenaire 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

implémentation de protocole de serveur de langage

Cet article décrit comment créer une extension Visual Studio qui utilise un serveur de langage basé sur des LSP.This article describes how to create a Visual Studio extension that uses an LSP-based language server. Il suppose que vous avez déjà développé un serveur de langage basé sur des LSP et que vous voulez uniquement pour l’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, langage peuvent communiquer avec le client (Visual Studio) via n’importe quel mécanisme de transmission de flux de données en fonction, par exemple :For support within Visual Studio, language servers can communicate with the client (Visual Studio) via any stream based transmission mechanism, for example:

  • Flux d’entrée/sortie standardStandard input/output streams
  • Canaux nommésNamed pipes
  • Sockets (TCP uniquement)Sockets (TCP only)

L’objectif des LSP et prise en charge dans Visual Studio consiste à des services de langage intégrée 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 existante 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 de 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).

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.

Pour plus d’informations sur la création d’un exemple de serveur de langage ou apprendre à intégrer 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.

Fonctionnalités de protocole de serveur de langage prises 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/symboleworkspace/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 ou résoudrecompletion/resolve ouiyes
textDocument/pointagetextDocument/hover ouiyes
textDocument/signatureHelptextDocument/signatureHelp ouiyes
textDocument/référencestextDocument/references ouiyes
textDocument/documentHighlighttextDocument/documentHighlight ouiyes
textDocument/documentSymboltextDocument/documentSymbol ouiyes
textDocument/la mise en formetextDocument/formatting ouiyes
textDocument/rangeFormattingtextDocument/rangeFormatting ouiyes
textDocument/onTypeFormattingtextDocument/onTypeFormatting
textDocument/définitiontextDocument/definition ouiyes
textDocument/codeActiontextDocument/codeAction ouiyes
textDocument/codeLenstextDocument/codeLens
codeLens ou résoudrecodeLens/resolve
textDocument/documentLinktextDocument/documentLink
documentLink ou résoudredocumentLink/resolve
textDocument/renametextDocument/rename ouiyes

Bien démarrerGetting started

Note

En commençant par Visual Studio 15.8 Preview 3, la prise en charge pour le protocole de serveur de langage commun est intégrée à Visual Studio.Starting with Visual Studio 15.8 Preview 3, support for the common Language Server Protocol is built into Visual Studio. Si vous avez créé à l’aide de notre version préliminaire des extensions de LSP langage serveur Client VSIX version, il cesse de fonctionner pour vous avez mis à niveau vers 15,8 Preview 3 ou version ultérieure.If you've built LSP extensions using our preview Language Server Client VSIX version, they will stop working once to you've upgraded to 15.8 Preview 3 or higher. Vous devez effectuer les opérations suivantes pour obtenir vos extensions LSP fonctionne à nouveau :You will need to do the following to get your LSP extensions working again:

  1. Désinstallez la préversion protocole de serveur dans Microsoft Visual Studio langage VSIX.Uninstall the Microsoft Visual Studio Language Server Protocol Preview VSIX. À partir de 15,8 Preview 4, chaque fois que vous effectuez une mise à niveau dans Visual Studio, nous automatiquement détecter et supprimer l’aperçu VSIX pour vous pendant le processus de mise à niveau.Starting with 15.8 Preview 4, every time you perform an upgrade in Visual Studio, we will automatically detect and remove the preview VSIX for you during the upgrade process.

  2. Mettre à jour vos références Nuget vers la dernière version non-preview pour packages des LSP.Update your Nuget reference to the latest non-preview version for LSP packages.

  3. Supprimez la dépendance à Microsoft Visual Studio langage serveur protocole aperçu VSIX dans votre manifeste VSIX.Remove the dependency to the Microsoft Visual Studio Language Server Protocol Preview VSIX in your VSIX manifest.

  4. Assurez-vous que votre projet VSIX spécifie 15.8 Preview 3 de Visual Studio en tant que la limite inférieure pour la cible d’installation.Make sure your VSIX specifies Visual Studio 15.8 Preview 3 as the lower bound for install target.

  5. Régénérez et déployez de nouveau.Rebuild and re-deploy.

Créez un projet VSIXCreate a VSIX project

Pour créer une extension de service de langage à l’aide d’un serveur de langage basé sur des LSP, commencez par vérifier que vous avez le développement d’extensions Visual Studio charge de travail installée 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.

Créez ensuite 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

Installation du serveur et de runtime de langageLanguage server and runtime installation

Par défaut, les extensions créées pour prendre en charge des serveurs de langage basé sur des LSP dans Visual Studio ne contiendra pas les serveurs de langage eux-mêmes 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 distribuer les serveurs de langage et les runtimes nécessités.Extension developers are responsible for distributing the language servers and the runtimes needed. Il existe plusieurs manières de procéder :There are several ways to do so:

  • Serveurs de langue peuvent être incorporés dans l’extension 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 informe de la place de marché comment obtenir des runtimes et langage de serveurs.Provide instructions on Marketplace informing users how to obtain runtimes and language servers.

Fichiers de grammaire TextMateTextMate grammar files

Le partenaire 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 une 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 de grammaire ou thème 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 que vous choisissez).Create a folder called "Grammars" inside your extension (or it can be whatever name you choose).

  2. À l’intérieur de la grammaires dossier, inclure les *.tmlanguage, *.plist, *.tmtheme, ou *.json vous souhaitez que les fichiers 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, puis sélectionnez propriétés.Right-click on the files and select Properties. Modifier le générer action à 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 .pkgdef fichier, puis ajoutez une ligne semblable à ceci :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, puis sélectionnez propriétés.Right-click on the files and select Properties. Modifier le générer action à 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 grammaires dossier est ajouté pour l’installation du package répertoire en tant que référentiel source nommé « MyLang » (« MyLang » est simplement un nom pour éviter les ambiguïtés et peut être n’importe quelle 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 (.tmlanguage fichiers) et les fichiers de thème (.tmtheme fichiers) dans ce répertoire sont sélectionnés en tant que sources 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éer un client de langage simpleCreate 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 terminé 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 ces nouvelles versions seront être installées sur la version de Visual Studio qui ciblée par votre 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 ne seront 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 faites référence à une version plus récente des assemblys que ce qui est installé sur un ordinateur d’utilisateur, votre extension ne fonctionnera 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 ensuite créer 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 basé sur des 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ées sont OnLoadedAsync et ActivateAsync.The main methods that need to be implemented are OnLoadedAsync and ActivateAsync. OnLoadedAsync est appelée lorsque Visual Studio a chargé votre extension et votre serveur de langage 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 à signaler que le serveur de langage doit être démarré, ou vous pouvez faire 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 langage, 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 pour 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 pour écrire sur le serveur et lire à 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ée, vous devez définir les deux attributs pour pouvoir définir la façon dont il est 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 en tant que ressource dans le manifeste VSIX.To use MEF, you must also define MEF as an Asset in the VSIX manifest.

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

Ajouter un actif 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 basé sur des 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, lorsque ouvert, entraîneront 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 qui correspondent à votre type de contenu défini n’est ouverts, 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 s’effectue via la définition d’une ou plusieurs classes de 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 fournie à 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 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 commencer à utiliser votre service de langage.Customers can open a single file or a folder in Visual Studio to start using your language service. En fait, la prise en charge pour les 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 fonctionnera 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 pour les paramètres linguistiques server personnalisés est disponible, mais il est toujours en cours améliorés.Support for custom language-server-specific settings is available, but it is still in the process of being improved. Les paramètres sont spécifiques à ce que le serveur de langage prend en charge et généralement contrôler comment le serveur de langage é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 langage 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 de l’extension définirait une valeur par défaut, ce 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 à votre extension de service de langage LSP :Follow these steps below to add support for settings to your LSP language service extension:

  1. Ajoutez 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. Exemple :For example:

    {
     "foo.maxNumberOfProblems": -1
    }
    
  2. Avec le bouton droit sur le fichier JSON et sélectionnez propriétés.Right-click on the JSON file and select Properties. Modification la Build action pour « Content » 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 le fichier 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 attribuez l’extension au 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 le générer action à contenu et inclure dans VSIX true à la propriété.Change the Build action to Content and the Include in VSIX property to true.

  6. Ouvrez le source.extension.vsixmanifest fichier, puis 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 la ressource de package Visual Studio

    • 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 .pkgdef fichier]Path: [Path to your .pkgdef file]

Modification de l’utilisateur des paramètres pour un espace de travailUser 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 .vs dossier appelé VSWorkspaceSettings.json.User adds a file in the .vs folder called VSWorkspaceSettings.json.
  3. Utilisateur ajoute une ligne à la VSWorkspaceSettings.json fichier pour un paramètre fournit le serveur.User adds a line to the VSWorkspaceSettings.json file for a setting the server provides. Exemple :For example:

    {
     "foo.maxNumberOfProblems": 10
    }
    

    L’activation du suivi de diagnosticEnabling diagnostics tracing

    Traçage de diagnostic peut être activé pour tous les messages entre le client et le serveur, 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 de 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 du fichier de paramètres json :Add the following line in the settings json file:
{
    "foo.trace.server": "Off"
}

Il existe trois valeurs possibles pour le niveau de détail de trace :There are three possible values for trace verbosity:

  • « Off » : le suivi complètement mise hors tension"Off": tracing turned off completely
  • « Messages » : le suivi activé mais 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.

Lorsque le suivi est activé sur le contenu est écrit dans un fichier dans le %temp%\VisualStudio\LSP directory.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]-[horodateur] .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 langage n’a pas la prise en charge de diagnostics.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 pour faciliter le passage de messages à et recevoir des 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, implémentez 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 de langage.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 s’apparente à une autre extension 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 Visual Studio) dans votre extension via 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 langage, vous devez implémenter le 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 langage, vous devez implémenter le 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 de langage est démarré et prêt à recevoir des messages.This method is invoked when your language server is started and ready to receive messages. Un JsonRpc objet est passé comme un paramètre, vous pouvez conserver ensuite pour envoyer des messages au serveur de langage avec 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 LSP messages envoyés et reçus à partir du serveur de langage.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é pour un message LSP particulier, ou modifier les résultats retournés à partir du serveur de langage pour une fonctionnalité LSP (saisies par exemple).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, les 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 ayant 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 ce 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 langage et de retourner une instance de votre 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 toujours 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 langageSample 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 des 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é en supplément de mon serveur de langage LSP pour fournir la prise en charge de fonctionnalités plus riches dans Visual Studio, comment faire pour effectuer cette opération ?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 basé sur des LSP dans Visual Studio s’appuie sur le fonctionnalité Ouvrir le dossier et est conçu spécialement 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 pendant 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 une 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 encore installer une extension de serveur de langage LSP qui offre des fonctionnalités supplémentaires (par exemple, linting) ?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 toutes les fonctionnalités ne fonctionneront correctement.Yes, but not all features will work properly. L’objectif ultime pour les extensions de serveur de langage LSP consiste à activer les services de langage pas en mode 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 langage LSP, mais certaines fonctionnalités (telles que IntelliSense) ne sera pas d’une expérience sans heurts.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 de serveur de langage LSP être utilisées 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 la place de marché ici.See the Marketplace instructions here.