How to: Enable Persistence for a Durable Service

Durable services are Windows Communication Foundation (WCF) services that are designed to be durable and long-running, and to survive application and server restarts. Durable services are persisted using either the out-of-the-box provider created by a SqlPersistenceProviderFactory or a custom persistence provider derived from the abstract class PersistenceProvider or LockingPersistenceProvider.

The LockingPersistenceProvider abstract class derives from PersistenceProvider and exposes functionality for explicitly locking, unlocking, loading, saving, and deleting service state information. Service state information is locked before save or delete operations can take place, so that data contentions between multiple hosts do not occur. Before a lock can be acquired on state data, the following two criteria must be met:

• The record’s lockOwner must be null.

• The record’s lockExpiration value must be less than the current DateTime (that is, any previous locks must be expired).

When the lock is acquired, the record’s lockOwner field is set to the host ID of the locking host (this is unique to each provider instance and is generated in the provider’s constructor), and the record’s lockExpiration value is set to DateTime.UtcNow plus the lock time-out value. (This is either the value provided to the persistence provider’s constructor, or a default value defined in the provider implementation class. In the out-of-the-box SqlPersistenceProviderFactory implementation, the default is zero, which means that locking is not used by default.) If the lock is already held, the lock time-out value is also updated if Lock or Load is called with the lockInstance parameter set to True. The lock time-out is also updated if the lock is already held and Save is called with the unlockInstance parameter set to False.

The SqlPersistenceProviderFactory creates an out-of-the-box implementation of the LockingPersistenceProvider abstract class. SqlPersistenceProviderFactory targets SQL 2005 as a persistence store, and can persist state information in either text or binary formats.

The SqlPersistenceProviderFactory can be created with up to three constructor parameters. The following table shows the three constructor parameters.

Service state data is persisted to the InstanceData table. The following table shows the fields in the InstanceData table.

The SqlPersistenceProviderFactory can be configured in code using the class’s constructor, but it is usually preferable to configure it (and service providers in general) using an application configuration file. A sample configuration is as follows. (Note that the format for durable service configuration files is the same as for Windows Communication Foundation (WCF) services.)

<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=31bf3856ad364e35"
            connectionStringName="LocalConnection",
            lockTimeout="00:10:00" 
          />
        </behavior>
      </serviceBehaviors>
    </behaviors>
  </system.serviceModel>
</configuration>

Configuring Durable Services

WCF service implemented in code that is persisted to a storage medium, typically a SQL database. The service can then be reloaded so that a client can connect to a specific service at any time.

A durable service uses the same object model as a workflow service, and uses the same underlying context protocol channel mechanism, so that messages can be routed to the correct instance of a service.

The difference between a durable service written in code, and one written as a workflow, is that the workflow can get persisted in between an operation invocation, while a durable service is persisted after the operation invocation is completed.

To mark a service implementation as durable, mark the service using the DurableServiceAttribute. The following table shows the available parameter for this attribute.

When the attribute is present on a service, the ApplyDispatchBehavior method will configure the necessary DispatchRuntime components to correctly extract an instance ID from a message, route it to the correct instance, and perform persistence operations around invocation.

Operations on durable services should be marked with DurableOperationAttribute. The following table shows the property for this attribute.

The following code sample demonstrates creating a durable service.

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

See Also

Other Resources

Tutorial: Create a Durable Service
Creating Workflow Services and Durable Services