What is MinimalAPI?
Minimal APIs are a simplified way of building web APIs in ASP.NET Core. They are designed for scenarios where you need a quick and minimalistic approach to expose endpoints without the overhead of a full-fledged MVC application.
Why Minimal APIs?
-
Efficiency: Write less, do more. A mantra for the modern developer.
-
Performance: They’re lean, mean, and fast, perfect for high-performance scenarios.
-
Ease of Use: New to .NET? No problem! Minimal APIs are accessible and easy to grasp.
-
Flexibility: Simplicity doesn’t mean limited. From microservices to large-scale applications, they’ve got you covered.
How Minimal APIs Work?
Minimal APIs leverage the WebApplication class to define routes and handle HTTP requests. They rely on a functional approach, allowing developers to define endpoints using lambda expressions.
Limitations of Minimal API
-
No support for filters: For example, no support for IAsyncAuthorizationFilter, IAsyncActionFilter, IAsyncExceptionFilter, IAsyncResultFilter, and IAsyncResourceFilter.
-
No support for model binding, i.e. IModelBinderProvider, IModelBinder. Support can be added with a custom binding shim.
-
No support for binding from forms. This includes binding IFormFile. We plan to add support for IFormFile in the future.
-
No built-in support for validation, i.e. IModelValidator
-
No support for application parts or the application model. There's no way to apply or build your own conventions.
-
No built-in view rendering support. We recommend using Razor Pages for rendering views.
-
No support for JsonPatch
-
No support for OData
How to create a Minimal API?
Creating a Minimal API closely mirrors the traditional approach, so you should encounter no significant challenges. It is a straightforward procedure that can be accomplished in just a few easy steps.
Let's get started:
Step 1:
Open Visual Studio and select the ASP.NET Core Web API.
Provide a preferred name for your project and select the location where you wish to store it.
For the final step, choose the targeted framework, ensure that the "Configure for HTTPS" and "Enable OpenAPI support" checkboxes are checked, and, most importantly, leave the checkbox "Use controllers (uncheck to use Minimal API)" unchecked. Then, click the "Create" button.
Step 2:
Create one class with two fields and create one list class with some static values.
namespace MinimalAPI
{
public class Student
{
public int Id { get; init; }
public string Name { get; set; }
}
public static class StudentList
{
public static List<Student> student = new List<Student>()
{
new Student()
{
Id = 1,
Name = "Test1",
},
new Student()
{
Id = 2,
Name = "Test2",
},
new Student()
{
Id = 3,
Name = "Test3",
}
};
}
}
Now add register new endpoint in Program.cs file.
app.MapGet("GetAllStudent", () => StudentList.student);
Run the project and see the output.
I have added Create, Update and Delete student endpoint. See the full code below.
using MinimalAPI;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
var app = builder.Build();
// GetAll
app.MapGet("GetAllStudent", () => StudentList.student);
// GetById
app.MapGet("GetByStudentId/{id}", (int id) => StudentList.student.FirstOrDefault(user => user.Id == id));
// Create
app.MapPost("CreateStudent", (Student student) => StudentList.student.Add(student));
// Update
app.MapPut("UpdateStudent/{id}", (int id, Student student) =>
{
Student currentStudent = StudentList.student.FirstOrDefault(user => user.Id == id);
currentStudent.Name = student.Name;
});
// Delete
app.MapDelete("DeleteStudent/{id}", (int id) =>
{
var student = StudentList.student.FirstOrDefault(user => user.Id == id);
StudentList.student.Remove(student!);
});
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI();
}
app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.Run();
Run the code and see the output.
Conclusion:
Minimal APIs in ASP.NET Core, introduced in .NET 6, offer a simplified and concise approach to building lightweight HTTP services, reducing boilerplate and emphasizing convention-based routing. While ideal for rapid development of small to medium-sized APIs, they lack advanced features found in traditional ASP.NET Core applications and may not be suitable for complex scenarios.
