Partager via

Contrat de message par défaut

L’exemple Contrat de message par défaut illustre un service dans lequel un message personnalisé défini par l’utilisateur est transmis aux opérations de service et à partir des opérations de service. Cet échantillon est basé sur Prise en main qui implémente une interface de calculatrice sous la forme d’un service typé. Au lieu des opérations de service individuelles pour l’ajout, la soustraction, la multiplication et la division utilisés dans la mise en route, cet exemple transmet un message personnalisé qui contient les opérandes et l’opérateur, et retourne le résultat du calcul arithmétique.

Le client est un programme de console (.exe) et la bibliothèque de services (.dll) est hébergée par Internet Information Services (IIS). L’activité du client est visible dans la fenêtre de console.

Remarque

La procédure d’installation et les instructions de génération de cet exemple se trouvent à la fin de cette rubrique.

Dans le service, une seule opération de service est définie qui accepte et retourne des messages personnalisés de type MyMessage. Bien que dans cet exemple, les messages de demande et de réponse soient du même type, ils peuvent bien sûr être différents contrats de message si nécessaire.

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

Le message personnalisé MyMessage est défini dans une classe annotée avec les attributs MessageContractAttribute, MessageHeaderAttribute et MessageBodyMemberAttribute. Seul le troisième constructeur est utilisé dans cet exemple. L’utilisation de contrats de message vous permet d’exercer un contrôle total sur le message SOAP. Dans cet exemple, l’attribut MessageHeaderAttribute est utilisé pour placer Operation dans un en-tête SOAP. Les opérandes N1, N2 et le Result apparaissent dans le corps SOAP parce qu'ils ont l'attribut MessageBodyMemberAttribute appliqué.

[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 d’implémentation contient le code de l’opération de Calculate service. La CalculateService classe obtient les opérandes et l’opérateur du message de requête et crée un message de réponse qui contient le résultat du calcul demandé, comme indiqué dans l’exemple de code suivant.

// 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;
    }
}

Le code client généré pour le client a été créé avec l’outil Utilitaire de métadonnées ServiceModel (Svcutil.exe). L’outil crée automatiquement des types de contrats de message dans le code client généré si nécessaire. L’option /messageContract de commande peut être spécifiée pour forcer la génération de contrats de message.

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

L'exemple de code suivant présente le client utilisant le message 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);

Lorsque vous exécutez l’exemple, les calculs sont affichés dans la fenêtre de console cliente. Appuyez sur Entrée dans la fenêtre du client pour arrêter le 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.

À ce stade, les messages personnalisés définis par l’utilisateur sont passés entre le client et l’opération de service. Le contrat de message a défini que les opérandes et les résultats étaient dans le corps du message et que l’opérateur était dans un en-tête de message. La journalisation des messages peut être configurée pour observer cette structure de messages.

Pour configurer, générer et exécuter l’exemple

  1. Assurez-vous d’avoir effectué la Procédure d’installation unique pour les exemples Windows Communication Foundation.

  2. Pour générer l’édition C# ou Visual Basic .NET de la solution, conformez-vous aux instructions figurant dans Building the Windows Communication Foundation Samples.

  3. Pour exécuter l’exemple dans une configuration à un ou plusieurs ordinateurs, conformez-vous aux instructions figurant dans la rubrique Exécution des exemples Windows Communication Foundation.

  • Last updated on