Comment : activer la persistance pour un service fiable

Les services fiables sont des services Windows Communication Foundation (WCF) conçus pour être fiables et de longue durée et qui survivent à l'application et aux reprises de serveur. Les services fiables sont rendus persistants par l'utilisation du fournisseur prédéfini créé par un SqlPersistenceProviderFactory ou un fournisseur de persistances personnalisé dérivé de la classe abstraite PersistenceProvider ou LockingPersistenceProvider.

La classe abstraite LockingPersistenceProvider dérive de PersistenceProvider et expose les fonctionnalités à des fins de verrouillage, de déverrouillage, de chargement, d'enregistrement et de suppression explicites des informations d'état du service. Les informations d'état du service sont verrouillées avant que les opérations de sauvegarde ou de suppression aient lieu, afin qu'aucune contention de données entre plusieurs hôtes ne se produise. Avant qu'un verrou puisse être acquis sur les données d'état, les deux critères suivants doivent être réunis :

• Le lockOwner de l'enregistrement doit être null.

• La valeur lockExpiration de l'enregistrement doit être inférieure à la DateTime actuelle (autrement dit, tous les verrous précédents doivent avoir expiré).

Lorsque le verrou est acquis, le champ lockOwner de l'enregistrement a pour valeur l'ID hôte de l'hôte verrouillant (il doit être spécifique à chaque instance de fournisseur et généré dans le constructeur du fournisseur) et la valeur lockExpiration de l'enregistrement est DateTime.UtcNow plus la valeur du délai d'attente du verrou. (Il s'agit soit de la valeur fournie au constructeur du fournisseur de persistances, soit une valeur par défaut définie dans la classe d'implémentation du fournisseur. Dans l'implémentation SqlPersistenceProviderFactory prédéfinie, la valeur par défaut est zéro, ce qui signifie que le verrouillage n'est pas utilisé par défaut.) Si le verrou est déjà maintenu, la valeur du délai d'attente du verrou sera également mise à jour si Lock ou Load est appelé avec le jeu de paramètres lockInstance affecté de la valeur True. Le délai d'attente du verrou sera également mis à jour si le verrou est déjà maintenu et Save est appelé avec le paramètre unlockInstance affecté de la valeur False.

La SqlPersistenceProviderFactory crée une implémentation prédéfinie de la classe abstraite LockingPersistenceProvider. SqlPersistenceProviderFactory cible SQL 2005 comme magasin de persistances et peut rendre des informations d'état persistantes aux formats texte ou binaire.

La SqlPersistenceProviderFactory peut être créée avec jusqu'à trois paramètres de constructeur. Le tableau suivant affiche les trois paramètres de constructeur.

lockTimeout	Délai d'expiration correspondant à la propriété du verrou. L'instance de l'état du service est déverrouillée automatiquement après ce délai d'attente. Un délai d'expiration égal à zéro (valeur par défaut) empêchera l'utilisation du verrouillage et une valeur de TimeSpan.MaxValue empêchera les verrous d'expirer.
connectionString	Chaîne qui contient les paramètres utilisés pour établir une connexion à la base de données SQL. Notez que lors de la configuration du fournisseur de persistances à l'aide d'un fichier de configuration, la chaîne de connexion est placée dans le nœud connectionStrings, plutôt que le long des autres paramètres de création.
serializeAsText	Valeur booléenne qui indique si les informations d'état seront rendues persistantes au format XML ou binaire. La valeur par défaut est False (indiquer la sérialisation binaire).

Les données d'état de service sont rendues persistantes dans le tableau InstanceData. Le tableau suivant affiche les champs du tableau InstanceData.

id	Identificateur unique de l'instance d'état.
instanceType	Type d'instance qui est stocké.
instance	L'état de l'instance est rendu persistant sous forme de données binaires. Aura la valeur null si l'instance est rendue persistante sous forme de texte.
instanceXml	L'état de l'instance est rendu persistant au format XML. Aura la valeur null si l'instance est rendue persistante sous forme de données binaires.
created	Heure UTC lorsque l'instance a été écrite en premier dans la base de données.
lastUpdated	Heure UTC lorsque l'instance a été écrite en dernier dans la base de données.
lockOwner	ID de l'hôte qui possède actuellement le verrou sur l'enregistrement ou null s'il n'y a aucun verrou actif.
lockExpiration	Heure UTC à laquelle le verrou expirera.

Le SqlPersistenceProviderFactory peut être configuré dans le code à l'aide du constructeur de la classe, mais il est habituellement préférable de le configurer (et les fournisseurs de services en général) à l'aide d'un fichier de configuration de l'application. Voici un exemple de configuration. (Notez que le format des fichiers de configuration de service fiables est le même que pour les services Windows Communication Foundation (WCF).)

<configuration>
  <connectionStrings>
    <add name="LocalConnection" 
      connectionString="
        Initial Catalog=SqlPersistence;
        Data Source=localhost;
        Integrated Security=SSPI;" 
    />
  </connectionStrings>  <system.serviceModel>
    <services>
      <service 
        name="SampleService"
        behaviorConfiguration="ServiceBehavior">
        <endpoint
          address="ISampleService_Basic"
          binding="basicHttpContextBinding"
          contract="SampleApplication.ISampleService"
        />
      </service>
    </services>
    <behaviors>
      <serviceBehaviors>
        <behavior name="ServiceBehavior">
          <persistenceProvider
            persistenceOperationTimeout="00:00:15"
            type="
              System.ServiceModel.Persistence.SqlPersistenceProviderFactory,
              System.WorkflowServices,
              Version=3.5.0.0",
              Culture=neutral,
              PublicKeyToken=31bf3856ad364e5"
            connectionStringName="LocalConnection",
            lockTimeout="00:10:00" 
          />
        </behavior>
      </serviceBehaviors>
    </behaviors>
  </system.serviceModel>
</configuration>

Configuration de services fiables

Service WCF implémenté dans le code rendu persistant sur un support de stockage, en général une base de données SQL. Le service peut ensuite être rechargé afin qu'un client puisse se connecter n'importe quand à un service spécifique.

Un service fiable utilise le même modèle objet qu'un service de workflow et utilise le même mécanisme de canal de protocole du contexte sous-jacent, afin que les messages puissent être routés à l'instance appropriée d'un service.

La différence entre un service fiable écrit dans le code et un service fiable écrit comme un workflow, est que le workflow peut être rendu persistant au cours d'un appel d'opération, tandis qu'un service fiable est rendu persistant après que l'appel d'opération ait été effectué.

Pour marquer une implémentation de service comme fiable, marquez le service à l'aide du DurableServiceAttribute. Le tableau suivant affiche le paramètre disponible pour cet attribut.

SaveStateInOperationTransaction

Rend explicitement transactionnels tous les états de l'instance. Cet indicateur vérifie que ConcurrencyMode est Single, et que toutes les opérations s'exécuteront sous une transaction. (TransactionScopeRequired doit avoir la valeur True ou TransactionFlowOption doit être défini.)

Si l'attribut est présent sur un service, la méthode ApplyDispatchBehavior configurera les composants DispatchRuntime nécessaires pour extraire correctement l'ID d'instance d'un message, routez-le à l'instance correspondante et effectuez des opérations de persistance autour de l'appel.

Les opérations sur les services fiables doivent être marquées avec DurableOperationAttribute. Le tableau suivant affiche la propriété de cet attribut.

CompletesInstance

Spécifie que l'instance est effectuée (et sera rendu persistante et déchargée de la mémoire) une fois que cette opération sera terminée. La valeur par défaut est False.

L'exemple de code suivant montre la création d'un service fiable.

[ServiceContract()]
public interface IService1
{
    [OperationContract]
    string MyOperation1(string myValue);
    [OperationContract]
    string MyOperation2(DataContract1 dataContractValue);
}
[DurableService(MyPersistenceProvider)]
public class service1 : IService1
{
    [DurableOperation]
    public string MyOperation1(string myValue)
    {
        Return "Hello: " + myValue;
    }
    [DurableOperation]
    string MyOperation2(DataContract1 dataContractValue)
    {
        return "Hello: " + dataContractValue.DataName;
    }
}
[DataContract]
public class DataContract1
{
    string dataNameValue;
    [DataMember]
    public string DataName
    {
        get { return dataNameValue; }
        set { dataNameValue = value; }
    }
}

Voir aussi

Autres ressources

Didacticiel : créer un service fiable
Création de services de workflow et de services fiables

Copyright ©2007 par Microsoft Corporation. Tous droits réservés.