HTTP Operations GET, POST, PUT and DELETE From .NET Client

using System;    
using System.Collections.Generic;    
using System.Linq;    
using System.Net;    
using System.Net.Http;    
using System.Web;    
using TestWEB_API.Models;    
using System.Web.SessionState;using System.Web.Http;    
using System.Web.Mvc    
     
namespace TestWEB_API.Controllers    
{    
    public class ValuesController : ApiController    
    {          
        public List<string> Get()    
        {    
            List<string> Li = new List<string>();    
            Li.Add("Sourav");    
            Li.Add("Ajay");    
            Li.Add("Manish");    
            return Li;    
        }    
    }    
}

using System;    
using System.Collections.Generic;    
using System.Linq;    
using System.Text;    
using System.Threading.Tasks;    
using System.Net.Http;    
using System.Net.Http.Headers;     
    
namespace HttpClientAPP     
{        
    class Program      
    {    
        static void Main(string[] args)    
        {    
            HttpClient client = new HttpClient();    
            client.BaseAddress = new Uri("http://localhost:11129/");     
            // Add an Accept header for JSON format.    
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));     
            // List all Names.    
            HttpResponseMessage response = client.GetAsync("api/Values").Result;  // Blocking call!    
            if (response.IsSuccessStatusCode)    
            {    
                var products = response.Content.ReadAsStringAsync().Result;     
            }    
            else    
            {    
                Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);    
            }    
        }    
    }    
}

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
using System.Threading.Tasks;  
using System.Net.Http;  
using System.Net.Http.Headers;   
  
namespace HttpClientAPP  
{     
    class Program   
    {  
        static void Main(string[] args)  
        {  
            HttpClient client = new HttpClient();  
            client.BaseAddress = new Uri("http://localhost:11129/");   
            // Add an Accept header for JSON format.  
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));   
            // List all Names.  
            HttpResponseMessage response = client.GetAsync("api/Values").Result;  // Blocking call!  
            if (response.IsSuccessStatusCode)  
            {  
                Console.WriteLine("Request Message Information:- \n\n" + response.RequestMessage + "\n");  
                Console.WriteLine("Response Message Header \n\n" +  response.Content.Headers + "\n");  
            }  
            else  
            {  
                Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);  
            }  
            Console.ReadLine();  
        }  
    }  
}

The green box shows the request message format that out HttpClient class has formed for us. We are seeing that the request type is GET and the HTTP protocol version is 1.1. In the header part only one header information is there. The request is expecting JSON data in the body of the response message.

The red box shows the response message.

Post Request Method

In this article we will see how to post data to the Web API using a .NET client. We know that the RESTful API can consume another service more smoothly and any client that understands HTTP can consume the Web API. The .NET framework has provided nice classes to consume Web Services in any type of .NET application. In this article we will build a Console application to consume a service from the Web API. So, let's create the Web API part at first. Have a look at the following code.

using System;     
using System.Collections.Generic;     
using System.Linq;      
using System.Net;      
using System.Net.Http;      
using System.Web.Http;         
    
namespace WebAPI.Controllers      
{      
    public class person      
    {      
        public string name { get; set; }      
        public string surname { get; set; }      
    }         
    public class personController : ApiController      
    {      
        [HttpPost]      
        public void Post([FromBody] person p)      
        {           
        }      
    }      
}

The person controller is simple to understand. We have kept only one Post() method that we decorated with a [HttpPost] attribute. I believe the attribute decoration is not very helpful when our action name matches the HTTP verb. Anyway the post method is taking one argument that we will supply from the body of the HTTP request and the argument type is the object type of the person class. So we are sending a complex object from a .NET client.

Let's see the .NET code now. You can find that we have replicated the same class that we defined in the Web API in the client too. Then within the Main() function we are creating one object of that class that we wll send to the Web API.

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
using System.Threading.Tasks;  
using ClassLibrary;  
using System.Threading;  
using System.Net.Http;  
using System.Net.Http.Headers;  
using System.Net.Http.Formatting;  
using Newtonsoft.Json;  
  
namespace ConsoleAPP  
{  
    public class person  
    {  
        public string name { get; set; }  
        public string surname { get; set; }  
    }  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            using (var client = new HttpClient())  
            {  
                person p = new person { name = "Sourav", surname = "Kayal" };  
                client.BaseAddress = new Uri("http://localhost:1565/");  
                var response = client.PostAsJsonAsync("api/person", p).Result;  
                if (response.IsSuccessStatusCode)  
                {  
                    Console.Write("Success");  
                }  
                else  
                    Console.Write("Error");  
            }  
        }  
    }  
} 

We have specified the URL of the API and sent data to the Post action of the person controller using the “PostAsAsync” method. The result will store a response variable and then we check the "IsSuccessStatuscode" of the object.

Now, one thing to be considered during the client application development. It's good to install the following packages in the application.

<?xml version="1.0" encoding="utf-8"?>     
<packages>      
  <package id="EntityFramework" version="5.0.0" targetFramework="net45" />      
  <package id="Microsoft.AspNet.WebApi.Client" version="5.1.2" targetFramework="net45" />      
  <package id="Microsoft.AspNet.WebApi.Core" version="5.1.2" targetFramework="net45" />      
  <package id="Newtonsoft.Json" version="6.0.3" targetFramework="net45" />      
</packages> 

Put and Delete Request Method

In this example, we will call Put() and Delete() actions of the Web API from a .NET client. I hope you are already familiar with the relationship with HTTP verbs and the Web API.

Fine, so let's see implement the Put() method now. We know that Put() is able to update something in a RESTful service. Here is our Web API and we will pass the complex type object as an argument to the Put() method.

using System;     
using System.Collections.Generic;      
using System.Linq;      
using System.Net;      
using System.Net.Http;      
using System.Web.Http;         
    
namespace WebAPI.Controllers      
{      
    public class person      
    {      
        public string name { get; set; }      
        public string surname { get; set; }        }      
    public class personController : ApiController      
    {      
        [HttpPut]      
        public void Put([FromBody] person p)      
        {      
        }      
    }      
}

Ok, now we will implement a client application that will do a Put() operation to the Web API. Have a look at the following code.

using System;      
using System.Collections.Generic;      
using System.Linq;      
using System.Text;      
using System.Threading.Tasks;      
using ClassLibrary;      
using System.Threading;      
using System.Net.Http;      
using System.Net.Http.Headers;      
using System.Net.Http.Formatting;      
using Newtonsoft.Json;         
    
namespace ConsoleAPP      
{      
    public class person      
    {      
        public string name { get; set; }      
        public string surname { get; set; }      
    }      
    class Program      
    {      
        static void Main(string[] args)      
        {      
            using (var client = new HttpClient())      
            {      
                person p = new person { name = "Sourav", surname = "Kayal" };      
                client.BaseAddress = new Uri("http://localhost:1565/");      
                var response = client.PutAsJsonAsync("api/person", p).Result;      
                if (response.IsSuccessStatusCode)    
                {      
                    Console.Write("Success");      
                }      
                else      
                    Console.Write("Error");      
            }      
        }      
    }      
} 

We are sending the same object type to the Web API that it is expecting a Put() action/method. Once we run the application we will see that the data has been obtained using the Put() action.

The same is true for the Delete() operation. Let's have a quick look at the Delete() action now. Here is the client code. In the case of Delete() we are sending the key value that is an Integer type.

using (var client = new HttpClient())    
{    
    client.BaseAddress = new Uri("http://localhost:1565/");    
    var response = client.DeleteAsync("api/person/10").Result;    
    if (response.IsSuccessStatusCode)    
    {    
        Console.Write("Success");    
    }    
    else    
    Console.Write("Error");    
}

And the Delete() action in the API.

[HttpDelete]    
public void Delete([FromUri] Int32 Id)    
{    
}

If everything is fine then it will call the Delete() action by passing the value 10 as we are seeing in the following example.

Cool, so we have seen how to call the Put() and Delete() actions of the Web API from a .NET client.

Conclusion

In this article, we have learned how to make a HTTP client of our own using the HttpClient class of the .NET library. Since the client is getting the response asynchronously, we need to use .NET 4.5 to support Asynchronous operations.