ServiceBehaviorAttribute.ConcurrencyMode Propriedade

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

Valor da propriedade

ConcurrencyMode

Um dos valores ConcurrencyMode; o padrão é Single.

Exceções

Exemplos

O exemplo de código a seguir demonstra a diferença entre usar Singlee ReentrantMultiple. Este exemplo não é compilado sem uma implementação real por trás dele, mas demonstra o tipo de garantias de threading que Windows WCF (Communication Foundation) faz e o que isso significa para o código de operação.

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

Comentários

Essa propriedade indica se uma instância de um serviço pode lidar com um thread ou vários threads que são executados simultaneamente e se há suporte para uma única thread.

A configuração ConcurrencyMode para Single instrui o sistema a restringir instâncias do serviço a um thread de execução por vez, o que libera você de lidar com problemas de threading. Um valor de meios que os objetos de Multiple serviço podem ser executados por vários threads a qualquer momento. Nesse caso, você deve garantir a segurança do thread.

Reentrant também restringe o acesso a um único thread por vez; enquanto a operação está sendo processada, nenhuma outra mensagem pode entrar na operação. Se durante a operação uma chamada para outro serviço sair, a mensagem atual perderá o bloqueio na operação, que é livre para processar outras mensagens. Quando a chamada de serviço retorna, o bloqueio é restabelecido e a mensagem original pode continuar processando até sua conclusão ou até que outra chamada fora da operação ocorra.

Durante qualquer chamada de saída de uma operação de processamento, os dados não locais para a operação podem ser modificados. (Os dados de estado local têm a garantia de serem válidos quando a mensagem original retomar o processamento.) Como resultado, antes da chamada de saída, você deve garantir que os dados não locais sejam válidos para outras chamadas de entrada e revalidar dados não locais após o retorno da chamada de saída.

O pseudocódigo a seguir ilustra o padrão necessário para o suporte de reentrant bem-sucedido.

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

Usando o padrão de chamada assíncrona Begin/End para uma chamada de saída quando o ConcurrencyMode is Reentrant dispara uma exceção. Chamadas de saída assíncronas exigem uma operação na qual ConcurrencyMode , Multiplenesse caso, você deve lidar com problemas de sincronização.

Em geral, se uma mensagem chegar para uma instância que viole seu modo de simultaneidade, a mensagem aguardará até que a instância esteja disponível ou até atingir o tempo limite.

Além disso, se a ConcurrencyMode chamada for definida Single e uma chamada reentrante for bloqueada enquanto aguarda a liberação da instância, o sistema detectará o deadlock e gerará uma exceção.

Observe que você deve definir ReleaseServiceInstanceOnTransactionComplete false explicitamente se há uma operação com definido como OperationBehaviorAttribute.TransactionScopeRequired true e definido ConcurrencyMode como Reentrant. Caso contrário, uma exceção de validação será gerada porque o valor ReleaseServiceInstanceOnTransactionComplete padrão é true.

Há uma interação entre as propriedades e outras que podem alterar o ConcurrencyMode comportamento do runtime. Para obter uma descrição completa dessas interações, consulte Sessões, Instancamento e Simultaneidade.

Aplica-se a