Carter

ASP.NET Core Minimal API Using Carter

An ASP.NET Core Minimal API is a streamlined approach to building HTTP APIs with minimal setup and configuration. Unlike traditional ASP.NET Core MVC, Minimal APIs focus on reducing boilerplate code and simplifying the development process. Carter is a library that enhances ASP.NET Core with additional functionality, making it easier and more enjoyable to write clean and concise APIs.

1. Simplicity: Minimal APIs reduce the overhead of setting up controllers, actions, and routing. They provide a clean, straightforward way to create endpoints.

2. Performance: By stripping down to the essentials, Minimal APIs can offer improved performance with lower resource consumption.

3. Flexibility: Carter provides a thin layer of extension methods over ASP.NET Core, allowing you to write less code while maintaining high functionality. It excels at tasks like validation, authorization, and content negotiation.

Here’s a step-by-step guide to setting up an ASP.NET Core Minimal API using Carter, focusing on implementing content negotiation for JSON.

Step 1: Define the Data Model

Create a Blog class to represent your primary resource.

public class Blog
{
    public int Id { get; init; }
    public DateOnly DatePublished { get; init; }
    public string? Title { get; init; }
    public string? Author { get; init; }
    public string[]? Tags { get; init; }
}

Step 2: Set Up the Project

Create a new ASP.NET Core project and install Carter.

dotnet new web -n MinimalApiCarter
cd MinimalApiCarter
dotnet add package Carter

Step 3: Configure the Program Class

Configure the application to use Carter and set up routing.

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddCarter();
var app = builder.Build();
app.MapCarter();
app.UseHttpsRedirection();
app.Run();

Step 4: Create the BlogModule

Define a BlogModule class to handle routing and CRUD operations.

public class BlogModule : ICarterModule
{
    private static List<Blog> _blogs = new List<Blog>
    {
        new Blog
        {
            Id = 1,
            DatePublished = DateOnly.FromDateTime(DateTime.Now),
            Title = "Building .NET Minimal API's",
            Author = "Jane Doe",
            Tags = new[] { "c#", ".net", "api" }
        },
        new Blog
        {
            Id = 2,
            DatePublished = DateOnly.FromDateTime(DateTime.Now.AddDays(-1)),
            Title = "Content Negotiation in .NET API's",
            Author = "John Smith",
            Tags = new[] { "c#", ".net", "api", "content negotiation" }
        }
    };

    public void AddRoutes(IEndpointRouteBuilder app)
    {
        app.MapGet("/blogs", (HttpResponse response) => response.Negotiate(_blogs));
        app.MapGet("/blogs/{id}", (int id, HttpResponse response) => 
        {
            var blog = _blogs.FirstOrDefault(b => b.Id == id);
            return blog is not null ? Results.Ok(blog) : Results.NotFound();
        });
        app.MapPost("/blogs", (Blog newBlog, HttpResponse response) =>
        {
            newBlog.Id = _blogs.Max(b => b.Id) + 1;
            _blogs.Add(newBlog);
            return Results.Created($"/blogs/{newBlog.Id}", newBlog);
        });
        app.MapPatch("/blogs/{id}", (int id, Blog updatedBlog, HttpResponse response) =>
        {
            var blog = _blogs.FirstOrDefault(b => b.Id == id);
            if (blog is null)
            {
                return Results.NotFound();
            }
            blog.Title = updatedBlog.Title ?? blog.Title;
            blog.Author = updatedBlog.Author ?? blog.Author;
            blog.Tags = updatedBlog.Tags ?? blog.Tags;
            return Results.Ok(blog);
        });
        app.MapDelete("/blogs/{id}", (int id, HttpResponse response) =>
        {
            var blog = _blogs.FirstOrDefault(b => b.Id == id);
            if (blog is null)
            {
                return Results.NotFound();
            }
            _blogs.Remove(blog);
            return Results.NoContent();
        });
    }
}

Summary

Using ASP.NET Core Minimal APIs with Carter provides a highly efficient and flexible way to build APIs. The streamlined setup reduces boilerplate code and enhances performance, while Carter's extensions simplify common tasks like content negotiation. This approach is ideal for developers looking to create clean, maintainable, and performant APIs with minimal effort.