Nota:
El acceso a esta página requiere autorización. Puede intentar iniciar sesión o cambiar directorios.
El acceso a esta página requiere autorización. Puede intentar cambiar los directorios.
En el ejemplo contrato de mensaje predeterminado se muestra un servicio en el que se pasa un mensaje personalizado definido por el usuario a las operaciones de servicio y desde estas. Este ejemplo se basa en Empezando, que implementa una interfaz de calculadora como un servicio tipado. En lugar de las operaciones de servicio individuales para suma, resta, multiplicación y división utilizadas en Getting Started, este ejemplo envía un mensaje personalizado que incluye tanto los operandos como el operador, y devuelve el resultado del cálculo aritmético.
El cliente es un programa de consola (.exe) y la biblioteca de servicios (.dll) está hospedada por Internet Information Services (IIS). La actividad del cliente está visible en la ventana de la consola.
Nota:
El procedimiento de instalación y las instrucciones de compilación de este ejemplo se encuentran al final de este tema.
En el servicio, se define una operación de servicio única que acepta y devuelve mensajes personalizados de tipo MyMessage. Aunque en este ejemplo, los mensajes de solicitud y respuesta son del mismo tipo, por supuesto podrían ser contratos de mensajes diferentes si es necesario.
[ServiceContract(Namespace="http://Microsoft.ServiceModel.Samples")]
public interface ICalculator
{
[OperationContract(Action="http://test/MyMessage_action",
ReplyAction="http://test/MyMessage_action")]
MyMessage Calculate(MyMessage request);
}
El mensaje MyMessage personalizado se define en una clase anotada con los atributos MessageContractAttribute, MessageHeaderAttribute y MessageBodyMemberAttribute. En este ejemplo solo se usa el tercer constructor. El uso de contratos de mensajes permite ejercer un control total sobre el mensaje SOAP. En este ejemplo, el MessageHeaderAttribute atributo se usa para colocar Operation en un encabezado SOAP. Los operandos N1, N2 y Result aparecen dentro del cuerpo SOAP porque tienen el atributo MessageBodyMemberAttribute aplicado.
[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 clase de implementación contiene el código para la operación de Calculate servicio. La CalculateService clase obtiene los operandos y el operador del mensaje de solicitud y crea un mensaje de respuesta que contiene el resultado del cálculo solicitado, como se muestra en el código de ejemplo siguiente.
// 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;
}
}
El código de cliente generado para el cliente se creó con la herramienta de utilidad de metadatos ServiceModel (Svcutil.exe). La herramienta crea automáticamente tipos de contrato de mensaje en el código de cliente generado si es necesario. Se puede especificar la /messageContract opción de comando para forzar la generación de contratos de mensajes.
svcutil.exe /n:"http://Microsoft.ServiceModel.Samples,Microsoft.ServiceModel.Samples" /o:client\generatedClient.cs http://localhost/servicemodelsamples/service.svc/mex
En el siguiente código de ejemplo se muestra el cliente usando el mensaje 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);
Al ejecutar el ejemplo, los cálculos se muestran en la ventana de la consola del cliente. Presione ENTRAR en la ventana del cliente para apagar el cliente.
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.
En este momento, los mensajes personalizados definidos por el usuario han pasado entre el cliente y la operación de servicio. El contrato de mensaje definió que los operandos y los resultados estaban en el cuerpo del mensaje y que el operador estaba en un encabezado de mensaje. El registro de mensajes se puede configurar para observar esta estructura de mensajes.
Para configurar, compilar y ejecutar el ejemplo
Asegúrese de que ha realizado el procedimiento de instalación única para los ejemplos de Windows Communication Foundation.
Para compilar el código C# o Visual Basic .NET Edition de la solución, siga las instrucciones de Building the Windows Communication Foundation Samples.
Para ejecutar el ejemplo en una configuración de una máquina única o entre máquinas, siga las instrucciones de Ejecución de los ejemplos de Windows Communication Foundation.