Module 10: Web API with ASP.NET Core

Building Web APIs is arguably the most critical skill for a modern .NET developer. In a world of mobile apps and single-page applications (React, Angular, Vue), the backend is almost always a Web API.

1. REST API Fundamentals

REST (Representational State Transfer) is an architectural style, not a protocol. It relies on a few core principles:

• Statelessness: The server doesn’t “remember” the client. Every request must contain all the info needed to process it (like an API key or token).
• Client-Server Separation: The backend handles data; the frontend handles the UI. They don’t need to know how the other is built.
• Uniform Interface: You use standard URLs (Nouns) and standard HTTP Methods (Verbs).

2. HTTP Methods & Status Codes

In a professional API, you must use the correct “verb” and return the correct “status” so the frontend knows exactly what happened.

The “Verbs” (Methods)

The “Status” (Responses)

• 200 OK: Success.
• 201 Created: Success (usually after a POST).
• 400 Bad Request: Client sent invalid data (e.g., missing a required field).
• 401 Unauthorized: Missing or invalid login credentials.
• 404 Not Found: The resource doesn’t exist.
• 500 Internal Server Error: Your code crashed.

3. DTOs & AutoMapper

As discussed in earlier modules, you shouldn’t expose your Database Entities (like User) directly to the internet because they might contain sensitive data like PasswordHash.

• DTO (Data Transfer Object): A simple class containing only the data the client needs (e.g., UserDto with only Username and Email).
• AutoMapper: A library that automates the tedious work of copying data from a User object to a UserDto.
  • Manual: dto.Name = user.Name; (boring and error-prone).
  • AutoMapper: _mapper.Map<UserDto>(user); (clean and fast).

4. Swagger / OpenAPI

Documentation is vital. Swagger (now technically OpenAPI) is built into .NET templates.

• It provides a web-based UI where you can see all your API endpoints.
• It allows you to test your API directly from the browser without writing any frontend code.

5. API Versioning

APIs evolve. If you change a field name in v1, you might break thousands of mobile apps using your service.

• Solution: Versioning.
• Example: api/v1/products and api/v2/products.
• You use the Asp.Versioning.Mvc package to handle this cleanly in .NET.

6. Consuming APIs

A .NET developer doesn’t just build APIs; they often have to call them (e.g., calling the Stripe API for payments or the Weather API).

• HttpClientFactory: The modern, high-performance way to manage outgoing HTTP requests in .NET.
• JSON Deserialization: Converting the JSON response from another server back into a C# object using System.Text.Json.