Popular C# Frameworks

C# on its own is just a language — the frameworks built on top of .NET are what turn it into a practical choice for shipping web applications. ASP.NET Core is the dominant one, and it's worth understanding its shape before picking a starting point for a real project.

ASP.NET Core: three application models

ASP.NET Core isn't one rigid framework — it's a set of building blocks that support a few different styles of building a web app, and real projects often mix them.

MVC (Model-View-Controller) is the traditional, full-featured style: controllers handle requests, models represent data, and views (Razor syntax, mixing HTML and C#) render pages server-side.

public class ProductsController : Controller
{
    public IActionResult Index()
    {
        var products = _repository.GetAll();
        return View(products);
    }
}

MVC is the right fit for larger, structured server-rendered applications where you want conventions for organizing controllers, views, and models as the codebase grows.

Minimal APIs (introduced in .NET 6) strip that structure down to just what a small API needs — routes defined directly, no controller classes required:

var app = WebApplication.Create(args);

app.MapGet("/products/{id}", (int id) => productService.GetById(id));
app.MapPost("/products", (Product product) => productService.Create(product));

app.Run();

This is the better starting point for a focused REST API or microservice, where MVC's controller conventions would be more ceremony than the project needs.

Blazor takes a different angle entirely: it lets you write interactive web UI in C# instead of JavaScript, running either server-side (UI updates streamed over a persistent connection) or client-side in the browser via WebAssembly. It's worth knowing it exists — a C# team building a UI without wanting to write a separate JavaScript frontend will often reach for Blazor — but it's a large enough topic to belong in its own dedicated course rather than this overview.

Choosing among them

Minimal APIs for a lean backend service or API-only project. MVC for a larger, more conventional server-rendered application, or a team that benefits from its established structure. Blazor when the goal is a C#-only full-stack app and a JavaScript-free frontend is a genuine priority. None of these are mutually exclusive within a single ASP.NET Core project — you can serve a minimal API alongside MVC controllers in the same app.

Azure: the cloud counterpart

Azure is Microsoft's cloud platform, and C#/.NET tooling generally treats it as a first-class deployment target — the two came from the same company and it shows in how smoothly they integrate.

• Azure App Service — the most common way to host an ASP.NET Core app; it handles scaling, TLS certificates, and deployment slots for you.
• Azure Functions — serverless compute, well-suited to event-driven or infrequent workloads, written in C# using the same language and much of the same tooling as a full ASP.NET Core app.
• Azure SQL Database and Cosmos DB — managed relational and NoSQL data stores that pair with Entity Framework Core, .NET's standard ORM, for a smooth data-access layer.
• Azure DevOps / GitHub Actions — CI/CD pipelines with first-party support for building and deploying .NET projects.

None of this locks you into Azure specifically — ASP.NET Core runs identically on AWS, Google Cloud, or a plain Linux server, since .NET itself is cross-platform. But the tooling integration with Azure (project templates, the Visual Studio publish wizard, managed identity support) is deep enough that many C# teams default to it unless they have a specific reason not to.