Create ASP.NET Minimal APIs for Single Microservice: A Hands-On Guide

We’re diving into the world of microservices with ASP.NET Core Minimal APIs, focusing on setting up a single microservice from scratch. This hands-on guide will walk you through each step, ensuring you have a functional Web API by the end of this tutorial.

Our Todo API serves as a classic example of a microservice architecture, where a client’s HTTP requests are elegantly handled by our ASP.NET Web API, performing CRUD operations using an in-memory database.

I have just published course — .NET 8 Microservices: C# 12, DDD, CQRS, Vertical/Clean Architecture.

Setting Up Your Project

First things first, let’s get our environment ready:

1. Launch Visual Studio: Start by opening Visual Studio and selecting “Create a new project.”
2. Choose ASP.NET Web API Project: Search for “ASP.NET Core Web API” and select it. Click “Next.”
3. Project Configuration: Name your project “TodoApi.” Make sure the ‘Top-level statement and Controller’ checkbox is ticked to utilize the new minimalistic setup. Click “Create.”

Understanding Program.cs

With your project set up, you’ll find yourself looking at the Program.cs file. This is where the magic starts. Let's decode what's happening here.

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

Here, builder sets up our application with default settings. app is essentially our application, compiled and ready to go with all the services and configurations we've added.

Shaping the Model

Introduce a TodoItem class within your project, encapsulating the essential properties of a Todo item:

public class TodoItem
{
    public int Id { get; set; }
    public string Name { get; set; }
    public bool IsComplete { get; set; }
}

Incorporating the Database

NuGet Packages:

Ensure your project is powered with the necessary tools by adding the Microsoft.EntityFrameworkCore.InMemory package via NuGet.

Database Context:

Create TodoDb.cs, a DbContext class to manage our Todo items within the database:

public class TodoDb : DbContext
{
    public TodoDb(DbContextOptions<TodoDb> options) : base(options) { }
    public DbSet<TodoItem> Todos { get; set; }
}

Adding Services

Register TodoDb in Program.cs to leverage dependency injection:

builder.Services.AddDbContext<TodoDb>(opt => opt.UseInMemoryDatabase("TodoList"));

This section is where we integrate built-in ASP.NET services or our custom ones, using dependency injection.

Defining Endpoints

Here’s where we define our API endpoints. In our case, we have a todoitems endpoint. Expand Program.cs to include our CRUD endpoints, establishing a seamless bridge between HTTP requests and database operations:

app.MapGet("/todoitems", async (TodoDb db) => await db.Todos.ToListAsync());
app.MapGet("/todoitems/{id}", async (int id, TodoDb db) => await db.Todos.FindAsync(id));
app.MapPost("/todoitems", async (TodoItem todo, TodoDb db) => { /* Add & Save Logic */ });
app.MapPut("/todoitems/{id}", async (int id, TodoItem inputTodo, TodoDb db) => { /* Update Logic */ });
app.MapDelete("/todoitems/{id}", async (int id, TodoDb db) => { /* Delete Logic */ });

Each endpoint is meticulously crafted to handle specific actions, providing a full-fledged API for our Todo service.

Testing Our API

It’s time to see our API in action:

1. Run Your Application: Hit the run button in Visual Studio or use dotnet run from the command line.
2. Access the Endpoint: Open your browser or an API tool like Postman and navigate to https://localhost:{port}/todoitems

You’ll be greeted with a JSON response containing the todo items, confirming that our API is up and running.

Wrapping Up

You’ve successfully set up a Todo service, embracing the minimalist yet powerful capabilities of ASP.NET Core’s Minimal API feature. This project not only reinforces fundamental concepts of microservices but also serves as a springboard for more complex and feature-rich applications.

I have just published course — .NET 8 Microservices: C# 12, DDD, CQRS, Vertical/Clean Architecture.

This is step-by-step development of reference microservices architecture that include microservices on .NET platforms which used ASP.NET Web API, Docker, RabbitMQ, MassTransit, Grpc, Yarp API Gateway, PostgreSQL, Redis, SQLite, SqlServer, Marten, Entity Framework Core, CQRS, MediatR, DDD, Vertical and Clean Architecture implementation with using latest features of .NET 8 and C# 12.