Megosztás a következőn keresztül:

Útmutató: Kétoldalas szerződés létrehozása

  • Cikk

Ez a témakör a kétirányú (kétirányú) szerződést használó metódusok létrehozásának alapvető lépéseit mutatja be. A kétoldalas szerződések lehetővé teszik, hogy az ügyfelek és a kiszolgálók egymástól függetlenül kommunikáljanak egymással, hogy vagy kezdeményezhessenek hívásokat a másik felé. A kétoldalas szerződés a Windows Communication Foundation (WCF) szolgáltatásai számára elérhető három üzenetminta egyike. A másik két üzenetminta egyirányú és a kérés-válasz. A kétirányú szerződések két egyirányú szerződésből állnak az ügyfél és a kiszolgáló között, és nem igénylik a metódushívások korrelációját. Ezt a szerződést akkor használja, ha a szolgáltatásnak le kell kérdeznie az ügyfelet további információkért, vagy explicit módon eseményeket kell létrehoznia az ügyfélen. További információ a kétoldalas szerződésekhez készült ügyfélalkalmazások létrehozásáról: How to: Access Services with a Duplex Contract. Működő minta esetén tekintse meg a Kétoldalas mintát.

Kétoldalas szerződés létrehozása

  1. Hozza létre a kétoldalas szerződés kiszolgálóoldalát alkotó felületet.

  2. Alkalmazza az osztályt ServiceContractAttribute a felületre.

    [ServiceContract(Namespace = "http://Microsoft.ServiceModel.Samples", SessionMode=SessionMode.Required,
                 CallbackContract=typeof(ICalculatorDuplexCallback))]
public interface ICalculatorDuplex
{
    [OperationContract(IsOneWay=true)]
    void Clear();
    [OperationContract(IsOneWay = true)]
    void AddTo(double n);
    [OperationContract(IsOneWay = true)]
    void SubtractFrom(double n);
    [OperationContract(IsOneWay = true)]
    void MultiplyBy(double n);
    [OperationContract(IsOneWay = true)]
    void DivideBy(double n);
}

    <ServiceContract(Namespace:="http://Microsoft.ServiceModel.Samples", SessionMode:=SessionMode.Required, _
                CallbackContract:=GetType(ICalculatorDuplexCallback))> _
Public Interface ICalculatorDuplex

    <OperationContract(IsOneWay:=True)> _
    Sub Clear()
    <OperationContract(IsOneWay:=True)> _
    Sub AddTo(ByVal n As Double)
    <OperationContract(IsOneWay:=True)> _
    Sub SubtractFrom(ByVal n As Double)
    <OperationContract(IsOneWay:=True)> _
    Sub MultiplyBy(ByVal n As Double)
    <OperationContract(IsOneWay:=True)> _
    Sub DivideBy(ByVal n As Double)
End Interface

  3. Deklarálja a metódus-aláírásokat a felületen.

  4. Alkalmazza az osztályt minden OperationContractAttribute olyan metódus-aláírásra, amelyeknek a közbeszerzési szerződés részét kell képezniük.

  5. Hozza létre a visszahívási felületet, amely meghatározza, hogy a szolgáltatás milyen műveleteket hívhat meg az ügyfélen.

    public interface ICalculatorDuplexCallback
{
    [OperationContract(IsOneWay = true)]
    void Equals(double result);
    [OperationContract(IsOneWay = true)]
    void Equation(string eqn);
}

    Public Interface ICalculatorDuplexCallback
    <OperationContract(IsOneWay:=True)> _
    Sub Equals(ByVal result As Double)
    <OperationContract(IsOneWay:=True)> _
    Sub Equation(ByVal eqn As String)
end interface

  6. Deklarálja a metódus-aláírásokat a visszahívási felületen.

  7. Alkalmazza az osztályt minden OperationContractAttribute olyan metódus-aláírásra, amelyeknek a közbeszerzési szerződés részét kell képezniük.

  8. Kapcsolja össze a két adaptert kétoldalas szerződéssel úgy, hogy az CallbackContract elsődleges felületen lévő tulajdonságot a visszahívási felület típusához állítja.

Metódusok meghívása az ügyfélen

  1. A szolgáltatás elsődleges szerződésének megvalósítása során deklaráljon egy változót a visszahívási felülethez.

  2. Állítsa a változót az osztály metódusa által GetCallbackChannel visszaadott objektumhivatkozásra OperationContext .

    ICalculatorDuplexCallback callback = null;

    Dim callback As ICalculatorDuplexCallback

    callback = OperationContext.Current.GetCallbackChannel<ICalculatorDuplexCallback>();

    callback = OperationContext.Current.GetCallbackChannel(Of ICalculatorDuplexCallback)()

  3. Hívja meg a visszahívási felület által definiált metódusokat.

Példa

Az alábbi példakód kétoldalas kommunikációt mutat be. A szolgáltatás szerződése az előre- és hátralépéshez szükséges szolgáltatásműveleteket tartalmazza. Az ügyfél szerződése egy szolgáltatási műveletet tartalmaz a pozíciójának jelentéséhez.

// Define a duplex service contract.
// A duplex contract consists of two interfaces.
// The primary interface is used to send messages from client to service.
// The callback interface is used to send messages from service back to client.
// ICalculatorDuplex allows one to perform multiple operations on a running result.
// The result is sent back after each operation on the ICalculatorCallback interface.
[ServiceContract(Namespace = "http://Microsoft.ServiceModel.Samples", SessionMode=SessionMode.Required,
                 CallbackContract=typeof(ICalculatorDuplexCallback))]
public interface ICalculatorDuplex
{
    [OperationContract(IsOneWay=true)]
    void Clear();
    [OperationContract(IsOneWay = true)]
    void AddTo(double n);
    [OperationContract(IsOneWay = true)]
    void SubtractFrom(double n);
    [OperationContract(IsOneWay = true)]
    void MultiplyBy(double n);
    [OperationContract(IsOneWay = true)]
    void DivideBy(double n);
}
// The callback interface is used to send messages from service back to client.
// The Equals operation will return the current result after each operation.
// The Equation operation will return the complete equation after Clear() is called.
public interface ICalculatorDuplexCallback
{
    [OperationContract(IsOneWay = true)]
    void Equals(double result);
    [OperationContract(IsOneWay = true)]
    void Equation(string eqn);
}
// Service class which implements a duplex service contract.
// Use an InstanceContextMode of PerSession to store the result
// An instance of the service will be bound to each duplex session
[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession)]
public class CalculatorService : ICalculatorDuplex
{
    double result;
    string equation;
    ICalculatorDuplexCallback callback = null;

    public CalculatorService()
    {
        result = 0.0D;
        equation = result.ToString();
        callback = OperationContext.Current.GetCallbackChannel<ICalculatorDuplexCallback>();
    }

    public void Clear()
    {
        callback.Equation(equation + " = " + result.ToString());
        result = 0.0D;
        equation = result.ToString();
    }

    public void AddTo(double n)
    {
        result += n;
        equation += " + " + n.ToString();
        callback.Equals(result);
    }

    public void SubtractFrom(double n)
    {
        result -= n;
        equation += " - " + n.ToString();
        callback.Equals(result);
    }

    public void MultiplyBy(double n)
    {
        result *= n;
        equation += " * " + n.ToString();
        callback.Equals(result);
    }

    public void DivideBy(double n)
    {
        result /= n;
        equation += " / " + n.ToString();
        callback.Equals(result);
    }
}

' Define a duplex service contract.
' A duplex contract consists of two interfaces.
' The primary interface is used to send messages from client to service.
' The callback interface is used to send messages from service back to client.
' ICalculatorDuplex allows one to perform multiple operations on a running result.
' The result is sent back after each operation on the ICalculatorCallback interface.
<ServiceContract(Namespace:="http://Microsoft.ServiceModel.Samples", SessionMode:=SessionMode.Required, _
                CallbackContract:=GetType(ICalculatorDuplexCallback))> _
Public Interface ICalculatorDuplex

    <OperationContract(IsOneWay:=True)> _
    Sub Clear()
    <OperationContract(IsOneWay:=True)> _
    Sub AddTo(ByVal n As Double)
    <OperationContract(IsOneWay:=True)> _
    Sub SubtractFrom(ByVal n As Double)
    <OperationContract(IsOneWay:=True)> _
    Sub MultiplyBy(ByVal n As Double)
    <OperationContract(IsOneWay:=True)> _
    Sub DivideBy(ByVal n As Double)
End Interface

' The callback interface is used to send messages from service back to client.
' The Equals operation will return the current result after each operation.
' The Equation operation will return the complete equation after Clear() is called.
Public Interface ICalculatorDuplexCallback
    <OperationContract(IsOneWay:=True)> _
    Sub Equals(ByVal result As Double)
    <OperationContract(IsOneWay:=True)> _
    Sub Equation(ByVal eqn As String)
end interface

' Service class which implements a duplex service contract.
' Use an InstanceContextMode of PerSession to store the result
' An instance of the service will be bound to each duplex session
<ServiceBehavior(InstanceContextMode:=InstanceContextMode.PerSession)> _
Public Class CalculatorService
    Implements ICalculatorDuplex
    Dim result As Double
    Dim equation As String
    Dim callback As ICalculatorDuplexCallback

    Public Sub New()
        result = 0D
        equation = result.ToString()
        callback = OperationContext.Current.GetCallbackChannel(Of ICalculatorDuplexCallback)()

    End Sub
    Public Sub AddTo(ByVal n As Double) Implements ICalculatorDuplex.AddTo
        result += n
        equation += " + " + n.ToString()
        callback.Equals(result)
    End Sub

    Public Sub Clear() Implements ICalculatorDuplex.Clear
        callback.Equation(equation + " = " + result.ToString())
        result = 0D
        equation = result.ToString()
    End Sub

    Public Sub DivideBy(ByVal n As Double) Implements ICalculatorDuplex.DivideBy
        result /= n
        equation += " / " + n.ToString()
        callback.Equals(result)
    End Sub

    Public Sub MultiplyBy(ByVal n As Double) Implements ICalculatorDuplex.MultiplyBy
        result *= n
        equation += " * " + n.ToString()
        callback.Equals(result)
    End Sub

    Public Sub SubtractFrom(ByVal n As Double) Implements ICalculatorDuplex.SubtractFrom
        result -= n
        equation += " - " + n.ToString()
        callback.Equals(result)
    End Sub
End Class

  • Az és OperationContractAttribute az ServiceContractAttribute attribútumok alkalmazása lehetővé teszi a szolgáltatásszerződés-definíciók automatikus létrehozását a webszolgáltatások leírási nyelvén (WSDL).

  • A ServiceModel metadata segédprogrammal (Svcutil.exe) lekérheti az ügyfél WSDL-dokumentumát és (nem kötelező) kódját és konfigurációját.

  • A kétoldalas szolgáltatásokat felfedő végpontokat védeni kell. Amikor egy szolgáltatás kétoldalas üzenetet kap, a bejövő üzenet válaszát tekinti át, hogy meghatározza, hol küldje el a választ. Ha a csatorna nincs biztosítva, akkor egy nem megbízható ügyfél rosszindulatú üzenetet küldhet a célgép Válaszüzenetével, ami a célgép szolgáltatásmegtagadásához vezethet. Normál válaszüzenetek esetén ez nem jelent problémát, mert a válaszüzenet figyelmen kívül lesz hagyva, és a válasz azon a csatornán lesz elküldve, amelyen az eredeti üzenet érkezett.

Lásd még