WCF Service Contracts And Operation Contracts

Basically a WCF Contract is an agreement between the two parties, in other words a Service and a Client. In Windows Communication Foundation, contracts can be categorized as behavioral or structural.

 

Behavioral Contracts

• The ServiceContract attribute marks a type as a Service Contract that contains operations.
• OperationContract attribute marks the operations that will be exposed.
• FaultContract defines what errors are raised by the service being exposed.

Structural Contracts

• The DataContract attribute defines the types that will be moved between the parties.
• The MessageContract attribute defines the structure of the SOAP message.

In this WCF Tutorial, we will discuss and implement contracts in Windows Communication Foundation using a step-by-step approach with practical examples.

 

Service Contract and Operation Contract

 

A Service Contract basically describes the operations a service exposes to another party (in other words a client). We can map a WCF Service Contract to a Web Service Description Language (WSDL).

 

It's recommended to apply the ServiceContract attribute to an interface, although it can be applied to a class as well. Applying it to an interface provides us a clear separation of contract and its implementation.

 

 

 

It describes:

• What operations are exposed by the service
• Platform independent description of the interface as well as methods of our service
• A Message Exchange Pattern (MEP) between the parties, in other words Request/Response, One-Way or Duplex. Please follow here for a detailed description of MEPs.

To define a Service Contract, we will apply the ServiceContract attribute to a .NET Interface and OperationContract attribute to methods as follows:

[ServiceContract]
interface ISimpleService
{
     [OperationContract]
     string SimpleOperation();
}
class SimpleService  :  ISimpleService
{
       public string SimpleOperation()
       {
            return "Simple Operation Result";
        }
}

In the code above, we used the ServiceContract attribute to mark ISimpleService (an interface) as a Service Contract and the OperationContract attribute to the method "SimpleOperation". Also provided an implementation class "SimpleService".

 

Note: The ServiceContract attribute is not inherited, in other words if we are defining another interface/class as a Service Contract inheriting from ISimpleContract, we still need to explicitly mark it with the ServiceContract attribute.

 

In the preceding example, we use a ServiceContract attribute without any parameter but we can pass parameters also like Name, Namespace, ConfigurationName, ProtectionLevel, SessionMode and so on as follows:

[ServiceContract(Name = "MySimpleService")]
interface ISimpleService
{
    [OperationContract]
    string SimpleOperation();
}