ServiceContractAttribute.SessionMode ServiceContractAttribute.SessionMode ServiceContractAttribute.SessionMode ServiceContractAttribute.SessionMode Property

Définition

Obtient ou définit si les sessions sont autorisées, ne sont pas autorisées ou sont requises.Gets or sets whether sessions are allowed, not allowed or required.

public:
 property System::ServiceModel::SessionMode SessionMode { System::ServiceModel::SessionMode get(); void set(System::ServiceModel::SessionMode value); };
public System.ServiceModel.SessionMode SessionMode { get; set; }
member this.SessionMode : System.ServiceModel.SessionMode with get, set
Public Property SessionMode As SessionMode

Valeur de propriété

SessionMode qui indique si les sessions sont autorisées, non autorisées ou requises.A SessionMode that indicates whether sessions are allowed, not allowed, or required.

Exceptions

Exemples

Le contrat de service suivant requiert que les liaisons configurées utilisent des sessions lors de l’interaction avec les implémentations de service SampleDuplexHello.The following service contract requires that configured bindings use sessions when interacting with SampleDuplexHello service implementations.

using System;
using System.Collections.Generic;
using System.ServiceModel;
using System.Threading;

namespace Microsoft.WCF.Documentation
{
  [ServiceContract(
    Name = "SampleDuplexHello",
    Namespace = "http://microsoft.wcf.documentation",
    CallbackContract = typeof(IHelloCallbackContract),
    SessionMode = SessionMode.Required
  )]
  public interface IDuplexHello
  {
    [OperationContract(IsOneWay = true)]
    void Hello(string greeting);
  }

  public interface IHelloCallbackContract
  {
    [OperationContract(IsOneWay = true)]
    void Reply(string responseToGreeting);
  }

  [ServiceBehaviorAttribute(InstanceContextMode=InstanceContextMode.PerSession)]
  public class DuplexHello : IDuplexHello
  {

    public DuplexHello()
    {
      Console.WriteLine("Service object created: " + this.GetHashCode().ToString());
    }

    ~DuplexHello()
    {
      Console.WriteLine("Service object destroyed: " + this.GetHashCode().ToString());
    }

    public void Hello(string greeting)
    {
      Console.WriteLine("Caller sent: " + greeting);
      Console.WriteLine("Session ID: " + OperationContext.Current.SessionId);
      Console.WriteLine("Waiting two seconds before returning call.");
      // Put a slight delay to demonstrate asynchronous behavior on client.
      Thread.Sleep(2000);
      IHelloCallbackContract callerProxy
        = OperationContext.Current.GetCallbackChannel<IHelloCallbackContract>();
      string response = "Service object " + this.GetHashCode().ToString() + " received: " + greeting;
      Console.WriteLine("Sending back: " + response);
      callerProxy.Reply(response);
    }
  }
}


Imports System
Imports System.Collections.Generic
Imports System.ServiceModel
Imports System.Threading

Namespace Microsoft.WCF.Documentation
    <ServiceContract(Name:="SampleDuplexHello", Namespace:="http://microsoft.wcf.documentation", _
                     CallbackContract:=GetType(IHelloCallbackContract), SessionMode:=SessionMode.Required)> _
    Public Interface IDuplexHello
        <OperationContract(IsOneWay:=True)> _
        Sub Hello(ByVal greeting As String)
    End Interface

  Public Interface IHelloCallbackContract
	<OperationContract(IsOneWay := True)> _
	Sub Reply(ByVal responseToGreeting As String)
  End Interface

  <ServiceBehaviorAttribute(InstanceContextMode:=InstanceContextMode.PerSession)> _
  Public Class DuplexHello
	  Implements IDuplexHello

	Public Sub New()
	  Console.WriteLine("Service object created: " & Me.GetHashCode().ToString())
	End Sub

	Protected Overrides Sub Finalize()
	  Console.WriteLine("Service object destroyed: " & Me.GetHashCode().ToString())
	End Sub

	Public Sub Hello(ByVal greeting As String) Implements IDuplexHello.Hello
	  Console.WriteLine("Caller sent: " & greeting)
	  Console.WriteLine("Session ID: " & OperationContext.Current.SessionId)
	  Console.WriteLine("Waiting two seconds before returning call.")
	  ' Put a slight delay to demonstrate asynchronous behavior on client.
	  Thread.Sleep(2000)
	  Dim callerProxy As IHelloCallbackContract = OperationContext.Current.GetCallbackChannel(Of IHelloCallbackContract)()
            Dim response = "Service object " & Me.GetHashCode().ToString() & " received: " & greeting
	  Console.WriteLine("Sending back: " & response)
	  callerProxy.Reply(response)
	End Sub
  End Class
End Namespace

Remarques

Utilisez la propriété SessionMode pour requérir des liaisons qui prennent en charge des sessions entre des points de terminaison.Use the SessionMode property to require bindings that support sessions between endpoints. Une session est une façon de faire correspondre un ensemble de messages échangés entre deux points de terminaison ou plus.A session is a way of correlating a set of messages exchanged between two or more endpoints. Si votre service prend en charge les sessions de canal, vous pouvez donc utiliser la propriété InstanceContextMode pour spécifier la relation entre les instances de votre implémentation de contrat de service et la session de canal.If your service supports channel sessions, you can then use the InstanceContextMode property to specify the relationship between instances your service contract implementation and the channel session. Si une liaison ne prend pas en charge les sessions, une exception est levée.If a binding does not support sessions, an exception is thrown.

Par exemple, si la propriété SessionMode a la valeur SessionMode.Required et la propriété InstanceContextMode a la valeur PerSession, les clients peuvent utiliser la même connexion pour faire des appels répétés au même objet du service.For example, if the SessionMode property is set to SessionMode.Required and the InstanceContextMode property is set to PerSession, clients can use the same connection to make repeated calls to the same service object.

Pour plus d’informations sur les sessions et instances de service, consultez à l’aide de Sessions et Sessions, Instancing et la concurrence.For more information about sessions and service instances, see Using Sessions and Sessions, Instancing, and Concurrency.

Notes

Un canal qui prend en charge les sessions prend en charge l'association par défaut d'une instance de service avec une session particulière.A channel that supports sessions supports the default association of a service instance with a particular session. Toutefois, différentes implémentations de session prennent en charge des fonctionnalités différentes en plus des contrôles d’instance basés sur une session.However, different session implementations support different features in addition to session-based instancing control. WCF fournit quatre types de sessions que vous pouvez utiliser pour fournir un comportement de l’application de session ; chaque type de session fournit le comportement supplémentaire spécifique au type de session.WCF provides four types of sessions that you can use to provide sessionful application behavior; each type of session provides additional behavior specific to the type of session it is.

  1. System.ServiceModel.Channels.SecurityBindingElement prend en charge des sessions de sécurité dans lesquelles les deux extrémités de communication ont convenu d'un chiffrement et/ou d'un processus de signature numérique ; tous les messages sont mis en corrélation avec cette conversation sécurisée spécifique.The System.ServiceModel.Channels.SecurityBindingElement supports security sessions, in which both ends of communication have agreed upon an encryption and/or digital signature process; all messages are correlated with that specific secure conversation. Pour plus d’informations, consultez sécurisation des Services.For more information, see Securing Services. Par exemple, System.ServiceModel.WSHttpBinding qui contient la prise en charge des sessions de sécurité et des sessions fiables utilise par défaut uniquement une session sécurisée qui chiffre et signe numériquement les messages.For example, the System.ServiceModel.WSHttpBinding, which contains support for both security sessions and reliable sessions, by default uses only a secure session which encrypts and digitally signs messages.

  2. System.ServiceModel.NetTcpBinding prend en charge les sessions exposées par les connexions TCP/IP pour garantir que tous les messages sont corrélés par la session de connexion au niveau du socket.The System.ServiceModel.NetTcpBinding supports the sessions exposed by the TCP/IP connections to ensure that all messages are correlated by the connection session at the socket level.

  3. System.ServiceModel.Channels.ReliableSessionBindingElement qui implémente la spécification WS-ReliableMessaging fournit la prise en charge des sessions fiables dans lesquelles les messages sont remis en ordre et exactement une fois, ce qui permet d'être confiant même lorsque les messages passent par plusieurs nœuds pendant la conversation.The System.ServiceModel.Channels.ReliableSessionBindingElement, which implements the WS-ReliableMessaging specification, provides support for reliable sessions in which messages are delivered in order and exactly once, enabling confidence even when messages travel across multiple nodes during the conversation. Pour plus d’informations, consultez Sessions fiables.For more information, see Reliable Sessions.

  4. System.ServiceModel.NetMsmqBinding fournit des sessions de datagramme MSMQ.The System.ServiceModel.NetMsmqBinding provides MSMQ datagram sessions. Pour plus d’informations, consultez files d’attente dans WCF.For more information, see Queues in WCF.

Souvenez-vous que la définition de la propriété SessionMode ne spécifie pas le type de session que le contrat requiert mais uniquement qu'il requiert un type de session.Remember that setting the SessionMode property does not specify the type of session the contract requires, only that it requires one.

S’applique à