.NET Documentation

ASP.NET Core Fundamentals

This guide covers the fundamental concepts of ASP.NET Core, a cross-platform, high-performance, open-source framework for building modern, cloud-enabled, internet-connected applications.

What is ASP.NET Core?

ASP.NET Core is a re-architected version of ASP.NET that runs on the cross-platform .NET (Core) runtime. It's designed for:

• High performance: Significantly faster than previous ASP.NET versions.
• Cross-platform development: Runs on Windows, macOS, and Linux.
• Modern application development: Supports microservices, Docker, and cloud deployment.
• Unified Framework: Combines the power of MVC and Web API into a single programming model.

Key Components and Concepts

Middleware Pipeline

ASP.NET Core applications use a middleware pipeline to handle HTTP requests. Each piece of middleware performs a specific task, such as authentication, logging, or routing. The order of middleware in the pipeline is critical.

Here's a conceptual example of a middleware pipeline:

// Example of a simple middleware pipeline
var builder = WebApplication.CreateBuilder(args);

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
}

app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();

app.UseEndpoints(endpoints =>
{
    endpoints.MapGet("/", () => "Hello World!");
});

app.Run();
                

Request Lifecycle

When a request arrives at the ASP.NET Core application, it passes through the configured middleware pipeline. Each middleware can:

• Execute code before the next middleware.
• Potentially short-circuit the request and not call the next middleware.
• Execute code after the next middleware has completed its execution.

The request eventually reaches the routing middleware, which determines which endpoint should handle the request. The request then goes through authorization, and finally, the endpoint handler (e.g., controller action, Razor Page handler) processes the request and generates a response.

Dependency Injection (DI)

ASP.NET Core has built-in support for dependency injection, making it easier to manage object lifecycles and dependencies. Services are registered with the DI container, and can be injected into constructors of controllers, Razor Pages, or other services.

public interface IMyService
{
    string GetData();
}

public class MyService : IMyService
{
    public string GetData() => "Service data";
}

// In Startup.cs (or Program.cs)
builder.Services.AddTransient<IMyService, MyService>();

// In a controller
public class HomeController : Controller
{
    private readonly IMyService _myService;

    public HomeController(IMyService myService)
    {
        _myService = myService;
    }

    public IActionResult Index()
    {
        ViewData["Message"] = _myService.GetData();
        return View();
    }
}
                

Configuration

ASP.NET Core provides a flexible configuration system that allows you to load settings from various sources, including environment variables, JSON files, command-line arguments, and Azure Key Vault.

Hosting

ASP.NET Core applications can be self-hosted using Kestrel (a cross-platform web server) or hosted behind a reverse proxy like IIS, Nginx, or Apache.

Core Application Types

• MVC (Model-View-Controller): A pattern that separates application logic into three interconnected components.
• Razor Pages: A page-focused model for building web UI with minimal boilerplate. Ideal for form-based scenarios.
• Web API: A framework for building HTTP services that can be consumed by a broad range of clients.
• Blazor: A framework for building interactive client-side web UI with .NET.

This overview provides a starting point for understanding ASP.NET Core. Dive deeper into specific topics to build powerful web applications.