ServiceBehaviorAttribute.ConcurrencyMode Propriété

Définition

Obtient ou définit si un service prend en charge un thread, plusieurs threads ou des appels réentrants.Gets or sets whether a service supports one thread, multiple threads, or reentrant calls.

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

Valeur de propriété

Une des valeurs ConcurrencyMode ; la valeur par défaut est Single.One of the ConcurrencyMode values; the default is Single.

Exceptions

La valeur ne fait pas partie des valeurs ConcurrencyMode.The value is not one of the ConcurrencyMode values.

Exemples

L'exemple de code suivant illustre la différence entre l'utilisation de Single, Reentrant et Multiple.The following code example demonstrates the different between using Single, Reentrant, and Multiple. Cet exemple ne se compile pas sans une véritable implémentation en arrière-plan, mais il démontre que le type de thread garantit que Windows Communication Foundation (WCF) effectue et ce que cela signifie pour votre code d’opération.This sample does not compile without a real implementation behind it, but does demonstrate the kind of threading guarantees that Windows Communication Foundation (WCF) makes and what that means for your operation code.

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

Remarques

Cette propriété indique si une instance d'un service peut gérer un ou plusieurs threads exécutés simultanément et si, en cas d'utilisation monothread, la réentrance est prise en charge.This property indicates whether an instance of a service can handle one thread or multiple threads that execute concurrently, and if single-threaded, whether reentrancy is supported.

Notes

La propriété ConcurrencyMode interagit avec plusieurs autres paramètres.The ConcurrencyMode property interacts with some other settings. Par exemple, si InstanceContextMode a la valeur Single, votre service ne peut traiter qu'un message à la fois, excepté si vous affectez la valeur ConcurrencyMode à Multiple.For example, if the InstanceContextMode value is set to Single the result is that your service can only process one message at a time unless you also set the ConcurrencyMode value to Multiple. Cette propriété produit également un comportement en association avec la propriété ServiceContractAttribute.SessionMode.This property also produces behavior in combination with the ServiceContractAttribute.SessionMode property. Pour plus d’informations, consultez sessions, instanciation et accès concurrentiel.For details, see Sessions, Instancing, and Concurrency.

Le fait d'affecter à ConcurrencyMode la valeur Single permet de demander au système de restreindre les instances du service à un thread d'exécution à la fois, ce qui vous évite d'avoir à gérer des problèmes de thread.Setting ConcurrencyMode to Single instructs the system to restrict instances of the service to one thread of execution at a time, which frees you from dealing with threading issues. La valeur Multiple signifie que plusieurs threads à la fois peuvent exécuter les objets de service.A value of Multiple means that service objects can be executed by multiple threads at any one time. Dans ce cas, vous devez garantir la sécurité des threads.In this case, you must ensure thread safety.

Reentrantrestreint également l’accès à un seul thread à la fois; pendant le traitement de l’opération, aucun autre message ne peut accéder à l’opération.Reentrant also restricts access to a single thread at a time; while the operation is processing, no other message can enter the operation. Si, pendant l'opération, un appel à un autre service est envoyé, le message actuel désactive le verrouillage de l'opération, qui est alors libre de traiter d'autres messages.If during the operation a call to another service leaves, the current message loses the lock on the operation, which is free to process other messages. Lorsque l'appel de service revient, le verrouillage est rétabli et le message d'origine peut continuer à traiter jusqu'à son terme ou jusqu'à ce qu'un autre appel soit lancé par l'opération.When the service call out returns, the lock is reestablished and the original message can continue processing to its conclusion or until another call out of the operation occurs.

Important

Même si Single restreint les instances du service à un thread d’exécution à la fois, vous devez également définir MaxConcurrentCalls sur 1 pour garantir l’absence de messages en désordre.Even though Single restricts instances of the service to one thread of execution at a time, you must also set MaxConcurrentCalls to 1 to guarantee no out-of-order messages.

En outre, il vous incombe de maintenir la cohérence de l’état de votre objet avant les appels. vous devez donc confirmer que les données locales de l’opération sont valides après les appels.Also, it is your responsibility to leave your object state consistent before callouts and you must confirm that operation-local data is valid after callouts. Notez que l’instance de service est déverrouillée uniquement en appelant un autre service sur un canal WCF.Note that the service instance is unlocked only by calling another service over a WCF channel. Dans ce cas, le service appelé peut réentrer le premier service via un rappel.In this case, the called service can reenter the first service via a callback. Si le premier service n'est pas réentrant, la séquence des appels provoque un interblocage.If the first service is not reentrant, the sequence of calls results in a deadlock. Pour plus d'informations, consultez ConcurrencyMode.For details, see ConcurrencyMode.

Lors de tout appel sortant à partir d'une opération de traitement, il est possible de modifier les données non locales de l'opération.During any outbound call from a processing operation, data not local to the operation can be modified. (La validité des données d'état locales est ainsi garantie lorsque le traitement du message d'origine reprend.) Par conséquent, avant votre appel sortant, vous devez vérifier que les données non locales sont valides pour d'autres appels entrants et revalider les données non locales après que l'appel sortant a été retourné.(Local state data is guaranteed to be valid when the original message resumes processing.) As a result, before your outbound call you must ensure that non-local data is valid for other incoming calls and revalidate non-local data after the outbound call returns.

Le pseudo-code suivant illustre le modèle requis pour la prise en charge des appels réentrants.The following pseudo-code illustrates the required pattern for successful reentrant support.

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

L’utilisation du modèle d’appel asynchrone Begin/End pour un appel sortant lorsque le ConcurrencyMode a la valeur Reentrant déclenche une exception.Using the Begin/End asynchronous call pattern for an outbound call when the ConcurrencyMode is Reentrant triggers an exception. Les appels sortants asynchrones requièrent une opération dans laquelle le ConcurrencyMode a la valeur Multiple, auquel cas vous devez gérer les problèmes de synchronisation.Asynchronous outbound calls require an operation in which ConcurrencyMode is Multiple, in which case you must handle synchronization issues.

En règle générale, si un message est reçu pour une instance qui enfreint son mode d'accès concurrentiel, le message patiente jusqu'à ce que l'instance soit disponible ou expire.Generally, if a message arrives for an instance that violates its concurrency mode, the message waits until the instance is available, or until it times out.

Qui plus est, si ConcurrencyMode a la valeur Single et qu'un appel réentrant est bloqué jusqu'à ce que l'instance soit libérée, le système détecte l'interblocage et lève une exception.In addition, if the ConcurrencyMode is set to Single and a reentrant call is blocked while waiting for the instance to be freed, the system detects the deadlock and throws an exception.

Notes

Une InvalidOperationException est levée au moment de l'exécution si ReleaseServiceInstanceOnTransactionComplete a la valeur true lorsque la propriété ConcurrencyMode a la valeur Single.A InvalidOperationException is thrown at runtime if ReleaseServiceInstanceOnTransactionComplete is true when the ConcurrencyMode property is set to Single.

Notez que vous devez affecter explicitement la valeur ReleaseServiceInstanceOnTransactionComplete à false s'il existe une opération avec OperationBehaviorAttribute.TransactionScopeRequired dont la valeur est true et que vous affectez la valeur ConcurrencyMode à Reentrant.Note that you must explicitly set ReleaseServiceInstanceOnTransactionComplete to false if there is an operation with OperationBehaviorAttribute.TransactionScopeRequired set to true and you set ConcurrencyMode to Reentrant. Sinon, une exception de validation est levée car la valeur par défaut de ReleaseServiceInstanceOnTransactionComplete est true.Otherwise a validation exception is thrown because the default value of ReleaseServiceInstanceOnTransactionComplete is true.

Il existe une interaction des ConcurrencyMode et d'autres propriétés qui peut altérer le comportement au moment de l'exécution.There is an interaction of the ConcurrencyMode and other properties that can alter runtime behavior. Pour obtenir une description complète de ces interactions, consultez sessions, instanciation et accès concurrentiel.For a complete description of these interactions, see Sessions, Instancing, and Concurrency.

S’applique à