Today, in this article let's see the concept of Message Contract in WCF and we
will try to implement in this session.
Questions Arises: What is Message Contract?
WCF messages that are used to process from one point to other point which
consists of data packet information with header and body. It uses Soap Format
processing. It provides customized way to send the information to requested
client.
Question Arises: What are MessageHeader and MessageBodyMember ?
- Message Header: Describes the header of
envelop to send message across.
- Message Body Member: Describe the data or body of envelop where all things are integrated into message to send across requested clients.
Question Arises: How Message Contract
Differs from Data Contract?
Message Contract is that which describes how the SOAP messages are sent to and
from services with header and bodies in the envelop. If you are more prescribed
about sending message and where by concentrating on layout then I would suggest
you go for message contract. On the other hand, the Data Contracts describes the
data structure with supported data types how the client can consume the WCF
Service. In other words, It is a standardize relationship between service and
client to exchange data.
So, now we all are good to go and implement this concept practically.
The Complete Code of MessageClass.cs looks like this:
using
System;
using
System.Collections.Generic;
using
System.Linq;
using System.Web;
using
System.ServiceModel;
namespace
MessageContractWCF
{
[MessageContract]
public class
MessageClass
{
private string
_typeofOperation;
private double
_firstNumber;
private double
_secondNumber;
private double
_output;
public MessageClass()
{
}
public MessageClass(string
operation, double firstnum,
double secondnum,
double outputresult)
{
this._typeofOperation = operation;
this._firstNumber = firstnum;
this._secondNumber = secondnum;
this._output = outputresult;
}
public MessageClass(MessageClass
simple)
{
this._typeofOperation =
simple._typeofOperation;
this._firstNumber =
simple._firstNumber;
this._secondNumber =
simple._secondNumber;
this._output = simple._output;
}
[MessageHeader]
public string
TypeofOperation
{
get {
return _typeofOperation; }
set { _typeofOperation =
value; }
}
[MessageBodyMember]
public double
FirstNumber
{
get {
return _firstNumber; }
set { _firstNumber =
value; }
}
[MessageBodyMember]
public double
SecondNumber
{
get {
return _secondNumber; }
set { _secondNumber =
value; }
}
[MessageBodyMember]
public double
Output
{
get {
return _output; }
set { _output =
value; }
}
}
}
The Complete Code of IService1.cs looks like this:
using
System;
using
System.Collections.Generic;
using
System.Linq;
using
System.Runtime.Serialization;
using
System.ServiceModel;
using
System.ServiceModel.Web;
using
System.Text;
namespace
MessageContractWCF
{
// NOTE: You can use the "Rename" command on the "Refactor"
menu to change the interface name "IService1" in both code and config file
together.
[ServiceContract]
public interface
IService1
{
[OperationContract] MessageClass Arthimetic(MessageClass data);
}
}
The Complete Code of Service1.svc looks like this:
using
System;
using
System.Collections.Generic;
using
System.Linq;
using
System.Runtime.Serialization;
using
System.ServiceModel;
using
System.ServiceModel.Web;
using
System.Text;
namespace
MessageContractWCF
{
// NOTE: You can use the "Rename" command on the "Refactor"
menu to change the class name "Service1" in code, svc and config file together.
public class
Service1 : IService1
{
public MessageClass
Arthimetic(MessageClass data)
{
var result =
new MessageClass(data);
switch (result.TypeofOperation)
{
case
"+": result.Output = data.FirstNumber + data.SecondNumber;
break;
case "-":
result.Output = data.FirstNumber - data.SecondNumber;
break; case
"*": result.Output = data.FirstNumber *
data.SecondNumber;
break;
case "/":
result.Output = data.FirstNumber / data.SecondNumber;
break;
default: result.Output = 0;
break;
}
return result;
}
}
}
The Complete Code of Web.Config looks like this:
<?xml
version="1.0"?>
<configuration>
<system.web>
<compilation
debug="true"
targetFramework="4.0"
/>
</system.web>
<system.serviceModel>
<behaviors>
<serviceBehaviors>
<behavior>
<!--
To avoid disclosing metadata information, set the value below to false and
remove the metadata endpoint above before deployment
-->
<serviceMetadata
httpGetEnabled="true"/>
<!--
To receive exception details in faults for debugging purposes, set the value
below to true. Set to false before deployment to avoid disclosing exception
information
-->
<serviceDebug
includeExceptionDetailInFaults="false"/>
</behavior>
</serviceBehaviors>
</behaviors>
<serviceHostingEnvironment
multipleSiteBindingsEnabled="true"
/>
</system.serviceModel>
<system.webServer>
<modules
runAllManagedModulesForAllRequests="true"/>
</system.webServer>
</configuration>
The Complete Code of WebForm1.aspx looks like this:
<%@
Page Language="C#"
AutoEventWireup="true"
CodeBehind="WebForm1.aspx.cs"
Inherits="WCFMessage.WebForm1"
%>
vikas kumarPosted Apr 13, 2012, 5:55 AM
Great post,
Arjun PanwarPosted Dec 26, 2011, 12:03 PM
Thanks for sharing
Monika AroraPosted Dec 26, 2011, 3:23 AM
Great what a concept. I will surely implement it.
Manish TewatiaPosted Dec 26, 2011, 1:57 AM
Nice one vijay....it gives a simple yet clearly illustrated example of WCF hosting.....