ConcurrencyMode Enumerazione

Definizione

Spazio dei nomi:

System.ServiceModel

Assembly:

System.ServiceModel.Duplex.dll

Assembly:

System.ServiceModel.dll

Specifica se una classe del servizio supporta modalità operative a thread singolo o multithread.

public enum class ConcurrencyMode

public enum ConcurrencyMode

type ConcurrencyMode = 

Public Enum ConcurrencyMode

Ereditarietà

Object

ValueType

Enum

ConcurrencyMode

Campi

Multiple	2	L'istanza del servizio è multithread. Non viene resa alcuna garanzia di sincronizzazione. Poiché è possibile che altri thread modifichino l'oggetto servizio in qualsiasi momento, è necessario gestire sempre la sincronizzazione e la coerenza dello stato.
Reentrant	1	L'istanza del servizio è a thread singolo e accetta chiamate rientranti. Il servizio rientrante accetta chiamate quando viene chiamato un altro servizio; è pertanto responsabilità dello sviluppatore garantire la coerenza dello stato dell'oggetto prima dei callout ed è necessario confermare che i dati locali dell'operazione siano validi dopo i callout. Si noti che l'istanza del servizio viene sbloccata solo chiamando un altro servizio su un canale WCF. In questo caso, il servizio chiamato può rientrare nel primo servizio tramite un callback. Se il primo servizio non è rientrante, la sequenza di chiamate determina un deadlock. Per informazioni dettagliate, vedere ConcurrencyMode.
Single	0	L'istanza del servizio è a thread singolo e non accetta chiamate rientranti. Se la proprietà InstanceContextMode è Single e giungono altri messaggi mentre l'istanza elabora una chiamata, tali messaggi restano in attesa fino a quando il servizio non diventa disponibile o fino al loro timeout.

Esempio

Nell'esempio di codice seguente viene illustrata la differenza tra l'uso di Single, Reentrant e Multiple. In questo esempio non viene compilata senza un'implementazione reale, ma viene illustrato il tipo di threading garantito da WCF e ciò che significa per il codice dell'operazione.

using System;
using System.ServiceModel;

[ServiceContract]
public interface IHttpFetcher
{
  [OperationContract]
  string GetWebPage(string address);
}

// These classes have the invariant that:
//     this.slow.GetWebPage(this.cachedAddress) == this.cachedWebPage.
// When you read cached values you can assume they are valid. When
// you write the cached values, you must guarantee that they are valid.
// With ConcurrencyMode.Single, WCF does not call again into the object
// so long as the method is running. After the operation returns the object
// can be called again, so you must make sure state is consistent before
// returning.
[ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Single)]
class SingleCachingHttpFetcher : IHttpFetcher
{
    string cachedWebPage;
    string cachedAddress;
    readonly IHttpFetcher slow;

    public string GetWebPage(string address)
    {
        // <-- Can assume cache is valid.
        if (this.cachedAddress == address)
        {
            return this.cachedWebPage;
        }

        // <-- Cache is no longer valid because we are changing
        // one of the values.
        this.cachedAddress = address;
        string webPage = slow.GetWebPage(address);
        this.cachedWebPage = webPage;
        // <-- Cache is valid again here.

        return this.cachedWebPage;
        // <-- Must guarantee that the cache is valid because we are returning.
    }
}

// With ConcurrencyMode.Reentrant, WCF makes sure that only one
// thread runs in your code at a time. However, when you call out on a
// channel, the operation can get called again on another thread. Therefore
// you must confirm that state is consistent both before channel calls and
// before you return.
[ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Reentrant)]
class ReentrantCachingHttpFetcher : IHttpFetcher
{
  string cachedWebPage;
  string cachedAddress;
  readonly SlowHttpFetcher slow;

  public ReentrantCachingHttpFetcher()
  {
    this.slow = new SlowHttpFetcher();
  }

  public string GetWebPage(string address)
  {
    // <-- Can assume that cache is valid.
    if (this.cachedAddress == address)
    {
        return this.cachedWebPage;
    }

    // <-- Must guarantee that the cache is valid, because
    // the operation can be called again before we return.
    string webPage = slow.GetWebPage(address);
    // <-- Can assume cache is valid.

    // <-- Cache is no longer valid because we are changing
    // one of the values.
    this.cachedAddress = address;
    this.cachedWebPage = webPage;
    // <-- Cache is valid again here.

    return this.cachedWebPage;
    // <-- Must guarantee that cache is valid because we are returning.
  }
}

// With ConcurrencyMode.Multiple, threads can call an operation at any time.
// It is your responsibility to guard your state with locks. If
// you always guarantee you leave state consistent when you leave
// the lock, you can assume it is valid when you enter the lock.
[ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Multiple)]
class MultipleCachingHttpFetcher : IHttpFetcher
{
  string cachedWebPage;
  string cachedAddress;
  readonly SlowHttpFetcher slow;
  readonly object ThisLock = new object();

  public MultipleCachingHttpFetcher()
  {
    this.slow = new SlowHttpFetcher();
  }

  public string GetWebPage(string address)
  {
    lock (this.ThisLock)
    {
      // <-- Can assume cache is valid.
      if (this.cachedAddress == address)
      {
          return this.cachedWebPage;
          // <-- Must guarantee that cache is valid because
          // the operation returns and releases the lock.
      }
      // <-- Must guarantee that cache is valid here because
      // the operation releases the lock.
    }

    string webPage = slow.GetWebPage(address);

    lock (this.ThisLock)
    {
      // <-- Can assume cache is valid.

      // <-- Cache is no longer valid because the operation
      // changes one of the values.
      this.cachedAddress = address;
      this.cachedWebPage = webPage;
      // <-- Cache is valid again here.

      // <-- Must guarantee that cache is valid because
      // the operation releases the lock.
    }

    return webPage;
  }
}

Commenti

L'enumerazione ConcurrencyMode viene utilizzata insieme alla proprietà ConcurrencyMode per specificare se una classe del servizio supporta modalità operative a thread singolo o multithread. Un'operazione a thread singolo può essere rientrante o non rientrante.

Nella tabella seguente viene illustrato quando Windows Communication Foundation (WCF) consente di richiamare un'operazione mentre è in corso un'altra operazione, a seconda di ConcurrencyMode.

Valore di ConcurrencyMode	Possibilità di richiamare una nuova operazione
Single	Mai
Rientrante	Solo durante la chiamata di un altro servizio o un callback
Più elementi	Sempre