A
data contract is a formal agreement between a service and a client that
abstractly describes the data to be exchanged.
Data
contract can be explicit or implicit. Simple type such as int, string etc has
an implicit data contract. User defined object are explicit or Complex type,
for which you have to define a Data contract using [DataContract] and
[Data Member] attribute.
A
data contract can be defined as follows:
- It describes the external format of data passed to and from service operations
- It defines the structure and types of data exchanged in service messages
- It maps a CLR type to an XML Schema
- t defines how data types are serialized and deserialized. Through serialization, you convert an object into a sequence of bytes that can be transmitted over a network. Through deserialization, you reassemble an object from a sequence of bytes that you receive from a calling application.
- It is a versioning system that allows you to manage changes to structured data
We
need to include System.Runtime.Serialization reference to the project.
This assembly holds the DataContract and DataMember attribute.Create
user defined data type called Employee. This data type should be identified for
serialization and deserialization by mentioning with [DataContract] and
[Data Member] attribute.
[ServiceContract]
public interface IEmployeeService
{
[OperationContract]
Employee GetEmployeeDetails(int EmpId);
}
[DataContract]
public class Employee
{
private string m_Name;
private int m_Age;
private int m_Salary;
private string m_Designation;
private string m_Manager;
[DataMember]
public string Name
{
get { return m_Name; }
set { m_Name = value; }
}
[DataMember]
public int Age
{
get { return m_Age; }
set { m_Age = value; }
}
[DataMember]
public int Salary
{
get { return m_Salary; }
set { m_Salary = value; }
}
[DataMember]
public string Designation
{
get { return m_Designation; }
set { m_Designation = value; }
}
[DataMember]
public string Manager
{
get { return m_Manager; }
set { m_Manager = value; }
}
}
Implementation
of the service class is shown below. In GetEmployee method we have created the
Employee instance and return to the client. Since we have created the data
contract for the Employee class, client will aware of this instance whenever he
creates proxy for the service.
public class
EmployeeService : IEmployeeService
{
public Employee GetEmployeeDetails(int
empId)
{
Employee empDetail = new
Employee();
//Do something to get employee
details and assign to 'empDetail' properties
return empDetail;
}
}
Client side:
On
client side we can create the proxy for the service and make use of it. The
client side code is shown below.
protected void
btnGetDetails_Click(object sender, EventArgs e)
{
EmployeeServiceClient
objEmployeeClient = new EmployeeServiceClient();
Employee empDetails;
empDetails =
objEmployeeClient.GetEmployeeDetails(empId);
//Do something on
employee details
}
