ASP.NET Fundamentals: Overview

Welcome to the fundamental concepts of ASP.NET. This section provides a comprehensive introduction to the core technologies and patterns that underpin modern web development with ASP.NET.

What is ASP.NET?

ASP.NET is a free, open-source, cross-platform framework for building modern, cloud-based, internet-connected applications. It consists of:

  • .NET Core: A modern, high-performance, open-source, cross-platform runtime.
  • ASP.NET Core: The successor to ASP.NET, designed for performance, modularity, and cross-platform support.
  • Entity Framework Core: A modern object-relational mapper (ORM) for .NET.

ASP.NET allows developers to build a wide range of applications, including web apps, mobile apps, and backends for services, using C#, F#, or Visual Basic.

Key Concepts

Understanding these core concepts is crucial for effective ASP.NET development:

1. Request Pipeline and Middleware

ASP.NET Core applications process incoming HTTP requests through a series of components called middleware. Each middleware component has the option to:

  • Execute code before the next component.
  • Pass the request to the next component.
  • Short-circuit the request, preventing further processing.

This pipeline model provides a flexible and modular way to handle requests, from authentication and routing to response generation.


// Example of a simple middleware
app.Use(async (context, next) =>
{
    await context.Response.WriteAsync("Hello from first middleware! ");
    await next(); // Call the next middleware in the pipeline
    await context.Response.WriteAsync("Hello from first middleware after next! ");
});

2. MVC and Razor Pages

ASP.NET Core offers two primary models for building the user interface:

  • Model-View-Controller (MVC): A well-established pattern that separates concerns into Model (data), View (UI), and Controller (request handling).
  • Razor Pages: A page-centric approach that simplifies building server-rendered UI by combining handlers and UI logic into a single page model. It's often a good choice for simpler web pages and forms.

Both models utilize Razor syntax (.cshtml files) for embedding server-side code within HTML.

3. Dependency Injection (DI)

ASP.NET Core has built-in support for Dependency Injection, a powerful design pattern that promotes loose coupling and testability. Services are registered with the DI container and can be injected into constructors or properties of classes that need them.

Tip: Leveraging DI makes your application more maintainable and easier to test by enabling the substitution of dependencies with mocks or fakes.

4. Configuration

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

5. Data Access

For data persistence, ASP.NET Core commonly uses Entity Framework Core, which simplifies database interactions by allowing you to work with your database as if it were a collection of C# objects.


// Example of querying data with EF Core
var blogs = await _context.Blogs
    .OrderBy(b => b.Url)
    .ToListAsync();

Getting Started

To start building with ASP.NET Core, you'll typically need:

  1. .NET SDK: Download and install the latest .NET SDK.
  2. Code Editor: Visual Studio, VS Code, or your preferred editor.
  3. Command-line Tools: Use the `dotnet` CLI to create, build, and run projects.
Note: This documentation focuses on ASP.NET Core, the modern evolution of ASP.NET. For information on the older ASP.NET Framework, please refer to the archived documentation.

Explore the links in the sidebar to dive deeper into specific ASP.NET Core fundamentals.