Esempio di provider di persistenza file

In questo esempio viene dimostrato come creare un provider di persistenza che funziona con servizi durevoli. Lo stato dell'istanza del servizio viene archiviato nei file sul computer.

L'esempio contiene anche l'implementazione di un servizio calcolatrice uguale all'Servizi durevoli. La differenza è che questo servizio utilizza il provider di persistenza file creato nell'esempio invece di utilizzare il provider di persistenza SQL di blocco standard.

Nota

Per poter essere generato ed eseguito, l'esempio richiede che sia installato .NET Framework versione 3.5. Per aprire il progetto e i file della soluzione è necessario Visual Studio 2008.

L'Esempio client calcolatrice deve essere eseguito con questo servizio (Per ulteriori informazioni, vedere , le procedure di configurazione sono fornite alla fine di questo argomento).

Provider di persistenza file

Il provider di persistenza file in questo esempio è definito nel file FilePersistenceProviderFactory.cs. Notare che la classe FilePersistenceProvider effettiva è situata in una classe incorporata. Per creare il provider di persistenza file, viene utilizzato un modello factory nel quale la factory passa la classe del provider di persistenza effettivo al runtime del servizio quando viene richiesto. Questo è il metodo standard per creare provider in WCF.

La classe factory del provider di persistenza file eredita dalla classe astratta PersistenceProviderFactory. La classe astratta PersistenceProviderFactory è definita nel codice seguente.

namespace System.ServiceModel.Persistence
{
    public abstract class PersistenceProviderFactory : CommunicationObject
    {
        protected PersistenceProviderFactory();

        public abstract PersistenceProvider CreateProvider(Guid id);
    }
}

Notare che PersistenceProviderFactory eredita dalla classe astratta CommunicationObject. CommunicationObject fornisce i metodi necessari per gestire la durata dell'oggetto nell'arco del relativo utilizzo durante la fase di esecuzione del servizio.

Il modello factory per il provider aiuta a garantire che la factory gestisca tutte le risorse comuni tra tutte le istanze del provider. Ad esempio, nel caso del provider di persistenza file, la factory è in grado di determinare il percorso nel quale i file di persistenza vengono archiviati e quindi condivisi tra tutte le istanze del provider di persistenza file effettivo.

Il risultato è la presenza di un'istanza del provider per ogni istanza del servizio. Vi è anche un'istanza della factory per ciascun host.

Il provider di persistenza file stesso eredita dalla classe astratta PersistenceProvider. Questa classe è definita nel codice riportato di seguito.

namespace System.ServiceModel.Persistence
{
    public abstract class PersistenceProvider : CommunicationObject
    {
        protected PersistenceProvider(Guid id);

        public Guid Id { get; }

        public abstract IAsyncResult BeginCreate(object instance, TimeSpan timeout, AsyncCallback callback, object state);
        public abstract IAsyncResult BeginDelete(object instance, TimeSpan timeout, AsyncCallback callback, object state);
        public abstract IAsyncResult BeginLoad(TimeSpan timeout, AsyncCallback callback, object state);
        public virtual IAsyncResult BeginLoadIfChanged(TimeSpan timeout, object instanceToken, AsyncCallback callback, object state);
        public abstract IAsyncResult BeginUpdate(object instance, TimeSpan timeout, AsyncCallback callback, object state);
        public abstract object Create(object instance, TimeSpan timeout);
        public abstract void Delete(object instance, TimeSpan timeout);
        public abstract object EndCreate(IAsyncResult result);
        public abstract void EndDelete(IAsyncResult result);
        public abstract object EndLoad(IAsyncResult result);
        public virtual bool EndLoadIfChanged(IAsyncResult result, out object instance);
        public abstract object EndUpdate(IAsyncResult result);
        public abstract object Load(TimeSpan timeout);
        public virtual bool LoadIfChanged(TimeSpan timeout, object instanceToken, out object instance);
        public abstract object Update(object instance, TimeSpan timeout);    
    }
}

La classe del provider di persistenza è anche un oggetto di comunicazione. Nel provider di persistenza sono disponibili 4 metodi: Create(), Update(), Load() e Delete(). Sono definite le varianti asincrone di questi metodi e anche gli overload delle varianti asincrone. Le regole seguenti vengono applicate all'archiviazione dello stato dell'istanza nei file:

I file effettivi sono archiviati in una directory denominata FilePersistenceProvider nella directory Temp nel computer che ospita il servizio.
Lo stato di un'istanza viene archiviato in un file, il nome del quale è l'identificatore univoco dell'istanza. Il file viene archiviato con un'estensione bin.
Quando è necessario eliminare un file, questo non viene eliminato effettivamente, ma viene rinominato come "eliminato".

Configurazione del provider di persistenza

Prima di utilizzarlo, il provider di persistenza file deve essere specificato nel file di configurazione del servizio. La configurazione del provider di persistenza è specificata nella sezione servicebBehaviors del file di configurazione. In questo esempio è illustrata la voce nel file Web.config.

<behaviors>
      <serviceBehaviors>
        <behavior name="ServiceBehavior"  >
          <serviceMetadata httpGetEnabled="true" />
          <serviceDebug includeExceptionDetailInFaults="true" />
          <serviceCredentials>
            <windowsAuthentication allowAnonymousLogons="false" includeWindowsGroups="true" />
          </serviceCredentials>
          <persistenceProvider type="Microsoft.WorkflowServices.Samples.FilePersistenceProviderFactory, DurableServiceFactory, Version=1.0.0.0"/>
        </behavior>
      </serviceBehaviors>
    </behaviors>

Codice di servizio durevole – Contratto di servizio

Nell'esempio di codice seguente viene illustrato un contratto di servizio per il servizio calcolatrice.

[ServiceContract(Namespace = "http://Microsoft.WorkflowServices.Samples")]
    public interface ICalculator
    {
        [OperationContract()]
        int PowerOn();
        [OperationContract()]
        int Add(int value);
        [OperationContract()]
        int Subtract(int value);
        [OperationContract()]
        int Multiply(int value);
        [OperationContract()]
        int Divide(int value);
        [OperationContract()]
        void PowerOff();
    }

Implementazione del servizio

Nel codice seguente, l'attributo DurableServiceAttribute viene utilizzato nell'implementazione del servizio per specificare che si tratta di un servizio durevole.

[Serializable]
[DurableService]
public class DurableCalculator : ICalculator
{
    int currentValue = default(int);

    [DurableOperation(CanCreateInstance=true)]
    public int PowerOn()
    {
        return currentValue;
    }

    [DurableOperation()]
    public int Add(int value)
    {
        return (currentValue += value);
    }

    [DurableOperation()]
    public int Subtract(int value)
    {
        return (currentValue -= value);
    }

    [DurableOperation()]
    public int Multiply(int value)
    {
        return (currentValue *= value);
    }

    [DurableOperation()]
    public int Divide(int value)
    {
        return (currentValue /= value);
    }

    [DurableOperation(CompletesInstance=true)]
    public void PowerOff()
    {
    }

}

L'attributo DurableOperationAttribute specifica che lo stato dell'istanza viene salvato al completamento dell'operazione.

Nell'attributo DurableOperationAttribute è possibile utilizzare 2 parametri. La proprietà CanCreateInstance specifica che l'istanza viene creata quando viene richiamata l'operazione. La proprietà CompletesInstance specifica che l'istanza del servizio è completata dopo che l'operazione nella quale è stato specificato questo attributo ha terminato l'esecuzione. Al completamento dell'operazione lo stato viene eliminato anche dal database.

Nel codice seguente viene illustrato il file con estensione svc destinato a ospitare questo esempio in Internet Information Services (IIS).

<%@ServiceHost language=c# Debug="true" Service="Microsoft.WorkflowServices.Samples.DurableCalculator" Factory="System.ServiceModel.Activation.ServiceHostFactory" %>

L'associazione del servizio è configurata nel file Web.config. L'associazione WSHttpContextBinding consente di mantenere il contesto utilizzato per indirizzare le richieste a una particolare istanza dell'applicazione. La voce del provider di persistenza che specifica il provider di persistenza è situata nella sezione ServiceBehaviors.

Per impostare, compilare ed eseguire l'esempio

Verificare l'esecuzione delle istruzioni di installazione descritte in Procedura di installazione singola per gli esempi di Windows Communication Foundation.
In IIS, attivare l'autenticazione di Windows sulla directory virtuale ServiceModelSamples.

Per attivare l'autenticazione di Windows in IIS 5.1 o 6.0:
1. Aprire una finestra del prompt dei comandi e digitare start inetmgr per aprire lo snap-in MMC di Gestione Internet Information Services (IIS).
2. Fare clic con il pulsante destro del mouse sulla radice virtuale ServiceModelSamples all'interno di Sito Web predefinito, scegliere Proprietàe quindi la scheda Protezione directory.
3. In Controllo autenticazione e accesso, scegliere Modifica.
4. Nella finestra di dialogo Metodi di autenticazione selezionare Autenticazione integrata di Windows.
Per attivare l'autenticazione di Windows in IIS 7.0:
1. Aprire una finestra del prompt dei comandi e digitare start inetmgr per aprire lo snap-in MMC di Gestione Internet Information Services (IIS).
2. Selezionare la radice virtuale ServiceModelSamples all'interno di Sito Web predefinito.
3. Nel riquadro iniziale ServiceModelSamples, fare doppio clic su Autenticazione nel gruppo IIS.
4. Selezionare Autenticazione di Windows e selezionare l'azione Attiva.
Compilare il progetto. Il progetto compila e aggiorna ServiceModelSamples.
Per garantire che il servizio sia installato correttamente, puntare all'indirizzo https://localhost/servicemodelsamples/service.svc. Dovrebbe essere visualizzata la pagina della Guida del servizio. Per consultare WSDL (Web Services Descriptor Language), digitare https://localhost/servicemodelsamples/service.svc?wsdl.
Per eseguire l'esempio è necessario utilizzare l'Esempio client calcolatrice. Si tratta di un'interfaccia utente calcolatrice creata utilizzando Windows Presentation Foundation (WPF) che funge da client per il servizio. Per testare la natura durevole del servizio, chiudere il client e riaprirlo mentre il servizio di calcolatrice è in esecuzione. Il client calcolatrice comunica di ritorno con la stessa istanza del servizio e visualizza l'ID dell'istanza nella parte inferiore. Il client calcolatrice utilizza un file di testo denominato Client.ctx per archiviare il contesto in una posizione durevole la prima volta che viene eseguita una chiamata (in questo caso, nella directory \bin dell'esempio). Quando viene riavviato, il client controlla se il file è presente. Se lo è, applica il contesto archiviato al canale che viene creato. Se il servizio è stato completato e viene aperto il client con il file Client.ctx ancora nella directory \bin, il servizio tenterà di applicare il contesto al canale. Viene generato un errore, perché il servizio con il quale si desidera comunicare non è presente. Eliminare il file e provare nuovamente.
È inoltre possibile riciclare il servizio riavviando IIS. Poiché dopo ogni operazione viene utilizzato un archivio di persistenza, lo stato del servizio è archiviato. Pertanto, quando si tenta di comunicare con il servizio dal client dopo il riavvio di IIS, l'infrastruttura del servizio riceve l'istanza dall'archivio di persistenza e sarà possibile comunicare con la stessa istanza.

Nota

Quando si richiama un'operazione per la prima volta dopo il riavvio di IIS, si riceve un'eccezione MessageSecurityException causata da un token di protezione scaduto sul canale. Richiamare un'altra operazione e l'operazione riuscirà.

Last updated on 2008-09-12

Condividi tramite