MSDN Documentation

Introduction to ASP.NET Core

Welcome to the introductory tutorial for ASP.NET Core! This guide will walk you through the fundamental concepts and steps required to start building modern, cross-platform web applications with ASP.NET Core.

ASP.NET Core is a high-performance, open-source framework for building web applications, APIs, and mobile backends. It's a complete rewrite of the ASP.NET platform, designed for cloud-native applications and modern development practices. Whether you're a seasoned developer or new to web development, ASP.NET Core offers a powerful and flexible foundation.

Prerequisites

Before you begin, ensure you have the following installed:

  • .NET SDK (latest version recommended)
  • A code editor or Integrated Development Environment (IDE) such as Visual Studio, VS Code, or JetBrains Rider.

You can download the .NET SDK from the official .NET website.

Setting Up Your Environment

The .NET SDK includes the command-line interface (CLI) tools necessary for developing ASP.NET Core applications. You can verify your installation by opening a terminal or command prompt and running:

dotnet --version

This command should output the installed .NET SDK version.

Creating Your First ASP.NET Core App

Let's create a simple web application. Open your terminal, navigate to the directory where you want to create your project, and run the following commands:

  1. Create a new project directory: 
    mkdir MyAspNetCoreApp
cd MyAspNetCoreApp
  2. Create a new Razor Pages project: 
    dotnet new razor
  3. Run the application: 
    dotnet run

Once the application is running, you'll see output indicating the URL where it's hosted. Open this URL in your web browser to see your first ASP.NET Core application!

Tip: You can also create other project types like MVC (Model-View-Controller) using dotnet new mvc.

Understanding the Project Structure

After running dotnet new razor, your project directory will have a structure similar to this:

MyAspNetCoreApp/
├── Pages/
│   ├── _Layout.cshtml
│   ├── _ValidationScriptsPartial.cshtml
│   ├── Error.cshtml
│   ├── Error.cshtml.cs
│   ├── Index.cshtml
│   ├── Index.cshtml.cs
│   └── Privacy.cshtml
│   └── Privacy.cshtml.cs
├── Properties/
│   └── launchSettings.json
├── appsettings.json
├── appsettings.Development.json
├── Program.cs
├── MyAspNetCoreApp.csproj
└── README.md
  • Pages/: Contains Razor Pages, which are a page-based programming model for ASP.NET Core. Each .cshtml file represents a web page, and its corresponding .cshtml.cs file (if present) contains the C# code-behind logic.
  • Properties/launchSettings.json: Defines environment variables and application startup configurations for different profiles (e.g., IIS Express, Kestrel).
  • appsettings.json: Configuration settings for the application.
  • Program.cs: The entry point of your ASP.NET Core application.
  • .csproj file: The project file that defines project dependencies and settings.

Handling Requests

When a user makes a request to your application, ASP.NET Core processes it through a series of middleware. Middleware components form a pipeline, where each component can perform an action on the request or response, or pass it to the next component in the pipeline.

The Program.cs file defines this middleware pipeline using the WebApplication.CreateBuilder() and app.Use...() methods. Common middleware includes:

  • Static files middleware (e.g., for serving CSS, JS, images)
  • Routing middleware
  • Authentication and authorization middleware
  • Endpoint mapping (e.g., to Razor Pages or MVC controllers)

Routing

Routing is the process of mapping incoming HTTP requests to the correct code to handle that request. In ASP.NET Core Razor Pages, routing is largely convention-based. The file path within the Pages/ directory determines the URL path. For example, Pages/About.cshtml would typically be accessible at the /About URL.

You can customize routing using attributes like [Route("some/path")] on page models or by configuring routes in Program.cs.

Views and Razor

ASP.NET Core uses Razor syntax for creating dynamic HTML. Razor is a templating engine that allows you to embed C# code within HTML markup. This is commonly used in:

  • Razor Pages: The .cshtml files in the Pages/ directory are Razor Pages.
  • MVC Views: In MVC applications, .cshtml files in the Views/ directory are used to render the UI.

Key Razor syntax elements include:

  • @variableName: Renders the value of a variable.
  • @{ ... }: A code block for C# statements.
  • @if (...) { ... }: Conditional rendering.
  • @foreach (...) { ... }: Looping through collections.
  • @Html.Raw(string): Renders HTML strings without encoding.

Next Steps

Congratulations on getting started with ASP.NET Core! Here are some recommendations for your next steps:

  • Explore building MVC applications.
  • Learn about dependency injection in ASP.NET Core.
  • Dive into data access with Entity Framework Core.
  • Understand API development with ASP.NET Core Web API.
  • Discover deployment options for your ASP.NET Core applications.

Continue your learning journey on Microsoft Learn.