ServiceBehaviorAttribute.ConcurrencyMode Proprietà

public:
 property System::ServiceModel::ConcurrencyMode ConcurrencyMode { System::ServiceModel::ConcurrencyMode get(); void set(System::ServiceModel::ConcurrencyMode value); };

public System.ServiceModel.ConcurrencyMode ConcurrencyMode { get; set; }

member this.ConcurrencyMode : System.ServiceModel.ConcurrencyMode with get, set

Public Property ConcurrencyMode As ConcurrencyMode

Valore della proprietà

Uno dei valori di ConcurrencyMode. Il valore predefinito è Single.

Eccezioni

Esempio

Nell'esempio di codice seguente vengono illustrate le differenze tra l'utilizzo di Single, Reentrant e Multiple. Questo esempio non viene compilato senza un'implementazione reale dietro di esso, ma illustra il tipo di threading garantisce che Windows Communication Foundation (WCF) faccia e cosa 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

Questa proprietà indica se un'istanza di un servizio può supportare un solo thread o più thread eseguiti contemporaneamente e, in caso di thread singolo, se è supportata la reentrancy.

L'impostazione di ConcurrencyMode su Single indica al sistema di limitare le istanze del servizio a un solo thread di esecuzione alla volta, evitando in questo modo di incorrere in problemi di threading. Un valore Multiple indica che gli oggetti servizio possono essere eseguiti da più thread contemporaneamente. In questo caso, è necessario garantire la sicurezza dei thread.

Reentrant limita inoltre l'accesso a un singolo thread alla volta; durante l'elaborazione dell'operazione, nessun altro messaggio può immettere l'operazione. Se durante l'operazione, viene avviata una chiamata a un'altro servizio, il messaggio corrente perde il blocco sull'operazione che diventa libera di elaborare altri messaggi. Quando la chiamata del servizio viene restituita, il blocco viene ristabilito e il messaggio originale può continuare l'elaborazione fino al termine o fino a quando non si verifica un'altra chiamata dell'operazione.

Durante qualsiasi chiamata in uscita da un'operazione di elaborazione, è possibile modificare i dati non locali rispetto all'operazione I dati sullo stato locale sono sicuramente validi quando il messaggio originale riprende l'elaborazione. Di conseguenza, prima della chiamata in uscita è necessario assicurarsi che i dati non locali siano validi per altre chiamate in ingresso e riconvalidare i dati non locali dopo la restituzione della chiamata in uscita.

Nello pseudo-codice seguente viene illustrato il modello necessario per il supporto delle chiamate rientranti.

public void MyMethod()
{
  this.SomeNonLocalDataState;
  // Here you need to clean nonlocal state for other users
  OutboundProxy proxy = new OutboundProxy();
  int returnValue = proxy.CallOutOfOperation();
  // Ensure that this.SomeNonLocalDataState is valid for continued use.
  this.ModifyNonLocalState;
  return returnValue;
}

Se si utilizza il modello di chiamata asincrona Begin/End per una chiamata in uscita quando la proprietà ConcurrencyMode è Reentrant, viene generata un'eccezione. Per le chiamate in uscita asincrone è necessaria un'operazione in cui ConcurrencyMode è Multiple, nel qual caso sarà necessario gestire problemi di sincronizzazione.

In genere, se arriva un messaggio per un'istanza che viola la modalità di concorrenza, il messaggio resta in attesa fino a quando l'istanza non diventa disponibile o fino al timeout.

Inoltre, se ConcurrencyMode è impostata su Single e una chiamata rientrante è bloccata in attesa che l'istanza sia disponibile, il sistema rileva il deadlock e genera un'eccezione.

Si noti che è necessario impostare in modo esplicito la proprietà ReleaseServiceInstanceOnTransactionComplete su false se è presente un'operazione con la proprietà OperationBehaviorAttribute.TransactionScopeRequired impostata su true e si imposta la proprietà ConcurrencyMode su Reentrant. In caso contrario, viene generata un'eccezione di convalida perché il valore predefinito della proprietà ReleaseServiceInstanceOnTransactionComplete è true.

Esiste un'interazione fra la proprietà ConcurrencyMode e altre proprietà in grado di modificare il comportamento di runtime. Per una descrizione completa di queste interazioni, vedere Sessioni, istanze e concorrenza.

Si applica a