Asp.Net Web Api Creating A Web Api Project Framework And Core Complete Guide

ASP.NET Web API: Creating a Web API Project Framework and Core

Key Concepts:

1. HTTP: At its core, ASP.NET Web API is an HTTP service, which means it uses standard HTTP verbs like GET, POST, PUT, DELETE.
2. Controllers: Similar to ASP.NET MVC, a controller in the Web API handles all HTTP requests and returns appropriate responses.
3. Routing: Web API uses routing to determine which action method should be executed based on the URL, HTTP verb, and possibly additional route data.
4. MediaFormatters: These handle the serialization of objects into HTTP responses in various formats (XML, JSON) and the deserialization of HTTP request bodies into .NET types.
5. Model Binding: This is the process by which the Web API framework extracts parameters needed to run an action method from an HTTP request (query string, form data, route values).
6. Action Methods: Methods within controllers that correspond to specific HTTP operations (GET, POST, PUT, DELETE).
7. Dependency Injection: Enables you to insert dependencies in different classes using composition or constructors rather than creating them directly.
8. Authentication and Authorization: Security features that help manage user access and permissions.

Step-by-Step Guide:

1. Setting Up Your Environment Before starting, make sure you have Microsoft Visual Studio (preferably the Community Edition) installed. Also, ensure you have the latest .NET SDK and the ASP.NET and web development workload selected during Visual Studio’s setup.

2. Create a New ASP.NET Web API Project

• Launch Visual Studio and select "Create a new project".
• Search for "ASP.NET Core Web Application (.NET Core)" and pick the project template.
• Follow the prompts to name your project and choose a location.
• In the next window, select the .NET Core version and choose the ASP.NET Core Web API template.

3. Project Structure Your project will typically contain these folders and files:

• Controllers: A folder where your API controllers reside.
• Models: A folder where your data model classes are stored.
• appsettings.json: Holds configuration settings.
• Startup.cs: Configures services and the app middleware pipeline.
• Program.cs: Contains the entry point for the application and builds the host.

4. Understanding Startup.cs and Program.cs Startup.cs contains two important methods:

• ConfigureServices(IServiceCollection services): Registers the types to make them available via dependency injection.
• Configure(IApplicationBuilder app, IWebHostEnvironment env): Sets up the middleware pipeline that processes HTTP requests.

With .NET 6 and later versions, Startup.cs functionality has been merged into Program.cs.

5. Creating a Controller

• Right-click on the Controllers folder, select Add → Controller.
• Choose "API Controller - Empty" and give it a name, such as ProductsController.
• An empty controller class derived from ControllerBase will scaffold automatically for you.

using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("[controller]")]
public class ProductsController : ControllerBase
{
    // GET: api/Products
    [HttpGet]
    public IEnumerable<Product> Get()
    {
        return GetAllProducts(); // Method to retrieve products
    }

    // GET: api/Products/5
    [HttpGet("{id}")]
    public ActionResult<Product> Get(int id)
    {
        var product = GetProductById(id); // Method to find a specific product by ID
        if (product == null)
        {
            return NotFound();
        }
        return product;
    }

    // POST: api/Products
    [HttpPost]
    public void Post([FromBody] Product value)
    {
        AddProduct(value); // Add a new product
    }

    // PUT: api/Products/5
    [HttpPut("{id}")]
    public void Put(int id, [FromBody] Product value)
    {
        UpdateProduct(id, value); // Update an existing product
    }

    // DELETE: api/Products/5
    [HttpDelete("{id}")]
    public void Delete(int id)
    {
        RemoveProduct(id); // Remove a product
    }

    private static List<Product> _products = new();

    private IEnumerable<Product> GetAllProducts() => _products;
    private Product? GetProductById(int id) => _products.FirstOrDefault(p => p.Id == id);
    private void AddProduct(Product product) { /* logic to add product */ }
    private void UpdateProduct(int id, Product product) { /* logic to update product */ }
    private void RemoveProduct(int id) { /* logic to remove product */ }
}

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
    public decimal Price { get; set; }
}

6. Routing

• The default routing structure [Route("[controller]")] in the controller maps routes to actions automatically based on their names.
• You can customize routes using various attributes like [Route("api/[controller]")], [HttpGet("{id}")], etc.
• Ensure your URLs align correctly with the HTTP methods and any required parameters.

7. Middleware Configuration In Program.cs, configure middleware to provide necessary services to the application.

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllers();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

8. Model Binding Model binding converts HTTP-request data into objects which are parameters passed into controller actions.

• Automatic Model Binding: When you use parameter names in action methods, the system looks for those names in the incoming request, whether it's in the URI, query string, or form body.
• Manual Model Binding: You can bind models manually using [FromBody], [FromForm], [FromQuery], etc.

9. Action Filters Attribute-based action filters are used to execute code before and after controller action methods.

• Use cases include validation, logging, exception handling.
• Example: [Authorize], [HttpGet].

10. Return Types

• Commonly used return types in controllers include IActionResult, Task<IActionResult>, etc.
• These allow you to specify more nuanced results like NotFound(), BadRequest(), OK().

11. Dependency Injection

• ASP.NET Core promotes loose coupling between classes and their dependencies via built-in DI container.
• Register services in ConfigureServices method and inject them through constructor or properties of controllers.

12. Authentication and Authorization

• Configure authentication in Program.cs via AddAuthentication() and AddAuthorization().

• Example:

  builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
                 .AddJwtBearer(options =>
                 {
                     options.TokenValidationParameters = new TokenValidationParameters
                     {
                         // Token validation parameters
                     };
                 });
  
  builder.Services.AddAuthorization(builder =>
  {
      builder.AddPolicy("ReadAccess", policy => policy.RequireClaim("ReadAccess"));
  });
  

• Apply authorization policies on controllers or actions.

13. Testing the API

• Run the project using F5 or Start Debugging.
• Test endpoints using tools like Postman or via browser (for GET requests).

Conclusion Creating a Web API project in ASP.NET Core involves setting up your environment, scaffolding the initial structure, defining routes, configuring middleware, implementing action methods, leveraging model binding, handling dependencies, configuring authentication and authorization, and testing the API. Each step plays a key role in building a robust and scalable service that can effectively serve various client applications.