In this article, we are going to explain the core idea and basic concepts of the minimal APIs in .NET 6. But if we try to explain it in one sentence, it will be that it is an API without the need for a controller.<\/p>\n
Other than a theoretical explanation, we are going to dive into the code and show how we can implement a minimal API that has all CRUD operations.<\/p>\n
Let’s start.<\/p>\n
The story of the minimal API started in November 2019. The developer community got a chance to see the implementation of the distributed calculator<\/a> in Go, Python, C#, and Javascript. When the community started comparing how many files and lines of code are needed to do almost the same thing with C# compared to other languages, it was apparent that C# seems more complicated than the rest of them.<\/p>\n Imagine the number of concepts and features accumulated over the years and how overwhelming it might be for a newcomer to dig into the world of .NET web development. Therefore, a .NET Core team wanted to reduce the complexity for all developers (newcomers and veterans) and embrace minimalism. So if we’re going to create a simple API with a single endpoint, we should be able to do it within a single file. But if we need to switch later to use controllers again, we should also be able to do that.<\/p>\n Let’s see what they have accomplished.<\/p>\n We need to have Visual Studio 2022<\/a> with the ASP.NET and web development workload to follow along with this article.<\/p>\n To create a minimal API, we are going to create a C# project from the ASP.NET Core Empty template and uncheck all the checkboxes in the additional information dialog. Doing that, we are going to end up with the And that’s it. Once we run our app, we will see the Let’s explain how it is possible to have an API with one endpoint up and running with four lines of code.<\/p>\n The first thing we can notice is missing Then we can see Lastly, with the A new feature in the dependency injection<\/a> (DI) container in the .NET 6 enables us to know which type is registered as a resolvable type in the container. That means we can amend a delegate in the And the framework will know that For this example, we are going to use the Entity Framework Core<\/a> in-memory database. You can find a detailed setup in the Creating Multiple Resources with a Single Request in ASP.NET Core<\/a> article.<\/p>\n Since we are going to operate on articles, let’s create an And an Let’s first implement get methods and explain what’s happening:<\/p>\n For both methods, we add the route pattern as a first parameter. In the first And everything will continue to work. That is that nifty feature where the compiler tries to resolve any delegate as a To continue, let’s implement POST and DELETE methods:<\/p>\n Finally, we are going to implement the PUT method:<\/p>\n Since we want to focus on Minimal APIs our implementation is simple and it is missing proper request model validations or using mapping with AutoMapper<\/a>. You can read how to apply all these properly in our ASP.NET Core Web API \u2013 Post, Put, Delete<\/a> article.<\/p>\n Interestingly, there isn’t an extension method If you want to implement the PATCH method in the right way, you can read more about it in our Using HttpClient to Send HTTP PATCH Requests in ASP.NET Core<\/a> article.<\/p>\n The great thing is that there isn’t any real difference in how to set up and use Swagger in the Minimal APIs than before. You can read more about Swagger, and how to configure it in our Configuring and Using Swagger UI in ASP.NET Core Web API<\/a>\u00a0article.<\/p>\nHow to Setup Minimal APIs?<\/h2>\n
Program<\/code> class with four lines in it:<\/p>\nvar builder = WebApplication.CreateBuilder(args);\r\nvar app = builder.Build();\r\n\r\napp.MapGet(\"\/\", () => \"Hello World!\");\r\n\r\napp.Run();<\/pre>\n
Hello Word!<\/code> message in a browser.<\/p>\nusing<\/code> directives. C#10 introduced global using<\/code> directives, and the common ones are included by default if the feature is enabled. Since one of them is Microsoft.AspNetCore.Builder<\/code> we don’t need to write anything.<\/p>\nMapGet<\/code>, an extension method from the EndpointRouteBuilderExtensions<\/code> class that accepts a delegate as one of the parameters. Accepting any delegate is another example where C#10 put minimal API at its best. We can pass any method to the MapGet<\/code> method, and the compiler will do its best to figure out how to convert it to the RequestDelegate<\/code>. If it can’t, it will let us know.<\/p>\napp.Run()<\/code> method, we are able to run our app.<\/p>\nHow Does Dependency Injection Work With the Minimal APIs?<\/h3>\n
MapGet<\/code> method with some types that we have registered with the DI without the need for additional attributes or injections via constructors. For example, we can write:<\/p>\napp.MapGet(\"\/\", (IHttpClientFactory httpClientFactory) =>\u00a0 \"Hello World!\"));<\/code><\/p>\nIHttpClientFactory<\/code> is registered as a resolvable type. It can visit the DI container and populate it with the registered type. This was not possible before .NET 6.<\/p>\nImplementation of the CRUD Methods in the Minimal APIs<\/h2>\n
Article<\/code> class:<\/p>\npublic class Article\r\n{\r\n public int Id { get; set; }\r\n\r\n public string? Title { get; set; }\r\n\r\n public string? Content { get; set; }\r\n\r\n public DateTime? PublishedAt { get; set; }\r\n}<\/pre>\nArticleRequest<\/code> record:<\/p>\npublic record ArticleRequest(string? Title, string? Content, DateTime? PublishedAt);<\/code><\/p>\napp.MapGet(\"\/articles\", async (ApiContext context) => Results.Ok(await context.Articles.ToListAsync()));\r\n\r\napp.MapGet(\"\/articles\/{id}\", async (int id, ApiContext context) =>\r\n{\r\n var article = await context.Articles.FindAsync(id);\r\n\r\n return article != null ? Results.Ok(article) : Results.NotFound();\r\n});<\/pre>\nMapGet<\/code> implementation ApiContext<\/code> is resolved in the delegate because it is registered as a resolvable type. In the second MapGet<\/code> implementation, we add id<\/code> as an additional parameter in the delegate. We could also change the order of the parameters:<\/p>\napp.MapGet(\"\/articles\/{id}\", async (ApiContext context, int id) =>\r\n{\r\n var article = await context.Articles.FindAsync(id);\r\n return article != null ? Results.Ok(article) : Results.NotFound();\r\n});<\/pre>\nRequestDelegate<\/code>, and it is doing a pretty good job.<\/p>\napp.MapPost(\"\/articles\", async (ArticleRequest article, ApiContext context) =>\r\n{\r\n var createdArticle = context.Articles.Add(new Article\r\n {\r\n Title = article.Title ?? string.Empty, \r\n Content = article.Content ?? string.Empty,\r\n PublishedAt = article.PublishedAt,\r\n });\r\n\r\n await context.SaveChangesAsync();\r\n\r\n return Results.Created($\"\/articles\/{createdArticle.Entity.Id}\", createdArticle.Entity);\r\n});\r\n\r\napp.MapDelete(\"\/articles\/{id}\", async (int id, ApiContext context) =>\r\n{\r\n var article = await context.Articles.FindAsync(id);\r\n\r\n if (article == null)\r\n {\r\n return Results.NotFound();\r\n }\r\n\r\n context.Articles.Remove(article);\r\n\r\n await context.SaveChangesAsync();\r\n\r\n return Results.NoContent();\r\n});<\/pre>\napp.MapPut(\"\/articles\/{id}\", async (int id, ArticleRequest article, ApiContext context) =>\r\n{\r\n var articleToUpdate = await context.Articles.FindAsync(id);\r\n \r\n if (articleToUpdate == null)\r\n return Results.NotFound();\r\n\r\n if (article.Title != null)\r\n articleToUpdate.Title = article.Title;\r\n\r\n if (article.Content != null)\r\n articleToUpdate.Content = article.Content;\r\n\r\n if (article.PublishedAt != null)\r\n articleToUpdate.PublishedAt = article.PublishedAt;\r\n\r\n await context.SaveChangesAsync();\r\n\r\n return Results.Ok(articleToUpdate);\r\n});<\/pre>\nMapPatch<\/code> in the EndpointRouteBuilderExtensions<\/code> class. But we can use MapMethods<\/code> method that is more robust and adaptable than the previous ones:<\/p>\napp.MapMethods(\"\/articles\/{id}\", new[] { \"PATCH\" }, async (int id, ArticleRequest article, ApiContext context) => { ... });<\/code><\/p>\nHow to Use Swagger, Authentication, and Authorization?<\/h3>\n