Procedura: Fornire un servizio

Un VSPackage può fornire servizi che l'altro Vspackage possibile utilizzare. Per fornire un servizio, un VSPackage deve effettuare le attività seguenti:

• registrare il servizio con Visual Studio.

  Per ulteriori informazioni, vedere Registrare servizi.

• Implementare IServiceProvider

la classe di Package implementa sia IServiceProvider che IServiceContainer. IServiceContainer utilizza i metodi di callback per fornire a locale e servizi globali su richiesta.

Nota

Quando un package VS sta per essere scaricato, attende di Visual Studio fino a tutte le richieste per i servizi in un VSPackage fornisce è stato distribuito.Non consente le nuove richieste per questi servizi.Di conseguenza, Vspackage non deve chiamare in modo esplicito il metodo di RevokeService per revocare un servizio quando vengono scaricati.

Il codice seguente viene ricavato dall'esempio di Reference.Services (c#) in Esempi di estensibilità di Visual Studio. Fornisce al servizio locale, a SMyLocalService e al servizio globale, SMyGlobalService.

Per fornire un servizio

1. Aggiungere ProvideServiceAttribute al package VS che fornisce il servizio globale.

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

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

   log SMyGlobalService diProvideServiceAttribute con Visual Studio. Solo il servizio globale deve essere registrato. Per ulteriori informazioni, vedere Procedura: registrare un servizio.

2. Aggiungere i metodi di callback al contenitore del servizio per creare servizi.

   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);
   }
   

   Il flag di true indica al contenitore del servizio per fare in SMyGlobalService un servizio globale.

   Nota

   Visual Studio possibile rifiutare una richiesta di fornire un servizio.Viene eseguita questa operazione se un altro package VS già fornisce al servizio.

3. implementare il metodo di callback.

   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 crea SMyGlobalService o SMyLocalService su richiesta.

4. Implementare la classe di servizi globale.

   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 di MyGlobalService implementa i SMyGlobalService che l'interfaccia di IMyGlobalInterface fornita dal servizio. Il provider di servizi passato al costruttore viene memorizzato nella cache in modo che i metodi di interfaccia di disporre di accesso agli altri servizi.

5. implementare la classe di servizio locale.

   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.
   }
   

Vedere anche

Attività

Procedura: utilizzare un servizio

Concetti

Esempi di estensibilità di Visual Studio

Concetti di base del servizio

Altre risorse

servizi