WCF - Gestion des instances

L'ensemble des techniques utilisées par WCF pour lier un ensemble de messages (demandes client) à des instances de service est appelé Gestion d'instances. WCF prend en charge trois types d'activation d'instance et ils sont traités dans ce chapitre.

Service par appel

Le service par appel est le mode d'activation d'instance par défaut de WCF. Lorsqu'un service WCF est configuré pour un service par appel, un objet CLR est créé pour la durée pendant laquelle un appel ou une demande client est en cours. CLR signifie Common Language Runtime et inclut des instances de service dans WCF.

Dans le service par appel, chaque demande client obtient une nouvelle instance de service dédiée et sa consommation de mémoire est inférieure à celle d'autres types d'activation d'instance.

La propriété InstanceContextMode doit être définie sur InstanceContextMode.PerCall, afin d'indiquer qu'un service WCF agira en tant que service par appel. La propriété InstanceContextMode appartient à l'attribut ServiceBehavior. Par conséquent, un service par appel peut être configuré comme suit -

[ServiceContract]
interface IMyContract
{...}
[ServiceBehavior (InstanceContextMode = InstanceContextMode.PerCall)]
class MyService : IMyContract
{...}

Un service est ici exprimé en IMyContract. La figure suivante montre le processus d'activation de l'instance de service par appel.

Implémentation d'un service par appel

[DataContract]
class Param {....}

[ServiceContract]
interface IMyContract {
   [OperationContract]
   void MyMethod(Param objectIdentifier);
}
class MyPerCallService : IMyContract, IDisposable {
   public void MyMethod(Param objectIdentifier) {
      GetState(objectIdentifier); 
      DoWork();
      SaveState(objectIdentifier);
   }
   
   void GetState(Param objectIdentifier) {....}
   void DoWork() {....}
   void SaveState(Param objectIdentifier) {....}
   public void Dispose() {....}
}

Ici, Param est le paramètre de pseudo type inventé pour l'exemple ci-dessus.

Service par session

Dans ce mode d'activation de WCF, une session privée ou on peut dire confidentielle est maintenue entre les deux entités, c'est-à-dire le client et une instance de service particulière. Également connu sous le nom de service de session privée, le service par session offre une nouvelle instance de service qui reste dédiée à chaque demande client et autonome de toutes les autres instances appartenant à ce service sensible à la session.

Pour lancer un service par session, la propriété InstanceContextMode doit être définie sur PerSession. Ici, l'instance de service reste en mémoire pendant toute la durée de la session.

Le mode d'activation souffre de l'évolutivité car le service configuré est incapable de prendre en charge des clients en attente supplémentaires autres que quelques-uns (ou peut-être jusqu'à une centaine) en raison du coût impliqué dans chacune de cette instance de service dédiée.

Un service par session peut être configuré comme -

[ServiceBehavior (InstanceContextMode = InstanceContextMode.PerSession)]
class MyService : IMyContract
{...}

Le processus du service par session peut être décrit comme illustré dans la figure suivante -

Le code suivant montre un contrat et un service configurés pour l'utilisation d'une session privée. La sortie indique que le client a effectivement obtenu une instance de service dédiée.

Code de service

[ServiceContract(Session = true)]
interface IMyContract {
   [OperationContract]
   void MyMethod();
}

[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession)]
class MyService : IMyContract, IDisposable {
   int m_Counter = 0; MyService() {Console.WriteLine("MyService.MyService()"); }
   
   public void MyMethod() {
      m_Counter++;
      Console.WriteLine("Counter = " + m_Counter);
   }
   public void Dispose() { 
      Console.WriteLine("MyService.Dispose()"); 
   }
}

Code client

MyContractProxy proxy = new MyContractProxy(); proxy.MyMethod(); proxy.MyMethod(); 
proxy.Close();

Production

MyService.MyService() Counter = 1 Counter = 2 MyService.Dispose()

Service Singleton

Dans ce mode d'activation de WCF, toutes les demandes client indépendantes les unes des autres sont connectées à la même instance unique bien connue, indépendamment de leur connexion aux points de terminaison de service. Le service singleton est supprimé uniquement lorsque l'hôte se ferme.

Ce service est créé une seule fois lors de la création de l'hôte. Dans le cas où l'hôte ne dispose d'aucune instance de singleton, le service renvoie la valeur NULL. Le mode d'activation est à son meilleur lorsque la quantité de travail dans chaque appel de méthode est faible et qu'aucune opération en attente n'est là en arrière-plan.

La propriété InstanceContextMode doit être définie sur InstanceContextMode.Single pour lancer ce service Singleton.

Par conséquent, un service Singleton peut être configuré comme -

[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]
class MySingleton : ...
{...}

Le processus du service Singleton est illustré dans la figure suivante -

Le code suivant est utilisé pour initialiser et héberger une instance singleton.

Code de service

[ServiceContract]
interface IMyContract {
   [OperationContract]
   void MyMethod( );
}
[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]
class MySingleton : IMyContract {
   int m_Counter = 0;
   
   public int Counter {
      get {
         return m_Counter;
      }
      set {
         m_Counter = value;
      }
   }
   public void MyMethod( ) {
      m_Counter++;
      Trace.WriteLine("Counter = " + Counter);
   }
}

Code hôte

MySingleton singleton = new MySingleton( );
singleton.Counter = 42;
ServiceHost host = new ServiceHost(singleton);
host.Open( );

//Do some blocking calls then
host.Close( );

Code client

MyContractClient proxy = new MyContractClient( );
proxy.MyMethod( );
proxy.Close( );

Production

Counter = 43