var builder = WebApplication.CreateBuilder(args); // Add DbContext with SQL Server connection string builder.Services.AddDbContext<AppDbContext>(options =>     options.UseSqlServer(builder.Configuration.GetConnectionString(“DefaultConnection”))); var app = builder.Build(); // Define an endpoint that interacts with the database app.MapGet(“/products”, async (AppDbContext db) => { return await db.Products.ToListAsync(); }); app.Run();

6. Database Integration with Minimal APIs

Using Entity Framework: Minimal APIs easily integrate with Entity Framework Core (EF Core) for database access.

• Here’s a quick setup to demonstrate how to connect to a database:

Install EF Core packages:

Define your DbContext: Create a class that represents your database context and models.

                     Configure the database in Program.cs:

• Best Practices: To keep your Minimal API maintainable and clean:

1. Separate Business Logic: Use services or repositories to keep your API lean and focused only on handling HTTP requests. Avoid putting business logic directly in your endpoint.
2. Inject Services: Register and Inject services in your API to maintain separation of concerns.

• By Separating concerns and structuring your code properly, you’ll ensure that your Minimal APIs remain maintainable, scalable and easy to work with.

7. Routing and Parameter Binding

• Route Mapping: In Minimal APIs, routes are defined directly in code using methods like MapGet(), MapPost(), MapPut(), and MapDelete(). These methods simplify routing by allowing you to map HTTP requests (e.g., GET, POST) to specific endpoints and logic without needing to use traditional controllers or attributes, as in the MVC framework.
• How It Works: Each method represents an HTTP verb (e.g., GET, POST) and directly ties the URL route to the code that handles the request. You define everything in your Program.cs file, keeping the API logic centralized and minimal.
• Examples: MapGet() for GET Requests: MapGet() is used to map a route to an HTTP GET request. It responds when the client sends a GET request to the specified URL.

In this example:

• /products is the URL route.
• When a GET request is made to /products, the code inside the lambda function fetches all products from the database.

Key Benefits:

• Simple and Direct: Each route is mapped to its corresponding HTTP method, making the code easy to understand and maintain.
• No Attribute Routing: You don’t need attributes like [HttpGet] or [HttpPost]—just inline method calls.
• One-File Setup: You can manage all your routes and logic in a single file (Program.cs), reducing complexity.

In short, Minimal APIs let you define routes and handlers directly in code using MapGet(), MapPost(), etc., simplifying the setup and making your API lightweight and faster to develop.

• Binding Parameters:
  When a parameter is part of the route (i.e., part of the URL), you can bind it directly in the handler by specifying it as an argument in the lambda function. The route placeholders are indicated by curly braces {} in the URL pattern.

• Route: /products/{id}
• Binding: The id is extracted from the URL and passed into the handler as the id argument.
• Usage: When a GET request is made to /products/5, the id parameter will be 5, and the function will use this value to return or process the corresponding product.

 

8. Middleware in Minimal APIs

How Middleman Works: How to dd middleware to minimal APIs.

Code Example:

i. Basic Exception Handling in Route Handlers

You can handle exceptions directly in each route handler using try-catch blocks.

ii. Global Error Handling with Middleware

To manage exceptions globally across your entire API, you can use middleware that captures any unhandled exceptions and returns a standardized error response. This approach avoids the need to handle exceptions in every route individually.

• UseExceptionHandler(): This middleware catches unhandled exceptions and redirects them to the /error route.
• Map(“/error”): Defines a centralized error-handling endpoint that returns a generic error response to the client (Results.Problem()).iii. Custom Error Responses

You can customize the error response based on the exception details, returning a more specific error message or even different HTTP status codes.

iii. Custom Error Responses

To manage exceptions globally across your entire API, you can use middleware that captures any unhandled exceptions and returns a standardized error response. This approach avoids the need to handle exceptions in every route individually.

• This middleware captures the exception details and returns a JSON response with a custom error message and the exception’s message.

9. Authentication and Authorization

• Securing Minimal APIs: You can still secure Minimal APIs using ASP.NET Core’s built-in authentication and authorization mechanism.
• Even though Minimal APIs focus on simplicity, they can still be secured using ASP.NET Core’s built-in authentication and authorization mechanism. These security features ensure that only authenticated and authorized users can access certain endpoints.
• Example:

11. Real-world Use Cases

Minimal APIs are perfect for scenarios that require fast, lightweight, and easily maintainable APIs. Here are a few real-world scenarios where Minimal APIs shine:

Microservices: Microservices are small, independent services that focus on a single business capability. Minimal APIs are ideal for microservices because they:

• Require minimal setup, making it easy to spin up new services.
• Have lower overhead compared to traditional ASP.NET Core MVC, leading to faster startup times.
• Enable each service to be small and self-contained.

Example: A retail company might have separate microservices for order processing, inventory management, and payment processing. Each microservice can be developed as a Minimal API that handles only its specific function, leading to faster development and easier scaling.

Serverless Applications: Serverless platforms like Azure Functions or AWS Lambda are well-suited for Minimal APIs. In serverless apps, the infrastructure is abstracted away, and the focus is on the code itself. Minimal APIs work well in this environment because they:

• Use minimal boilerplate code, which fits the lightweight nature of serverless applications.
• Can be easily deployed as individual, event-driven functions.
• Provide fast execution times due to low overhead.

Example: A company can use Azure Functions with Minimal APIs to build a serverless backend for a mobile application that handles simple tasks like retrieving user data, sending notifications, or performing authentication, all without managing servers.

Prototypes and MVPs (Minimum Viable Products): When building prototypes or MVPs, speed and simplicity are essential. Minimal APIs allow developers to quickly build and iterate on APIs without worrying about the complex setup of controllers, models, and routing systems. This makes Minimal APIs a great choice for:

• Rapid prototyping: Quickly build an API for testing and validating ideas.
• Iterating faster: Make changes to the API structure easily during development.

Example: A startup might build a Minimal API to support a new web application idea, handling user authentication and simple CRUD operations on products. The small API can evolve as needed without getting bogged down by a large framework.