ConcurrencyMode Enumeration

Definition

Namespace:

System.ServiceModel

Assembly:

System.ServiceModel.Primitives.dll

Paket:

System.ServiceModel.Primitives v8.0.0

Quelle:

ConcurrencyMode.cs

Gibt an, ob eine Dienstklasse den Singlethread- oder den Multithread-Betriebsmodus unterstützt.

public enum class ConcurrencyMode

public enum ConcurrencyMode

type ConcurrencyMode = 

Public Enum ConcurrencyMode

Vererbung

Object

ValueType

Enum

ConcurrencyMode

Felder

Multiple	2	Diese Dienstinstanz ist eine Multithread-Instanz. Es werden keine Synchronisierungsgarantien gegeben. Da andere Threads jederzeit das Dienstobjekt ändern können, müssen Sie die Synchronisierung und die Zustandskonsistenz ständig verarbeiten.
Reentrant	1	Die Dienstinstanz ist eine Singlethread-Instanz und nimmt wiedereintrittsfähige Aufrufe an. Der wiedereintrittsfähige Dienst nimmt Aufrufe an, wenn Sie einen anderen Dienst aufrufen. Sie sind daher verantwortlich dafür, den Objektzustand vor Aufrufen konsistent zu lassen, und Sie müssen bestätigen, dass lokale Operationsdaten nach Aufrufen gültig sind. Beachten Sie, dass die Dienstinstanz nur durch das Aufrufen eines anderen Diensts über einen WCF-Kanal entsperrt wird. In diesem Fall kann der aufgerufene Dienst über einen Rückruf wieder in den ersten Dienst eintreten. Wenn der erste Dienst nicht wiedereintrittsfähig ist, führt die Sequenz der Aufrufe zu einem Deadlock. Ausführliche Informationen finden Sie unter ConcurrencyMode.
Single	0	Die Dienstinstanz ist eine Singlethread-Instanz und nimmt keine wiedereintrittsfähige Aufrufe an. Wenn die InstanceContextMode-Eigenschaft Single ist und weitere Meldungen ankommen, während die Instanz einen Aufruf bedient, müssen diese Meldungen warten, bis der Dienst verfügbar ist oder bis eine Zeitüberschreitung bei den Meldungen eintritt.

Beispiele

Im folgenden Codebeispiel wird die unterschiedliche Verwendung von Single, Reentrant und Multiple veranschaulicht. Dieses Beispiel kompiliert nicht ohne eine echte Implementierung, sondern veranschaulicht die Art von Threadinggarantien, die WCF vornimmt, und was dies für Ihren Vorgangscode bedeutet.

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

Hinweise

ConcurrencyMode wird in Verbindung mit der ConcurrencyMode-Eigenschaft verwendet, um anzugeben, ob eine Dienstklasse den Singlethread- oder den Multithread-Betriebsmodus unterstützt. Ein Singlethread-Betrieb kann wiedereintrittsfähig oder nicht wiedereintrittsfähig sein.

Die folgende Tabelle zeigt, wann Windows Communication Foundation (WCF) das Aufrufen eines Vorgangs zulässt, während ein anderer vorgang ausgeführt wird, je nach ConcurrencyMode.

Parallelitätsmodus-Wert	Kann eine neue Operation aufgerufen werden?
Single	Nie
Eintrittsinvariante	Nur, wenn ein anderer Dienst oder ein Rückruf aufgerufen wird
Mehrere	Immer