👏🏻 你好！欢迎访问IT教程网，0门教程，教程全部原创，计算机教程大全，全免费！

🔥 新增教程

《黑神话 悟空》游戏开发教程，共40节，完全免费，点击学习

《AI副业教程》，完全原创教程，点击学习

发表更新软件开发 / ASP.NET7 分钟读完 (大约1030个字)

13 控制器与视图之控制器的创建与使用

在ASP.NET Core中，控制器是MVC（模型-视图-控制器）模式的重要组成部分，负责处理用户请求并返回相应的视图或数据。在本篇教程中，我们将深入探讨如何创建和使用控制器，并结合实际案例来说明其重要性和用法。

1. 控制器的基本结构

在ASP.NET Core中，控制器通常是一个类，该类继承自Controller基类。控制器中的每个公共方法通常称为动作，这些动作处理来自视图或API的请求。控制器类的名称通常以“Controller”结尾，以便于MVC框架能够识别。

示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
using Microsoft.AspNetCore.Mvc;

namespace MyApp.Controllers
{
    public class HomeController : Controller
    {
        // GET: /Home/
        public IActionResult Index()
        {
            return View();
        }

        // GET: /Home/About
        public IActionResult About()
        {
            return View();
        }
    }
}

在这个简单的例子中，我们创建了一个名为HomeController的控制器，其中包含了两个动作：Index和About。这两个动作分别返回了不同的视图。

2. 控制器的路由

在ASP.NET Core中，路由机制用于将请求映射到相应的控制器和动作。我们可以在Startup.cs文件中配置路由。

配置路由

1
2
3
4
5
6
7
8
9
10
11
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseRouting();

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

在这个例子中，我们将默认的路由模式设置为{controller=Home}/{action=Index}/{id?}，这意味着当访问/Home时，系统会调用HomeController的Index动作。

3. 控制器与视图的交互

控制器不仅仅是处理请求，它们还与视图进行交互。控制器可以通过模型将数据传递到视图中，以便进行渲染。

传递数据到视图

1
2
3
4
5
public IActionResult About()
{
    ViewData["Message"] = "Your application description page.";
    return View();
}

在以上的About动作中，我们使用ViewData字典将消息传递给视图。ViewData是一个动态对象，能够在控制器与视图之间传递数据。

4. 使用视图

控制器返回的视图需要在 Views 文件夹中进行创建。视图的命名通常与控制器的动作名称一致。例如，对于About动作，我们需要在 Views/Home 下新建一个 About.cshtml 文件。

About.cshtml 示例

1
2
3
4
5
@{
    ViewData["Title"] = "About";
}

<h2>@ViewData["Message"]</h2>

这个视图将显示About动作中传递的消息。

5. 路由参数与控制器

控制器动作还可以接受参数，这些参数可以从URL中获取。例如，可以通过在路由中添加参数来访问特定的资源。

示例代码

1
2
3
4
5
6
public IActionResult Details(int id)
{
    // 假设我们根据id获取数据
    var item = GetItemById(id);
    return View(item);
}

在这个例子中，我们创建了一个名为Details的动作，它接受一个整型参数id。然后，我们假设使用该id从数据库中获取了一个具体的项目，并将其传递给视图。

路由规则

为了能够正确传递参数，我们还需要确保路由支持这个参数。例如，可以在路由配置中添加相应的规则：

1
2
3
4
endpoints.MapControllerRoute(
    name: "details",
    pattern: "Home/Details/{id}",
    defaults: new { controller = "Home", action = "Details" });

6. 总结

在本篇教程中，我们重点介绍了控制器的创建与使用。控制器作为MVC模式的核心角色，用于处理请求、传递数据到视图及返回响应。通过结合实际的代码示例，我们展示了如何创建控制器、配置路由并与视图进行交互。

在下一篇教程中，我们将继续深入探讨视图的创建与使用，了解如何更好地展示数据和用户界面。

通过此系列教程的学习，相信您已具备了使用ASP.NET Core框架进行Web开发的初步能力。期待在下篇文章中与您继续探索！

分享转发

发表更新软件开发 / ASP.NET6 分钟读完 (大约966个字)

14 控制器与视图之视图的创建与使用

在上一篇中，我们讨论了如何创建控制器。在本篇中，我们将重点放在视图的创建与使用上，进一步完善我们的ASP.NET Core应用程序。

什么是视图？

在ASP.NET Core MVC中，视图是负责展示用户界面的部分。视图通常是HTML页面，它可以通过C#代码生成动态内容。我们的目标是通过控制器将数据传递到视图，使用户能够看到动态生成的内容。

在此过程中，视图将使用 Razor 语法进行编写，这是 ASP.NET 中用于创建动态网页的引擎。

创建视图

首先，我们需要创建一个视图。在我们之前创建的控制器中，假设我们有一个简单的 HomeController，我们将在其中创建一个名为 Index 的动作方法。

步骤 1: 创建 Index 动作方法

1
2
3
4
5
6
7
public class HomeController : Controller
{
    public IActionResult Index()
    {
        return View();
    }
}

在这个 Index 方法中，我们调用了 View() 方法，这将会返回 Index 视图。

步骤 2: 创建视图文件

在项目的 Views 目录下，创建一个名为 Home 的子目录（与控制器名称相同）。然后，在 Home 目录中创建一个名为 Index.cshtml 的文件，这是我们的视图文件。

1
2
3
4
5
6
@{
    ViewData["Title"] = "首页";
}

<h1>欢迎来到首页</h1>
<p>这是我的第一个ASP.NET Core MVC应用。</p>

这个视图文件使用了 Razor 语法，我们为该视图设置了一个标题，并显示了一些文本。

使用视图

当我们启动应用程序并访问 /Home/Index 路径时，ASP.NET Core将调用 HomeController 的 Index 方法，并返回 Index.cshtml 视图。

传递数据到视图

在大多数情况下，我们希望将一些数据传递给视图。我们可以使用 ViewData 或 ViewBag 来实现这一点。

使用 ViewData

我们可以在控制器中添加一些数据：

1
2
3
4
5
public IActionResult Index()
{
    ViewData["Message"] = "欢迎来到我的网站！";
    return View();
}

然后，在 Index.cshtml 中使用这些数据：

1
<p>@ViewData["Message"]</p>

使用 ViewBag

ViewBag 也可以用来传递动态数据，类似于 ViewData：

1
2
3
4
5
public IActionResult Index()
{
    ViewBag.Message = "这是通过ViewBag传递的消息！";
    return View();
}

在视图中访问它：

1
<p>@ViewBag.Message</p>

使用模型

除了用 ViewData 和 ViewBag 传递数据外，最推荐的方式是使用模型。模型是一个类，它通常包含我们希望在视图中展示的数据。

创建模型

让我们创建一个简单的模型类，比如 Product：

1
2
3
4
5
public class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }
}

然后在 HomeController 中使用这个模型：

1
2
3
4
5
public IActionResult Index()
{
    var product = new Product { Name = "笔记本", Price = 9.99M };
    return View(product);
}

修改视图

接下来，我们需要更新视图以使用这个模型。在 Index.cshtml 文件的顶部，添加以下代码来声明模型：

1
@model Product

然后，我们可以直接使用模型的数据：

1
2
<h1>产品名称: @Model.Name</h1>
<p>产品价格: @Model.Price</p>

总结

在本篇中，我们学习了如何创建和使用视图。我们看到了如何通过控制器返回视图，并且我们讨论了如何使用 ViewData、ViewBag 和模型来传递数据。通过这些基础知识，我们可以构建更复杂的视图逻辑和用户界面。

在下一篇中，我们将探讨数据传递与模型绑定的话题，进一步增强我们应用程序的功能。希望这篇文章能够帮助你更好地理解 ASP.NET Core MVC 中视图的创建与使用。

分享转发

发表更新软件开发 / ASP.NET6 分钟读完 (大约895个字)

15 控制器与视图之数据传递与模型绑定

在我们上篇的内容中，我们讨论了如何创建和使用视图。在这一章中，我们将深入探讨如何在控制器与视图之间传递数据，以及如何进行模型绑定。这些知识对于构建动态网站非常重要，因为它们使得用户输入的数据能够与我们的后端逻辑无缝对接。

数据传递

1. 将数据发送到视图

在ASP.NET Core MVC中，控制器是处理用户请求的主要组件。我们可以通过控制器将数据发送到视图。有几种方法可以做到这一点：

  • 视图数据（ViewData）
    使用 ViewData 传递数据是最简单的方法之一。ViewData 是一个字典，您可以在控制器中将数据添加到其中，随后在视图中读取这些值。

    1
    2
    3
    4
    5
    6
    7
    8
    public class HomeController : Controller
    {
        public IActionResult Index()
        {
            ViewData["Message"] = "欢迎来到我的网站!";
            return View();
        }
    }

    在视图中，您可以这样访问这个值：

    1
    <h1>@ViewData["Message"]</h1>

  • 视图模型（ViewModel）
    使用专门的视图模型（ViewModel）是另一种推荐的方式。视图模型是一个类，用于封装视图所需的数据。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    public class MyViewModel
    {
        public string Message { get; set; }
        public int Count { get; set; }
    }

    public class HomeController : Controller
    {
        public IActionResult Index()
        {
            var model = new MyViewModel
            {
                Message = "欢迎来到我的网站!",
                Count = 10
            };
            return View(model);
        }
    }

    在视图中，您可以通过强类型的视图模型来访问数据：

    1
    2
    3
    4
    @model MyViewModel

    <h1>@Model.Message</h1>
    <p>计数: @Model.Count</p>

2. 从视图接收数据

用户输入的数据通常会通过表单提交到控制器。ASP.NET Core MVC通过模型绑定（Model Binding）来处理这些数据。模型绑定的过程是自动的，它会将从表单提交的数据映射到控制器方法的参数中。

模型绑定

模型绑定的工作机制非常强大。下面是一个基本的示例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class User
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public class HomeController : Controller
{
    [HttpPost]
    public IActionResult Submit(User user)
    {
        if (ModelState.IsValid)
        {
            // 处理用户数据
            return RedirectToAction("Success");
        }
        
        return View(user);
    }
}

在视图中，您可以使用 Tag Helpers 创建一个简单的表单：

1
2
3
4
5
6
7
8
9
10
11
@model User

<form asp-action="Submit" method="post">
    <label asp-for="Name"></label>
    <input asp-for="Name" />
    
    <label asp-for="Age"></label>
    <input asp-for="Age" />
    
    <button type="submit">提交</button>
</form>

3. 处理复杂模型

有时候，您的模型可能会更复杂，包含嵌套对象或集合。模型绑定同样能处理这些情况：

1
2
3
4
5
6
7
8
9
10
11
public class Order
{
    public int Id { get; set; }
    public List<Item> Items { get; set; }
}

public class Item
{
    public string ProductName { get; set; }
    public int Quantity { get; set; }
}

您的视图可以包含一个包含多个项目的表单：

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

<form asp-action="SubmitOrder" method="post">
    <input type="hidden" asp-for="Id" />
    
    @for (int i = 0; i < Model.Items.Count; i++)
    {
        <div>
            <label asp-for="Items[i].ProductName"></label>
            <input asp-for="Items[i].ProductName" />
            
            <label asp-for="Items[i].Quantity"></label>
            <input asp-for="Items[i].Quantity" />
        </div>
    }
    
    <button type="submit">提交订单</button>
</form>

在控制器中，您可以通过模型绑定容易地获取提交的数据：

1
2
3
4
5
6
7
8
9
10
[HttpPost]
public IActionResult SubmitOrder(Order order)
{
    if (ModelState.IsValid)
    {
        // 处理订单数据
    }
    
    return View(order);
}

结论

在本节中，我们讨论了如何在ASP.NET Core MVC中进行数据传递和模型绑定。通过使用 ViewData、视图模型和表单，我们能够有效地从控制器向视图传递数据，并将视图中的用户输入数据提交回控制器。这为构建动态和互动丰富的Web应用打下了坚实的基础。

在下一章节中，我们将探讨依赖注入的概念，这是ASP.NET Core框架的核心特性之一，能够帮助我们创建更松耦合和易于测试的应用程序。

分享转发

发表更新软件开发 / ASP.NET7 分钟读完 (大约1004个字)

16 依赖注入之什么是依赖注入

在 ASP.NET Core 中，依赖注入（Dependency Injection）是一个核心概念，它帮助我们管理对象的创建和生命周期。在上一节中，我们讨论了控制器与视图的数据传递与模型绑定，这一节我们将深入探讨什么是依赖注入，以及它如何使我们的应用程序更加灵活和可维护。

依赖注入的定义

依赖注入是一种软件设计模式，它允许我们创建松散耦合的应用程序。通过将对象所依赖的其他对象（即依赖项）传递给这些对象，而不是在对象内部创建这些依赖项，依赖注入使得我们可以更方便地管理对象之间的关系。

在 ASP.NET Core 中，框架内置了支持依赖注入的机制，这让我们可以轻松地在各个组件之间传递依赖项。

为什么需要依赖注入？

在没有使用依赖注入的情况下，类会直接在内部创建其依赖项，这种做法有几个缺点：

  1. 紧耦合: 依赖项的具体实现被硬编码到类内部，导致类之间的关系非常紧密。当依赖项发生变化时，依赖它的类也必须更改。

  2. 难以测试: 单元测试中，我们往往需要替换真实的依赖项（例如，数据库访问或网络请求）为模拟对象。没有依赖注入，进行这些替换会非常困难。

  3. 可维护性差: 随着类的复杂性增加，内部的依赖关系也会随之增加，导致代码难以维护。

依赖注入的工作原理

在 ASP.NET Core 中，依赖注入的工作流程通常如下：

  1. 服务注册: 在 Startup 类的 ConfigureServices 方法中，将需要注入的服务注册到依赖注入容器中。
  2. 服务请求: 在使用服务的地方（例如控制器或其他服务），通过构造函数注入这些服务。
  3. 服务解析: ASP.NET Core 的依赖注入容器会管理服务的生命周期，并在需要使用服务时提供正确的实例。

示例：通过依赖注入使用服务

让我们通过一个简单的示例，来展示如何使用依赖注入。

1. 创建服务接口和实现

首先，我们定义一个简单的服务接口 IGreetingService 和它的实现类 GreetingService。

1
2
3
4
5
6
7
8
9
10
11
12
public interface IGreetingService
{
    string Greet(string name);
}

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

2. 注册服务

接下来，在 Startup.cs 文件的 ConfigureServices 方法中注册这个服务。

1
2
3
4
5
6
7
8
public void ConfigureServices(IServiceCollection services)
{
    // 注册IGreetingService为Transient服务
    services.AddTransient<IGreetingService, GreetingService>();
    
    // 其他服务注册
    services.AddControllersWithViews();
}

3. 使用依赖注入服务

在控制器中，我们可以通过构造函数注入的方式使用 IGreetingService。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class GreetingController : Controller
{
    private readonly IGreetingService _greetingService;

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

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

4. 发起请求

当我们访问 /Greeting/Greet?name=World 时，控制器会调用 GreetingService 的 Greet 方法，并返回 Hello, World!。通过依赖注入，控制器与具体的服务实现解耦。

总结

依赖注入是 ASP.NET Core 的一个重要特性，它使得我们的应用程序易于管理和测试。在这一节中，我们讨论了依赖注入的基本概念、必要性以及如何在 ASP.NET Core 中使用依赖注入。通过使用依赖注入，我们可以更轻松地维护应用程序并提高代码的可重用性和可测试性。

在下一节中，我们将探讨如何注册服务，并深入了解服务的生命周期管理。

分享转发

发表更新软件开发 / ASP.NET6 分钟读完 (大约891个字)

17 依赖注入之注册服务

在上一篇文章中，我们介绍了什么是依赖注入，它如何帮助我们降低组件之间的耦合度并提高代码的可维护性。现在，我们将深入探讨如何在 ASP.NET Core 框架中注册和管理服务。理解服务的注册是依赖注入机制中至关重要的一环。

依赖注入的基本概念

在 ASP.NET Core 中，依赖注入的核心是“服务”与“容器”。服务是实现某种功能的类，而容器是负责实例化和管理这些服务生命周期的地方。我们通过将服务注册到容器中，使得系统能够根据需要自动注入这些服务。

服务的注册

在 ASP.NET Core 中，服务的注册通常在 Startup 类的 ConfigureServices 方法中完成。我们通常会使用 IServiceCollection 接口来进行服务的注册。以下是一个简化的示例，显示了如何注册一个服务：

1
2
3
4
5
6
7
8
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddTransient<IMyService, MyService>();
        // ... 其他服务的注册
    }
}

在上面的代码中，我们注册了一个名为 IMyService 的服务接口以及它的实现类 MyService。这里有几种不同的注册方式：

  • AddTransient：每次请求都会创建一个新的服务实例。
  • AddScoped：在每个请求的范围内只创建一个服务实例。
  • AddSingleton：整个应用程序的生命周期内只创建一个服务实例。

服务的生命周期

选择正确的服务生命周期对于应用的性能和内存使用是至关重要的。每种生命周期的使用场景如下：

  • Transient：适用于无状态服务或者轻量级服务，不需要在请求之间保存状态。
  • Scoped：适用于需要在整个请求期间共享状态的服务，比如与数据库上下文交互的服务。
  • Singleton：适用于在整个应用程序中共享的状态，通常用于配置或不经常变化的数据。

注册服务的示例

假设我们有一个简单的电子邮件服务接口和它的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
public interface IEmailService
{
    void SendEmail(string to, string subject, string body);
}

public class EmailService : IEmailService
{
    public void SendEmail(string to, string subject, string body)
    {
        // 实际的发送邮件逻辑
        Console.WriteLine($"Sending Email to {to} with subject {subject}");
    }
}

我们可以在 Startup 类中注册这个服务：

1
2
3
4
5
6
7
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddScoped<IEmailService, EmailService>();
    }
}

使用注册的服务

在控制器或其他服务中，我们可以通过构造函数注入来使用这些注册的服务。例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class HomeController : Controller
{
    private readonly IEmailService _emailService;

    public HomeController(IEmailService emailService)
    {
        _emailService = emailService;
    }

    public IActionResult SendMail()
    {
        _emailService.SendEmail("user@example.com", "Hello", "This is a test email.");
        return Ok("Email sent!");
    }
}

在这个控制器中，IEmailService 会在构造的时候自动注入，从而我们可以直接使用 _emailService 发送邮件。

小结

通过注册服务，我们可以有效地管理服务的生命周期并实现依赖注入，提高了代码的可维护性和可测试性。在下一篇文章中，我们将实际演示如何在 ASP.NET Core 应用中使用已注册的服务进行业务逻辑的实现和测试。希望您对本篇文章有深入的理解，并能在实际项目中运用这些知识。

分享转发

发表更新软件开发 / ASP.NET6 分钟读完 (大约856个字)

18 依赖注入之使用依赖注入

在上一篇中，我们讨论了如何在ASP.NET Core中注册服务。服务的注册是依赖注入（DI）过程的第一步，而在本篇中，我们将深入探讨如何在实际应用中使用这些已注册的服务。

什么是依赖注入

依赖注入是将对象的依赖从对象内部移到外部的一种设计模式。在ASP.NET Core中，依赖注入使得组件之间的耦合度降低，提高了代码的可测试性和灵活性。

在使用依赖注入之前，首先需要确保你已经注册了服务。假设在上一篇中，我们注册了一个简单的IMyService接口和它的实现MyService，代码如下：

1
2
3
4
5
6
7
8
9
public interface IMyService
{
    string GetGreeting();
}

public class MyService : IMyService
{
    public string GetGreeting() => "Hello from MyService!";
}

如上代码中，我们创建了一个简单的服务接口和实现。

使用依赖注入

在ASP.NET Core中，使用依赖注入非常简单。你可以在需要使用这个服务的地方请求它。在ASP.NET Core中，通常是在控制器、Razor页面或中间件中进行注入。

1. 在控制器中使用依赖注入

下面是一个使用了IMyService服务的控制器示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
using Microsoft.AspNetCore.Mvc;

public class HomeController : Controller
{
    private readonly IMyService _myService;

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

    public IActionResult Index()
    {
        var greeting = _myService.GetGreeting();
        ViewData["Greeting"] = greeting;
        return View();
    }
}

在上面的代码中，我们在HomeController的构造函数中通过依赖注入将IMyService的实例传递到控制器的私有变量_myService中。接着，在Index方法中，我们可以使用这个服务来获取问候信息。

2. 在Razor页面中使用依赖注入

与控制器类似，你也可以在Razor页面中使用依赖注入。例如，修改Index.cshtml.cs代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
using Microsoft.AspNetCore.Mvc.RazorPages;

public class IndexModel : PageModel
{
    private readonly IMyService _myService;

    public string Greeting { get; private set; }

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

    public void OnGet()
    {
        Greeting = _myService.GetGreeting();
    }
}

这里我们在IndexModel中通过构造函数注入了IMyService，并在OnGet方法中调用它以提供数据。

测试依赖注入

使用依赖注入的另一个好处是，你可以轻松地进行单元测试。下面是一个简单的HomeController的测试示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
using Microsoft.AspNetCore.Mvc;
using Moq;
using Xunit;

public class HomeControllerTests
{
    [Fact]
    public void Index_ReturnsViewWithGreeting()
    {
        // Arrange
        var mockService = new Mock<IMyService>();
        mockService.Setup(s => s.GetGreeting()).Returns("Test Greeting");
        var controller = new HomeController(mockService.Object);

        // Act
        var result = controller.Index() as ViewResult;

        // Assert
        Assert.NotNull(result);
        Assert.Equal("Test Greeting", result.ViewData["Greeting"]);
    }
}

在这个测试中，我们使用了Moq库来创建IMyService的一个模拟（mock）实例。这样可以保证在测试中不会依赖于真实的服务实现，从而提高测试的隔离性和稳定性。

总结

在本篇中，我们讨论了如何在ASP.NET Core应用程序中实际使用依赖注入。我们从控制器和Razor页面的使用示例出发，展示了如何通过构造函数注入获取服务并使用它们。通过依赖注入，我们提高了代码的可维护性和可测试性。

在下一篇中，我们将继续讨论如何使用Entity Framework Core进行数据访问，敬请期待！

分享转发

发表更新软件开发 / ASP.NET6 分钟读完 (大约890个字)

19 数据访问之使用Entity Framework Core

在我们的ASP.NET Core框架入门教程中，上一节我们学习了依赖注入如何帮助我们管理依赖关系以及如何提高代码的可测试性。在本节中，我们将深入探讨如何使用Entity Framework Core来进行数据访问。Entity Framework Core（简称EF Core）是一个现代的对象关系映射（ORM）框架，通过它我们可以轻松地与数据库进行交互。

什么是Entity Framework Core？

Entity Framework Core是一个轻量级、可扩展的开源ORM框架，适用于.NET应用程序。它使得开发者能够使用C#代码与数据库进行交互，而无需编写复杂的SQL查询。

配置Entity Framework Core

安装NuGet包

在使用Entity Framework Core前，我们需要安装相关的NuGet包。我们可以通过NuGet包管理器或命令行工具来安装。以下是使用命令行安装SQL Server提供程序和EF Core的命令：

1
2
dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet add package Microsoft.EntityFrameworkCore.Tools

创建DbContext

DbContext是与数据库交互的主要类。在我们的示例中，我们将创建一个BlogDbContext，用于描述我们的博客应用程序。

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 BlogDbContext : DbContext
{
    public BlogDbContext(DbContextOptions<BlogDbContext> options) : base(options) { }

    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }
}

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }
    public List<Post> Posts { get; set; }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    public int BlogId { get; set; }
    public Blog Blog { get; set; }
}

注册DbContext到依赖注入容器

确保在Startup.cs文件中将DbContext注册到依赖注入容器中。这可以在ConfigureServices方法中完成：

1
2
3
4
5
6
7
8
public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<BlogDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
    
    // 其他服务
    services.AddControllersWithViews();
}

配置数据库连接字符串

在appsettings.json中添加数据库连接字符串：

1
2
3
4
5
6
{
  "ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=BlogDatabase;Trusted_Connection=True;MultipleActiveResultSets=true"
  },
  // 其他配置
}

使用Entity Framework Core执行CRUD操作

接下来，让我们在一个控制器中使用Entity Framework Core进行CRUD（创建、读取、更新、删除）操作。

创建控制器

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
using Microsoft.AspNetCore.Mvc;
using System.Linq;

public class BlogsController : Controller
{
    private readonly BlogDbContext _context;

    public BlogsController(BlogDbContext context)
    {
        _context = context;
    }

    public IActionResult Index()
    {
        var blogs = _context.Blogs.ToList();
        return View(blogs);
    }

    [HttpPost]
    public IActionResult Create(Blog blog)
    {
        if (ModelState.IsValid)
        {
            _context.Blogs.Add(blog);
            _context.SaveChanges();
            return RedirectToAction(nameof(Index));
        }
        
        return View(blog);
    }

    public IActionResult Edit(int id)
    {
        var blog = _context.Blogs.SingleOrDefault(b => b.BlogId == id);
        if (blog == null)
        {
            return NotFound();
        }
        return View(blog);
    }

    [HttpPost]
    public IActionResult Edit(Blog blog)
    {
        if (ModelState.IsValid)
        {
            _context.Blogs.Update(blog);
            _context.SaveChanges();
            return RedirectToAction(nameof(Index));
        }
        return View(blog);
    }
    
    public IActionResult Delete(int id)
    {
        var blog = _context.Blogs.SingleOrDefault(b => b.BlogId == id);
        if (blog == null)
        {
            return NotFound();
        }
        _context.Blogs.Remove(blog);
        _context.SaveChanges();
        return RedirectToAction(nameof(Index));
    }
}

使用Razor视图展示数据

在Views/Blogs/Index.cshtml中，我们可以展示博客列表：

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
@model IEnumerable<Blog>

<h2>Blogs</h2>

<table>
    <thead>
        <tr>
            <th>BlogId</th>
            <th>Url</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
    @foreach (var blog in Model)
    {
        <tr>
            <td>@blog.BlogId</td>
            <td>@blog.Url</td>
            <td>
                <a asp-action="Edit" asp-route-id="@blog.BlogId">Edit</a>
                <form asp-action="Delete" asp-route-id="@blog.BlogId" method="post" style="display:inline;">
                    <button type="submit">Delete</button>
                </form>
            </td>
        </tr>
    }
    </tbody>
</table>

<a asp-action="Create">Create New</a>

小结

在本节中，我们学习了如何使用Entity Framework Core进行数据访问。我们创建了DbContext，配置了数据库连接，执行了基本的CRUD操作。这些知识为我们后续更复杂的数据库迁移打下了基础。在下一节中，我们将讨论如何进行数据库迁移，管理数据模式的演变。

助于确保代码的可维护性和可扩展性，Entity Framework Core为我们提供了强大的功能，使得开发者能够更加高效地管理应用程序的数据层。

分享转发

发表更新软件开发 / ASP.NET7 分钟读完 (大约1094个字)

20 数据访问之数据库迁移

在前一篇中，我们介绍了如何使用 Entity Framework Core 与数据库进行交互。在本篇中，我们将讨论数据库迁移的概念，以及如何使用 Entity Framework Core 进行数据库的版本管理和迁移。这一过程对于确保数据库结构与应用程序模型的一致性至关重要。

什么是数据库迁移？

数据库迁移是指对数据库结构的版本管理，它帮助开发者在更改数据模型时同步更新数据库。通过迁移，我们可以轻松地添加、修改或删除数据库中的表、列及其约束，而无需手动编写 SQL 语句。

为什么要使用数据库迁移？

  • 版本控制：迁移文件可以作为代码的一部分进行版本控制，这样我们可以记录所有的数据库更改。
  • 简化更新：通过迁移，可以一步到位地将新的数据库结构应用于现有数据库。
  • 协作开发：在团队开发中，通过迁移文件，团队成员可以获取最新的数据库更改，并通过迁移确保本地数据库与主数据库一致。

创建数据库迁移

在开始之前，请确保您已经安装了 Entity Framework Core 并创建了一个数据模型。现在，我们将完成以下步骤：

  1. 创建迁移。
  2. 应用迁移。

假设我们在前一篇中定义了一个简单的 Product 模型，代码如下面所示：

1
2
3
4
5
6
public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
}

1. 创建迁移

确保您已在项目根目录中打开终端，然后运行以下命令以创建迁移：

1
dotnet ef migrations add InitialCreate

上面的命令会生成一个迁移文件，该文件包含将 Product 类映射到数据库表的代码。迁移文件将位于项目的 Migrations 文件夹中，命名规则为 时间戳_迁移名称。

2. 应用迁移

创建迁移后，我们需要将其应用到数据库，以创建相应的表。执行以下命令：

1
dotnet ef database update

此命令将数据库更新到最新的迁移状态。在这个过程中，Entity Framework Core 将应用所有未应用的迁移，并在数据库中创建 Products 表。

迁移示例

以下是迁移自动生成的一个示例代码：

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 partial class InitialCreate : Migration
{
    protected override void Up(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.CreateTable(
            name: "Products",
            columns: table => new
            {
                Id = table.Column<int>(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                Name = table.Column<string>(nullable: true),
                Price = table.Column<decimal>(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_Products", x => x.Id);
            });
    }

    protected override void Down(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.DropTable(
            name: "Products");
    }
}

在上述代码中，Up 方法定义了迁移时要执行的操作，而 Down 方法定义了回滚迁移时要执行的操作。

迁移变更

当我们需要更改模型时，例如添加一个新的 Category 属性到 Product 类中，首先修改 Product 类：

1
2
3
4
5
6
7
public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public string Category { get; set; }  // 新增字段
}

接下来，我们再次创建新的迁移：

1
dotnet ef migrations add AddCategoryToProduct

最后，应用新的迁移：

1
dotnet ef database update

迁移的最佳实践

  1. 频繁迁移：尽量保持小而频繁的迁移，这样可以减少合并冲突和错误的可能性。
  2. 代码审查：在迁移后，确保进行代码审查，以捕捉可能的数据库设计问题。
  3. 数据迁移：如果需要，在迁移中使用 SQL 或 C# 代码迁移现有数据，确保新字段的数据一致性。

总结

在本篇中，我们学习了Entity Framework Core 中数据库迁移的基本概念及其操作步骤。通过创建和应用迁移，我们能够确保模型与数据库之间的一致性，使数据库管理变得更加简单和高效。接下来的内容将会讨论如何在数据库中执行 CRUD 操作，这是应用程序开发的重要组成部分。

分享转发

发表更新软件开发 / ASP.NET5 分钟读完 (大约785个字)

21 数据访问之CRUD操作

在上一篇中，我们讨论了如何进行数据库迁移以确保数据库的结构与我们应用程序中的实体类相匹配。本篇将重点讲解如何在ASP.NET Core应用程序中实现基本的CRUD（创建、读取、更新、删除）操作。

1. CRUD操作概述

CRUD是指对数据库中数据的基本操作，分别对应于以下四种功能：

  • 创建（Create）：向数据库中添加新数据。
  • 读取（Read）：从数据库中检索数据。
  • 更新（Update）：修改已存在的数据。
  • 删除（Delete）：从数据库中移除数据。

我们将通过一个简单的示例来实现对“用户”数据的CRUD操作。我们假设有一个名为User的实体，其具有Id、Name和Email等属性。

2. 创建用户实体

首先，我们需要在项目中定义User实体。可以在Models文件夹中创建一个名为User.cs的文件，并添加以下代码：

1
2
3
4
5
6
7
8
public class User
{
    public int Id { get; set; }
    
    public string Name { get; set; }
    
    public string Email { get; set; }
}

3. 配置DbContext

接下来，我们需要在Data文件夹中创建一个ApplicationDbContext类，继承DbContext并配置我们的User实体。

1
2
3
4
5
6
7
8
9
10
11
using Microsoft.EntityFrameworkCore;

public class ApplicationDbContext : DbContext
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options)
    {
    }

    public DbSet<User> Users { get; set; }
}

然后，在Startup.cs中配置数据库上下文，确保已添加到ConfigureServices方法中：

1
2
3
4
5
6
public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
    services.AddControllersWithViews();
}

4. 创建CRUD控制器

现在我们将创建一个控制器UsersController来处理CRUD操作。在Controllers文件夹中添加UsersController.cs文件。

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System.Collections.Generic;
using System.Threading.Tasks;

public class UsersController : Controller
{
    private readonly ApplicationDbContext _context;

    public UsersController(ApplicationDbContext context)
    {
        _context = context;
    }

    // GET: Users
    public async Task<IActionResult> Index()
    {
        return View(await _context.Users.ToListAsync());
    }

    // GET: Users/Create
    public IActionResult Create()
    {
        return View();
    }

    // POST: Users/Create
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> Create(User user)
    {
        if (ModelState.IsValid)
        {
            _context.Add(user);
            await _context.SaveChangesAsync();
            return RedirectToAction(nameof(Index));
        }
        return View(user);
    }

    // GET: Users/Edit/5
    public async Task<IActionResult> Edit(int? id)
    {
        if (id == null)
        {
            return NotFound();
        }

        var user = await _context.Users.FindAsync(id);
        if (user == null)
        {
            return NotFound();
        }
        return View(user);
    }

    // POST: Users/Edit/5
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> Edit(int id, User user)
    {
        if (id != user.Id)
        {
            return NotFound();
        }

        if (ModelState.IsValid)
        {
            try
            {
                _context.Update(user);
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!UserExists(user.Id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }
            return RedirectToAction(nameof(Index));
        }
        return View(user);
    }

    // GET: Users/Delete/5
    public async Task<IActionResult> Delete(int? id)
    {
        if (id == null)
        {
            return NotFound();
        }

        var user = await _context.Users
            .FirstOrDefaultAsync(m => m.Id == id);
        if (user == null)
        {
            return NotFound();
        }

        return View(user);
    }

    // POST: Users/Delete/5
    [HttpPost, ActionName("Delete")]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> DeleteConfirmed(int id)
    {
        var user = await _context.Users.FindAsync(id);
        _context.Users.Remove(user);
        await _context.SaveChangesAsync();
        return RedirectToAction(nameof(Index));
    }

    private bool UserExists(int id)
    {
        return _context.Users.Any(e => e.Id == id);
    }
}

5. 创建视图

接下来，我们需要为Index、Create、Edit和Delete操作创建视图。可以使用ASP.NET Core的Razor视图引擎来实现。

在Views/Users文件夹下创建以下视图文件：

Views/Users/Index.cshtml

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
@model IEnumerable<User>

<h1>用户列表</h1>

<table class="table">
    <thead>
        <tr>
            <th>姓名</th>
            <th>Email</th>
            <th>操作</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var user in Model)
        {
            <tr>
                <td>@user.Name</td>
                <td>@user.Email</td>
                <td>
                    <a asp-action="Edit" asp-route-id="@user.Id">编辑</a> |
                    <a asp-action="Delete" asp-route-id="@user.Id">删除</a>
                </td>
            </tr>
        }
    </tbody>
</table>

<a asp-action="Create">创建新用户</a>

Views/Users/Create.cshtml

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

<h1>创建用户</h1>

<form asp-action="Create">
    <div class="form-group">
        <label asp-for="Name"></label>
        <input asp-for="Name" class="form-control" />
        <span asp-validation-for="Name" class="text-danger"></span>
    </div>
    <div class="form-group">
        <label asp-for="Email"></label>
        <input asp-for="Email" class="form-control" />
        <span asp-validation-for="Email" class="text-danger"></span>
    </div>
    <button type="submit" class="btn btn-primary">创建</button>
</form>

Views/Users/Edit.cshtml

@model User

<h1>

分享转发

发表更新软件开发 / ASP.NET8 分钟读完 (大约1193个字)

22 身份验证与授权之身份验证的概念

在上一篇中，我们探讨了如何在 ASP.NET Core 应用程序中执行 CRUD 操作。数据的管理和处理是应用程序的重要部分，而如何确保这些数据的安全性同样至关重要。今天我们将深入探讨身份验证的概念，它是确保用户能够安全访问应用资源的基础。

什么是身份验证？

身份验证是确认用户身份的过程。在软件开发中，身份验证通常涉及让用户提供某种凭据，比如用户名和密码，以便确认他们的身份。这一过程的核心在于确保用户确实是他们声称的那个人。

身份验证的类型

在 ASP.NET Core 中，身份验证可以采用多种不同的方式，最常见的包括：

  1. 基于表单的身份验证：用户输入用户名和密码，系统验证其有效性。
  2. Cookie 身份验证：当用户登录后，系统会生成一个 cookie 来保存用户的登录状态，用户在后续请求中携带这个 cookie。
  3. JWT（JSON Web Token）身份验证：用于无状态身份验证，客户端和服务器通过生成、解析和验证 JWT 来实现身份验证。
  4. OAuth/OpenID Connect：通过社交平台或其他身份提供者进行身份验证。

在 ASP.NET Core 中，我们将重点关注基于 cookie 的身份验证，原因是它简单易用且广泛适用。

身份验证的工作流程

无论哪种身份验证方式，其基本的工作流程通常如下：

  1. 用户提交凭据（如用户名和密码）。
  2. 服务器验证这些凭据的有效性。
  3. 如果凭据有效，服务器创建并发送一个标识符（如 token 或 cookie）给用户。
  4. 用户在随后的请求中携带该标识符，以此证明其身份。
  5. 服务器根据该标识符来确认用户的身份。

这一流程帮助我们在 Web 应用程序中实现安全性，确保只有经过身份验证的用户才能访问受保护的资源。

ASP.NET Core 中的身份验证

在 ASP.NET Core 中，身份验证通常使用中间件进行配置和管理。身份验证系统为用户的身份验证和信息安全提供了一个全面解决方案。我们通过使用 Microsoft.AspNetCore.Authentication 命名空间下的组件来实现身份验证。

身份验证的实施

在实际应用中，你可以使用 Entity Framework Core 来管理用户和其凭据。用户信息通常存储在数据库中，包括用户名和加密后的密码。在实施身份验证时，你可能会执行以下步骤：

  1. 创建用户模型：定义用户的基本属性。
  2. 使用 Identity 模块：添加 ASP.NET Core Identity，简化用户和角色的管理。
  3. 配置身份验证服务：在 Startup.cs 中设置相应的服务和中间件。

代码示例

以下是一个简化的示例，展示如何在 ASP.NET Core 中配置身份验证。假设我们已经设置好一个 MVC 项目。

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
// Startup.cs

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // 添加数据库上下文
        services.AddDbContext<ApplicationDbContext>(options =>
            options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

        // 添加 Identity 服务
        services.AddIdentity<ApplicationUser, IdentityRole>()
            .AddEntityFrameworkStores<ApplicationDbContext>()
            .AddDefaultTokenProviders();

        // 添加身份验证
        services.ConfigureApplicationCookie(options =>
        {
            options.LoginPath = "/Account/Login"; // 设置登录路径
            options.LogoutPath = "/Account/Logout"; // 设置登出路径
            options.AccessDeniedPath = "/Account/AccessDenied"; // 设置拒绝访问路径
        });

        services.AddControllersWithViews();
    }

    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.UseAuthentication(); // 启用身份验证
        app.UseAuthorization(); // 启用授权

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

在上述代码中，我们配置了 ASP.NET Core Identity，指定了用户模型和数据存储，同时设置了 cookie 身份验证的相关路径。

小结

身份验证在保护应用程序的安全性方面起着关键作用。在本节中，我们了解了身份验证的基本概念及其在 ASP.NET Core 中的实现方法。接下来，在下一篇中，我们将深入探讨如何实现 Cookie 身份验证，将具体代码和案例结合起来，帮助你更好地理解这一主题。

准备好进入实现 Cookie 身份验证的实践了吗？让我们一起继续探索。

分享转发

发表更新软件开发 / ASP.NET6 分钟读完 (大约965个字)

23 身份验证与授权之实现Cookie身份验证

在上一篇中，我们探讨了“身份验证”的概念，了解了用户身份的确认过程。而在本篇中，我们将深入学习如何在ASP.NET Core应用程序中实现基于Cookie的身份验证。通过这个过程，我们将清楚地看到如何通过Cookie存储用户的身份信息，从而为用户的每次请求提供身份验证支持。

什么是Cookie身份验证？

Cookie身份验证是一种常用的身份验证机制，在该机制下，当用户成功登录后，服务器会生成一个Cookie并将其存储在用户的浏览器中。这个Cookie中通常包含了用户的身份信息，作为用户后续请求时的凭证。每当用户发送请求时，浏览器会将该Cookie附加到请求中，从而让服务器能够识别用户身份。

实现Cookie身份验证的步骤

1. 配置服务

首先，我们需要在Startup.cs文件中配置身份验证服务。在ConfigureServices方法中添加以下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
public void ConfigureServices(IServiceCollection services)
{
    services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
        .AddCookie(options =>
        {
            options.LoginPath = "/Account/Login"; // 未登录时的重定向路径
            options.LogoutPath = "/Account/Logout"; // 注销后的重定向路径
            options.AccessDeniedPath = "/Account/AccessDenied"; // 权限访问被拒绝后的路径
        });

    // 其他服务配置...
    services.AddControllers_withViews();
}

在上面的代码中，我们通过AddAuthentication方法添加了Cookie身份验证，并指定了一些基本的配置，如用户未登录时的重定向路径。

2. 创建登录控制器

接下来，我们需要创建一个控制器来处理用户的登录请求。以下是一个简单的AccountController示例：

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
39
40
41
42
43
44
45
46
47
48
49
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Authentication.Cookies;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using System.Security.Claims;
using System.Threading.Tasks;

public class AccountController : Controller
{
    [HttpGet]
    public IActionResult Login()
    {
        return View();
    }

    [HttpPost]
    public async Task<IActionResult> Login(string username, string password)
    {
        // 此处应添加验证逻辑，比如查询数据库验证用户的用户名和密码
        if (username == "admin" && password == "password") // 示例验证
        {
            var claims = new[]
            {
                new Claim(ClaimTypes.Name, username)
                // 可以添加其他声称
            };
            var claimsIdentity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
            var authProperties = new AuthenticationProperties
            {
                IsPersistent = true // 用户注销后是否保持登录状态
            };

            await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, 
                new ClaimsPrincipal(claimsIdentity), authProperties);

            return RedirectToAction("Index", "Home"); // 登录成功后重定向
        }

        ModelState.AddModelError("", "Invalid login attempt.");
        return View();
    }

    [HttpPost]
    public async Task<IActionResult> Logout()
    {
        await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
        return RedirectToAction("Index", "Home"); // 注销后重定向
    }
}

在上面的Login方法中，我们首先验证用户的凭证。如果验证成功，则创建一个ClaimsIdentity，并使用HttpContext.SignInAsync方法将其添加到用户的Cookie中。

3. 创建登录视图

接下来，我们需要创建一个登录页面。可以在Views/Account/Login.cshtml中创建一个简单的表单：

1
2
3
4
5
6
7
8
9
10
11
12
13
@model YourNamespace.Models.LoginViewModel

<form asp-action="Login" method="post">
    <div>
        <label asp-for="Username"></label>
        <input asp-for="Username" />
    </div>
    <div>
        <label asp-for="Password"></label>
        <input asp-for="Password" type="password" />
    </div>
    <button type="submit">登录</button>
</form>

4. 使用 [Authorize] 特性进行保护

通过在需要保护的控制器或方法上添加 [Authorize] 特性，我们可以确保这些资源只有经过身份验证的用户才能访问。例如：

1
2
3
4
5
6
7
8
[Authorize]
public class HomeController : Controller
{
    public IActionResult Index()
    {
        return View();
    }
}

如果用户未登录，则会自动重定向到登录页面。

小结

到此为止，我们已经走过了实现Cookie身份验证的基础步骤。用户通过登录页面提交凭证，服务器验证登录信息并创建Cookie，后续请求中Cookie将被用于身份验证。这种机制为我们的应用提供了一种安全的用户状态管理方式。

在下一篇中，我们将继续深入探讨基于角色的授权，学习如何通过角色来控制用户的访问权限，敬请期待！

分享转发

发表更新软件开发 / ASP.NET6 分钟读完 (大约877个字)

24 身份验证与授权之角色授权

在上一篇中，我们讨论了如何实现Cookie身份验证，了解了用户如何通过表单登录来访问我们的ASP.NET Core应用程序。身份验证后，用户将被赋予一个身份，而授权则是决定这些身份可以做什么的过程。在本篇中，我们将深入探讨ASP.NET Core提供的角色授权机制。

什么是角色授权？

角色授权是一种基于角色的访问控制机制，它通过将用户分配到预定义的角色中来简化授权要求。每个角色相当于一组权限，可以用来控制用户访问特定的资源和功能。

例如，一个在线学习平台可能会有以下角色：

  • 学生
  • 教师
  • 管理员

在这种情况下，不同角色的用户将拥有不同的访问权限。例如，学生可以查看课程，教师可以发布课程和成绩，而管理员可以管理所有用户和课程。

配置角色授权

要在ASP.NET Core中使用角色授权，我们首先需要确保已经安装了相应的NuGet包。通常情况下，Microsoft.AspNetCore.Identity包已经包含在内。如果未安装，可以通过NuGet Package Manager或命令行安装：

1
dotnet add package Microsoft.AspNetCore.Identity

启用角色服务

在Startup.cs的ConfigureServices方法中，我们需要添加角色服务：

1
2
3
4
5
6
7
8
9
10
11
public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

    services.AddIdentity<IdentityUser, IdentityRole>()
        .AddEntityFrameworkStores<ApplicationDbContext>()
        .AddDefaultTokenProviders();

    services.AddControllersWithViews();
}

创建和分配角色

我们可以创建角色并将用户分配到这些角色。以下是一个示例代码，通过RoleManager来创建和管理角色。

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
public class SeedData
{
    public static async Task Initialize(IServiceProvider serviceProvider)
    {
        var roleManager = serviceProvider.GetRequiredService<RoleManager<IdentityRole>>();
        var userManager = serviceProvider.GetRequiredService<UserManager<IdentityUser>>();

        string[] roleNames = { "学生", "教师", "管理员" };
        IdentityResult roleResult;

        foreach (var roleName in roleNames)
        {
            var roleExists = await roleManager.RoleExistsAsync(roleName);
            if (!roleExists)
            {
                roleResult = await roleManager.CreateAsync(new IdentityRole(roleName));
            }
        }

        var user = await userManager.FindByEmailAsync("teacher@example.com");
        if (user != null)
        {
            await userManager.AddToRoleAsync(user, "教师");
        }
    }
}

您可以在Program.cs中调用SeedData.Initialize来确保在应用启动时创建这些角色。

使用角色进行授权

一旦角色被创建并分配给用户后，我们就可以在控制器或操作方法中使用角色进行授权。例如：

1
2
3
4
5
6
7
8
[Authorize(Roles = "管理员")]
public class AdminController : Controller
{
    public IActionResult Index()
    {
        return View();
    }
}

在上述代码中，只有管理员角色的用户才能访问AdminController的Index动作。

从控制器访问用户角色

在控制器中，我们可以使用User.IsInRole方法来检查当前用户是否属于某个角色。例如：

1
2
3
4
5
6
7
8
9
public IActionResult Index()
{
    if (User.IsInRole("教师"))
    {
        // 给教师特定的视图或操作
        return View("TeacherView");
    }
    return View("DefaultView");
}

总结

通过以上步骤，我们已经在ASP.NET Core应用程序中成功实现了角色授权。角色授权让我们能够根据用户的角色来细分访问权限，使得权限管理变得更加清晰和易于维护。

在接下来的部分中，我们将转向日志管理，深入探讨日志的基本概念，以及如何在ASP.NET Core应用中有效地使用日志记录功能。这将帮助我们更好地监控应用程序的运行状态，提高故障排查的效率。

分享转发

×