ConcurrencyMode Sabit listesi

Tanım

Ad Alanı:

System.ServiceModel

Bütünleştirilmiş Kodlar:

System.ServiceModel.dll, System.ServiceModel.Primitives.dll

Paket:

System.ServiceModel.Primitives v10.0.652802

Kaynak:

ConcurrencyMode.cs

Hizmet sınıfının tek iş parçacıklı veya çok iş parçacıklı işlem modlarını destekleyip desteklemediğini belirtir.

public enum class ConcurrencyMode

public enum ConcurrencyMode

type ConcurrencyMode = 

Public Enum ConcurrencyMode

Devralma

Object

ValueType

Enum

ConcurrencyMode

Alanlar

Name	Değer	Description
Single	0	Hizmet örneği tek iş parçacıklıdır ve yeniden gelen çağrıları kabul etmez. InstanceContextMode özelliği ise Singleve örnek bir çağrıyı sunarken ek iletiler geliyorsa, bu iletilerin hizmet kullanılabilir olana kadar veya iletiler zaman aşımına kadar beklemesi gerekir.
Reentrant	1	Hizmet örneği tek iş parçacıklıdır ve yeniden gelen çağrıları kabul eder. Yeniden giriş hizmeti, başka bir hizmeti çağırdığınızda çağrıları kabul eder; Bu nedenle, açıklama balonlarından önce nesne durumunuzu tutarlı bırakmak sizin sorumluluğunuzdadır ve açıklama balonlarından sonra işlem yerel verilerinin geçerli olduğunu onaylamanız gerekir. Hizmet örneğinin kilidinin yalnızca bir WCF kanalı üzerinden başka bir hizmet çağrılarak açıldığını unutmayın. Bu durumda, çağrılan hizmet bir geri arama yoluyla ilk hizmete yeniden giriş yapabilir. İlk hizmet yeniden giriş yapmadıysa, çağrı dizisi kilitlenmeyle sonuçlanır. Ayrıntılar için bkz. ConcurrencyMode.
Multiple	2	Hizmet örneği çok iş parçacıklı. Eşitleme garantisi sunulmaz. Diğer iş parçacıkları hizmet nesnenizi istediğiniz zaman değiştirebildiğinden, eşitlemeyi ve durum tutarlılığını her zaman işlemeniz gerekir.

Örnekler

Aşağıdaki kod örneği, Tek, Yeniden Giriş ve Çoklu kullanma arasındaki farkı gösterir. Bu örnek, arkasında gerçek bir uygulama olmadan derlenmez, ancak WCF'nin yaptığı iş parçacığı garantilerinin türünü ve bunun işlem kodunuz için ne anlama geldiğini gösterir.

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

Açıklamalar

ConcurrencyMode , bir hizmet sınıfının tek iş parçacıklı veya çok iş parçacıklı işlem modlarını destekleyip desteklemediğini belirtmek için özelliğiyle ConcurrencyMode birlikte kullanılır. Tek iş parçacıklı bir işlem yeniden giriş yapabilir veya yeniden girişsiz olabilir.

Aşağıdaki tabloda, Windows Communication Foundation'ın (WCF) işlemine bağlı olarak başka bir işlem devam ederken çağrılmaya izin vermesi ConcurrencyModegösterilmektedir.

ConcurrencyMode Değeri	Yeni bir işlem çağrılabilir mi?
Single	Hiç.
Evresel	Yalnızca başka bir hizmeti veya bir geri çağırmayı çağırırken.
Multiple	Her zaman.