Dhananjay Kumar

In this post we will learn to work with CRUD operation on ASP.NET Web API. We will learn

• To create CRUD operation on ASP.NET Web API
• Using Entity model to create model
• Creating repository to perform CRUD operation
• Consuming service in .NET Console Client

I can draw architecture of this blog post as following,

Let us follow step by step approach to perform CRUD operation using ASP.NET Web API service.

Create ASP.Net Web API

In this part of blog, we will learn to create ASP.NET Web API. To create launch Visual Studio and create a project by choosing ASP.NET MVC 4 Web Application template.

Next you select Web API from the existing project template. Make sure to select Razor as View engine in drop down.

Next we need to add model. We will use ADO.Net Entity model to create model out of database. To add model, right click on the Models folder and select Add New Item. Next from Data tab select ADO.NET Entity Data Model

Next select Generate from database option and click on Next.

In next dialog box, you need to configure Connection Properties. Here select Northwind database after giving server name.

After configuring connection, you will get Entity Data Model Wizard populated with connection string as below. Click on next to proceed further

Here you need to select tables, views etc. For purpose of this post, let us select three tables, Customers, Employees and Products. After selecting tables click on Finish to create model of database in project.

We are going to work with Product table. To perform CRUD operation on this, let us go ahead and created a Repository. To create this right click on model and add an Interface from Code tab. I am giving name as IProductRepository.

In this interface we will define all the operations needed to be performed on Product table. Interface is defined as below,

using System.Collections.Generic;

namespace NorthwindService.Models
{
    public  interface IProductRepository
    {
        IEnumerable<Product> GetProducts();
        bool AddProduct(Product p);
        bool UpdateProduct(Product p);
        bool DeleteProduct(int ProductID);
    }
}

Next we need to implement CRUD operation. To do that add a class and implement IProductRepository in that class. Let us implement all four operations one by one.

Note : All these operations would be defined under ProductRepository class.

We can fetch all the Products as below by writing simple LINQ

public IEnumerable<Product> GetProducts()
        {
            NorthwindEntities entities = new NorthwindEntities();
            var products = from r in entities.Products select r;
            return products.ToList();
        }

A product can be added as below,

 public bool AddProduct(Product p)
        {
            try
            {
                NorthwindEntities entities = new NorthwindEntities();
                entities.Products.Add(p);
                entities.SaveChanges();
                return true; 
            }
            catch (Exception ex)
            {
                return false; 
            }

        }

Product can be updated as below,

public bool UpdateProduct(Product p)
        {
            try
            {
                NorthwindEntities entities = new NorthwindEntities();
                Product proudctToUpdate = (from r in entities.Products where 
                                               r.ProductID == p.ProductID select r).FirstOrDefault();

                proudctToUpdate.ProductName = p.ProductName;
                proudctToUpdate.UnitPrice = p.UnitPrice;
                entities.SaveChanges();
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }
        }

Product can be deleted as below,

public bool DeleteProduct(int productID)
        {
            try
            {
                NorthwindEntities entities = new NorthwindEntities();
                Product proudctToDelete = (from r in entities.Products
                                           where
                                               r.ProductID == productID
                                           select r).FirstOrDefault();
                entities.Products.Remove(proudctToDelete);
                entities.SaveChanges();
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }
        }

After creating repository for CRUD operation, let us go ahead and create Controller. To create Controller, right click on the Controller folder and select Add new Controller. You need to rename Controller name to ProductsController.

You will get controller class created as following. Make sure that you have changed Controller to ApiController

Now we can create CRUD operation as below,

Products can be fetched as below,

static readonly IProductRepository repository = new ProductRepository();

        public IEnumerable<Product> GetProducts()
        {
            return repository.GetProducts();
        }

A new record can be created as following. We are passing Product as a resource to create here. While creating new record make sure

• Action name is PostProduct. Essentially Action name should be started with Post to perform insert operation
• Pass Product as input parameter
• Return HttpResponse

We are calling AddProduct method of Repository class. Repository class is returning true on successful insertion of record. We are checking returned value and constructing returned HttpResponse.

public HttpResponseMessage PostProduct(Product p)
        {
            bool result = repository.AddProduct(p);
            HttpResponseMessage response;
            if(result)
            {
            response  = Request.CreateResponse(System.Net.HttpStatusCode.Created);
            }
            else
            {
                response = Request.CreateResponse(System.Net.HttpStatusCode.ExpectationFailed);
            
            }
            return response ; 
        }

Modification of resource or Put operation can be performed as below. It is exactly same as Put operation with two differences

• Action or function name starts from Put
• UpdateProduct function of Repository class is being called.

  public HttpResponseMessage PutProduct(Product p)
        {
            bool result = repository.UpdateProduct(p);
            HttpResponseMessage response;
           if(result)
            {
                response = Request.CreateResponse(System.Net.HttpStatusCode.OK);
            }
            else
            {
                 response  = Request.CreateResponse(System.Net.HttpStatusCode.ExpectationFailed);
            
            }
            return response ; 

        }

Delete of resource or Put operation can be performed as below. It is exactly same as other operation with two differences

• Action or function name starts from Delete
• It takes Id as input parameter to delete record with particular id
• DeleteProduct function of Repository class is being called.

 public HttpResponseMessage DeleteProduct(int id)
        {
            bool result = repository.DeleteProduct(id);
            HttpResponseMessage response;
            if(result)
            {
            response  = Request.CreateResponse(System.Net.HttpStatusCode.OK);
            }
            else
            {
                response = Request.CreateResponse(System.Net.HttpStatusCode.ExpectationFailed);
            
            }
            return response ; 

        }

This is what all you need to do to create ASP.NET Web API with CRUD operation on Northwind database.

Creating .NET or Console Client

We are going to create .NET Console client to consumer service we created earlier. To create Console Application project, you need to select Console Application project template from Windows tab. After creating project, right click on project and select manage Nuget packages. Here search for Microsoft.AspNet.WebApi.Client library. Install this NuGet package in client project.

After installing package, add following namespaces in project,

using System.Net.Http;
using System.Net.Http.Headers;

Before we perform any operation, first initialize following in the project. Below

• Initializing HttpClient
• Setting base address
• Setting Http Request Header as JSON

 HttpClient client = new HttpClient();
            client.BaseAddress = new Uri("http://localhost:37780/api/");
          
            client.DefaultRequestHeaders.Accept.Add(
                new MediaTypeWithQualityHeaderValue("application/json"));

After initializing HttpClient and base address, we need to create client side representation of Product class. Let us create Product class at client side. Make sure that definition of class is same as the server side. Client side Product class is as following,

public class Product
    {
        public int ProductID { get; set; }
        public string ProductName { get; set; }
        public Nullable<int> SupplierID { get; set; }
        public Nullable<int> CategoryID { get; set; }
        public string QuantityPerUnit { get; set; }
        public Nullable<decimal> UnitPrice { get; set; }
        public Nullable<short> UnitsInStock { get; set; }
        public Nullable<short> UnitsOnOrder { get; set; }
        public Nullable<short> ReorderLevel { get; set; }
        public bool Discontinued { get; set; }
    }

Read Products from service

You can fetch all the Products as below.

 HttpResponseMessage response = client.GetAsync("products").Result;
            if (response.IsSuccessStatusCode)
            {
                var products = response.Content.ReadAsAsync<IEnumerable<Product>>().Result;
                foreach (var p in products)
                {
                    Console.WriteLine("{0}\t{1};\t{2}", p.ProductName, p.UnitPrice, p.QuantityPerUnit);
                }
            }
            else
            {
                Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
            }

We are fetching records performing following steps in above code.

• Records being fetched using GetAsync method of HttpClient class.
• We are passing name of entity in GetAsync
• After fetching records reading JSON data using Conent.ReadAsAsync() method of HttpResponseMessage
• If response is erroneous then we are displaying error code as output.

Creating a Record

To create record or insert a record (in this case Product), we need to perform following steps ,

• Create instance of product to be inserted
• Perform PostAsJsonAsync operation on HttpClient and pass entity name and object to be inserted as parameter
• On successful insertion you will get successful status code else error code.

Following code snippet will create a Product in database perform Put operation using ASP.NET Web API.

 Product p = new Product
            {
                ProductName = "DJ'S Pen",
                QuantityPerUnit = "20",
                Discontinued = true

            };
            HttpResponseMessage response = client.PostAsJsonAsync("products", p).Result;
            if (response.IsSuccessStatusCode)
            {
                Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
            }
            else
            {
                Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
            }

On successful creation of record you will get response as below,

Updating Record

Updating record is exactly same as creating record. Only you need to use PutAsJsonAsync() method. You can update a record as below,

Product p = new Product
            {
                ProductID = 90,
                ProductName = "DJ'S Bat",
                QuantityPerUnit = "20",
                Discontinued = true

            };
            HttpResponseMessage response = client.PutAsJsonAsync("products", p).Result;
            if (response.IsSuccessStatusCode)
            {
                Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
            }
            else
            {
                Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
            }

On successful update you should get success message as below,

Deleting Record

You can delete a resource using DeleteAsync function. You need to pass URI of the resource to be deleted.

HttpResponseMessage response = client.DeleteAsync("Products/90").Result;
            if (response.IsSuccessStatusCode)
            {
                Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
            }
            else
            {
                Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
            }

Here 90 is ProductId we want to delete. On successful deletion you will get success message as below,

Conclusion

In this blog post we learn following items,

1. Using ADO.NET Entity Model as model in Web API
2. Creating CRUD operation on ASP.NET Web API
3. Consuming service in .NET client

I hope you find this post useful. Thanks for reading.