IBindingRuntimePreferences Interfejs

Definicja

Przestrzeń nazw:

System.ServiceModel.Channels

Zestaw:

System.ServiceModel.dll

Definiuje opcjonalny kontrakt, który może implementować powiązanie w celu określenia, czy żądania przychodzące są obsługiwane synchronicznie, czy asynchronicznie przez usługę.

public interface class IBindingRuntimePreferences

public interface IBindingRuntimePreferences

type IBindingRuntimePreferences = interface

Public Interface IBindingRuntimePreferences

Pochodne

System.ServiceModel.HttpBindingBase

System.ServiceModel.MsmqBindingBase

System.ServiceModel.NetNamedPipeBinding

System.ServiceModel.NetPeerTcpBinding

System.ServiceModel.NetTcpBinding

System.ServiceModel.UdpBinding

System.ServiceModel.WebHttpBinding

System.ServiceModel.WSDualHttpBinding

System.ServiceModel.WSHttpBindingBase

Przykłady

W poniższym przykładzie pokazano implementację powiązania, które implementuje IBindingRuntimePreferences interfejs. Ten kod jest pobierany z przykładowego kanału fragmentowania :

public class TcpChunkingBinding : Binding, IBindingRuntimePreferences
{
    TcpTransportBindingElement tcpbe;
    ChunkingBindingElement be;
    public TcpChunkingBinding()
        : base()
    {
        Initialize();
    }
    public TcpChunkingBinding(string name, string ns)
        : base(name, ns)
    {
        Initialize();
    }
    public override BindingElementCollection CreateBindingElements()
    {
        BindingElementCollection col = new BindingElementCollection();
        col.Add(be);
        col.Add(tcpbe);
        return col;
    }

    public override string Scheme
    {
        get { return tcpbe.Scheme;  }
    }
    public int MaxBufferedChunks
    {
        get { return this.be.MaxBufferedChunks; }
        set { this.be.MaxBufferedChunks = value; }
    }

    void Initialize()
    {
         be = new ChunkingBindingElement();
         tcpbe = new TcpTransportBindingElement();
        tcpbe.TransferMode=TransferMode.Buffered; //no transport streaming
        tcpbe.MaxReceivedMessageSize = ChunkingUtils.ChunkSize + 100 * 1024; //add 100KB for headers
         this.SendTimeout = new TimeSpan(0, 5, 0);
         this.ReceiveTimeout = this.SendTimeout;
    }

    #region IBindingRuntimePreferences Members
    public bool ReceiveSynchronously
    {
        get { return true; }
    }
    #endregion
}

Uwagi

W niektórych przypadkach może być bardziej wydajne, aby powiązanie przetwarzało komunikaty za pomocą synchronicznych Receive lub Request metod. Klasa Binding może opcjonalnie zaimplementować IBindingRuntimePreferences element w celu wskazania elementów wywołujących, że jest to preferowane.

Jeśli powiązanie nie implementuje IBindingRuntimePreferenceswarstwy środowiska uruchomieniowego modelu usługi Windows Communication Foundation (WCF) domyślnie używa asynchronicznych wersji Receive metod i Request . Jeśli powiązanie implementuje IBindingRuntimePreferences, warstwa środowiska uruchomieniowego modelu usługi WCF sprawdza wartość ReceiveSynchronously i używa jej w celu określenia, czy wywołać synchroniczne wersje tych metod (Receive lub Request) lub wersje asynchroniczne (BeginReceive i i EndReceive(IAsyncResult)BeginRequestEndRequest(IAsyncResult)). Jeśli IBindingRuntimePreferences jest implementowany przez powiązanie i zwraca true z ReceiveSynchronously właściwości , zaleca się użycie synchronicznych Receive i Request metod do odbierania komunikatów z kanału. Jeśli powiązanie nie implementuje IBindingRuntimePreferences właściwości lub zwraca jej wartość ReceiveSynchronouslyfalse, zaleca się użycie metod asynchronicznych BeginReceive i EndReceive(IAsyncResult) lub BeginRequest i EndRequest(IAsyncResult) .

Niezależnie od wartości zwracanej przez ReceiveSynchronously właściwość wszystkie powiązania muszą nadal zapewniać prawidłowe implementacje zarówno synchronicznych, jak i asynchronicznych wersji Receive metod dla wdrożonych typów kanałów. Aby uzyskać więcej informacji na temat implementowania kanałów niestandardowych, zobacz Tworzenie kanałów.

Właściwości

ReceiveSynchronously

Pobiera wartość wskazującą, czy żądania przychodzące mogą być obsługiwane wydajniej synchronicznie, czy asynchronicznie.