Creating Self Hosted Asp.Net WebAPI with CURD operations in Visual Studio 2010


Introduction

I have been writing a lot over WebAPIs in my Learning WebAPI series, but one crucial topic that I missed was hosting an asp.net WebAPI .

Hosting a WebAPI in IIS is pretty straight forward and is more similar to how you host a typical asp.net web application.In this article, I’ll explain how we can host a WebAPI in another process independent of IIS.

I’ll explain how to quickly create a WebAPI having CURD operations with Entity Framework 4.0 and then host it in an independent server.I’ll call the service endpoints through a console application acting as a client. You can use any client to check the service end points and verify their functionality. I’ll try to explain the topic with practical implementations , create a service and a test client in Visual Studio 2010 around target framework as .Net Framework 4.0.

Download Source Code   Download Database Script

 

independent

WebAPI project

The traditional way of creating an asp.net REST service is to select a WebAPI project from visual studio , create a controller, expose endpoints and host that on IIS. But when it comes to creating a self-hosted web api on windows, we need to take windows or a console based application, that generates an exe when compiled which in turn can be used for hosting through a command prompt. You can host WebAPI 2 with Owin and that is very straight forward with the help of two NuGet packages mentioned below,

Microsoft.Owin.SelfHost

Microsoft.AspNet.WebApi.OwinSelfHost

But we’ll do hosting for WebAPI 1 and will not make use of Owin for this application.

Step 1 : Create Console Application.

Open your visual studio and create a new console application named SelfHostedAPI

1

 

We’ll add a WebAPI controller to it and write code for CURD operations, but before that we need the database and a communication for performing database transactions.I’ll use EntityFramework for database transactions.

Step 2 : Create Database

You can create any database you want. I am using SQL Server and will create a database named WebAPIdb having a table named Products for performing CURD operations.There are more tables in this database but we’ll not use them.

2

I’ll provide that database script along with this article. Script for Products table is as follows,

   1:

 

   2: USE [WebApiDb]

 

   3: GO

 

   4: /****** Object: Table [dbo].[Products] Script Date: 

 

   5: 04/14/2016 11:02:51 ******/

 

   6: SET ANSI_NULLS ON

 

   7: GO

 

   8: SET QUOTED_IDENTIFIER ON

 

   9: GO

 

  10: SET ANSI_PADDING ON

 

  11: GO

 

  12: CREATE TABLE [dbo].[Products](

 

  13:  [ProductId] [int]

 

  14: IDENTITY(1,1) NOT NULL,

 

  15:  [ProductName] [varchar](50) NOT

 

  16: NULL,

 

  17: CONSTRAINT [PK_Products] PRIMARY KEY CLUSTERED

 

  18:

 

  19: (

 

  20:  [ProductId] ASC

 

  21: )WITH (PAD_INDEX = OFF,

 

  22: STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS

 

  23: = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]

 

  24: ) ON [PRIMARY]

 

  25: GO

 

  26: SET ANSI_PADDING OFF

 

  27: GO

 

So we are done with database creation , now let us setup the entity layer for communication.

Step 2 : Set up data access using Entity Framework

In your Visual Studio, select Tool->Packet Manager->Packet Manager Console to add Entity framework package,

image

I’ll install Entity Framework 5.0, as it works well with .Net Framework 4.0. So select SelfHostedAPI as Default project and type command Install-Package EntityFramework –Version 5.0.0 and press enter.

3

Once installed successfully, you’ll see Entity framework dll added to your project.

Now right click your project and add the new item. Select ADO.Net Entity Data Model from a list of Visual c# items.

4

You’ll be prompted with options to generate a model. Choose Generate From Database option and proceed.

5

After providing database details in the next step, choose database tables that you want to map with the model. I have only selected products table as we’ll perform CURD over this table only.

6

Click on Finish and your Entity Data Model will be ready with your database tables mapping. You’ll see that an App.Config file is generated and a connection string specific to the selected database is added to that config file.

Now we need to generate object context that handles transactions and objectset acting as model classes mapped to the table.

Right click on your edmx view and in the context menu , click Add Code Generation Item.

7

In the open window for the list of items select ADO.NET EntityObject Generator like shown in below image.

8

Select this and press OK, this will generate your Model1.tt class containing context and entities in the same class. Now we are done with all database related stuff.I’ll now create a WebAPI controller and in place all CURD operations in it.

Step 3: Add WebAPI Controller

Since we need an API where we can perform all CURD operations on our database, we have to add a WebAPI controller class in the project. Since this is a console application and not a WebAPI project, so we don’t have a proper structure defined for adding the controller. you can create your own folder structure for the sake of understanding.I am directly adding an API controller class named ProductController in the project.

Right click on the project, add new item and select WebAPI controller class from the list of items. You can name it as per your choice. I have named it as ProductController

9

The generated class is derived from APIController class that means it is a valid WebAPI controller class. The class by default contains default CURD methods that have following implementations,

   1: using System;

 

   2: using System.Collections.Generic;

 

   3: using System.Linq;

 

   4: using System.Net;

 

   5: using System.Net.Http;

 

   6: using System.Web.Http;

 

   7:

 

   8: namespace SelfHostedAPI

 

   9: {

 

  10:     public class ProductController : ApiController

 

  11:     {

 

  12:         // GET api/<controller>

 

  13:         public IEnumerable<string> Get()

 

  14:         {

 

  15:             return new string[] { "value1", "value2" };

 

  16:         }

 

  17:

 

  18:         // GET api/<controller>/5

 

  19:         public string Get(int id)

 

  20:         {

 

  21:             return "value";

 

  22:         }

 

  23:

 

  24:         // POST api/<controller>

 

  25:         public void Post([FromBody]string value)

 

  26:         {

 

  27:         }

 

  28:

 

  29:         // PUT api/<controller>/5

 

  30:         public void Put(int id, [FromBody]string value)

 

  31:         {

 

  32:         }

 

  33:

 

  34:         // DELETE api/<controller>/5

 

  35:         public void Delete(int id)

 

  36:         {

 

  37:         }

 

  38:     }

 

  39: }

 

 

We’ll make use of these default methods but write our own business logic for DB operations.

Step 4: Add CURD methods

We’ll add all the four methods for Create, Update, Read and Delete.Note that we’ll not make use of any design pattern like UnitOfWork or Repository for data persistence as our main target is to self-host this service and expose its CURD endpoint.

1. Fetch All Records

Modify Get() method to return a list of Product entities and make use of WebAPIEntities class generated in Model1.cs file to get the list of products. The method name here signifies the type of method as well, so basically this is a Get method of the service and should be called as method type get from the client as well. Same applies to every method we write here in this class for all CURD operations.

   1: // GET api/<controller>

 

   2:         public IEnumerable<Product> Get()

 

   3:         {

 

   4:             var entities=new WebApiDbEntities();

 

   5:             return entities.Products;

 

   6:         }

 

in the above-mentioned code base we return IEnumerable of product entities and use object of WebApiDbEntities (auto generated context class) to fetch all the objects using entities.Products.

2. Fetch product by id

Modify Get(int id) method to return a product entity.The method takes an id and returns the product specific to that id. you can enhance the method with validations and checks to make it more robust, but for the sake of understanding the concept, I am just doing it straight away.

   1: // GET api/<controller>/5

 

   2:        public Product Get(int id)

 

   3:        {

 

   4:            var entities = new WebApiDbEntities();

 

   5:            return entities.Products.FirstOrDefault(p=>p.ProductId==id);

 

   6:        }

 

3. Create product

   1: // POST api/<controller>

 

   2:        public bool Post([FromBody]Product product)

 

   3:        {

 

   4:            var entities = new WebApiDbEntities();

 

   5:            entities.AddToProducts(product);

 

   6:            var i = entities.SaveChanges();

 

   7:            return i > 0;

 

   8:        }

 

As the name signifies, this is a Post method , that fetches a Product class object from a body of the request and adds that product into entities.Note that your product will be added to the actual database only when you execute entities.SaveChanges(). This method actually inserts your record in the database and returns 1 in the case of successful insert else 0.

4. Edit/Update Product

   1: // PUT api/<controller>/5

 

   2:      public bool Put(int id, [FromBody]Product product)

 

   3:      {

 

   4:          using (var entities = new WebApiDbEntities())

 

   5:          {

 

   6:              var prod = (from p in entities.Products

 

   7:                          where p.ProductId == id

 

   8:                          select p).FirstOrDefault();

 

   9:

 

  10:              prod.ProductName = product.ProductName;

 

  11:              var i=entities.SaveChanges();

 

  12:              return i > 0;

 

  13:          }

 

  14:      }

 

Since this is an update operation, we name it as Put method, and as the name signifies, it is of PUT type. The method takes id and product object as an argument, where first an actual product from the database is fetched having an id that is passed as an argument and then that product is modified with the details of parameter product and then again saved to the database.In our case, we have the only product name that could be changed because id is fixed primary key, so we update the product name of a product in this method and save changes to that entity.

5. Delete product

   1: // DELETE api/<controller>/5

 

   2:         public bool Delete(int id)

 

   3:         {

 

   4:             using (var entities = new WebApiDbEntities())

 

   5:             {

 

   6:                 var prod = (from p in entities.Products

 

   7:                             where p.ProductId == id

 

   8:                             select p).FirstOrDefault();

 

   9:

 

  10:                entities.Products.DeleteObject(prod);

 

  11:                var i=entities.SaveChanges();

 

  12:                return i > 0;

 

  13:             }

 

  14:         }

 

The above-mentioned delete method is of DELETE type and accepts id of the product as a parameter. The method fetches product from database w.r.t. passed the id and then deletes that product and save changes. the implementation is pretty simple and self-explanatory.

With this method, we have completed all our CURD endpoints that we needed to expose. As you can see I have not applied any special routing for endpoints and rely upon the default routing provided by WebAPI i.e. api/<controller>/<id>

Step 5: Hosting WebAPI

Here comes the most important piece of this post, “self-hosting”. Remember when you created SelfHostedAPI project, it was a console application and so it came with a Program.cs file created within the project.The Program.cs file contains the main method i.e. entry point of the application. We’ll use this main method to write self-hosting code for our WebAPI.

Before we write any code we need to add a NuGet package through Package manager console. This package contains hosting specific classes required to host API in console application i.e. independently in a separate process other  than IIS. Note that in WebAPI 2 we have Owin middleware that provides this flexibility.

Since we are using Visual Studio 2010 and .net framework 4.0, we need to install a specific version of the package named Microsoft.AspNet.WebApi.SelfHost. the compatible version that I found was version 4.0.20710

 

11

So open your package manager console and choose default project and execute the command “Install-Package Microsoft.AspNet.WebApi.SelfHost -Version 4.0.20710”

This installs the package for your project and now you can use it for implementation.

Open the Program.cs file and add a namespace

   1: using System.Web.Http.SelfHost;

 

and in the main method define the base address of your endpoint that you want to expose, I am choosing the endpoint to be 8082. make sure you are running your visual studio in Administrator mode else you’ll have to change few configurations to work it for you. I have taken the following explanation from this asp.net article to explain configuration changes,

“Add an HTTP URL Namespace Reservation

This application listens to http://localhost:8080/. By default, listening at a particular HTTP address requires administrator privileges. When you run the tutorial, therefore, you may get this error: “HTTP could not register URL http://+:8080/&#8221; There are two ways to avoid this error:

  • Run Visual Studio with elevated administrator permissions, or
  • Use Netsh.exe to give your account permissions to reserve the URL.

To use Netsh.exe, open a command prompt with administrator privileges and enter the following command:following command:

netsh http add urlacl url=http://+:8080/ user=machine\username

where machine\username is your user account.

When you are finished self-hosting, be sure to delete the reservation:

netsh http delete urlacl url=http://+:8080/”
1. Define an object for SelfHostConfiguration as follows,
   1: var config = new HttpSelfHostConfiguration("http://localhost:8082");

 

2. Define the default route of your WebAPI

   1: config.Routes.MapHttpRoute(

 

   2:                "API Default", "api/{controller}/{id}",

 

   3:                new { id = RouteParameter.Optional });

 

This is the default route that our service will follow while running.

3. Start server in a process

   1: using (var server = new HttpSelfHostServer(config))

 

   2:  {

 

   3:      server.OpenAsync().Wait();

 

   4:      Console.WriteLine("Server started....");

 

   5:      Console.WriteLine("Press Enter to quit.");

 

   6:      Console.ReadLine();

 

   7:  }

 

The above piece of code is used to host and start a server for the service that we have created. As you can see its just few lines of code to get our service started in a separate process and we don’t actually need to rely upon IIS server.

Hence our Program.cs becomes,

   1: using System;

 

   2: using System.Web.Http;

 

   3: using System.Web.Http.SelfHost;

 

   4:

 

   5: namespace SelfHostedAPI

 

   6: {

 

   7:     class Program

 

   8:     {

 

   9:         static void Main(string[] args)

 

  10:         {

 

  11:             var config = new HttpSelfHostConfiguration("http://localhost:8082");

 

  12:

 

  13:             config.Routes.MapHttpRoute(

 

  14:                 "API Default", "api/{controller}/{id}",

 

  15:                 new { id = RouteParameter.Optional });

 

  16:

 

  17:             using (var server = new HttpSelfHostServer(config))

 

  18:             {

 

  19:                 server.OpenAsync().Wait();

 

  20:                 Console.WriteLine("Server started....");

 

  21:                 Console.WriteLine("Press Enter to quit.");

 

  22:                 Console.ReadLine();

 

  23:             }

 

  24:         }

 

  25:     }

 

  26: }

 

Now when you start the application by pressing F5, you’ll get your server started and service endpoints listening to your request. We’ll test the end points with our own test client that we are about to create. but before that let us start our server.

Compile the application and in windows explorer navigate to SelfHostedAPI.exe in bin\debug folder and run it as an administrator.

image

Your server will start immediately,

image

And when you type the URL in browser http://localhost:8082, you’ll see that the server actually returns a response of resource not found,

image

That means our port is listening to the requests.

WebAPI Test Client

Now that we know our services are up and running, its time to test them through a test client. You can use your own test client or build a one as a console application. I am building a separate test client in .net itself to test the services.

Step1: Add a console application

Add a console application in the same or another solution with the name APITestClient or the name of your choice.We’ll use Program.cs to write all the code for calling WebAPI methods.But before that, we need to install a NuGet package that helps us in creating a HTTP client through which we’ll make API calls.

Step2: Add web client package

Open Library package manager, select APITestClient as default project and execute the command “Install-Package Microsoft.AspNet.WebApi.Client -Version 4.0.20710”

image

This will install the necessary package and its dependencies in your test client project.

Step3: Setup client

Time to code, open program.cs and add the namespace ,

   1: using System.Net.Http;

 

   2: using System.Net.Http.Headers;

 

Define HttpClient variable,

   1: private static readonly HttpClient Client = new HttpClient();

 

and in Main method initialize the client with basic requirements like with base address of services to be called and media type,

   1: Client.BaseAddress = new Uri("http://localhost:8082");

 

   2: Client.DefaultRequestHeaders.Accept.Clear();

 

   3: Client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

 

All set , now we can write CURD calling methods and call them from the main method.

Step4 : Calling Methods

1. GetAllProducts :

   1: /// <summary>

 

   2:        /// Fetch all products

 

   3:        /// </summary>

 

   4:        private static void GetAllProducts()

 

   5:        {

 

   6:            HttpResponseMessage resp = Client.GetAsync("api/product").Result;

 

   7:            resp.EnsureSuccessStatusCode();

 

   8:

 

   9:            var products = resp.Content.ReadAsAsync<IEnumerable<SelfHostedAPI.Product>>().Result.ToList();

 

  10:            if (products.Any())

 

  11:            {

 

  12:                Console.WriteLine("Displaying all the products...");

 

  13:                foreach (var p in products)

 

  14:                {

 

  15:                    Console.WriteLine("{0} {1} ", p.ProductId, p.ProductName);

 

  16:                }

 

  17:            }

 

  18:        }

 

The above method makes the call to “api/product “ endpoint via HttpClient instance and expects a result in HttpResponseMessage from service. Note that it uses the method GetAsync to make an endpoint call, this states that it is calling a Get method of REST API.

We have about 6 records in database that needs to be displayed,

image

Let’s run the application by calling the method from Main method but before that make sure your WebAPI is running in console application like we did earlier,

   1: private static void Main(string[] args)

 

   2: {

 

   3:     Client.BaseAddress = new Uri("http://localhost:8082");

 

   4:     Client.DefaultRequestHeaders.Accept.Clear();

 

   5:     Client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

 

   6:     GetAllProducts();

 

   7:

 

   8:     Console.WriteLine("Press Enter to quit.");

 

   9:     Console.ReadLine();

 

  10: }

 

The result is as below.

image

Hurray, we got all our products from database to this client.

victory

This proves that our service is well hosted and working fine. We can define other methods too in a similar way and test the API endpoints.

2.  GetProduct():

This method fetches product by id.

   1: /// <summary>

 

   2: /// Get product by id

 

   3: /// </summary>

 

   4: private static void GetProduct()

 

   5: {

 

   6:     const int id = 1;

 

   7:     var resp = Client.GetAsync(string.Format("api/product/{0}", id)).Result;

 

   8:     resp.EnsureSuccessStatusCode();

 

   9:

 

  10:     var product = resp.Content.ReadAsAsync<SelfHostedAPI.Product>().Result;

 

  11:     Console.WriteLine("Displaying product having id : " + id);

 

  12:     Console.WriteLine("ID {0}: {1}", id, product.ProductName);

 

  13: }

 

Again the method is self-explanatory, I have by default called this method for product id “1”, you can customize the method as per your need.Just compile and run the method.We get,

image

Hence, we get the result.

3.  AddProduct():

   1: /// <summary>

 

   2:        /// Add product

 

   3:        /// </summary>

 

   4:        private static void AddProduct()

 

   5:        {

 

   6:            var newProduct = new Product() { ProductName = "Samsung Phone" };

 

   7:            var response = Client.PostAsJsonAsync("api/product", newProduct);

 

   8:            response.Wait();

 

   9:            if (response.Result.IsSuccessStatusCode)

 

  10:            {

 

  11:                Console.WriteLine("Product added.");

 

  12:            }

 

  13:        }

 

In above method, I am trying to add a new product named “Samsung Phone” in our existing product list. Since we have auto-id generation at the database, so ve don’t have to provide the id of the product.It will automatically get inserted in database with a unique id. Note that this method makes the call with a Post type method to API end point. Run the application.

image

It says product added. now let’s go to the database and check our table. Execute a select query over your table in SQL Server database and we get one new product with id “7” added in the table having name “Samsung Phone”,

image

4.  EditProduct():

   1: /// <summary>

 

   2:        /// Edit product 

 

   3:        /// </summary>

 

   4:        private static void EditProduct()

 

   5:        {

 

   6:            const int productToEdit = 4;

 

   7:            var product = new Product() { ProductName = "Xamarin" };

 

   8:

 

   9:            var response =

 

  10:                Client.PutAsJsonAsync("api/product/" + productToEdit, product);

 

  11:            response.Wait();

 

  12:            if (response.Result.IsSuccessStatusCode)

 

  13:            {

 

  14:                Console.WriteLine("Product edited.");

 

  15:            }

 

  16:

 

  17:        }

 

In above code, I am editing product having product id “4” and changing the existing product name i.e. IPad to Xamarin.Note that this method makes the call with a Put type method to API endpoint.Run the application

image

In database,

image

We see here that our existing product named Ipad is updated to new name “Xamarin”. We see that one new product has also been added with id 8, that’s because we again called add method from the main method , ideally, we would have commented it out while testing edit methodSmile.

4.  DeleteProduct():

   1: /// <summary>

 

   2:     /// Delete product

 

   3:     /// </summary>

 

   4:     private static void DeleteProduct()

 

   5:     {

 

   6:         const int productToDelete = 2;

 

   7:         var response = Client.DeleteAsync("api/product/" + productToDelete);

 

   8:         response.Wait();

 

   9:         if (response.Result.IsSuccessStatusCode)

 

  10:         {

 

  11:             Console.WriteLine("Product deleted.");

 

  12:         }

 

  13:     }

 

In above method, we delete a product having id 2.Note that this method makes the call with a Delete type method to API endpoint.Run the application

image

Product deleted. Let’s check in database,

image

We see the product with id “2” as deleted.

So , we have performed all the CURD operations on a self-hosted WebAPI. And the result was as expected. Following is the code for Program.cs file in consolidation.

   1: #region Using namespaces

 

   2: using System;

 

   3: using System.Collections.Generic;

 

   4: using System.Linq;

 

   5: using System.Net.Http;

 

   6: using System.Net.Http.Headers;

 

   7: using SelfHostedAPI;

 

   8: #endregion

 

   9:

 

  10: namespace APITestClient

 

  11: {

 

  12:     internal class Program

 

  13:     {

 

  14:         #region Private member variables

 

  15:         private static readonly HttpClient Client = new HttpClient();

 

  16:         #endregion

 

  17:

 

  18:         #region Main method for execution entry

 

  19:         /// <summary>

 

  20:         /// Main method

 

  21:         /// </summary>

 

  22:         /// <param name="args"></param>

 

  23:         private static void Main(string[] args)

 

  24:         {

 

  25:             Client.BaseAddress = new Uri("http://localhost:8082");

 

  26:             Client.DefaultRequestHeaders.Accept.Clear();

 

  27:             Client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

 

  28:             GetAllProducts();

 

  29:             GetProduct();

 

  30:             AddProduct();

 

  31:             EditProduct();

 

  32:             DeleteProduct();

 

  33:             Console.WriteLine("Press Enter to quit.");

 

  34:             Console.ReadLine();

 

  35:         }

 

  36:         #endregion

 

  37:

 

  38:         #region Private client methods

 

  39:         /// <summary>

 

  40:         /// Fetch all products

 

  41:         /// </summary>

 

  42:         private static void GetAllProducts()

 

  43:         {

 

  44:             HttpResponseMessage resp = Client.GetAsync("api/product").Result;

 

  45:             resp.EnsureSuccessStatusCode();

 

  46:

 

  47:             var products = resp.Content.ReadAsAsync<IEnumerable<SelfHostedAPI.Product>>().Result.ToList();

 

  48:             if (products.Any())

 

  49:             {

 

  50:                 Console.WriteLine("Displaying all the products...");

 

  51:                 foreach (var p in products)

 

  52:                 {

 

  53:                     Console.WriteLine("{0} {1} ", p.ProductId, p.ProductName);

 

  54:                 }

 

  55:             }

 

  56:         }

 

  57:

 

  58:         /// <summary>

 

  59:         /// Get product by id

 

  60:         /// </summary>

 

  61:         private static void GetProduct()

 

  62:         {

 

  63:             const int id = 1;

 

  64:             var resp = Client.GetAsync(string.Format("api/product/{0}", id)).Result;

 

  65:             resp.EnsureSuccessStatusCode();

 

  66:

 

  67:             var product = resp.Content.ReadAsAsync<SelfHostedAPI.Product>().Result;

 

  68:             Console.WriteLine("Displaying product having id : " + id);

 

  69:             Console.WriteLine("ID {0}: {1}", id, product.ProductName);

 

  70:         }

 

  71:

 

  72:         /// <summary>

 

  73:         /// Add product

 

  74:         /// </summary>

 

  75:         private static void AddProduct()

 

  76:         {

 

  77:             var newProduct = new Product() { ProductName = "Samsung Phone" };

 

  78:             var response = Client.PostAsJsonAsync("api/product", newProduct);

 

  79:             response.Wait();

 

  80:             if (response.Result.IsSuccessStatusCode)

 

  81:             {

 

  82:                 Console.WriteLine("Product added.");

 

  83:             }

 

  84:         }

 

  85:

 

  86:         /// <summary>

 

  87:         /// Edit product 

 

  88:         /// </summary>

 

  89:         private static void EditProduct()

 

  90:         {

 

  91:             const int productToEdit = 4;

 

  92:             var product = new Product() { ProductName = "Xamarin" };

 

  93:

 

  94:             var response =

 

  95:                 Client.PutAsJsonAsync("api/product/" + productToEdit, product);

 

  96:             response.Wait();

 

  97:             if (response.Result.IsSuccessStatusCode)

 

  98:             {

 

  99:                 Console.WriteLine("Product edited.");

 

 100:             }

 

 101:

 

 102:         }

 

 103:

 

 104:         /// <summary>

 

 105:         /// Delete product

 

 106:         /// </summary>

 

 107:         private static void DeleteProduct()

 

 108:         {

 

 109:             const int productToDelete = 2;

 

 110:             var response = Client.DeleteAsync("api/product/" + productToDelete);

 

 111:             response.Wait();

 

 112:             if (response.Result.IsSuccessStatusCode)

 

 113:             {

 

 114:                 Console.WriteLine("Product deleted.");

 

 115:             }

 

 116:         }

 

 117:

 

 118:         #endregion

 

 119:     }

 

 120: }

 

 

Conclusion

I have tried to keep this tutorial simple and straight forward, and explain each and every step through which you can create a simple WebAPI with all CURD operations using Entity Framework, and finally, self-host that API and test it.I hope you enjoyed reading this article. You can download the complete source code from GitHub.

Read more:

Other Series

My other series of articles:

· Learning WebAPIs in .Net

· Learning OOP concepts with C#

· Learning MVC

For more technical articles you can reach out to my personal blog CodeTeddy.

Advertisements

Author: Akhil Mittal

Akhil Mittal is a Microsoft MVP,C# Corner MVP, Code project MVP, blogger, programmer by heart and currently working as a Sr. Analyst in Magic Software and have an experience of more than 9 years in C#.Net. He holds a B.Tech in Computer Science and hold a diploma in Information Security and Application Development. His work experience includes Development of Enterprise Applications using C#,.Net and Sql Server,Analysis, Product Management as well as Research and Development. He is a MCP in Web Applications(MCTS-70-528,MCTS-70-515) and .Net Framework 2.0 (MCTS-70-536).