Service Contract<\/h3>\n
Service contract describes the operations<\/strong>, or methods, that are available on the service endpoint<\/strong>, and exposed to the outside world. A Service contract describes the client-callable operations (functions) exposed by the service, apart from that it also describes. <\/p>\n To create a service contract you define an interface with related methods representative of a collection of service operations, and then decorate the interface\/class with the ServiceContract<\/strong><\/i> Attribute to indicate it is a service contract. Methods in the interface that should be included in the service contract are decorated with the OperationContract<\/strong><\/i> Attribute. <\/p>\n In one line, data contract describes the data to be exchanged<\/strong>. it is formal agreement between service and client, that contains information about the data they will be exchanging<\/strong>. the important point, which needs to be mentioned here is that the two parties don’t have to share the same data types to communicate, they only need the share the same data contracts. Data contract defines which parameter & return type will be serialized\/de-serialized to and from (Binary <==> XML) in order to be transmitted between one party to another. Data contracts can be defined by annotating a class, enumeration, or even a structure, but not an interface.<\/p>\n to define a data contract, you simply decorate a class or enumeration with [DataContract]<\/strong> attribute, as shown below.<\/p>\n [DataContract] WCF uses SOAP message for communication. Most of the time developer concentrates more on developing the DataContract<\/strong>, Serializing the data, etc. Some time developer will also require control over the SOAP message format. In that case WCF provides Message Contract to customize the message as per requirement.<\/p>\n A Message Contract<\/strong> is used to control the structure of a message body and serialization process. It is also used to send \/ access information in SOAP headers. By default WCF takes care of creating SOAP messages according to service DataContracts<\/strong> and OperationContracts<\/strong>. <\/p>\n So when you need full control on SOAP messages structure and how serialization happens specially when your service needs to be interoperable for consuming by different types of clients or service needs to provide extra layer of security on messages and message parts, A message is nothing but a packet and WCF uses this packet to transfer information from source to destination. This message contains an envelope<\/strong>, header <\/strong>and body<\/strong>. There are some rules, which one needs to follow, while working with message contract.<\/p>\n 90 % of the time, DataContract will be sufficient<\/strong>, You’ll only need message contracts if you need to very closely and very specifically control the layout of your SOAP messages. In most of the time, you don’t need to.<\/p>\n A message contract allows you to specifically say which elements (scalar types or compound types as DataContracts<\/strong>) will be in the SOAP header, and which will be in the SOAP body.<\/p>\n You might need this if you have a communication partner, with whom you have agreed to a very specific format and you have to tweak your SOAP messages to match that given layout exactly. That’s just about the only valid scenario <\/strong>when you’ll need<\/strong> to and should use message contracts<\/strong>.<\/p>\n However, sometimes complete control over the structure of a SOAP message is just as important as control over its contents. This is especially true when interoperability is important or to specifically control security issues at the level of the message or message part<\/strong>. In these cases, you can create a message contract<\/em> that enables you to use a type for a parameter or return value that serializes directly into the precise SOAP message that you need<\/strong>.<\/p>\n So, to making the long story short: always<\/strong> use data contracts<\/strong>, practically never use message contracts <\/strong>(unless you really have to). <\/p>\n Fault Contract provides documented view for error accorded in the service to client<\/b>. This help as to easy identity the what error has occurred, and where. By default when we throw any exception from service, it will not reach the client side. The less the client knows about what happened on the server side, the more dissociated the interaction will be, this phenomenon (not allowing the actual cause of error to reach client). is known as error masking. By default all exceptions thrown on the service side always reach the client as FaultException,<\/strong> as by having all service exceptions indistinguishable from one another, WCF decouples the client from service. <\/p>\n While the default policy of error-masking is best practice of WCF, but there are times when client is required to respond to these exceptions in a prescribed and meaningful way<\/strong>. WCF provides the option to handle and convey the error message to client from service using SOAP Fault <\/strong>contract. SOAP <\/strong>faults are based on industry standard that is independent of any technology specific exceptions, it is a way to map technology specific exceptions to some neutral error information. So when service meets as unexpected error, instead of throwing a raw CLR exception (technology specific), service can throw an instance of the FaultException <T><\/strong> class. <\/p>\n This article has been divided into 4 modules: <\/p>\n To create this project, you can simply take a "Class Library" <\/strong>project, while choosing from project wizard option. let’s name it " [DataContract] [DataMember] [DataMember]<\/strong> [DataMember] [DataMember] }<\/font><\/p>\n This DataContract<\/strong> defines the data the data to be exchanged when a CuboidFaultException <\/strong>is thrown from service. As the service is also implementing Fault contract, this information is sent to client from the service. I have defined 4 fields, to send the error information to the client, you can define more fields you you need to to send some other contextual information to client. <\/p>\n Reason: <\/strong>The actual cause of the exception, why the service has thrown an CuboidFaultException<\/strong>.<\/p>\n Source : <\/strong>The source information, which has thrown the exception, in this field you can Send the name of the function, or line number where exception occurred, or what ever information you think will fit as source field of the error.<\/p>\n Detail:<\/strong> here you can pack the information regarding, the actual detail of the error. <\/p>\n HelpLink:<\/strong> a web link about the documentation about this kind of error, any thing which you can think can be a help.<\/p>\n [DataContract]<\/strong> This Data contract simply defines the 3 dimensions of a cuboid, which is length, width and height.<\/p>\n <\/strong> [DataContract]<\/strong> This Data contract simply defines a class which contains two fields, first field is the ID of the Cuboid and second field is an object of CuboidDimension <\/strong>class, which was defined previously, that contains the dimensions (length, width and height) of the cuboid. <\/p>\n [DataContract]<\/strong> This Data contract simply defines a class which contains 3 fields, first field is the ID of the Cuboid and second field is a double, that will hold the value of surface area of the Cuboid, and the 3rd field is a double that will contain the Volume of the cuboid. <\/p>\n [MessageContract]<\/strong> <\/font> [MessageHeader] [MessageBodyMember]<\/strong> This Message contract simply defines a class which contains two fields, first field is the ID of the Cuboid, which has been defined as Message Header. In the message body contains a single member CuboidDimension<\/strong>, that is details (dimensions) of the cuboid. <\/p>\n [MessageContract] [MessageHeader] [MessageBodyMember] [MessageBodyMember] This Message contract defines a class which contains 3 fields, ID of the cuboid has been defined as Message Header. Message body contains a two members, that is the Volume <\/strong>and Area <\/strong>of the Cuboid. <\/p>\n [ServiceContract] Service defines two methods as Exposed Operation(s) of the service. <\/p>\n The first method CalculateDetails1<\/font><\/strong> of the service takes a Message Contract type CuboidInfoRequest<\/font><\/strong> as an input parameter, and returns a Message Contract type CuboidDetailResponse<\/font><\/strong> , abiding by the rules.<\/p>\n implements a FaultContract<\/font><\/strong>, which raises CuboidFaultException<\/font>, <\/strong>if there is something not the way, as it supposed to be.<\/p>\n The second method CalculateDetails2<\/font><\/strong> of the service takes a Data Contract type CuboidInfo<\/font><\/strong> as an input parameter, and returns a Data Contract type CuboidDetail.<\/strong><\/font> although method takes only one parameter. <\/p>\n implements a FaultContract<\/font><\/strong>, which raises CuboidFaultException<\/font>, <\/strong>if there is something not the way, as it supposed to be.<\/p>\n public CuboidDetailResponse CalculateDetails1(CuboidInfoRequest cInfo) CuboidDetailResponse dInfo = new CuboidDetailResponse(); (cInfo.Dimension.Width * cInfo.Dimension.Height) + <\/font><\/p>\n (cInfo.Dimension.Length * cInfo.Dimension.Height )); Operation takes a MessageContrat (CuboidInfoRequest<\/font><\/strong>) type parameter, checks whether the attributes (length, width, height) of the cuboid is not zero or negative. if yes then simply creates and raises a FaultException<\/font><\/strong> of type CuboidFaultExeception<\/font><\/strong>, assigning the values for the field of CuboidFaultExeception<\/font><\/strong>.<\/p>\n and if everything is in place, calculates the desired values, creates a new MessageContract <\/strong>object (<\/strong>CuboidDetailResponse)<\/strong> and assigns its field and returns that object.<\/p>\n public CuboidDetail CalculateDetails2(CuboidInfo cInfo) \n
[ServiceContract]
interface ICuboidService
{
[OperationContract]
CuboidDetail CalculateDetails2(CuboidInfo cInfo);
}<\/font><\/h5>\nData Contract<\/h3>\n
public class CuboidInfo
{
}<\/strong><\/font><\/p>\nMessage Contract<\/h3>\n
![\"image\"](\"http:\/\/praveenkatiyar.wordpress.com\/wp-content\/uploads\/2013\/10\/image8.png\" "\\"image\\"")
<\/a><\/p>\n\n
Choosing between DataContract and MessageContract.<\/h3>\n
Fault Contract<\/h3>\n
Using the code<\/h3>\n
\n
First Module: WCF Service Library (ContractLib.dll) <\/h3>\n
ContractLib<\/strong><\/code>", it is the actual service which implements the business logic. The project already contains a file Class1.cs<\/em>, let us do some house keeping, before we write any code for the service library <\/p>\nLittle House Keeping<\/h4>\n
\n
ICuboidService<\/strong><\/font><\/code> to the project, a new file ICuboidService.cs<\/font><\/strong><\/code><\/em> will be added to the project. <\/li>\nCuboidService<\/strong><\/font><\/code>, to the project. that will implement the ICuboidService<\/strong><\/font><\/code> interface, a new file CuboidService.<\/font><\/code><\/font>cs<\/em><\/strong> will be added to the project. <\/li>\n<\/ul>\nDefining Service Interface – Data Contract(s) <\/h4>\n
Definition of CuboidFaulltException<\/h5>\n
<\/strong>public class CuboidFaultException
{
private string _reason;
private string _source;
private string _detail;
private string _helpLink;<\/font><\/font><\/p>\n
<\/strong> public string Reason
{
get { return _reason; }
set { _reason = value; }
}<\/font><\/font><\/p>\n
public string Source
{
get { return _source; }
set { _source = value; }
}<\/font><\/font><\/p>\n
<\/strong> public string Detail
{
get { return _detail; }
set { _detail = value; }
}<\/font><\/font><\/p>\n
<\/strong> public string HelpLink
{
get { return _helpLink; }
set { _helpLink = value; }
}<\/font><\/font> <\/p>\nExplanation<\/h6>\n
Definition of CuboidDimension<\/h5>\n
public class CuboidDimension<\/strong>
{
[DataMember] public int Length;
[DataMember] public int Width;
[DataMember] public int Height;
}<\/font><\/p>\nExplanation<\/h6>\n
Definition of CuboidInfo<\/h5>\n
public class CuboidInfo<\/strong>
{
[DataMember] public int ID;
[DataMember] public CuboidDimension<\/strong> Dimension = new CuboidDimension<\/strong>();
}<\/font><\/p>\nExplanation<\/h6>\n
Definition of CuboidDetail<\/h5>\n
public class CuboidDetail<\/strong>
{
[DataMember] public int ID;
[DataMember] public double SurfaceArea;
[DataMember] public double Volume;
}<\/font><\/p>\nExplanation<\/h6>\n
Defining Service Interface – Message Contract<\/h4>\n
Defining CuboidInfoRequest<\/h5>\n
public class CuboidInfoRequest
{
private int m_nID ;
private CuboidDimension m_Dims = new CuboidDimension();<\/font><\/p>\n
<\/strong> public int ID
{
get { return m_nID; }
set { m_nID = value; }
}<\/font><\/font><\/p>\n
public CuboidDimension Dimension
{
get { return m_Dims; }
set { m_Dims = value; }
}
}<\/font><\/p>\nExplanation<\/h6>\n
Defining CuboidDetailResponse<\/h5>\n
public class CuboidDetailResponse
{
private int m_nID;
private double m_dblArea;
private double m_dblVolume;<\/font><\/p>\n
public int ID
{
get { return m_nID; }
set { m_nID = value; }
}<\/font><\/p>\n
public double SurfaceArea
{
get { return m_dblArea ; }
set { m_dblArea = value ; }
}<\/font><\/p>\n
public double Volume
{
get { return m_dblVolume; }
set { m_dblVolume = value; }
}
}<\/font><\/p>\nExplanation<\/h6>\n
Defining Service Interface – Service Contract, Operation Contract, Fault Contract<\/h4>\n
Defining ServiceContract ICuboidService <\/h5>\n
<\/strong>interface ICuboidService
{
[OperationContract]
<\/strong> [FaultContract<\/strong>(typeof(CuboidFaultException<\/strong>))]
CuboidDetailResponse CalculateDetails1(CuboidInfoRequest cInfo);
[OperationContract]
<\/strong> [FaultContract<\/strong>(typeof(CuboidFaultException<\/strong>))]
CuboidDetail CalculateDetails2(CuboidInfo cInfo);
}<\/font><\/p>\nExplanation<\/h6>\n
\n
\n
Implementing Service Interface <\/h4>\n
Implementing method CalculateDetails1<\/h5>\n
{
if ((cInfo.Dimension.Length<=0)||(cInfo.Dimension.Width<=0)||(cInfo.Dimension.Height <= 0))
{
CuboidFaultException faultEx = new CuboidFaultException ();
faultEx.Reason = "Any dimension of Cuboid (length\/width\/height) can not be zero or negative value";
faultEx.Source = "CalculateDetails1()";
faultEx.HelpLink = "<\/font>http:\/\/praveenkatiyar.wordpress.com";<\/font><\/a>
StringBuilder sbDetail = new StringBuilder ("");
if (cInfo.Dimension.Length <= 0) sbDetail.Append ( "[Length is <= 0] ");
if (cInfo.Dimension.Width <= 0) sbDetail.Append ( "[Width is <= 0] ");
if (cInfo.Dimension.Height <= 0) sbDetail.Append ( "[Height is <= 0]") ;
faultEx.Detail = sbDetail.ToString();
throw new FaultException<CuboidFaultException>(faultEx);
}<\/font><\/p>\n
dInfo.ID = cInfo.ID ;
dInfo.Volume = (cInfo.Dimension.Length * cInfo.Dimension.Width * cInfo.Dimension.Height);
dInfo.SurfaceArea = 2 * ( (cInfo.Dimension.Length * cInfo.Dimension.Width) + <\/font><\/p>\n
return dInfo;
}<\/font><\/p>\nExplanation<\/h6>\n
Implementing method CalculateDetails2<\/h5>\n