IBindingRuntimePreferences Interface

Définition

Espace de noms:

System.ServiceModel.Channels

Assembly:

System.ServiceModel.Primitives.dll

Paquet:

System.ServiceModel.Primitives v6.2.0

Source:

IBindingRuntimePreferences.cs

Définit le contrat facultatif qu'une liaison peut implémenter pour spécifier si les demandes entrantes sont gérées de façon synchrone ou de façon asynchrone par le service.

public interface class IBindingRuntimePreferences

public interface IBindingRuntimePreferences

type IBindingRuntimePreferences = interface

Public Interface IBindingRuntimePreferences

Dérivé

System.ServiceModel.MsmqBindingBase

System.ServiceModel.NetPeerTcpBinding

System.ServiceModel.UdpBinding

System.ServiceModel.WebHttpBinding

System.ServiceModel.WSDualHttpBinding

Exemples

L’exemple suivant présente l’implémentation d’une liaison qui implémente l’interface IBindingRuntimePreferences. Ce code est extrait de l’exemple De canal de segmentation :

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
}

Remarques

Dans certains cas, il peut être plus efficace pour une liaison de traiter des messages avec les méthodes synchrones Receive ou Request. Une classe Binding peut implémenter de façon facultative IBindingRuntimePreferences pour indiquer aux appelants que cela est préférable.

Si une liaison n’implémente IBindingRuntimePreferencespas , la couche Windows Communication Foundation (WCF) Service Model Runtime utilise par défaut les versions asynchrones des Receive méthodes et Request . Si une liaison implémente IBindingRuntimePreferences, la couche Wcf Service Model Runtime vérifie la valeur de ReceiveSynchronously et l’utilise pour déterminer s’il faut appeler les versions synchrones de ces méthodes (Receive ou Request) ou les versions asynchrones (BeginReceive et EndReceive(IAsyncResult) ou BeginRequest et EndRequest(IAsyncResult)). Si IBindingRuntimePreferences est implémentée par la liaison et retourne true de la propriété ReceiveSynchronously, il est recommandé d’utiliser les méthodes synchrones Receive et Request pour recevoir les messages du canal. Si la liaison n'implémente pas IBindingRuntimePreferences ou retourne false de la propriété ReceiveSynchronously, il est recommandé d'utiliser les méthodes asynchrones BeginReceive et EndReceive(IAsyncResult) ou BeginRequest et EndRequest(IAsyncResult).

Quelle que soit la valeur retournée par la propriété ReceiveSynchronously, toutes les liaisons doivent toujours fournir des implémentations valides des versions synchrones et asynchrones des méthodes Receive pour les types de canaux spécifiques implémentés. Pour plus d’informations sur l’implémentation de canaux personnalisés, consultez Développement de canaux.

Propriétés

ReceiveSynchronously

Obtient une valeur qui indique si les demandes entrantes peuvent être gérées plus efficacement de manière synchrone ou asynchrone.