Building Scalable Backend Services with .NET: ASP.NET Core, Minimal APIs, and More

Introduction

The .NET ecosystem is a powerful, cross-platform framework for building modern web applications, APIs, and microservices. With ASP.NET Core, Minimal APIs, Blazor, and Entity Framework Core, developers can create high-performance, secure, and scalable backend systems.

In this guide, we’ll explore:

• .NET Core vs. .NET Framework

• ASP.NET Core MVC (Full-stack framework)

• Minimal APIs (Lightweight HTTP services)

• Blazor (Full-stack C# with WebAssembly)

• Entity Framework Core (ORM)

• Performance optimization strategies

---

1. .NET Core vs. .NET Framework

Use .NET Core (or .NET 5+) for new projects.

---

2. ASP.NET Core MVC: Full-Stack Framework

ASP.NET Core MVC is a batteries-included framework for building web apps and APIs.

Key Features

• Razor Pages (Simple UI + backend)

• Dependency Injection (Built-in)

• Middleware Pipeline (Flexible request handling)

• Integrated Authentication (Identity, JWT, OAuth)

Example: ASP.NET Core REST API

dotnet new webapi -n MyApi
cd MyApi
dotnet add package Microsoft.EntityFrameworkCore.InMemory

// Models/User.cs
public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
}

// Controllers/UsersController.cs
[ApiController]
[Route("api/[controller]")]
public class UsersController : ControllerBase
{
    private static List<User> _users = new();

    [HttpGet]
    public IActionResult GetUsers() => Ok(_users);

    [HttpPost]
    public IActionResult AddUser(User user)
    {
        _users.Add(user);
        return CreatedAtAction(nameof(GetUsers), user);
    }
}

Performance Tips

• Use AsNoTracking() for read-only queries

• Enable Response Caching ([ResponseCache])

• Use Redis for distributed caching

---

3. Minimal APIs: Lightweight HTTP Services

Introduced in .NET 6, Minimal APIs reduce boilerplate for microservices.

Example: Minimal API (CRUD)

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

var users = new List<User>();

app.MapGet("/users", () => users);
app.MapPost("/users", (User user) => 
{
    users.Add(user);
    return Results.Created($"/users/{user.Id}", user);
});

app.Run();

When to Use Minimal APIs?

• Small microservices

• Serverless functions (Azure Functions)

• Rapid prototyping

---

4. Blazor: Full-Stack C# with WebAssembly

Blazor lets you build interactive UIs using C# instead of JavaScript.

Blazor Hosting Models

Example: Blazor Server Component

@page "/users"
@inject HttpClient Http

<h3>Users</h3>

@if (users == null)
{
    <p>Loading...</p>
}
else
{
    <ul>
        @foreach (var user in users)
        {
            <li>@user.Name</li>
        }
    </ul>
}

@code {
    private User[] users;

    protected override async Task OnInitializedAsync()
    {
        users = await Http.GetFromJsonAsync<User[]>("api/users");
    }
}

---

5. Entity Framework Core (ORM)

EF Core is a modern ORM for .NET with LINQ support.

Example: EF Core with SQL Server

// Data/AppDbContext.cs
public class AppDbContext : DbContext
{
    public DbSet<User> Users { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder options)
        => options.UseSqlServer("Server=localhost;Database=MyDb;Trusted_Connection=True;");
}

// In Controller
[HttpGet]
public IActionResult GetUsers()
{
    var users = _db.Users.ToList();
    return Ok(users);
}

Performance Tips

• Use AsSplitQuery() for complex joins

• Bulk inserts with AddRange()

• Disable change tracking for read-heavy apps

---

6. Performance Optimization

General .NET

• AOT Compilation (.NET 8+)

• Use Span<T> for memory efficiency

• Profile with dotTrace

ASP.NET Core

• Enable HTTP/2

• Use Kestrel with YARP (Reverse proxy)

Database

• Connection pooling (Default in EF Core)

• Use Dapper for micro-optimizations

---

7. Framework Comparison

Choose ASP.NET Core MVC for:

• Traditional web apps

• Complex server-side logic

Choose Minimal APIs for:

• Lightweight services

• Cloud-native apps

Choose Blazor for:

• JavaScript-free frontends

• Real-time dashboards

---

Conclusion

• ASP.NET Core is a versatile backend framework.

• Minimal APIs are great for microservices.

• Blazor enables full-stack C# development.

• EF Core simplifies database interactions.

---

References

• ASP.NET Core Docs

• EF Core Documentation

• Blazor Official Guide