Condividi tramite

Contratto di messaggio predefinito

L'esempio di Contratto di Messaggio Predefinito illustra un servizio in cui un messaggio personalizzato definito dall'utente viene passato alle operazioni del servizio e da queste restituito. Questo esempio si basa su Getting Started che implementa un'interfaccia calcolatrice come servizio tipizzato. Anziché le singole operazioni di servizio per addizione, sottrazione, moltiplicazione e divisione usate nel Getting Started, questo esempio passa un messaggio personalizzato che contiene sia gli operandi che l'operatore e restituisce il risultato del calcolo aritmetico.

Il client è un programma console (.exe) e la libreria di servizi (.dll) è ospitata da Internet Information Services (IIS). L'attività del client è visibile nella finestra della console.

Annotazioni

La procedura di installazione e le istruzioni di compilazione per questo esempio si trovano alla fine di questo argomento.

Nel servizio viene definita una singola operazione del servizio che accetta e restituisce messaggi personalizzati di tipo MyMessage. Anche se in questo esempio i messaggi di richiesta e risposta sono dello stesso tipo, possono naturalmente essere contratti di messaggio diversi, se necessario.

[ServiceContract(Namespace="http://Microsoft.ServiceModel.Samples")]
public interface ICalculator
{
    [OperationContract(Action="http://test/MyMessage_action",
                  ReplyAction="http://test/MyMessage_action")]
    MyMessage Calculate(MyMessage request);
}

Il messaggio personalizzato MyMessage è definito in una classe annotata con gli attributi MessageContractAttribute, MessageHeaderAttribute e MessageBodyMemberAttribute. In questo esempio viene usato solo il terzo costruttore. L'uso dei contratti di messaggio consente di esercitare il controllo completo sul messaggio SOAP. In questo esempio l'attributo MessageHeaderAttribute viene usato per inserire Operation in un'intestazione SOAP. Gli operandi N1N2 e Result vengono visualizzati all'interno del corpo SOAP perché hanno l'attributo MessageBodyMemberAttribute applicato.

[MessageContract]
public class MyMessage
{
    private string operation;
    private double n1;
    private double n2;
    private double result;

    //Constructor - create an empty message.

    public MyMessage() {}

    //Constructor - create a message and populate its members.

    public MyMessage(double n1, double n2, string operation,
                     double result)
    {
        this.n1 = n1;
        this.n2 = n2;
        this.operation = operation;
        this.result = result;
    }

    //Constructor - create a message from another message.

    public MyMessage(MyMessage message)
    {
        this.n1 = message.n1;
        this.n2 = message.n2;
        this.operation = message.operation;
        this.result = message.result;
    }

    [MessageHeader]
    public string Operation
    {
        get { return operation; }
        set { operation = value; }
    }

    [MessageBodyMember]
    public double N1
    {
        get { return n1; }
        set { n1 = value; }
    }

    [MessageBodyMember]
    public double N2
    {
        get { return n2; }
        set { n2 = value; }
    }

    [MessageBodyMember]
    public double Result
    {
        get { return result; }
        set { result = value; }
    }
}

La classe di implementazione contiene il codice per l'operazione del Calculate servizio. La CalculateService classe ottiene gli operandi e l'operatore dal messaggio di richiesta e crea un messaggio di risposta che contiene il risultato del calcolo richiesto, come illustrato nel codice di esempio seguente.

// Service class which implements the service contract.
public class CalculatorService : ICalculator
{
    // Perform a calculation.

    public MyMessage Calculate(MyMessage request)
    {
        MyMessage response = new MyMessage(request);
        switch (request.Operation)
        {
            case "+":
                response.Result = request.N1 + request.N2;
                break;
            case "-":
                response.Result = request.N1 - request.N2;
                break;
            case "*":
                response.Result = request.N1 * request.N2;
                break;
            case "/":
                response.Result = request.N1 / request.N2;
                break;
            default:
                response.Result = 0.0D;
                break;
        }
        return response;
    }
}

Il codice client generato per il client è stato creato con lo strumento Utilità metadati ServiceModel (Svcutil.exe). Lo strumento crea automaticamente i tipi di contratto messaggio nel codice client generato, se necessario. È possibile specificare l'opzione /messageContract di comando per forzare la generazione di contratti di messaggio.

svcutil.exe /n:"http://Microsoft.ServiceModel.Samples,Microsoft.ServiceModel.Samples" /o:client\generatedClient.cs http://localhost/servicemodelsamples/service.svc/mex

Il codice di esempio seguente illustra il client che usa il messaggio MyMessage.

// Create a client with given client endpoint configuration
CalculatorClient client = new CalculatorClient();

// Perform addition using a typed message.

MyMessage request = new MyMessage()
                    {
                        N1 = 100D,
                        N2 = 15.99D,
                        Operation = "+"
                    };
MyMessage response = ((ICalculator)client).Calculate(request);
Console.WriteLine("Add({0},{1}) = {2}", request.N1, request.N2, response.Result);

Quando si esegue l'esempio, i calcoli vengono visualizzati nella finestra della console client. Premere INVIO nella finestra del client per chiudere il client.

Add(100,15.99) = 115.99
Subtract(145,76.54) = 68.46
Multiply(9,81.25) = 731.25
Divide(22,7) = 3.14285714285714

Press <ENTER> to terminate client.

A questo punto, i messaggi personalizzati definiti dall'utente sono stati scambiati tra il client e il servizio operativo. Il contratto di messaggio ha definito che gli operandi e i risultati erano nel corpo del messaggio e che l'operatore si trovava in un'intestazione del messaggio. La registrazione dei messaggi può essere configurata per osservare questa struttura di messaggi.

Per configurare, compilare ed eseguire l'esempio

  1. Assicurati di aver eseguito la procedura di installazione di One-Time per gli esempi di Windows Communication Foundation.

  2. Per compilare l'edizione C# o Visual Basic .NET della soluzione, seguire le istruzioni in Compilazione degli esempi di Windows Communication Foundation.

  3. Per eseguire l'esempio in una configurazione con computer singolo o incrociato, seguire le istruzioni riportate in Esecuzione degli esempi di Windows Communication Foundation.

  • Last updated on