Een Language Server Protocol-extensie toevoegen
Language Server Protocol (LSP) is een algemeen protocol, in de vorm van JSON RPC v2.0, dat wordt gebruikt om taalservicefuncties te bieden aan verschillende code-editors. Met behulp van het protocol kunnen ontwikkelaars één taalserver schrijven om taalservicefuncties zoals IntelliSense, foutdiagnose, alle verwijzingen te vinden, enzovoort, naar verschillende code-editors die ondersteuning bieden voor de LSP. Traditioneel kunnen taalservices in Visual Studio worden toegevoegd met behulp van TextMate-grammaticabestanden om basisfuncties te bieden, zoals syntaxismarkeringen of door aangepaste taalservices te schrijven die gebruikmaken van de volledige set Api's voor uitbreidbaarheid van Visual Studio om uitgebreidere gegevens te bieden. Met Visual Studio-ondersteuning voor LSP is er een derde optie.
Om de best mogelijke gebruikerservaring te garanderen, kunt u overwegen ook taalconfiguratiete implementeren, die lokale verwerking van veel van dezelfde bewerkingen biedt, en kan daarom de prestaties verbeteren van veel taalspecifieke editorbewerkingen die worden ondersteund door de LSP.
Taalserverprotocol
implementatie van 
In dit artikel wordt beschreven hoe u een Visual Studio-extensie maakt die gebruikmaakt van een taalserver op basis van LSP. Hierbij wordt ervan uitgegaan dat u al een op LSP gebaseerde taalserver hebt ontwikkeld en deze alleen wilt integreren in Visual Studio.
Voor ondersteuning in Visual Studio kunnen taalservers communiceren met de client (Visual Studio) via een overdrachtsmechanisme op basis van stromen, bijvoorbeeld:
- Standaardinvoer-/uitvoerstromen
- Benoemde pijpen
- Sockets (alleen TCP)
De intentie van de LSP en ondersteuning hiervoor in Visual Studio is het onboarden van taalservices die geen deel uitmaken van het Visual Studio-product. Het is niet bedoeld om bestaande taalservices (zoals C#) in Visual Studio uit te breiden. Als u bestaande talen wilt uitbreiden, raadpleegt u de uitbreidbaarheidshandleiding van de taalservice (bijvoorbeeld de 'Roslyn' .NET Compiler Platform) of raadpleegt u De editor- en taalservices uitbreiden.
Zie de documentatie hiervoor meer informatie over het protocol zelf.
Zie de documentatie hiervoor meer informatie over het maken van een voorbeeldtaalserver of het integreren van een bestaande taalserver in Visual Studio Code.
Ondersteunde functies van Language Server Protocol
In de volgende tabellen ziet u welke LSP-functies worden ondersteund in Visual Studio:
| Bericht | Heeft ondersteuning in Visual Studio |
|---|---|
| initialiseren | ja |
| Geïnitialiseerd | ja |
| Uitschakelen | ja |
| uitgang | ja |
| $/cancelRequest | ja |
| venster/toonBericht | ja |
| window/showMessageRequest | ja |
| window/logMessage | ja |
| telemetrie/gebeurtenis | |
| klant/registreerCapaciteit | |
| client/capaciteit afmelden | |
| werkruimte/configuratieGewijzigd | ja |
| werkruimte/didChangeWatchedFiles | ja |
| werkruimte/symbool | ja |
| workspace/executeCommand | ja |
| workspace/applyEdit | ja |
| textDocument/publishDiagnostics | ja |
| textDocument/didOpen | ja |
| textDocument/didChange | ja |
| textDocument/willSave | |
| textDocument/willSaveWaitUntil | |
| textDocument/didSave | ja |
| textDocument/didClose | ja |
| textDocument/completion | ja |
| voltooiing/oplossen | ja |
| tekstdocument/muisaanwijzer | ja |
| textDocument/signatureHelp | ja |
| textDocument/references | ja |
| textDocument/documentHighlight | ja |
| textDocument/documentSymbol | ja |
| textDocument/formattering | ja |
| textDocument/bereikOpmaak | ja |
| textDocument/onTypeFormatting | |
| textDocument/definition | ja |
| textDocument/codeAction | ja |
| textDocument/codeLens | |
| codeLens/resolve | |
| textDocument/documentLink | |
| documentLink/oplossen | |
| textDocument/rename (herschrijven van documenttekst) | ja |
Aan de slag
Notitie
Vanaf Visual Studio 2017 versie 15.8 is ondersteuning voor het algemene Language Server Protocol ingebouwd in Visual Studio. Als u LSP-extensies hebt gemaakt met behulp van de preview-versie Language Server Client VSIX versie, werken ze niet meer wanneer u een upgrade uitvoert naar versie 15.8 of hoger. U moet het volgende doen om uw LSP-extensies opnieuw te laten werken:
Verwijder microsoft Visual Studio Language Server Protocol Preview VSIX.
Vanaf versie 15.8 wordt elke keer dat u een upgrade uitvoert in Visual Studio, de preview-VSIX automatisch gedetecteerd en verwijderd.
Werk uw Nuget-verwijzing bij naar de nieuwste niet-preview-versie voor LSP-pakketten.
Verwijder de afhankelijkheid van microsoft Visual Studio Language Server Protocol Preview VSIX in uw VSIX-manifest.
Zorg ervoor dat uw VSIX Visual Studio 2017 versie 15.8 Preview 3 opgeeft als de ondergrens voor het installatiedoel.
Herbouwen en opnieuw implementeren.
Een VSIX-project maken
Als u een taalservice-extensie wilt maken met behulp van een op LSP gebaseerde taalserver, zorg er dan eerst voor dat de Visual Studio-extensie-ontwikkelings Workload is geïnstalleerd voor uw exemplaar van VS.
Maak vervolgens een nieuw VSIX-project door te navigeren naar File>New Project>Visual C#>Extensibility>VSIX Project:
Taalserver en runtime-installatie
De extensies die zijn gemaakt ter ondersteuning van op LSP gebaseerde taalservers in Visual Studio bevatten standaard niet de taalservers zelf of de runtimes die nodig zijn om ze uit te voeren. Extensieontwikkelaars zijn verantwoordelijk voor het distribueren van de taalservers en de benodigde runtimes. U kunt dit op verschillende manieren doen:
- Taalservers kunnen worden ingesloten in VSIX als inhoudsbestanden.
- Maak een MSI om de taalserver en/of benodigde runtimes te installeren.
- Instrueer gebruikers op Marketplace over hoe zij runtimes en taalservers kunnen verkrijgen.
TextMate-grammaticabestanden
De LSP bevat geen specificatie voor het leveren van tekstkleuring voor talen. Als u aangepaste kleuren wilt bieden voor talen in Visual Studio, kunnen extensieontwikkelaars een TextMate-grammaticabestand gebruiken. Volg deze stappen om aangepaste TextMate-grammatica- of themabestanden toe te voegen:
Maak een map met de naam Grammars in uw extensie (of het kan elke gewenste naam zijn).
Neem in de map Grammars alle *.tmlanguage-, *.plist-, *.tmtheme-bestanden op, of welke andere *.json-bestanden dan ook die aangepaste kleuraanpassingen bieden.
Tip
Een .tmtheme-bestand definieert hoe de scopes worden toegewezen aan Visual Studio-classificaties (benoemde kleurcodes). Voor hulp kunt u verwijzen naar het algemene bestand .tmtheme in de %ProgramFiles(x86)%\Microsoft Visual Studio\<versie>\<SKU>\Common7\IDE\CommonExtensions\Microsoft\TextMate\Starterkit\Themesg directory.
Maak een bestand .pkgdef en voeg een regel toe die er ongeveer als volgt uit ziet:
[$RootKey$\TextMate\Repositories] "MyLang"="$PackageFolder$\Grammars"Klik met de rechtermuisknop op de bestanden en selecteer Eigenschappen. Wijzig de actie Build in Content en wijzig de eigenschap Include in VSIX in true.
Nadat u de vorige stappen hebt voltooid, wordt een map Grammars toegevoegd aan de installatiemap van het pakket als opslagplaatsbron met de naam 'MyLang' ('MyLang' is slechts een naam voor ondubbelzinnigheid en kan elke unieke tekenreeks zijn). Alle grammatica's (.tmlanguage bestanden) en themabestanden (.tmtheme bestanden) in deze map worden als potentieel opgehaald en vervangen de ingebouwde grammatica's van TextMate. Als de gedeclareerde extensies van het grammaticabestand overeenkomen met de extensie van het geopende bestand, stapt TextMate in.
Een eenvoudige taalclient maken
Hoofdinterface - ILanguageClient
Voeg na het maken van uw VSIX-project de volgende NuGet-pakketten toe aan uw project:
Notitie
Wanneer u afhankelijk bent van het NuGet-pakket nadat u de vorige stappen hebt voltooid, worden de Newtonsoft.Json- en StreamJsonRpc-pakketten ook aan uw project toegevoegd. Werk deze pakketten niet bij tenzij u er zeker van bent dat deze nieuwe versies worden geïnstalleerd op de versie van Visual Studio waarop uw extensie is gericht. De assembly's worden niet opgenomen in uw VSIX; In plaats daarvan worden ze opgehaald uit de installatiemap van Visual Studio. Als u verwijst naar een nieuwere versie van de assembly's dan wat op de computer van een gebruiker is geïnstalleerd, werkt uw extensie niet.
Vervolgens kunt u een nieuwe klasse maken waarmee de ILanguageClient--interface wordt geïmplementeerd. Dit is de belangrijkste interface die nodig is voor taalclients die verbinding maken met een op LSP gebaseerde taalserver.
Hier volgt een voorbeeld:
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 Task OnServerInitializeFailedAsync(Exception e)
{
return Task.CompletedTask;
}
public Task OnServerInitializedAsync()
{
return Task.CompletedTask;
}
}
}
De belangrijkste methoden die moeten worden geïmplementeerd, zijn OnLoadedAsync- en ActivateAsync-. OnLoadedAsync- wordt aangeroepen wanneer Visual Studio uw extensie heeft geladen en uw taalserver klaar is om te worden gestart. In deze methode kunt u de StartAsync gemachtigde onmiddellijk aanroepen om aan te geven dat de taalserver moet worden gestart, of u kunt aanvullende logica uitvoeren en StartAsync- later aanroepen. Om uw taalserver te activeren, moet u Op een bepaald moment StartAsync aanroepen.
ActivateAsync is de methode die uiteindelijk wordt aangeroepen door de StartAsync gemachtigde aan te roepen. Het bevat de logica om de taalserver te starten en er verbinding mee te maken. Een verbindingsobject dat streams bevat voor het schrijven naar de server en het lezen van de server moet worden geretourneerd. Eventuele uitzonderingen die hier worden gegooid, worden afgevangen en aan de gebruiker getoond via een InfoBar-bericht in Visual Studio.
Activering
Zodra uw taalclientklasse is geïmplementeerd, moet u twee kenmerken definiëren om te definiëren hoe deze in Visual Studio wordt geladen en geactiveerd:
[Export(typeof(ILanguageClient))]
[ContentType("bar")]
MEF
Visual Studio maakt gebruik van MEF (Managed Extensibility Framework) om de uitbreidbaarheidspunten te beheren. Het kenmerk Export geeft aan Visual Studio dat deze klasse moet worden opgehaald als een extensiepunt en op het juiste moment moet worden geladen.
Als u MEF wilt gebruiken, moet u MEF ook definiëren als een asset in het VSIX-manifest.
Open uw VSIX-manifestontwerper en navigeer naar het tabblad Assets:
Klik op Nieuwe om een nieuwe asset te maken:
- Type: Microsoft.VisualStudio.MefComponent
- Bron: een project in de huidige oplossing
- Project: [Uw project]
Definitie van inhoudstype
Momenteel is de enige manier om uw op LSP gebaseerde taalserverextensie te laden op basis van het bestandsinhoudstype. Bij het definiëren van uw taalclientklasse (die ILanguageClient-implementeert), moet u de typen bestanden definiëren die, wanneer deze worden geopend, de extensie laden. Als er geen bestanden worden geopend die overeenkomen met uw gedefinieerde inhoudstype, wordt uw extensie niet geladen.
Dit wordt gedaan door een of meer ContentTypeDefinition klassen te definiëren:
namespace MockLanguageExtension
{
public class BarContentDefinition
{
[Export]
[Name("bar")]
[BaseDefinition(CodeRemoteContentDefinition.CodeRemoteContentTypeName)]
internal static ContentTypeDefinition BarContentTypeDefinition;
[Export]
[FileExtension(".bar")]
[ContentType("bar")]
internal static FileExtensionToContentTypeDefinition BarFileExtensionDefinition;
}
}
In het vorige voorbeeld wordt een definitie van het inhoudstype gemaakt voor bestanden die eindigen op .bar bestandsextensie. De definitie van het inhoudstype krijgt de naam 'balk' en moet zijn afgeleid van CodeRemoteContentTypeName.
Nadat u een definitie van het inhoudstype hebt toegevoegd, kunt u definiëren wanneer de taalclientextensie moet worden geladen in de taalclientklasse:
[ContentType("bar")]
[Export(typeof(ILanguageClient))]
public class BarLanguageClient : ILanguageClient
{
}
Het toevoegen van ondersteuning voor LSP-taalservers vereist niet dat u uw eigen projectsysteem in Visual Studio implementeert. Klanten kunnen één bestand of map in Visual Studio openen om uw taalservice te gebruiken. In feite is ondersteuning voor LSP-taalservers ontworpen om alleen te werken in geopende map-/bestandsscenario's. Als een aangepast projectsysteem is geïmplementeerd, werken sommige functies (zoals instellingen) niet.
Geavanceerde functies
Instellingen
Ondersteuning voor aangepaste taal-serverspecifieke instellingen is beschikbaar, maar het wordt nog steeds verbeterd. Instellingen zijn specifiek voor wat de taalserver ondersteunt en meestal bepaalt hoe de taalserver gegevens verzendt. Een taalserver kan bijvoorbeeld een instelling hebben voor het maximum aantal fouten dat is gerapporteerd. Auteurs van extensies definiëren een standaardwaarde, die door gebruikers voor specifieke projecten kan worden gewijzigd.
Volg deze stappen hieronder om ondersteuning voor instellingen toe te voegen aan uw LSP-taalservice-extensie:
Voeg een JSON-bestand (bijvoorbeeld MockLanguageExtensionSettings.json) toe aan uw project dat de instellingen en de standaardwaarden bevat. Bijvoorbeeld:
{ "foo.maxNumberOfProblems": -1 }Klik met de rechtermuisknop op het JSON-bestand en selecteer Eigenschappen. Wijzig de actie Build in 'Content' en de eigenschap 'Opnemen in VSIX' in true.
Implementeer ConfigurationSections en retourneer de lijst met voorvoegsels voor de instellingen die zijn gedefinieerd in het JSON-bestand (in Visual Studio Code zou dit worden toegewezen aan de naam van de configuratiesectie in package.json):
public IEnumerable<string> ConfigurationSections { get { yield return "foo"; } }Voeg een PKGDEF-bestand toe aan het project (voeg een nieuw tekstbestand toe en wijzig de bestandsextensie in .pkgdef). Het pkgdef-bestand moet deze informatie bevatten:
[$RootKey$\OpenFolder\Settings\VSWorkspaceSettings\[settings-name]] @="$PackageFolder$\[settings-file-name].json"Proef:
[$RootKey$\OpenFolder\Settings\VSWorkspaceSettings\MockLanguageExtension] @="$PackageFolder$\MockLanguageExtensionSettings.json"Klik met de rechtermuisknop op het PKGDEF-bestand en selecteer Eigenschappen. Wijzig de Build-actie in Content en de Include in VSIX-eigenschap naar true.
Open het bestand source.extension.vsixmanifest en voeg een asset toe op het tabblad Asset:
- Type: Microsoft.VisualStudio.VsPackage
- Bron: Bestand op bestandssysteem
- pad: [Pad naar uw .pkgdef-bestand]
Het bewerken van instellingen door gebruikers voor de werkruimte
Gebruiker opent een werkruimte met bestanden die eigenaar zijn van uw server.
Gebruiker voegt een bestand toe in de map .vs met de naam VSWorkspaceSettings.json.
Gebruiker voegt een regel toe aan het VSWorkspaceSettings.json-bestand voor een instelling die de server biedt. Bijvoorbeeld:
{ "foo.maxNumberOfProblems": 10 }
Diagnostische tracering inschakelen
Diagnostische tracering kan worden ingeschakeld om alle berichten tussen de client en de server uit te voeren. Dit kan handig zijn bij het opsporen van fouten. Ga als volgt te werk om diagnostische tracering in te schakelen:
- Open of maak het bestand met werkruimte-instellingen VSWorkspaceSettings.json (zie 'Gebruikersbewerking van instellingen voor een werkruimte').
- Voeg de volgende regel toe in het JSON-bestand instellingen:
{
"foo.trace.server": "Off"
}
Er zijn drie mogelijke waarden voor de uitgebreidheid van traceringen:
- "Uit": tracering is volledig uitgeschakeld
- 'Berichten': tracering is ingeschakeld, maar alleen de methodenaam en antwoord-id worden getraceerd.
- "Uitgebreid": tracering ingeschakeld; het volledige rpc-bericht wordt getraceerd.
Wanneer tracering is ingeschakeld, wordt de inhoud naar een bestand geschreven in de map %temp%\VisualStudio\LSP. Het logboek volgt de naamgevingsindeling [LanguageClientName]-[Datum/tijdstempel].log. Op dit moment kan tracering alleen worden ingeschakeld voor geopende mapscenario's. Het openen van één bestand om een taalserver te activeren, biedt geen ondersteuning voor diagnostische tracering.
Aangepaste berichten
Er zijn API's aanwezig om berichten door te geven aan en te ontvangen van de taalserver die geen deel uitmaken van het standaard Language Server Protocol. Als u aangepaste berichten wilt verwerken, implementeert u ILanguageClientCustomMessage2-interface in uw taalclientklasse. VS-StreamJsonRpc bibliotheek wordt gebruikt voor het verzenden van aangepaste berichten tussen uw taalclient en taalserver. Omdat uw LSP-taalclientextensie net als elke andere Visual Studio-extensie is, kunt u besluiten om extra functies (die niet worden ondersteund door de LSP) toe te voegen aan Visual Studio (met andere Visual Studio-API's) in uw extensie via aangepaste berichten.
Aangepaste berichten ontvangen
Als u aangepaste berichten van de taalserver wilt ontvangen, implementeert u de eigenschap [CustomMessageTarget]((/dotnet/api/microsoft.visualstudio.languageserver.client.ilanguageclientcustommessage.custommessagetarget) op ILanguageClientCustomMessage2 en retourneert u een object dat weet hoe u uw aangepaste berichten moet verwerken. Voorbeeld hieronder:
(/dotnet/api/microsoft.visualstudio.languageserver.client.ilanguageclientcustommessage.custommessagetarget) op ILanguageClientCustomMessage2 en retourneer een object dat met uw aangepaste berichten om kan gaan. Voorbeeld hieronder:
internal class MockCustomLanguageClient : MockLanguageClient, ILanguageClientCustomMessage2
{
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
}
}
}
Aangepaste berichten verzenden
Als u aangepaste berichten naar de taalserver wilt verzenden, implementeert u de methode AttachForCustomMessageAsync op ILanguageClientCustomMessage2. Deze methode wordt aangeroepen wanneer uw taalserver wordt gestart en gereed is voor het ontvangen van berichten. Een JsonRpc--object wordt doorgegeven als een parameter, die u vervolgens kunt behouden om berichten naar de taalserver te verzenden met behulp van VS-StreamJsonRpc API's. Voorbeeld hieronder:
internal class MockCustomLanguageClient : MockLanguageClient, ILanguageClientCustomMessage2
{
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);
}
}
Middelste laag
Soms wil een extensieontwikkelaar LSP-berichten onderscheppen die worden verzonden naar en ontvangen van de taalserver. Een extensieontwikkelaar kan bijvoorbeeld de berichtparameter wijzigen die is verzonden voor een bepaald LSP-bericht of de resultaten wijzigen die worden geretourneerd van de taalserver voor een LSP-functie (bijvoorbeeld voltooiingen). Wanneer dit nodig is, kunnen extensieontwikkelaars de MiddleLayer-API gebruiken om LSP-berichten te onderscheppen.
Als u een bepaald bericht wilt onderscheppen, maakt u een klasse die de ILanguageClientMiddleLayer interface implementeert. Implementeer vervolgens de ILanguageClientCustomMessage2-interface in uw taalclientklasse en retourneer een exemplaar van uw object in de eigenschap MiddleLayer. Voorbeeld hieronder:
public class MockLanguageClient : ILanguageClient, ILanguageClientCustomMessage2
{
public object MiddleLayer => DiagnosticsFilterMiddleLayer.Instance;
private class DiagnosticsFilterMiddleLayer : ILanguageClientMiddleLayer
{
internal readonly static DiagnosticsFilterMiddleLayer Instance = new DiagnosticsFilterMiddleLayer();
private DiagnosticsFilterMiddleLayer() { }
public bool CanHandle(string methodName)
{
return methodName == "textDocument/publishDiagnostics";
}
public async Task HandleNotificationAsync(string methodName, JToken methodParam, Func<JToken, Task> sendNotification)
{
if (methodName == "textDocument/publishDiagnostics")
{
var diagnosticsToFilter = (JArray)methodParam["diagnostics"];
// ony show diagnostics of severity 1 (error)
methodParam["diagnostics"] = new JArray(diagnosticsToFilter.Where(diagnostic => diagnostic.Value<int?>("severity") == 1));
}
await sendNotification(methodParam);
}
public async Task<JToken> HandleRequestAsync(string methodName, JToken methodParam, Func<JToken, Task<JToken>> sendRequest)
{
return await sendRequest(methodParam);
}
}
}
De middelste laagfunctie is nog in ontwikkeling en is nog niet uitgebreid.
Voorbeeld van LSP-taalserverextensie
Als u de broncode van een voorbeeldextensie wilt zien met behulp van de LSP-client-API in Visual Studio, raadpleegt u VSSDK-Extensibility-Samples LSP-voorbeeld.
FAQ
ik een aangepast projectsysteem wil bouwen om mijn LSP-taalserver aan te vullen om uitgebreidere functieondersteuning te bieden in Visual Studio, hoe ga ik dat doen?
Ondersteuning voor taalservers op basis van LSP in Visual Studio is afhankelijk van de functie voor geopende mappen en is ontworpen om geen aangepast projectsysteem te vereisen. Je kunt je eigen aangepaste projectsysteem bouwen volgens de instructies hier, maar bepaalde functies, zoals instellingen, kunnen mogelijk niet werken. De standaard initialisatielogica voor LSP-taalservers is het doorgeven van de locatie van de hoofdmap van de map die momenteel wordt geopend. Als u dus een aangepast projectsysteem gebruikt, moet u mogelijk aangepaste logica opgeven tijdens de initialisatie om ervoor te zorgen dat uw taalserver correct kan worden gestart.
Hoe voeg ik ondersteuning voor foutopsporingsprogramma's toe?
We bieden ondersteuning voor het algemene foutopsporingsprotocol in een toekomstige release.
Als er al een door VS ondersteunde taalservice is geïnstalleerd (bijvoorbeeld JavaScript), kan ik nog steeds een LSP-taalserverextensie installeren die extra functies biedt (zoals linting)?
Ja, maar niet alle functies werken goed. Het ultieme doel voor LSP-taalserverextensies is om taalservices in te schakelen die niet systeemeigen worden ondersteund door Visual Studio. U kunt extensies maken die aanvullende ondersteuning bieden met behulp van LSP-taalservers, maar sommige functies (zoals IntelliSense) zijn geen soepele ervaring. Over het algemeen wordt geadviseerd dat LSP-taalserverextensies worden gebruikt voor het bieden van nieuwe taalervaringen, niet voor het uitbreiden van bestaande.
Waar publiceer ik mijn voltooide LSP-taalserver VSIX?
Zie de Marketplace-instructies hier.