Comment : fournissez un service

Un VSPackage peut fournir des services que l'autre des VSPackages peut consommer. Pour fournir un service, un VSPackage doit exécuter les tâches suivantes :

• enregistrez le service avec Visual Studio.

  Pour plus d'informations, consultez Enregistrement des services.

• Implémentez IServiceProvider.

la classe d' Package implémente IServiceProvider et IServiceContainer. IServiceContainer contient des méthodes de rappel pour fournir des services locaux et globaux à la demande.

Notes

Lorsqu'un VSPackage est sur le point d'être déchargé, Visual Studio attend jusqu'à ce que toutes les requêtes de services qu'un VSPackage le fournit ont été remis.elle ne permet pas de nouvelles demandes pour ces services.Par conséquent, les VSPackages ne doit pas appeler explicitement la méthode d' RevokeService pour révoquer un service en déchargeant.

Le code suivant est extrait de l'exemple de Reference.Services (c#) dans Exemples d'extensibilité Visual Studio. il fournit le service local, SMyLocalService, et le service global, SMyGlobalService.

pour fournir un service

1. ajoutez ProvideServiceAttribute au VSPackage qui fournit le service global.

   <ProvideService(GetType(SMyGlobalService))> _
   Public NotInheritable Class ServicesPackage
       Inherits Package
   

   [ProvideService(typeof(SMyGlobalService))]
   public sealed class ServicesPackage : Package
   

   inscriptions SMyGlobalService d'ProvideServiceAttribute à Visual Studio. Seul le service global doit être enregistré. Pour plus d'informations, consultez Comment : enregistrez un service.

2. Ajoutez des méthodes de rappel au conteneur de service pour créer des services.

   Public Sub New()
       Dim serviceContainer As IServiceContainer = TryCast(Me, IServiceContainer)
       Dim callback As New ServiceCreatorCallback(AddressOf CreateService)
       serviceContainer.AddService(GetType(SMyGlobalService), callback, True)
       serviceContainer.AddService(GetType(SMyLocalService), callback)
   End Sub
   

   public ServicesPackage()
   {
       IServiceContainer serviceContainer = this as IServiceContainer;
       ServiceCreatorCallback callback =
          new ServiceCreatorCallback(CreateService);
       serviceContainer.AddService(typeof(SMyGlobalService), callback, true);
       serviceContainer.AddService(typeof(SMyLocalService), callback);
   }
   

   La balise d' true demande au conteneur de service pour établir SMyGlobalService un service global.

   Notes

   Visual Studio peut rejeter une demande de fournir un service.Il fait si un autre VSPackage fournit déjà le service.

3. Implémentez la méthode de rappel.

   Private Function CreateService(ByVal container As IServiceContainer, ByVal serviceType As Type) As Object 
       If GetType(SMyGlobalService) Is serviceType Then 
           Return New MyGlobalService(Me)
       End If 
   
       If GetType(SMyLocalService) Is serviceType Then 
           Return New MyLocalService(Me)
       End If 
   End Function
   

   private object CreateService(IServiceContainer container, Type serviceType)
   {
       if (typeof(SMyGlobalService) == serviceType)
           return new MyGlobalService(this);
   
       if (typeof(SMyLocalService) == serviceType)
           return new MyLocalService(this);
   
       return null;
   }
   

   CreateService crée SMyGlobalService ou SMyLocalService à la demande.

4. implémentez la classe de service global.

   Public Class MyGlobalService
       Inherits SMyGlobalService
       Implements IMyGlobalService
       Private serviceProvider As IServiceProvider
       Public Sub New(ByVal sp As IServiceProvider)
           Trace.WriteLine("Constructing a new instance of MyGlobalService")
           serviceProvider = sp
       End Sub 
       ' Implement the methods of IMyGlobalService here.  
   End Class
   

   public class MyGlobalService : SMyGlobalService, IMyGlobalService
   {
       private IServiceProvider serviceProvider;
       public MyGlobalService(IServiceProvider sp)
       {
           Trace.WriteLine(
              "Constructing a new instance of MyGlobalService");
           serviceProvider = sp;
       }
       // Implement the methods of IMyGlobalService here.
   }
   

   la classe d' MyGlobalService implémente SMyGlobalService et l'interface d' IMyGlobalInterface fournie par ce service. Le fournisseur de services passé au constructeur est mis en cache pour que les méthodes d'interface ont accès à d'autres services.

5. implémentez la classe de service local.

   Public Class MyLocalService
       Inherits SMyLocalService
       Implements IMyLocalService
       Private serviceProvider As IServiceProvider
       Public Sub New(ByVal sp As IServiceProvider)
           Trace.WriteLine("Constructing a new instance of MyLocalService")
           serviceProvider = sp
       End Sub 
       ' Implement the methods of IMyLocalService here.  
   End Class
   

   public class MyLocalService : SMyLocalService, IMyLocalService
   {
       private IServiceProvider serviceProvider;
       public MyLocalService(IServiceProvider sp)
       {
           Trace.WriteLine(
              "Constructing a new instance of MyLocalService");
           serviceProvider = sp;
       }
       // Implement the methods of IMyLocalService here.
   }
   

Voir aussi

Tâches

Comment : Consommer un service

Concepts

Exemples d'extensibilité Visual Studio

service Essentials

Autres ressources

services