WCF REST Service to get or post JSON data and retrieve JSON data with DataContract

Introduction to JSON

JSON stands for JavaScript Object Notation. It is a lightweight data exchange format. It does not create lengthy tags like XML and produce human readable clean data. JSON is completely language independent. It gives you a collection of Name/value pair. The data member names must be a valid JSON string and included in quotation marks or apostrophes. If you are not using reserved JavaScript keyword you may omit the quotation marks or apostrophes.

Follow below steps to implement WCF RESTful service with JSON and DataContract

Create WCF RESTful service

Follow the article how to create wcf restful services to understand what is RESTful services, when to use which http verbs and nature of RESTful services.

Create Orders DataContract for your RESTful OrderService

Create a DataContract Orders which will be used for exchanging orders information between service and client. Add below OrderData contract to the RESTfulWCFService application created in the previous step.

    
using System.Runtime.Serialization;

namespace RESTFulWCFService
{
    [DataContract]
    public class OrderContract
    {
        [DataMember] 
        public string OrderID { get; set; }

        [DataMember] 
        public string OrderDate { get; set; }

        [DataMember] 
        public string ShippedDate { get; set; }

        [DataMember] 
        public string ShipCountry { get; set; }

        [DataMember] 
        public string OrderTotal { get; set; }
    }
}
            

Orders data store

Download Orders XML file and place it in C: drive. The CRUD operations will be performed on this XML file using REST calls.

REST OrderService

Add OrderService to your application. Right click on RESTFulWCFService application from solution explorer -> Select Add -> Select New Item -> Select WCF Service -> Name it as OrderService.

It will add two files OrderService.svc and IOrderService.cs

Order ServiceContract

Open IOrderService ServiceContract. Add below OperationContracts to OrderService with WebGet or WebInvoke to make the service as RESTful.

Notice the following attributes for WebGet or WebInvoke

• UriTemplate: The corresponding Operation will be served with matching Uri.
• RequestFormat: Tells the format of the request is XML or JSON.
• ResponseFormat: Tells the format of the response is XML or JSON
• Method: WebInvoke has the Method attribute. The value for this could be PUT, POST, DELETE. WebGet does not have this attribute as it is used only for HTTP verb GET.

    
using System.ServiceModel.Web;

namespace RESTFulWCFService
{   
    [ServiceContract]
    public interface IOrderService 
    {
        [OperationContract]
        [WebGet(UriTemplate = "/GetOrderTotal/{OrderID}",
            ResponseFormat= WebMessageFormat.Json)]
        string GetOrderTotal(string OrderID);

        [OperationContract]
        [WebGet(UriTemplate = "/GetOrderDetails/{OrderID}", 
            RequestFormat=WebMessageFormat.Json,            
            ResponseFormat = WebMessageFormat.Json)]
        OrderContract GetOrderDetails(string OrderID);

        [OperationContract]
        [WebInvoke(UriTemplate = "/PlaceOrder", 
            RequestFormat= WebMessageFormat.Json,   
            ResponseFormat = WebMessageFormat.Json, Method = "POST")] 
        bool PlaceOrder(OrderContract order);
    }
}
            

Order ServiceContract implementation

Open OrderService.cs and implement operations from IOrderService.

• GetOrderTotal: method is WebGet operation for getting OrderTotal of particular OrderID.
• GetOrderDetails: method is WebGet operation for getting Order Details of particular OrderID. It takes the OrderID and returns corresponding OrderDetails in form of OrderContract DataContract.
• PlaceOrder: method is WebInvoke operation and performs the Create of CRUD operations. It takes OrderContract as input parameter and adds its details to Orders.xml

    
using System.Xml.Linq;
using System.Collections;

namespace RESTFulWCFService
{    
    public class OrderService : IOrderService
    {
        public string GetOrderTotal(string OrderID)
        {
            string orderTotal = string.Empty;

            try
            {
                XDocument doc = XDocument.Load("C:\\Orders.xml");

                orderTotal =
                (from result in doc.Descendants("DocumentElement")
                .Descendants("Orders")
                    where result.Element("OrderID").Value == OrderID.ToString()
                    select result.Element("OrderTotal").Value)
                .FirstOrDefault<string>();

            }
            catch (Exception ex)
            {
                throw new FaultException<string>
                        (ex.Message);
            }
            return orderTotal;
        }

        public OrderContract GetOrderDetails(string OrderID)
        {
            OrderContract order = new OrderContract();

            try
            {
                XDocument doc = XDocument.Load("C:\\Orders.xml");
                
                IEnumerable<XElement> orders =
                    (from result in doc.Descendants("DocumentElement")
                        .Descendants("Orders")
                    where result.Element("OrderID").Value == OrderID.ToString()
                    select result);

                order.OrderID = orders.ElementAt(0)
                                            .Element("OrderID").Value;
                order.OrderDate = orders.ElementAt(0)
                                            .Element("OrderDate").Value;
                order.ShippedDate = orders.ElementAt(0)
                                            .Element("ShippedDate").Value; 
                order.ShipCountry = orders.ElementAt(0)
                                            .Element("ShipCountry").Value; 
                order.OrderTotal = orders.ElementAt(0)
                                            .Element("OrderTotal").Value; 
            }
            catch (Exception ex)
            {
                throw new FaultException<string>
                        (ex.Message);
            }
            return order;
        }

        public bool PlaceOrder(OrderContract order)
        {
            try
            {
                XDocument doc = XDocument.Load("C:\\Orders.xml");

                doc.Element("DocumentElement").Add(
                        new XElement("Products",
                        new XElement("OrderID", order.OrderID),
                        new XElement("OrderDate", order.OrderDate),
                        new XElement("ShippedDate", order.ShippedDate),
                        new XElement("ShipCountry", order.ShipCountry),
                        new XElement("OrderTotal", order.OrderTotal)));

                doc.Save("C:\\Orders.xml");
            }
            catch (Exception ex)
            {
                throw new FaultException<string>
                        (ex.Message);
            }
            return true;
        }
    }
}
           

WCF RESTful Service endpoint Configuration

WCF RESTful Service endpoint Configuration is about similar to normal endpoints. Notice that we are using webHttpBinding.

We added the endpointBehaviors for webHttp settings. Add below service endpoints.

    
 <system.serviceModel>
    <serviceHostingEnvironment multipleSiteBindingsEnabled="true" />    
      
      <service behaviorConfiguration="Default" 
            name="RESTFulWCFService.OrderService">
        <endpoint address="" behaviorConfiguration="webBehavior" 
                binding="webHttpBinding" 
                contract="RESTFulWCFService.IOrderService" />
        
        <endpoint contract="IMetadataExchange" binding="mexHttpBinding" 
                        address="mex" />
      
      </service>
    </services>
    <behaviors>
        <endpointBehaviors>
            <behavior name="webBehavior">
                <webHttp helpEnabled="true" />
            </behavior>
        </endpointBehaviors>
        <serviceBehaviors>
            <behavior name="Default">
                <serviceMetadata httpGetEnabled="true" />
            </behavior>
            <behavior name="">
                <serviceMetadata httpGetEnabled="true" />
                <serviceDebug includeExceptionDetailInFaults="false" />
            </behavior>
        </serviceBehaviors>
    </behaviors>
</system.serviceModel>
            

View your OrderService

Right click on OrderService.svc and select View in browser. You may enter the below URL in the browser.

http://localhost:61090/OrderService.svc/GetOrderDetails/10250

Notice that DataMember attributes are shown in alphabetically order. You may set it using DataMembers Order property. Click here to know more about DataMember and enum member attributes.

Client application for RESTful OrderService

Add a console application to your solution. Add a reference to WCFServices where OrderService is. Add below client code in the console application.

    
using System.Net;
using System.Runtime.Serialization.Json;
using RESTFulWCFService;

namespace DotnetmentorsClient
{
    class Program
    {
        static void Main(string[] args)
        {
            GetOrderDetails("10248");
            GetOrderTotal("10250");
            PlaceOrder(); 
            Console.ReadKey(true);
        }

        private static void GetOrderDetails(string orderID)
        {
            WebClient proxy = new WebClient();
            string serviceURL = 
                    string.Format("http://localhost:61090/OrderService.svc
                                    /GetOrderDetails/{0}", orderID); 
            byte[] data = proxy.DownloadData(serviceURL);
            Stream stream = new MemoryStream(data);
            DataContractJsonSerializer obj = 
                        new DataContractJsonSerializer(typeof(OrderContract));
            OrderContract order = obj.ReadObject(stream) as OrderContract;
            Console.WriteLine("Order ID : " + order.OrderID);
            Console.WriteLine("Order Date : " + order.OrderDate);
            Console.WriteLine("Order Shipped Date : " + order.ShippedDate);
            Console.WriteLine("Order Ship Country : " + order.ShipCountry);
            Console.WriteLine("Order Total : " + order.OrderTotal);
        }

        private static void GetOrderTotal(string orderID)
        {
            Console.WriteLine();  
            Console.WriteLine("**** Output for GetOrderTotal ************");  
            WebClient proxy = new WebClient();
            string serviceURL = 
                    string.Format("http://localhost:61090/OrderService.svc
                                    /GetOrderTotal/{0}", orderID);
            byte[] data = proxy.DownloadData(serviceURL);
            Stream stream = new MemoryStream(data);
            DataContractJsonSerializer obj = 
                        new DataContractJsonSerializer(typeof(string));
            string order = Convert.ToString(obj.ReadObject(stream));
            Console.WriteLine(order);
        }

        private static void PlaceOrder()
        {            
            OrderContract order = new OrderContract
            {
                OrderID = "10550",
                OrderDate = DateTime.Now.ToString(),
                ShippedDate = DateTime.Now.AddDays(10).ToString(),
                ShipCountry = "India",
                OrderTotal = "781"
            };      
      
            DataContractJsonSerializer ser = 
                    new DataContractJsonSerializer(typeof(OrderContract));
            MemoryStream mem = new MemoryStream();
            ser.WriteObject(mem, order);
            string data = 
                Encoding.UTF8.GetString(mem.ToArray(), 0, (int)mem.Length);
            WebClient webClient = new WebClient();            
            webClient.Headers["Content-type"] = "application/json";            
            webClient.Encoding = Encoding.UTF8;
            webClient.UploadString("http://localhost:61090/OrderService.svc
                            /PlaceOrder", "POST", data);              
            Console.WriteLine("Order placed successfully...");  
        }
    }
}    
             

The client code for Operation PlaceOrder uses POST method which sends JSON data to service. It uses DataContractJsonSerializer to serialize DataContract. We use webClient.UploadString method to post data to service

Source Code on Github