Injection de dépendances dans les extensions VisualStudio.Extensibility

De nombreux composants du Kit de développement logiciel (SDK) VisualStudio.Extensibility, tels que les gestionnaires de commandes et les fournisseurs de fenêtres d’outils, sont implémentés en tant que classes individuelles. Pour faciliter le partage de composants entre ces classes, le SDK utilise injection de dépendances .NET pour instancier ces classes si nécessaire. Pour simplifier le partage de données entre ces composants, nous encourageons les développeurs d’extensions à contribuer également à leurs composants partagés au graphique d’injection de dépendances.

Ajout de services internes au graphique d’injection de dépendances

Chaque extension du Kit de développement logiciel (SDK) VisualStudio.Extensibility a son propre graphique de service créé lors du premier chargement de l’extension. Les extensions peuvent remplacer la méthode InitializeServices pour ajouter leurs propres services au graphique d’injection de dépendances. Vous pouvez faire référence à Markdown Linter pour obtenir un exemple d’utilisation de l’injection de dépendances pour partager un service.

Services fournis par le Kit de développement logiciel (SDK) VisualStudio.Extensibility

Outre les services fournis par l’extension, le Kit de développement logiciel (SDK) VisualStudio.Extensibility ajoute les services suivants au graphique lors de la création de l’instance d’extension :

• TraceSource: une instance partagée de TraceSource est ajoutée au graphique que les composants peuvent utiliser pour consigner les avertissements et les erreurs. Ces journaux d’activité peuvent être utiles pour diagnostiquer les problèmes liés à l’extension à partir de rapports clients.

• VisualStudioExtensibility: instance d’extensibilité qui expose les API pour interagir avec Visual Studio, comme les documents, l’éditeur, l’espace de travail.

• IServiceBroker : le Service Broker peut être utilisé pour accéder aux services réparti offerts par Visual Studio ou d’autres services qui peuvent ne pas faire partie de la surface d’exposition VisualStudioExtensibility.

• IServiceProvider: Le fournisseur de services peut être utilisé pour interroger des services au sein du propre graphe d’injection de dépendances de l’extension. Cette instance n’est pas la même instance que le fournisseur de services global dans le processus Visual Studio pour les extensions in-process.

Services supplémentaires pour les extensions en cours

Pour les extensions en cours d’exécution, les services suivants sont également disponibles :

• JoinableTaskFactory et JoinableTaskContext: lors de l’exécution en tant qu’extension in-process utilisant d’autres services Visual Studio, il peut être nécessaire d’utiliser ces instances pour interagir avec le thread principal sans provoquer d’interblocages. Pour plus d’informations, consultez livre de recettes Visual Studio Threading.

• AsyncServiceProviderInjection et MefInjection: ces classes peuvent être utilisées pour récupérer les services in-process proposés par l’infrastructure IServiceProvider ou MEF dans les composants d’extension VisualStudio.Extensibility. Lorsqu’il est disponible, nous vous recommandons d’utiliser d’abord les services proposés par le Kit de développement logiciel (SDK) VisualStudio.Extensibility.

• IAsyncServiceProvider2: cette classe peut être utilisée comme alternative à AsyncServiceProviderInjection pour rechercher des services Visual Studio in-process à l’aide de GetServiceAsync méthode.

Méthodes d’extension fournies par le Kit de développement logiciel (SDK) VisualStudio.Extensibility

Les méthodes d’extension de l’instance IServiceCollection peuvent également être utilisées pour aider à ajouter des services liés aux fonctionnalités d’extensibilité :

• AddSettingsObservers : Cette méthode est générée lorsqu'une extension contribue à une catégorie de paramètres et peut être appelée dans InitializeServices pour injecter des services d'observateurs pour la catégorie de paramètres ainsi contribuée. Vous pouvez vous référer à SettingsSample pour voir un exemple de cette méthode utilisée.

Durées de vie des services

Lors de l’ajout d’un nouveau service au graphique d’injection de dépendances dans InitializeServices méthode, il existe trois options de durée de vie différentes. Vous pouvez également faire référence à exemple sur la façon dont différentes options de durée de vie sont utilisées dans une extension.

• AddSingleton: ces services partagent la même durée de vie que l’instance d’extension. Dans la plupart des cas, l’utilisation de services singleton est le choix approprié pour une extension sdk VisualStudio.Extensibility.

• AddTransient: Les services transitoires créent une nouvelle instance de la classe d'implémentation ou appellent la méthode de fabrique à chaque fois qu'un service la sollicite. Par conséquent, chaque composant obtient sa propre instance du service.

• AddScoped: cette étendue s’applique uniquement aux classes qui ont l’attribut VisualStudioContribution et les services interrogés par eux. Dans le contexte du Kit de développement logiciel (SDK) VisualStudio.Extensibility, une étendue est définie par la durée de vie d’un composant fourni. Dans la plupart des cas, cette durée de vie est identique à celle de l’extension, de sorte que les services délimités et les services singleton se comportent de la même façon. La documentation fera une note spéciale s’il existe des composants fournis avec des durées de vie différentes.

Exemple de cas d’usage

Cet exemple montre comment utiliser un objet de source de données partagée entre une implémentation de fenêtre d’outil et un gestionnaire de commandes à l’aide de l’injection de dépendances et de InitializeServices.

• Dans MyExtension.InitializeServices, MyDataSource est ajouté en tant que service singleton, car il est partagé entre les composants. MyToolWindowControl est ajouté comme temporaire, car chaque instance de fenêtre d’outil doit avoir sa propre instance unique du contrôle hébergé.

• Dans MyToolWindow, nous injectons des IServiceProvider dans le constructeur pour éviter l’initialisation anticipée de MyToolWindowControl et nous l’interrogeons plutôt via GetRequiredService si nécessaire.

[VisualStudioContribution]
public class MyExtension : Extension
{
    protected override void InitializeServices(IServiceCollection serviceCollection)
    {
        // Always make sure to call the base method to add required services.
        base.InitializeServices(serviceCollection);

        serviceCollection.AddSingleton<MyDataSource>();
        serviceCollection.AddTransient<MyToolWindowControl>();
    }
}

[DataContract]
public class MyDataSource : NotifyPropertyChangedObject
{
}

public class MyToolWindowControl : RemoteUserControl
{
    public MyToolWindowControl(MyDataSource dataSource) : base(dataContext)
    {
    }
}

[VisualStudioContribution]
public class MyToolWindow : ToolWindow
{
    private readonly IServiceProvider serviceProvider;

    public MyToolWindow(IServiceProvider serviceProvider)
    {
    }

    public override Task<IRemoteUserControl> GetContentAsync(CancellationToken cancellationToken)
    {
        var control = this.serviceProvider.GetRequiredService<MyToolWindowControl>();
        return Task.FromResult<IRemoteUserControl>(control);
    }
}

[VisualStudioContribution]
public class MyCommand : Command
{
    public MyCommand(MyDataSource dataSource) { }
}