Overview Of Asp.Net Web Api Framework Complete Guide

Overview of ASP.NET Web API Framework

ASP.NET Web API is a framework that makes it easier to build HTTP services that reach a broad range of clients, including browsers and mobile devices. It is an ideal platform for building RESTful applications on the .NET Framework.

Key Features of ASP.NET Web API:

1. RESTful Architecture: Easily expose data and services over HTTP.
2. HTTP Support: Supports all verbs (GET, POST, PUT, DELETE, etc.).
3. Content Negotiation: Returns data in various formats such as JSON, XML, etc., depending on the client’s request.
4. Model Binding and Validation: Automatically binds data from HTTP requests to your code and validates it.
5. Routing: Provides powerful routing capabilities.
6. Cross-Origin Resource Sharing (CORS): Allows your API to be accessed from domains other than the one that hosts the API.
7. Testability: Supports unit testing.
8. Task-based Asynchronous Programming: Utilizes the latest techniques for building asynchronous applications.

Step-by-Step Guide to ASP.NET Web API Framework

Step 1: Create a New ASP.NET Web API Project

1. Open Visual Studio (2019 or later).
2. Create a New Project:
   • Go to File -> New -> Project.
   • Select ASP.NET Core Web Application.
3. Configure the Project:
   • Enter the project name and location.
   • Click Create.
4. Select the Template:
   • Choose API.
   • Click Create.

Step 2: Understand the Project Structure

Once you create a new ASP.NET Core Web API project, the project structure will be as follows:

• Controllers: This is where you create your API Controllers.
• wwwroot: This is where static content goes, although for a Web API, it is not commonly used.
• Program.cs and Startup.cs: These are the configuration files for setting up the application.

Step 3: Create a Model

Model represents the data structure. Let’s create a simple model for a Product.

1. Right-click on the project, then Add -> Class.
2. Name it Product.cs and add the following code:

using System;
using System.ComponentModel.DataAnnotations;

namespace WebAPIExample.Models
{
    public class Product
    {
        public int Id { get; set; }
        [Required]
        public string Name { get; set; }
        [Required]
        public decimal Price { get; set; }
        public DateTime CreatedAt { get; set; } = DateTime.Now;
    }
}

Step 4: Create a Controller

Controllers are responsible for handling the incoming HTTP requests and returning the HTTP response.

1. Right-click on the Controllers folder, then Add -> Controller.
2. Select "API Controller — Empty" and click Add.
3. Name it ProductsController.cs and add the following code:

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using System.Linq;
using WebAPIExample.Models;
using Microsoft.AspNetCore.Mvc.NewtonsoftJson;

namespace WebAPIExample.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ProductsController : ControllerBase
    {
        private static List<Product> _products = new List<Product>();
        private int _nextId = 1;

        // GET: api/Products
        [HttpGet]
        public ActionResult<IEnumerable<Product>> GetAll()
        {
            return Ok(_products);
        }

        // GET: api/Products/5
        [HttpGet("{id}")]
        public ActionResult<Product> GetById(int id)
        {
            var product = _products.FirstOrDefault(p => p.Id == id);
            if (product == null)
            {
                return NotFound();
            }
            return Ok(product);
        }

        // POST: api/Products
        [HttpPost]
        public ActionResult<Product> Post(Product product)
        {
            product.Id = _nextId++;
            _products.Add(product);
            return CreatedAtAction(nameof(GetById), new { id = product.Id }, product);
        }

        // PUT: api/Products/5
        [HttpPut("{id}")]
        public IActionResult Put(int id, Product product)
        {
            var index = _products.FindIndex(p => p.Id == id);
            if (index == -1)
            {
                return NotFound();
            }

            product.Id = id;
            _products[index] = product;
            return NoContent();
        }

        // DELETE: api/Products/5
        [HttpDelete("{id}")]
        public IActionResult Delete(int id)
        {
            var product = _products.FirstOrDefault(p => p.Id == id);
            if (product == null)
            {
                return NotFound();
            }

            _products.Remove(product);
            return NoContent();
        }
    }
}

Step 5: Run the Application

1. Press F5 to run the application.
2. Open a browser or a tool like Postman to test the API.
   • Get All Products: GET http://localhost:5000/api/products
   • Get Product by ID: GET http://localhost:5000/api/products/1
   • Add a Product: POST http://localhost:5000/api/products with JSON body {"Name": "Sample Product", "Price": 123.45}
   • Update a Product: PUT http://localhost:5000/api/products/1 with JSON body {"Id": 1, "Name": "Updated Product", "Price": 150.00}
   • Delete a Product: DELETE http://localhost:5000/api/products/1

Conclusion

In this step-by-step guide, you learned how to set up a basic ASP.NET Core Web API project. You created a model and a controller to handle HTTP requests. This setup allows you to build more complex APIs with authentication, security, and other important features.