ASP.NET Core 是一个跨平台的高性能框架，用于构建现代互联网连接应用程序。与传统的 ASP.NET 相比，ASP.NET Core 在设计上更为简洁、灵活，能够满足不同类型应用程序的需求。以下是 ASP.NET Core 的一些显著特点：

1. 跨平台支持

ASP.NET Core 可以在 Windows、macOS 和 Linux 上运行，这意味着开发者可以选择自己熟悉的操作系统进行开发和部署。通过使用 .NET Core，你可以在任何平台上运行你的应用程序，提高了开发效率和灵活性。

例如，假设你开发了一个 Web API，使用 ASP.NET Core 创建的应用可以在 Windows 服务器上运行，同时也能轻松地部署到 Ubuntu 服务器上。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddControllers();
    }
    
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseExceptionHandler("/Home/Error");
        }
        
        app.UseRouting();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
        });
    }
}

2. 高性能

ASP.NET Core 在性能上进行了大量优化，使其成为了速度最快的 Web 框架之一。它采用了异步编程模型，能够处理大量并发请求。

根据官方基准测试，ASP.NET Core 的性能可以和 Node.js 以及其他高效的 Web 框架相媲美，适合处理高负载的互联网应用。

3. 模块化与可扩展性

ASP.NET Core 使用了模块化的设计，开发者可以根据需要选择和添加所需的中间件组件。这使得应用程序可以保持轻量，避免引入不必要的依赖。

例如，在构建一个简单的 Web API 时，可以仅添加需要的服务，而不是整个框架：

1

services.AddMvc(options => options.EnableEndpointRouting = false);

4. 集成现代开发工具

ASP.NET Core 完美支持现代开发工具和开发流程，如容器化、持续集成和持续部署。通过 Docker，开发者可以轻松地创建和部署容器化应用，提高了发布的一致性。

以下是一个 Dockerfile 的例子，可用于发布 ASP.NET Core 应用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS base
WORKDIR /app
EXPOSE 80

FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /src
COPY ["MyApp/MyApp.csproj", "MyApp/"]
RUN dotnet restore "MyApp/MyApp.csproj"
COPY . .
WORKDIR "/src/MyApp"
RUN dotnet build "MyApp.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "MyApp.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "MyApp.dll"]

5. 内置依赖注入

ASP.NET Core 内置了对依赖注入（DI）的支持，允许开发者更方便地管理服务的生命周期和依赖关系。这种模式使得代码更易于测试和维护。

使用内置的 DI 容器，您可以在 Startup.ConfigureServices 方法中注册服务，然后在您的控制器中通过构造函数注入所需的依赖：

1

services.AddScoped<IMyService, MyService>();

6. 支持多种开发模式

ASP.NET Core 不仅支持开发 Web 应用程序，还可以创建 Web API、桌面应用程序和云服务。使用相同的平台和工具，可以轻松构建不同类型的应用。

例如，你可以使用 ASP.NET Core MVC 创建一个传统 Web 应用，同时也可以构建一个 RESTful API：

1
2
3
4
5
6
7
8
9
10

[ApiController]
[Route("api/[controller]")]
public class MyController : ControllerBase
{
    [HttpGet]
    public IActionResult Get()
    {
        return Ok("Hello, ASP.NET Core!");
    }
}

总结

ASP.NET Core 是一个现代的、高性能的 Web 框架，适合各种应用程序的开发需求。其跨平台特性、模块化设计、内置支持的 DI 以及现代化的开发工具，使得其成为开发人员的理想选择。在下一篇文章中，我们将深入探讨 ASP.NET Core 的开发历史，以了解其演变和背后的设计理念。

在了解ASP.NET Core的开发历史之前，我们首先要回顾一下上一篇讲述的内容，ASP.NET Core具备一些显著的特点，例如跨平台支持、模块化架构和内置的依赖注入等。这些特点为其后续的发展以及用户的使用带来了极大的便利和灵活性。

开发历史概述

ASP.NET Core是微软推出的一种全新的跨平台开发框架，旨在为现代Web应用提供一个轻量级、高性能的开发环境。我们可以将其开发历史追溯到以下几个关键的里程碑：

1. ASP.NET的演化

在ASP.NET Core之前，ASP.NET作为一个成熟的Web框架，已经经历了许多版本的迭代。从最初的ASP.NET Web Forms到后来的MVC（模型-视图-控制器），Microsoft逐步对ASP.NET进行了框架的演进。然而，这些版本仍然存在一些限制，比如对只在Windows上运行的支持以及相对较重的框架结构。

2. 开始探索跨平台

随着Web开发需求的不断变化，尤其是移动设备的普及和云计算的兴起，开发者希望能够在不同的操作系统上进行开发和部署。基于这一需求，微软于2014年开始探索一个新的框架，旨在打破现有ASP.NET的局限。

3. ASP.NET 5的诞生

2014年，微软在其Build大会上首次宣布了“ASP.NET 5”的计划，并表示该框架将完全重新构建。ASP.NET 5是一个全新的开发框架，针对现代开发的需求进行了优化，并引入了很多新特性，如“中间件”概念。

值得一提的是，ASP.NET 5的设计哲学是“简单、轻量和模块化”，这一点在后来的ASP.NET Core中得到了充分体现。

4. 诞生：ASP.NET Core

2016年6月，ASP.NET Core正式发布。这个新框架不仅将ASP.NET 5进行重命名，还是对其进行全面重构的结果。ASP.NET Core 1.0的发布，标志着微软迈向了跨平台的新时代，并提供了支持Linux、macOS等操作系统的能力。

ASP.NET Core 在设计时就考虑到了云原生应用的需求，采用了无状态和可扩展的架构，使其非常适合在云环境中使用。

5. 持续演进

自发布以来，ASP.NET Core经历了多个版本的更新，不断引入新的功能和性能优化。例如：

• ASP.NET Core 2.0（2017年8月）：引入了Razor Pages，简化了页面开发。
• ASP.NET Core 3.0（2019年9月）：增加了对Windows桌面应用的支持，提供更好的Blazor框架支持。
• ASP.NET Core 5.0（2020年11月）：整合了ASP.NET Core和.NET 5，进一步提升性能和开发体验。

每个版本的发布不仅提升了框架的功能，也积极响应了开发者的需求和行业的发展。

关键案例

我们可以通过一些实际的开发场景来体验ASP.NET Core的强大。例如，以创建一个基本的Web API项目为例：

1
2
3

dotnet new webapi -n MyFirstApi
cd MyFirstApi
dotnet run

上述命令用于创建一个新的ASP.NET Core Web API项目并运行它。开发者可以在Controllers目录下看到一个名为WeatherForecastController.cs的文件，这是一个简单的API示例，可以返回天气预报。

小结

从传统的ASP.NET到现代的ASP.NET Core，微软的开发理念发生了根本性的改变。ASP.NET Core不仅仅是一个新框架，更是一个响应市场变化、支持前沿开发的现代化工具。它的开发历史不仅反映了技术的演进，也展现了开发者需求的变迁。

在下一篇文章中，我们将深入探讨ASP.NET Core的架构概览，带领您进一步理解这一框架的构成与工作原理，期待您的参与。

在前一篇文章中，我们简要回顾了ASP.NET Core的开发历史及其重要性。现在，我们将深入探讨ASP.NET Core的架构，理解它是如何构建的一，以及这一架构为开发者带来的优势。

ASP.NET Core架构概览

ASP.NET Core是一个开源、跨平台的框架，旨在支持现代的云端开发。它的设计背后有多个重要的核心概念，这些概念帮助开发者构建高效且可扩展的应用程序。

1. 中间件Pipeline

ASP.NET Core使用一个称为「中间件」的概念来处理HTTP请求和响应。每个请求通过一系列的中间件组件进行处理。中间件可以是用于身份验证、授权、日志记录、错误处理、静态文件传输等功能的组件。

下面是一个简单的中间件示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class Startup
{
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        app.Use(async (context, next) =>
        {
            // 在请求之前
            await next.Invoke();
            // 在请求之后
        });

        app.UseStaticFiles(); // 处理静态文件
        app.UseRouting();     // 启用路由功能
        
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapGet("/", async context =>
            {
                await context.Response.WriteAsync("Hello World!");
            });
        });
    }
}

在这个例子中，app.Use方法注册了一个自定义中间件，它在请求处理前后执行代码。

2. 控制器和动作

在ASP.NET Core中，MVC（模型-视图-控制器）模式是推荐的开发模式。控制器是负责处理请求的类，具体的请求通过“动作”方法进行处理。这种设计使得不同的请求可以被分离到不同的控制器中进行管理，增强了代码的可读性和可维护性。

让我们来看一个简单的控制器示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

using Microsoft.AspNetCore.Mvc;

public class HomeController : Controller
{
    public IActionResult Index()
    {
        return View();
    }

    public IActionResult About()
    {
        return Content("这是关于页面");
    }
}

在这个例子中，HomeController有两个动作方法：Index和About。每个方法对应HTTP请求的不同处理方式。

3. 依赖注入

ASP.NET Core内置的依赖注入功能使得管理对象的生命周期和依赖关系变得更加容易。开发者可以通过构造函数注入将服务传递到控制器或其他组件中。

来看看如何配置和使用依赖注入：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

public interface IGreetingService
{
    string Greet(string name);
}

public class GreetingService : IGreetingService
{
    public string Greet(string name) => $"Hello, {name}!";
}

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddScoped<IGreetingService, GreetingService>();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        // ...
    }
}

public class HomeController : Controller
{
    private readonly IGreetingService _greetingService;

    public HomeController(IGreetingService greetingService)
    {
        _greetingService = greetingService;
    }

    public IActionResult Greet(string name)
    {
        var greeting = _greetingService.Greet(name);
        return Content(greeting);
    }
}

在这个示例中，我们定义了一个服务 IGreetingService 和其实现 GreetingService，使用 AddScoped 方法将其注册到DI容器中。然后，在HomeController中通过构造函数注入它。

结论

通过对ASP.NET Core的架构进行深入了解，我们可以看到它的设计理念是为了创建高效、可扩展并易于维护的应用程序。各个组件（如中间件、控制器和依赖注入）的协作使得ASP.NET Core成为构建现代应用的强大工具。

在下一篇文章中，我们将讨论如何搭建开发环境，安装.NET SDK，让我们开始构建自己的ASP.NET Core应用程序之旅吧！

在上篇中，我们对 ASP.NET Core 的架构有了初步的了解，接下来我们将深入探讨如何搭建开发环境。首先，安装 .NET SDK 是我们开展 ASP.NET Core 开发的第一步。本文将详细指导你如何在不同操作系统上安装 .NET SDK，以便你能够顺利地开始你的开发之旅。

什么是 .NET SDK？

.NET SDK（软件开发工具包）是开发 .NET 应用所必需的工具集，包含了编译代码、运行应用以及其他开发任务所需的工具。通过安装 .NET SDK，你可以使用 dotnet CLI（命令行界面）来创建、构建和运行 ASP.NET Core 应用。

安装 .NET SDK

下面将分别介绍在 Windows、macOS 和 Linux 环境中安装 .NET SDK 的步骤。

Windows 上的安装步骤

1. 下载 .NET SDK：
   访问 .NET 下载页面 ，选择适合的版本，建议选择最新的稳定版。你会看到两个主要选项：Windows Installer 和 ZIP 包。我们推荐使用 Windows Installer。

2. 运行安装程序：
   下载完成后，双击 .exe 文件，启动安装向导。接下来，按照提示完成安装。

3. 验证安装：
   打开命令提示符（CMD），输入以下命令：

   1	dotnet --version

   如果安装成功，你将看到当前安装的 .NET SDK 版本号。

macOS 上的安装步骤

1. 安装 Homebrew（如果未安装）：
   Homebrew 是 macOS 的包管理工具，可以让你方便地安装软件。在终端中输入以下命令来安装 Homebrew：

   1	/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

2. 安装 .NET SDK：
   使用 Homebrew 安装 .NET SDK，只需在终端中运行以下命令：

   1	brew install --cask dotnet-sdk

3. 设置 PATH：
   在终端中运行以下命令以设置 .NET SDK 的环境变量：

   1	export PATH="$PATH:/usr/local/share/dotnet"

   你可以将上述命令添加到你的 ~/.bash_profile 或 ~/.zshrc 文件中，以便每次启动终端时生效。

4. 验证安装：
   在终端中运行以下命令：

   1	dotnet --version

   你应该能看到当前安装的版本号。

Linux 上的安装步骤

Linux 的安装步骤会因发行版的不同而有所差异。以下是 Ubuntu 发行版的安装步骤。

1. 添加 Microsoft 包签名密钥：
   打开终端，输入以下命令：

   1 2	wget https://packages.microsoft.com/config/ubuntu/$(lsb_release -rs)/packages-microsoft-prod.deb sudo dpkg -i packages-microsoft-prod.deb

2. 安装所需的依赖项：

   1 2 3

   sudo apt-get update sudo apt-get install -y apt-transport-https sudo apt-get update

3. 安装 .NET SDK：
   输入以下命令以安装最新稳定版的 .NET SDK：

   1	sudo apt-get install -y dotnet-sdk-7.0

4. 验证安装：
   在终端中运行：

   1	dotnet --version

   确保正确显示版本信息。

小结

在本篇中，我们详细介绍了如何在三种主要操作系统上安装 .NET SDK，为下一步的开发奠定了基础。无论你是使用 Windows、macOS 还是 Linux，遵循以上步骤都能够轻松安装 .NET SDK。接下来，我们将继续讨论如何设置一个理想的开发环境，以提高我们的开发效率。

请保持对 ASP.NET Core 的热情与耐心，下一篇我们将深入探讨开发环境的设置，让我们继续这段学习之旅吧！

在上篇内容中，我们讨论了如何安装 .NET SDK，这是开发 ASP.NET Core 应用程序的第一步。在这一篇中，我们将深入探讨如何设置开发环境，以便让你能够高效地进行 ASP.NET Core 开发。

确定开发环境

在开始之前，我们需要明确几个概念：

• 操作系统：ASP.NET Core 可跨平台运行，但根据你的操作系统（Windows、macOS 或 Linux），设置过程可能会略有不同。
• 开发工具：开发者通常使用集成开发环境（IDE）或文本编辑器来编写代码。选择一个合适的工具将大大提高开发效率。

设置环境变量

在 Windows 环境中，正确设置环境变量可以确保系统能够在任何地方找到 .NET 命令。以下是设置环境变量的步骤：

1. 打开系统属性:

   • 右键点击“此电脑”或“我的电脑”，选择“属性”。
   • 点击“高级系统设置”。
   • 在打开的窗口中，选择“环境变量”。

2. 编辑 PATH 变量:

   • 在“系统变量”区域找到 Path 变量，选中后点击“编辑”。
   • 添加 .NET SDK 的安装路径，默认情况下，安装路径通常为 C:\Program Files\dotnet。
   • 确保路径已被添加成功并保存。

3. 验证设置:
   打开命令提示符，输入以下命令验证是否成功：

   1	dotnet --version

   如果输出显示已安装的 .NET SDK 版本，那么环境配置已成功。

安装其他必要工具

在 ASP.NET Core 开发中，除了 .NET SDK 之外，通常还会用到其他一些工具，如 Git 和 Node.js（用于管理前端依赖）。以下是安装这些工具的步骤：

安装 Git

Git 是一个版本控制工具，可以帮助你管理项目的代码版本。你可以从 Git 官网 下载并安装适合你操作系统的版本。

安装完成后，打开命令行，输入以下命令验证安装：

1

git --version

安装 Node.js

如果你的项目包括前端部分，建议安装 Node.js。Node.js 提供了 Node Package Manager（NPM），用于管理 JavaScript 库和工具。访问 Node.js 官网 进行下载和安装。

安装完成后，同样通过命令行验证：

1
2

node --version
npm --version

创建第一个 ASP.NET Core 项目

在完成开发环境的设置后，接下来我们将创建一个简单的 ASP.NET Core Web 项目。请按照以下步骤操作：

1. 打开命令提示符或终端。

2. 使用以下命令创建新的 ASP.NET Core 网站模板：

   1	dotnet new webapp -n MyFirstApp

   这会新建一个名为 MyFirstApp 的文件夹，并在其中创建一个基本的 ASP.NET Core 应用程序。

3. 进入新创建的项目文件夹：

   1	cd MyFirstApp

4. 使用以下命令运行应用程序：

   1	dotnet run

   打开浏览器，访问 http://localhost:5000，你应该能够看到 ASP.NET Core 默认的欢迎页面。

结语

通过以上步骤，我们已经成功设置了 ASP.NET Core 的开发环境，并创建了第一个示例项目。在下一篇教程中，我们将讨论如何选择合适的 IDE 来进一步提高我们的开发效率。希望你能在接下来的学习中不断进步，成为 ASP.NET Core 的高手！

在前一篇中，我们讨论了如何设置开发环境，确保我们的系统能够支持ASP.NET Core应用的开发。在这一篇中，我们将着重于选择合适的集成开发环境（IDE）。一个好的IDE不仅可以帮助我们编写代码，还可以提升我们的效率，提供调试、版本控制以及其他辅助功能。

1. 常见的IDE选择

在ASP.NET Core开发中，有几个常用的IDE可供选择：

• Visual Studio
  Visual Studio 是Microsoft的一款功能强大的IDE，专为Windows系统设计。它提供了丰富的功能，如：

  • 强大的调试工具
  • 代码自动完成
  • IntelliSense 支持
  • 集成的Azure开发工具

  Visual Studio提供了社区版（免费）、专业版和企业版。在进行ASP.NET Core开发时，推荐使用社区版，它已经包含了大多数开发所需的功能。

• Visual Studio Code (VS Code)
  这是一个轻量级、跨平台的代码编辑器，适用于Windows、Mac和Linux。通过丰富的插件，VS Code可以变得非常强大，不少开发者都将其作为主要的开发工具进行ASP.NET Core开发。它的一些优点包括：

  • 快速启动，性能优秀
  • 丰富的插件支持
  • 内置的终端功能

  使用VS Code的开发者通常需要手动配置一些扩展插件，比如C#和ASP.NET Core相关工具。

• JetBrains Rider
  Rider是JetBrains公司出品的一款跨平台IDE，专门用于.NET开发。它结合了ReSharper的智能代码分析和调试功能，具有非常友好的用户界面。虽然它是付费软件，但许多开发者认为其投资是值得的。

2. IDE的功能对比

提示：如果你刚开始学习ASP.NET Core，可以选择Visual Studio社区版，它提供了最全面的功能，而不需要额外的配置。

3. 安装与配置的简要步骤

以Visual Studio为例，下面是在Windows上安装和配置的简要步骤：

1. 下载Visual Studio
   前往Visual Studio官网下载最新版本的社区版。

2. 安装过程
   运行下载的安装程序，选择“ASP.NET和Web开发”工作负载，确保选择“.NET Core跨平台开发”。

3. 安装完成后
   启动Visual Studio，选择“新建项目”可以快速创建ASP.NET Core项目。

对于VS Code，步骤可以稍微不同：

1. 下载与安装VS Code
   前往VS Code官网下载适合你系统的版本并安装。

2. 安装扩展
   打开VS Code，点击左侧的扩展图标，搜索并安装C#插件，以增强对C#的支持。

3. 创建ASP.NET Core项目
   请确保你已经安装了.NET SDK，并可以通过命令行创建新的ASP.NET Core项目。

1

dotnet new webapp -n MyFirstApp

4. 小结

选择合适的IDE是进行ASP.NET Core开发的基础。无论是Visual Studio、VS Code还是Rider，各有各的优缺点。根据你的开发需求、系统平台以及个人偏好，选择最适合的IDE将有助于提高开发效率。

在下一篇中，我们将着重于创建我们第一个ASP.NET Core应用，并引导大家逐步实现一个简单的项目。希望你对IDE的选择和使用有了更清晰的理解，准备好迎接新的开发之旅！

在上一篇文章中，我们探讨了如何选择合适的IDE，以便为ASP.NET Core开发做好准备。现在我们将开始我们第一个ASP.NET Core应用的旅程，具体来说，我们将学习如何创建一个新的ASP.NET Core项目。

创建ASP.NET Core项目

步骤一：打开IDE

首先，打开您选择的IDE。通常情况下，使用的是Visual Studio、Visual Studio Code或Rider等。以下是如何在不同IDE中创建ASP.NET Core项目的指导。

在Visual Studio中创建项目

1. 启动Visual Studio。
2. 在“开始窗口”中，选择“创建新项目”。
3. 在“创建新项目”窗口中，搜索“ASP.NET Core Web 应用程序”，并选择它。点击“下一步”。
4. 输入项目名称和保存位置，然后点击“创建”。
5. 在下一个窗口中，选择“Web 应用程序（模型-视图-控制器）”模板，确保选择目标框架（例如.NET 6.0或.NET 7.0），然后点击“创建”。

在Visual Studio Code中创建项目

1. 首先确保你已经安装了.NET SDK。

2. 打开终端（Terminal），导航到你希望创建项目的目录。

3. 使用命令创建新项目：

   1	dotnet new mvc -n MyFirstApp

   这里MyFirstApp是你的项目名称。该命令将创建一个新的MVC项目。

4. 使用以下命令打开项目：

   1 2	cd MyFirstApp code .

步骤二：项目结构概述

在创建项目后，您会看到一系列的文件和文件夹。了解这些文件和文件夹的作用将帮助您更好地组织和管理您的应用。典型的ASP.NET Core MVC项目将包含以下结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

MyFirstApp/
├── Controllers/
│   └── HomeController.cs
├── Models/
├── Views/
│   └── Home/
│       └── Index.cshtml
├── wwwroot/
│   ├── css/
│   ├── js/
│   └── lib/
├── appsettings.json
├── Startup.cs
│   └── Program.cs
└── MyFirstApp.csproj

主要文件和文件夹说明

• Controllers/：存放控制器的地方，控制器用来处理用户请求和返回响应。
• Models/：用于存放数据模型的文件夹，通常会定义与数据交互相关的类。
• Views/：存放视图模板的地方，这些模板用于展示数据给用户。
• wwwroot/：该文件夹用于存放静态文件，例如CSS、JavaScript和图片等。
• appsettings.json：用于存放应用的配置信息，例如数据库连接字符串等。
• Startup.cs和Program.cs：应用的启动配置文件，包含中间件和服务的配置。

步骤三：运行应用

创建完项目后，我们可以运行应用以查看默认的欢迎页面。使用以下命令启动应用：

1

dotnet run

在终端中，您将看到输出，包括一个网址，例如 https://localhost:5001。您可以在浏览器中打开这个地址，看到默认的欢迎界面。

案例：创建一个简单的Welcome页面

让我们在项目中创建一个简单的Welcome页面，以便您更好地理解如何使用控制器和视图。

创建控制器

在Controllers文件夹中，创建一个名为WelcomeController.cs的文件，并添加以下代码：

1
2
3
4
5
6
7
8
9
10
11
12

using Microsoft.AspNetCore.Mvc;

namespace MyFirstApp.Controllers
{
    public class WelcomeController : Controller
    {
        public IActionResult Index()
        {
            return View();
        }
    }
}

创建视图

在Views文件夹中，创建一个名为Welcome的子文件夹，并在其中创建一个名为Index.cshtml的文件，添加以下内容：

1
2
3
4
5
6

@{
    ViewData["Title"] = "Welcome";
}

<h1>Welcome to ASP.NET Core!</h1>
<p>This is your first ASP.NET Core application.</p>

更新路由

最后，您需要在Startup.cs中配置新的路由，在Configure方法中将默认路由更改为：

1
2
3
4
5
6

app.UseEndpoints(endpoints =>
{
    endpoints.MapControllerRoute(
        name: "default",
        pattern: "{controller=Welcome}/{action=Index}/{id?}");
});

步骤四：再次运行应用

完成后，再次运行应用，并访问 https://localhost:5001。您将看到您刚刚创建的Welcome页面。

总结

在本节中，我们学习了如何创建一个新的ASP.NET Core项目，并了解了项目的基本结构以及如何添加控制器和视图。下一篇文章将详细介绍项目的结构和各个组件之间的关系，以便您能更深入地理解ASP.NET Core的运行机制。

期待在下一篇文章中与您继续探索！

在上一篇中，我们已经完成了创建第一个ASP.NET Core应用的步骤，接下来我们将对项目的结构进行深入解析。理解项目的结构对于日后的开发至关重要，因为它决定了我们如何组织代码和资源，从而提高开发效率。

一、项目结构概述

一个典型的ASP.NET Core项目在创建后，会生成一个标准的项目结构。以下是一个基本的ASP.NET Core项目的目录结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

MyFirstAspNetCoreApp/
│
├── wwwroot/
│   ├── css/
│   ├── js/
│   └── lib/
│
├── Controllers/
│   └── HomeController.cs
│
├── Models/
│   └── ExampleModel.cs
│
├── Views/
│   └── Home/
│       └── Index.cshtml
│
├── appsettings.json
├── Program.cs
└── Startup.cs

各个部分的详细解析

1. wwwroot/ 文件夹

wwwroot 文件夹是用于存放静态文件的地方，如 HTML、CSS、JavaScript 和图像等。这些文件可以直接通过 URL 访问，相当于项目的“根”目录。例如，如果在 wwwroot/css/style.css 中有一个样式文件，我们可以通过 http://localhost:5000/css/style.css 直接访问它。

注意：确保所有静态文件都放在 wwwroot 文件夹内，以便它们能被正确地托管。

2. Controllers/ 文件夹

Controllers 文件夹存放控制器类。控制器是 MVC 模式中的核心组成部分，负责处理用户的输入并返回相应的结果。例如，我们创建一个简单的控制器 HomeController.cs 如下：

1
2
3
4
5
6
7
8
9
10
11
12

using Microsoft.AspNetCore.Mvc;

namespace MyFirstAspNetCoreApp.Controllers
{
    public class HomeController : Controller
    {
        public IActionResult Index()
        {
            return View();
        }
    }
}

在上面的代码中，Index 方法将返回一个视图。

3. Models/ 文件夹

Models 文件夹用于存放数据模型和业务逻辑。模型通常与我们的数据库交互，并负责数据的验证和管理。以下是一个简单的模型示例 ExampleModel.cs：

1
2
3
4
5
6
7
8

namespace MyFirstAspNetCoreApp.Models
{
    public class ExampleModel
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }
}

4. Views/ 文件夹

Views 文件夹中存放视图文件。视图负责显示用户界面，通常使用 Razor 语法。假设我们在 Views/Home 文件夹中有一个 Index.cshtml 文件：

1
2
3
4
5
6

@{
    ViewData["Title"] = "Home Page";
}

<h1>Hello, ASP.NET Core!</h1>
<p>Welcome to your first ASP.NET Core application.</p>

5. appsettings.json

appsettings.json 文件用于存储应用程序的配置设置。你可以在这里定义数据库连接字符串、日志级别等。例如：

1
2
3
4
5
6
7
8
9
10

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
        }
  },
  "AllowedHosts": "*"
}

6. Program.cs

Program.cs 是应用程序的入口点。其中包含 Main 方法，负责启动应用程序并设置 Web 服务器。例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;

public class Program
{
    public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup<Startup>();
            });
}

7. Startup.cs

Startup.cs 文件定义了应用程序的请求处理管道、服务配置等。在这里，我们可以配置服务，例如添加 MVC 支持：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddControllersWithViews();
    }

    public void Configure(IApplicationBuilder app)
    {
        app.UseRouting();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllerRoute(
                name: "default",
                pattern: "{controller=Home}/{action=Index}/{id?}");
        });
    }
}

小结

通过了解每个文件夹和文件的功能，我们可以更有效地组织和管理我们的代码。ASP.NET Core 提供了一个灵活且结构清晰的设计，使得开发者能够快速上手并进行扩展。

下一篇文章我们将会探讨如何运行这个应用程序并观察它的行为。希望大家对项目结构的解析有所帮助，提前打下良好的基础。

在上一篇文章中，我们详细讨论了ASP.NET Core项目的结构。在这一篇中，我们将学习如何运行我们的第一个ASP.NET Core应用程序，并进行一些基本的测试。通过这一篇教程，你将能够启动你的应用程序，并看到它在浏览器中运行的样子。

1. 准备工作

确保你已经按照上篇文章中的指导，安装了必要的环境，包括 SDK 和 IDE（例如Visual Studio或Visual Studio Code）。首先，确保你在命令行中所在的目录是你创建项目的目录。

2. 运行你的ASP.NET Core应用

在你的项目目录下，打开命令行工具，输入以下命令来运行应用程序：

1

dotnet run

项目输出

执行上述命令后，你会看到类似如下的输出：

1
2

Now listening on: http://localhost:5000
Application started. Press Ctrl+C to shut down.

这意味着你的应用已经开始运行，并在 http://localhost:5000 监听请求。此时，打开你的浏览器，输入该地址，你应该能看到默认的欢迎页面。

常见错误处理

如果在运行过程中遇到任何问题，例如端口被占用，可以修改 launchSettings.json 文件中的端口设置，或在命令行中使用如下命令启动应用：

1

dotnet run --urls "http://localhost:5001"

3. 使用Visual Studio运行应用程序

若你使用Visual Studio作为IDE，可以通过以下方式运行应用程序：

1. 确保解决方案资源管理器中选择了你的项目。
2. 选择工具栏中的启动按钮（通常是绿色的“播放”按钮）。
3. Visual Studio会自动打开你的默认浏览器并显示应用程序。

配置启动选项

你可以在项目属性中配置启动选项，包括启动URL和环境变量。这为你的应用程序提供了更灵活的运行配置。

4. 测试应用程序

在浏览器中访问 http://localhost:5000（或你设置的其他端口），你应该能看到如下的欢迎页面：

这个页面表明你已经成功创建并运行了你的ASP.NET Core应用。

5. 热重载功能

在开发阶段，ASP.NET Core还支持热重载，允许你在不重启应用程序的情况下，实时查看代码的更改。确保你在使用支持该功能的IDE，并在运行你的应用时进行代码更改。

例如，修改 Startup.cs 文件中的 Hello World 语句，保存后，你会看到浏览器中直接反映出此变更，无需手动刷新。

6. 下一步

你已经成功运行了你的第一个ASP.NET Core应用程序，接下来，我们将深入了解如何处理请求和响应，以及如何 config 路由与中间件。在下一篇文章中，我们将学习“路由与中间件之理解路由”，这将为你理解 ASP.NET Core 的请求处理流程打下基础。

通过这些步骤，你已经成功地从零开始创建并运行了一个ASP.NET Core应用程序，为你后续的开发旅程奠定了坚实的基础。继续保持对新技术的探索，期待在下一篇文章中与大家见面！

在上篇教程中，我们一起创建并运行了第一个 ASP.NET Core 应用，了解了其基本架构和运行机制。这一章节将深入探讨“路由”的概念，以帮助你更好地理解 ASP.NET Core 在处理 HTTP 请求时是如何工作的。

什么是路由？

在 ASP.NET Core 中，路由是将传入的 HTTP 请求映射到特定的处理程序（如控制器和动作方法）的一种机制。它决定了请求 URL 应该如何处理，并将请求引导至正确的代码路径。

路由主要依赖于以下几个部分：

1. 请求 URL：用户通过浏览器请求的数据地址。
2. 路由模板：定义 URL 格式的方法，通常包括变量部分。
3. 终结点（Endpoints）：处理请求的最终目标，通常指向控制器中的动作方法。

路由的基本工作原理

一个典型的路由工作机制如下：

1. 接收到 HTTP 请求。
2. 路由系统根据请求的 URL 与预定义的路由模板进行匹配。
3. 找到匹配的终结点，并将请求转发至该终结点的处理函数（如控制器方法）。
4. 处理函数执行相应的逻辑，并生成 HTTP 响应返回给客户端。

案例：简单的路由示例

假设我们有一个 ASP.NET Core 应用，其中有一个控制器 HomeController，包含一个简单的 Index 方法，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12

using Microsoft.AspNetCore.Mvc;

namespace MyFirstApp.Controllers
{
    public class HomeController : Controller
    {
        public IActionResult Index()
        {
            return Content("欢迎来到首页");
        }
    }
}

在此示例中，Index 方法返回了一个简单的文本响应。当我们访问 http://localhost:5000/home/index 时，ASP.NET Core 的路由系统将匹配这个 URL，并找到对应的 HomeController.Index 方法进行处理。

路由的配置

在 ASP.NET Core 中，路由配置通常是在 Startup.cs 文件中进行。在 Configure 方法中，你会看到类似这样的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
    }

    app.UseStaticFiles();

    app.UseRouting();

    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllerRoute(
            name: "default",
            pattern: "{controller=Home}/{action=Index}/{id?}");
    });
}

在这里，endpoints.MapControllerRoute 方法定义了一条路由：

• 名称（name）：路由的标识，这里用的是 "default"。
• 模式（pattern）：定义 URL 的结构，包括{controller}、{action} 和 可选的{id}。

这意味着，当访问 http://localhost:5000/{controller}/{action}/{id} 时，ASP.NET Core 路由将根据 URL 的格式找到对应的控制器与动作。

路由参数

路由允许使用参数，你可以在 URL 中传递动态数据。例如，修改控制器中的方法以接受一个 id 参数：

1
2
3
4

public IActionResult Details(int id)
{
    return Content($"你正在查看的项目ID是 {id}");
}

然后你可以访问 http://localhost:5000/home/details/5，路由将匹配到 Details 方法，并传递 5 作为参数。

小结

本节内容介绍了 ASP.NET Core 的路由机制以及基础配置。你现在应该对路由概念有所了解，并能够自行创建一些基础的路由规则。接下来，在下一篇教程中，我们将讨论如何配置中间件，这是 ASP.NET Core 应用中的另一个重要概念。

在前一篇中，我们对 ASP.NET Core 中的 路由 进行了详细的解释，了解了如何根据 URL 将请求分配到相应的处理程序。接下来，我们将深入探讨如何在 ASP.NET Core 中配置 中间件，这也是实现应用程序功能的关键部分。

什么是中间件？

在 ASP.NET Core 中，中间件 是处理 HTTP 请求和响应的组件。中间件可以执行操作，如请求验证、日志记录、异常处理、请求转换等，同时还可以决定是否将请求传递给下一个中间件。

中间件的处理过程是一个流水线，每个中间件在请求进入之前和响应返回之后都可以进行处理。你可以将其视为一个责任链，每个环节都有机会对请求进行操作。

中间件的配置

中间件的配置通常发生在 Startup.cs 文件的 Configure 方法中。在这里，你可以按照顺序将中间件添加到请求处理管道中。以下是一个简单的配置示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage(); // 开发环境下使用异常页面
    }
    else
    {
        app.UseExceptionHandler("/Home/Error"); // 生产环境下使用异常处理
        app.UseHsts();
    }

    app.UseHttpsRedirection();
    app.UseStaticFiles();

    app.UseRouting();

    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers(); // 路由到控制器
    });
}

在上面的示例中，我们配置了多个中间件：

1. UseDeveloperExceptionPage：在开发环境中显示详细的异常信息。
2. UseExceptionHandler：在生产环境中处理异常。
3. UseHttpsRedirection：请求自动重定向到 HTTPS。
4. UseStaticFiles：处理静态文件的请求。
5. UseRouting：启用路由功能。
6. UseAuthorization：启用授权功能。
7. UseEndpoints：设置路由到控制器。

添加自定义中间件

除了使用内置的中间件外，您也可以创建自己的中间件。这通常是在需要特定逻辑来处理请求时使用。下面是创建一个简单的自定义中间件的示例，它会在每次请求时记录请求的路径：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class RequestLoggingMiddleware
{
    private readonly RequestDelegate _next;

    public RequestLoggingMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        Console.WriteLine($"Request Path: {context.Request.Path}");
        
        // 调用管道中的下一个中间件
        await _next(context);
    }
}

要在 Startup.cs 中使用这个中间件，可以在 Configure 方法中进行如下配置：

1
2
3
4
5
6

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseMiddleware<RequestLoggingMiddleware>(); // 使用自定义中间件

    // 其他中间件配置...
}

这样，任何传入的请求都会触发 RequestLoggingMiddleware，并在控制台记录请求路径。

组合中间件

中间件可以灵活组合，形成强大的请求处理能力。可以根据需要创建多个自定义中间件，在 Configure 方法中以特定顺序通过调用 app.UseMiddleware<T>() 添加到管道。注意，执行顺序非常重要，因为请求将按顺序经过中间件，而响应则是倒序返回。

结论

在本篇中，我们介绍了如何在 ASP.NET Core 中配置中间件。通过了解中间件的构成和如何顺序添加它们，您可以灵活地控制请求和响应的流转。接下来的文章中，我们将进一步探讨内置中间件的使用，介绍一些常用的内置中间件的具体应用场景和功能。

希望这些内容能帮助您更深入地理解 ASP.NET Core 中的路由与中间件的关系，顺利构建您的应用程序。

在ASP.NET Core框架中，中间件是构建应用程序的核心组成部分，它们负责处理请求和响应的各个环节。上一节我们探讨了如何配置中间件，今天我们将深入了解如何使用ASP.NET Core提供的各种内置中间件。这些中间件使得开发者能够快速实现常见的功能，如身份验证、会话管理、静态文件处理等。

1. 静态文件中间件

ASP.NET Core中有一个非常实用的内置中间件，可以直接为应用服务器提供静态文件，如HTML、CSS、JS和图片等。使用静态文件中间件，可以方便地将这些文件提供给客户端。

示例代码

首先，在Startup.cs文件中配置静态文件中间件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class Startup
{
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        // 开启静态文件中间件
        app.UseStaticFiles();

        // 其他中间件配置
        app.UseRouting();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapGet("/", async context =>
            {
                await context.Response.WriteAsync("Hello World!");
            });
        });
    }
}

在这里，app.UseStaticFiles()使得应用能够直接服务于wwwroot文件夹中的静态文件。如果你的项目结构类似于以下内容：

1
2
3
4
5
6
7
8

/MyAspNetCoreApp
|-- /wwwroot
|   |-- css
|   |   |-- style.css
|   |-- js
|   |   |-- app.js
|   |-- index.html
|-- Startup.cs

你可以通过浏览器访问http://localhost:5000/index.html来查看静态文件。

2. 日志记录中间件

ASP.NET Core 提供了强大的日志记录功能，借助内置的中间件，可以轻松地对请求进行日志记录。可以在请求进入管道时记录请求信息，也可以在响应返回时记录响应信息。

示例代码

在Startup.cs中，我们可以简单地添加日志记录：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILogger<Startup> logger)
{
    app.Use(async (context, next) =>
    {
        logger.LogInformation("Handling request: " + context.Request.Path);
        await next.Invoke();
        logger.LogInformation("Finished handling request.");
    });

    app.UseRouting();
    
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapGet("/", async context =>
        {
            await context.Response.WriteAsync("Hello World with Logging!");
        });
    });
}

在这个例子中，使用了一个简单的中间件来记录每个请求的路径。当请求进入和响应返回时，都会记录相关信息。

3. 身份验证中间件

ASP.NET Core 提供了多种身份验证模式，如Cookie、JWT等。身份验证中间件可以帮助保护你的应用，确保用户经过身份验证才能访问某些资源。

示例代码

以下是如何配置简单的Cookie身份验证中间件的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public void ConfigureServices(IServiceCollection services)
{
    services.AddAuthentication("MyCookieAuth")
        .AddCookie("MyCookieAuth", options =>
        {
            options.LoginPath = "/Account/Login";
        });
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseAuthentication(); // 添加身份验证中间件

    app.UseRouting();
    
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapGet("/", async context =>
        {
            await context.Response.WriteAsync("Hello World with Authentication!");
        });
    });
}

在这个例子中，我们首先在ConfigureServices中配置了Cookie身份验证。在Configure方法中，通过app.UseAuthentication()添加身份验证中间件。

4. 使用中间件处理错误

使用中间件处理应用程序中的错误也是一种常见的需求。ASP.NET Core提供了UseExceptionHandler中间件可以帮助我们处理未处理的异常。

示例代码

以下是如何设置错误处理的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseExceptionHandler("/Home/Error"); // 错误处理

    app.UseRouting();
    
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapGet("/", async context =>
        {
            throw new Exception("Test Exception");
        });

        endpoints.MapGet("/Home/Error", async context =>
        {
            await context.Response.WriteAsync("An error occurred!");
        });
    });
}

在此示例中，如果在根路径抛出异常，用户将被重定向到/Home/Error页面，显示错误信息。

总结

通过了解和使用ASP.NET Core内置中间件，开发者可以轻松地实现许多常见的功能，不需要从零开始进行实现。在本节中，我们介绍了静态文件中间件、日志记录中间件、身份验证中间件和错误处理中间件的使用，帮助你构建更加健壮的应用程序。接下来，我们将进入控制器与视图的章节，深入探讨控制器的创建与使用。