Post
Ask Question

Contracts in WCF Service

Contracts are useful for building WCF service applications. They define what the protocol (binding) the service uses, how the communication will be done, what message exchange format to use and so on.
 
The following are the contracts are available in WCF:
  • Service contracts
  • Data Contracts
  • Message contracts
  • Fault Contract
  • Operation Contract

Service contracts

 
Service contracts define the Interface for the service. It can be defined as follows.
 
Syntax
  1. [ServiceContract]  
  2. public interface IService1  
  3. {  
  4.  
  5.     // TODO: Add your service operations here  
  6. } 
Key Points
  • Any WCF service can have more than one service contract.
  • Declare at least one service contract in a service.
  • A service contract can be declared using the [ServiceContract] attribute.
  • It allows defining an Operation Contract under it to expose the service outside the world.
  • It maps the interface and methods of your service to a platform-independent description.
  • It describes message exchange patterns that the service can have with another party. Some service operations might be one-way, others might require a request-reply pattern.
The service contract attribute has the following properties:
  • CallbackContract
  • ConfigurationName
  • HasProtectionLevel
  • Name
  • Namespace
  • ProtectionLevel
  • SessionMode
  • TypeId

Operation Contract

 
An Operation Contract defines the method exposed to the client to exchange the information between the client and server. An Operation Contract describes what functionality is to be given to the client, such as addition, subtraction and so on.
 
It can be defined as in the following:
  1. public interface IService1  
  2. {  
  3.     [OperationContract]  
  4.     string GetData(int value);  
  5.   
  6.     [OperationContract]  
  7.     CompositeType GetDataUsingDataContract(CompositeType composite);  
  8.     
  9. } 
The Operation Contract attribute has the following properties:
  • CallbackContract: Gets or sets the type of callback contract when the contract is a duplex contract.
  • ConfigurationName: Gets or sets the name used to locate the service in an application configuration file.
  • HasProtectionLevel: Gets a value that indicates whether the member has a protection level assigned.
  • Name: Gets or sets the name of the <portType> element in the Web Services Description Language (WSDL).
  • Namespace: Gets or sets the namespace of the <portType> element in the Web Services Description Language (WSDL).
  • ProtectionLevel: Specifies whether the binding for the contract must support the value of the ProtectionLevel property.
  • SessionMode: Gets or sets whether sessions are allowed, not allowed or required.
  • TypeId: When implemented in a derived class, gets a unique identifier for this Attribute.

Data Contract

 
Data Contracts define the data type for variables that are the same as get and set properties but the difference is that a Data Contract in WCF is used to serialize and deserialize the complex data. It defines how data types are serialized and deserialized. Using serialization, you can convert an object into a sequence of bytes that can be transmitted over a network. Using de-serialization, you reassemble an object from a sequence of bytes that you receive from a calling application.
 
It can be defined as follows:
  1. [DataContract]  
  2. public class Student  
  3. {  
  4.     private string _Name;  
  5.   
  6.     private string _City;  
  7.   
  8.   
  9.     [DataMember]  
  10.     public string Name  
  11.     {  
  12.         get { return _Name; }  
  13.         set { _Name = value; }  
  14.     }  
  15. } 

Fault Contract

 
A Fault Contract handles the exception and understands the cause of the error that occurs in the WCF service. When we develop a managed application or service, we will handle the exception using a try- catch block, but these exceptions handlers are technology-specific.
 
The following is the syntax to raise the custom error in WCF:
  1. [ServiceContract]  
  2. public interface IGetDetailsService  
  3. {  
  4.      [OperationContract]  
  5.      [FaultContract(typeof(Student))]  
  6.      Student GetDetails(string Name);  
  7. }  
  8.   
  9. [DataContract]  
  10. public class Student  
  11. {  
  12.      private string _Name;  
  13.   
  14.      private string _City;  
  15.   
  16.      [DataMember]  
  17.      public string Name  
  18.      {  
  19.          get { return _Name; }  
  20.          set { _Name = value; }  
  21.      }  
  22.   
  23.      [DataMember]  
  24.      public string City  
  25.      {  
  26.          get { return _City; }  
  27.          set { _City = value; }  
  28.      }  
  29. } 

Message contracts

 
The default SOAP message format is provided by the WCF runtime for communication between the client and the service. If it does not meet your requirements then we can create our own message format. This can be done using the Message Contract attribute.
 
It can be defined as:
  1. [MessageContract]  
  2. public class Person  
  3. {  
  4.    [MessageHeader] public Operation Name;  
  5.    [MessageHeader] public string city;  
  6.    [MessageBodyMember] private Home Address;  
  7.    [MessageBodyMember] private Home Streat;  
  8.    [MessageBodyMember] public int age;  
  9. } 
Note
 
 
I hope this article is useful for all students and beginners. If you have any suggestion related to this article then please contact me.


Similar Articles