ServiceBehaviorAttribute.ConcurrencyMode Vlastnost

Definice

Obor názvů:

System.ServiceModel

Sestavení:

System.ServiceModel.dll

Získá nebo nastaví, zda služba podporuje jedno vlákno, více vláken nebo znovu zadat volání.

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

Hodnota vlastnosti

ConcurrencyMode

Jedna z ConcurrencyMode hodnot; výchozí hodnota je Single.

Výjimky

ArgumentOutOfRangeException

Hodnota není jednou z ConcurrencyMode hodnot.

Příklady

Následující příklad kódu ukazuje rozdíl mezi using Single, Reentranta Multiple. Tato ukázka se nezkompiluje bez skutečné implementace, ale předvádí druh threadingu záruky, že Windows Communication Foundation (WCF) dělá a co znamená pro váš provozní kód.

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

Poznámky

Tato vlastnost označuje, zda instance služby může zpracovávat jedno vlákno nebo více vláken, která se spouští souběžně, a pokud je podporována jednovláknová architektura, zda je podporována opětovná podpora.

Poznámka:

Vlastnost ConcurrencyMode komunikuje s některými dalšími nastaveními. Pokud InstanceContextMode je například hodnota nastavena na Single výsledek je, že vaše služba může zpracovat pouze jednu zprávu najednou, pokud hodnotu nenastavíte ConcurrencyMode na Multiplehodnotu . Tato vlastnost také vytváří chování v kombinaci s ServiceContractAttribute.SessionMode vlastností. Podrobnosti najdete v tématu Relace, Vytváření instancí a Souběžnost.

Nastavení ConcurrencyMode , které Single dává systému pokyn, aby omezil instance služby na jedno vlákno spuštění najednou, což vám umožní řešit problémy s vlákny. Hodnota Multiple znamená, že objekty služby lze spustit několika vlákny najednou. V tomto případě je nutné zajistit bezpečnost vláken.

Reentrant zároveň omezuje přístup k jednomu vláknu; během zpracování operace nemůže operaci zadat žádná jiná zpráva. Pokud během operace volání jiné služby odejde, aktuální zpráva ztratí zámek operace, což je zdarma ke zpracování dalších zpráv. Při volání služby se zámek znovu obnoví a původní zpráva může pokračovat ve zpracování na závěr nebo dokud nedojde k jinému volání operace.

Důležité

I když Single instance služby omezuje na jedno vlákno provádění najednou, musíte také nastavit MaxConcurrentCalls hodnotu 1, aby se neručily žádné zprávy mimo pořadí.

Je také vaší zodpovědností ponechat stav objektu konzistentní před popisky a musíte potvrdit, že místní data operace jsou po bublinových popiscích platná. Všimněte si, že instance služby je odemknutá pouze voláním jiné služby přes kanál WCF. V tomto případě může volaná služba znovu zadat první službu prostřednictvím zpětného volání. Pokud první služba není znovu zaváděná, výsledkem posloupnosti volání je zablokování. Podrobnosti najdete v ConcurrencyMode.

Během jakéhokoli odchozího volání z operace zpracování je možné upravit data, která nejsou místní pro operaci. (Při obnovení původní zprávy je zaručeno, že data místního stavu budou platná.) V důsledku toho musíte před odchozím voláním zajistit, aby jiná než místní data byla platná pro ostatní příchozí hovory a po návratu odchozího volání znovu obnovte jiná než místní data.

Následující pseudokód znázorňuje požadovaný vzor pro úspěšnou podporu opakování.

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

Použití vzoru asynchronního volání Begin/End pro odchozí volání při aktivaci ConcurrencyModeReentrant výjimky Asynchronní odchozí volání vyžadují operaci, ve které ConcurrencyMode je Multiplev takovém případě nutné zpracovat problémy se synchronizací.

Obecně platí, že pokud zpráva dorazí pro instanci, která porušuje režim souběžnosti, zpráva počká, dokud instance nebude dostupná, nebo dokud nevystane časový limit.

Kromě toho, pokud je nastavena ConcurrencyModeSingle a reentrant volání je blokován při čekání na uvolnění instance, systém zjistí zablokování a vyvolá výjimku.

Poznámka:

Při spuštění je vyvolán při InvalidOperationException spuštění, pokud ReleaseServiceInstanceOnTransactionComplete je trueConcurrencyMode vlastnost nastavena na Single.

Všimněte si, že je nutné explicitně nastavit ReleaseServiceInstanceOnTransactionCompletefalse , zda je operace s OperationBehaviorAttribute.TransactionScopeRequired nastavenou na hodnotu true a je nastavena ConcurrencyMode na Reentranthodnotu . V opačném případě je vyvolán výjimka ověření, protože výchozí hodnota ReleaseServiceInstanceOnTransactionComplete je true.

Existuje interakce s dalšími ConcurrencyMode vlastnostmi, které mohou změnit chování modulu runtime. Úplný popis těchto interakcí najdete v tématu Relace, Vytváření instancí a Souběžnost.