C# .NET面试系列七：ASP.NET Core

第一部分：ASP.NET Core

1. 如何在 controller 中注入 service?

在.NET中，在ASP.NET Core应用程序中的Controller中注入服务通常使用依赖注入（Dependency Injection）来实现。以下是一些步骤，说明如何在Controller中注入服务：

1、创建服务

首先，确保你已经在应用程序中注册了服务。这通常在Startup.cs文件的ConfigureServices方法中完成。例如：

services.AddScoped<IMyService, MyService>();

// 上述代码将IMyService接口和MyService实现类注册为Scoped服务。你需要替换这里的接口和实现类为你自己的服务。

2、在Controller中注入服务

一旦服务已经注册，你可以在Controller的构造函数中注入服务。例如：

public class MyController : Controller
{
  private readonly IMyService _myService;
  public MyController(IMyService myService)
  {
      _myService = myService;
  }
  // 在这里可以使用 _myService 进行操作
}

// 上述代码中，IMyService作为构造函数的参数传递给Controller，ASP.NET Core框架会自动通过依赖注入提供相应的服务实例。

3、使用注入的服务

一旦服务被注入到Controller中，你就可以在Controller的方法中使用它。例如：

public IActionResult MyAction()
{
  var result = _myService.DoSomething();
  return View(result);
}

// 在上述代码中，调用了_myService实例的DoSomething方法。

确保你的服务和Controller都在相同的依赖注入范围（例如Scoped），以确保它们共享相同的服务实例。

2. 谈一谈对 DDD 的理解?

领域驱动设计（Domain-Driven Design，简称DDD）是一种软件开发方法，强调在解决问题的过程中，通过对领域的深入理解来指导软件系统的设计和开发。在.NET中，DDD常常与ASP.NET Core等框架一起使用，以建立更健壮、可维护且符合业务需求的应用程序。

以下是在.NET中对DDD的一些理解：

领域模型：

DDD的核心概念之一是领域模型。领域模型是对业务领域的抽象，包括实体、值对象、聚合根、仓储等。在.NET中，你可以使用C#类来表示领域模型的各个方面。

public class Order
{
  public int Id { get; set; }
  public List<OrderItem> Items { get; set; }
  // Other properties and methods...
}

public class OrderItem
{
  public int ProductId { get; set; }
  public int Quantity { get; set; }
  // Other properties and methods...
}

聚合根：

聚合根是领域模型的根实体，负责保护整个聚合的一致性。在.NET中，你可以使用C#类来表示聚合根，并通过领域事件等机制来维护聚合的一致性。

public class Order : IAggregateRoot
{
  public int Id { get; set; }
  public List<OrderItem> Items { get; set; }
  // Other properties and methods...
}

领域服务：

领域服务是协调领域对象之间的操作，处理不适合放在实体或值对象中的业务逻辑。在.NET中，你可以创建领域服务的类，并将其注入到需要的地方。

public class OrderService
{
  public void ProcessOrder(Order order)
  {
      // Business logic related to order processing
  }
}

仓储模式：

仓储负责将领域对象持久化到数据库中，或从数据库中加载领域对象。在.NET中，你可以使用Entity Framework Core等ORM工具来实现仓储模式。

public interface IOrderRepository
{
  Order GetById(int orderId);
  void Save(Order order);
  // Other methods...
}

DDD强调与业务人员密切合作，通过共同的语言来理解和解决问题。在.NET中，通过使用C#和相关的技术，可以更自然地映射领域模型和业务需求，从而实现更高质量的软件系统。

3. ASP.NET Core 比 ASP.NET 更具优势的地方是什么？

ASP.NET Core相对于传统的ASP.NET框架在许多方面具有优势，这些优势使得它更加现代化、灵活、高性能和跨平台。以下是一些ASP.NET Core相对于传统ASP.NET的优势：

1、跨平台支持

ASP.NET Core 是一个跨平台的框架，可以在 Windows、Linux 和 macOS 等多个操作系统上运行。这使得开发者可以选择更适合他们的平台进行应用程序的开发和部署。 

2、开放源代码

ASP.NET Core 是开源的，这意味着开发者可以查看、修改和共享源代码。这为开发者提供了更多的自由度和透明度，使其能够更好地理解框架的内部工作机制。

3、轻量级和高性能

ASP.NET Core 经过重新设计，具有更轻量级的架构。它引入了新的 HTTP 请求处理管道，性能更高，同时支持异步编程模型，提高了应用程序的吞吐量和响应性能。

4、模块化和可插拔性

ASP.NET Core 采用了更模块化的设计，允许你只引用并使用你实际需要的组件。这种可插拔性使得开发者能够更灵活地构建和扩展应用程序。

5、自包含部署

ASP.NET Core 应用程序可以以自包含的方式部署，即应用程序和所有其依赖项可以打包为一个单独的文件。这简化了应用程序的部署和维护。

6、集成新的技术和模式

ASP.NET Core 引入了一系列新的技术和模式，如依赖注入、中间件、Razor Pages 等。这些使得开发更加现代化、灵活，并提供了更多的选择。

7、支持现代开发工具

ASP.NET Core 支持 Visual Studio Code 等轻量级编辑器，同时与 Visual Studio 等主流 IDE 紧密集成。这使得开发者可以选择他们喜欢的工具进行开发。

8、容器化支持

ASP.NET Core 天然支持容器化，可以更轻松地在 Docker 等容器环境中运行。这为应用程序的部署和扩展提供了更多的选择。

总体而言，ASP.NET Core通过引入一系列现代化的特性和改进，使得.NET应用程序更加灵活、高性能、跨平台，并能够更好地适应当今的软件开发需求。

4. asp.net core 主要的特性有哪些？

ASP.NET Core是一个现代、跨平台的开发框架，具有许多强大的特性，以满足不同类型的应用程序开发需求。以下是ASP.NET Core的一些主要特性：

1、跨平台支持

ASP.NET Core可以在Windows、Linux和macOS等多个操作系统上运行，提供了更大的灵活性和可移植性。

2、开源

ASP.NET Core 是开源的，开发者可以查看、修改和共享源代码。这促进了社区参与和开发者之间的协作。

3、轻量级和高性能

ASP.NET Core 经过重新设计，具有更轻量级的架构。它引入了新的 HTTP 请求处理管道，支持异步编程模型，提高了应用程序的性能和响应速度。

4、依赖注入

ASP.NET Core内置了依赖注入容器，简化了组件之间的解耦和测试。它支持构造函数注入和属性注入等方式。

5、模块化和可插拔性

ASP.NET Core 采用了模块化的设计，允许开发者只使用他们实际需要的组件。这种可插拔性使得开发更加灵活，能够更好地构建和扩展应用程序。

6、中间件

ASP.NET Core 使用中间件来处理 HTTP 请求和响应。开发者可以按照需要添加、删除或重排序中间件，以自定义请求处理管道。

7、Razor Pages

Razor Pages 是一种新的轻量级Web页面编程模型，简化了页面和处理程序的创建。它允许在一个页面中组织HTML、代码和其他资源。

8、MVC框架

ASP.NET Core 包括一个现代化的 MVC 框架，用于构建 Web 应用程序和 API。它支持模型-视图-控制器的设计模式，以提高代码的组织和可维护性。

9、SignalR

SignalR 是 ASP.NET Core 中的实时通信库，支持 WebSocket 和其他实时通信技术，使得开发者能够构建具有实时性的应用程序。

10、Entity Framework Core

Entity Framework Core是轻量级、跨平台的对象关系映射（ORM）框架，用于处理数据库访问和数据持久化。

11、自包含部署

ASP.NET Core 应用程序可以以自包含的方式部署，即应用程序和所有依赖项可以打包为一个单独的文件，简化了部署过程。

12、安全性

ASP.NET Core 提供了强大的身份验证和授权系统，支持常见的认证提供程序和标准，以确保应用程序的安全性。

这些特性使ASP.NET Core成为一个强大、灵活、高性能且现代的Web开发框架，适用于构建各种类型的应用程序，包括Web应用、API、实时应用程序等。

5. ASP.NET Core Filter 如何支持依赖注入?

在ASP.NET Core中，Filter是一种用于在请求处理管道中执行某些操作的组件。Filter可以用于处理请求前后、异常处理等场景。为了支持依赖注入，ASP.NET Core提供了IFilterFactory接口和ServiceFilterAttribute特性。

以下是如何在ASP.NET Core中使用Filter并支持依赖注入的步骤：

1、创建一个实现了IFilterFactory接口的Filter

public class MyFilter : IFilterFactory
{
  private readonly IService _myService;
  public MyFilter(IService myService)
  {
      _myService = myService;
  }

  public IFilterMetadata CreateInstance(IServiceProvider serviceProvider)
  {
      return new MyFilterInstance(_myService);
  }

  public bool IsReusable => false;
}

public class MyFilterInstance : IAsyncActionFilter
{
  private readonly IService _myService;
  public MyFilterInstance(IService myService)
  {
      _myService = myService;
  }

  public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
  {
      // 在执行操作之前执行一些操作
      _myService.DoSomething();
      // 继续执行请求处理管道中的下一个阶段
      var resultContext = await next();
      // 在执行操作之后执行一些操作
  }
}

2、将Filter添加到MVC管道中

在Startup.cs文件的ConfigureServices方法中，注册服务和添加Filter：

services.AddScoped<IService, MyService>(); // 替换 IService 和 MyService 为实际的服务接口和实现类

services.AddControllers(options =>
{
  options.Filters.Add<MyFilter>();
});

3、使用ServiceFilterAttribute特性

你还可以使用ServiceFilterAttribute特性，这样可以更简单地将Filter应用于Controller或Action，并支持依赖注入：

[ServiceFilter(typeof(MyFilter))]
public class MyController : Controller
{
  // Controller的代码...
}

在这种情况下，MyFilter中所需的服务将会被注入到Controller中。

通过以上步骤，你就可以在ASP.NET Core中使用Filter并支持依赖注入。这种方式允许你使用依赖注入容器（如ASP.NET Core的内置容器）来注入Filter所需的服务。

6. Asp.Net Core 中有哪些异常处理的方案？

在ASP.NET Core中，有多种方式来处理异常，以确保应用程序能够优雅地处理错误情况。以下是一些常见的异常处理方案：

1、中间件异常处理

UseExceptionHandler中间件： 在Startup.cs文件的Configure方法中，使用UseExceptionHandler中间件来捕获全局未处理的异常，并进行相应的处理。

app.UseExceptionHandler("/Home/Error");
// 在/Home/Error中你可以自定义错误处理的视图或其他操作。

2、MVC中的异常过滤器

在MVC中，可以使用异常过滤器来处理Controller和Action中的异常。你可以在Controller或Action上应用[ExceptionHandler]特性。

[ExceptionHandler]
public class MyController : Controller
{
  // Controller的代码...
}

3、自定义中间件处理异常

创建一个自定义的中间件，捕获异常并处理。这样可以在请求管道中的任何位置进行全局异常处理。

public class CustomExceptionHandlerMiddleware
{
  private readonly RequestDelegate _next;
  public CustomExceptionHandlerMiddleware(RequestDelegate next)
  {
      _next = next;
  }

  public async Task Invoke(HttpContext context)
  {
      try
      {
          await _next(context);
      }
      catch (Exception ex)
      {
          // 处理异常，例如记录日志等
          Log.Error(ex, "An error occurred");
          // 返回自定义错误响应
          context.Response.StatusCode = 500;
          await context.Response.WriteAsync("Internal Server Error");
      }
  }
}

4、注册中间件

app.UseMiddleware<CustomExceptionHandlerMiddleware>();

5、全局过滤器

在MVC中，可以使用全局过滤器处理所有Controller和Action中的异常。

services.AddControllers(options =>
{
  options.Filters.Add<GlobalExceptionFilter>();
});

public class GlobalExceptionFilter : IExceptionFilter
{
  public void OnException(ExceptionContext context)
  {
      // 处理异常，例如记录日志等
      Log.Error(context.Exception, "An error occurred");
      // 返回自定义错误响应
      context.Result = new ObjectResult("Internal Server Error")
      {
          StatusCode = 500
      };
      context.ExceptionHandled = true;
  }
}

这些是ASP.NET Core中一些常见的异常处理方案，可以根据应用程序的需求选择适当的方式。通常，全局异常处理和局部异常处理（例如Controller或Action级别）可以组合使用，以确保全面而细致的错误处理。

7. 介绍ASP.NET Core 中服务的生命周期？

在ASP.NET Core中，服务的生命周期管理是通过依赖注入（DI）系统来实现的。ASP.NET Core支持三种主要的服务生命周期，每种生命周期都适用于不同的场景和需求。以下是ASP.NET Core中的服务生命周期：

1、瞬态（Transient）生命周期

// 瞬态服务在每次请求时都会创建新的实例，并在请求处理结束后被销毁。每次注入瞬态服务时，都会得到一个新的实例。适用于轻量级且不需要保持状态的服务。
services.AddTransient<IMyService, MyService>();

2、作用域（Scoped）生命周期

// 作用域服务在每个请求过程中都会创建一个新的实例，但在同一请求中，多次请求同一个服务时将会得到相同的实例。适用于需要在请求期间保持状态的服务，例如数据库上下文。
services.AddScoped<IMyScopedService, MyScopedService>();

3、单例（Singleton）生命周期

// 单例服务在应用程序的整个生命周期中只会创建一个实例，并在应用程序关闭时销毁。适用于需要在整个应用程序中共享状态的服务，例如配置信息。
services.AddSingleton<IMySingletonService, MySingletonService>();

这些生命周期选项使开发者能够灵活地管理服务的生命周期，以满足应用程序的不同需求。在服务注册时，可以根据服务的性质和用途选择适当的生命周期。生命周期管理有助于提高性能、降低资源消耗，并确保在不同部件之间正确地共享或隔离状态。

此外，ASP.NET Core还支持自定义的生命周期管理，通过实现IServiceScopeFactory接口和IServiceScope接口，你可以创建自定义的作用域。这对于一些特殊情况下的服务生命周期管理非常有用。

8. 什么是依赖注入？

依赖注入（Dependency Injection，简称DI）是一种软件设计模式，旨在实现组件之间的松耦合。在依赖注入中，一个组件的依赖关系不是由组件自己创建，而是由外部系统（通常是一个依赖注入容器）负责提供。这样可以使得组件更加灵活、可测试、可维护，同时降低了组件之间的耦合性。

在依赖注入中，通常有三个主要角色：

1、服务（Service）

服务是应用程序中的一个组件，它提供某种功能或服务。服务可以包括数据库访问、日志记录、业务逻辑等。服务的实现通常是由开发者编写的。

2、客户端（Client）

客户端是依赖服务的组件，它需要某些功能或服务来完成自己的任务。客户端不直接创建或掌握服务的实例，而是依赖注入容器负责提供服务的实例。

3、依赖注入容器（DI Container）

依赖注入容器是一个工具，用于管理和提供应用程序中的服务实例。容器负责创建、管理、注入服务，以及解决服务之间的依赖关系。常见的 .NET DI 容器包括 ASP.NET Core内置的DI容器、Autofac、Ninject等。

依赖注入的主要目的是减少组件之间的直接依赖，使得代码更加可维护和可测试。通过将依赖关系从组件内部移动到外部容器中，代码变得更加灵活，易于替换和扩展。依赖注入还促使开发者遵循单一职责原则、开闭原则等面向对象设计原则，从而提高代码质量和可读性。

9. 依赖注入有哪几种方式？

在依赖注入中，有三种主要的依赖注入方式，它们分别是构造函数注入、属性注入和方法注入。这些方式允许将依赖关系传递给一个组件，以满足该组件的需求。以下是这三种方式的简要介绍：

1、构造函数注入（Constructor Injection）

构造函数注入是最常见的依赖注入方式。在这种方式中，依赖关系通过组件的构造函数传递。当组件被创建时，依赖关系会作为构造函数的参数传入。

public class MyComponent
{
  private readonly IDependency _dependency;
  public MyComponent(IDependency dependency)
  {
      _dependency = dependency;
  }
  // 使用 _dependency 进行操作...
}

2、属性注入（Property Injection）

属性注入是通过公共属性将依赖关系注入到组件中。在这种方式中，依赖关系可以在组件创建后通过属性设置。

public class MyComponent
{
  public IDependency Dependency { get; set; }
  // 使用 Dependency 进行操作...
}

注入容器在创建组件后会设置属性的值。

3、方法注入（Method Injection）

方法注入是通过方法调用将依赖关系注入到组件中。在这种方式中，组件的方法接受依赖关系作为参数。

public class MyComponent
{
  public void SetDependency(IDependency dependency)
  {
      // 使用 dependency 进行操作...
  }
}

注入容器在创建组件后调用相应的方法，并传递依赖关系。

不同的依赖注入方式适用于不同的场景。构造函数注入是最常用的方式，因为它提供了在组件创建时传递依赖关系的一种清晰和一致的方法。属性注入和方法注入适用于某些特殊情况，例如在不改变类的构造函数签名的情况下注入依赖。在选择依赖注入方式时，可以根据具体的需求和项目约定来决定使用哪种方式。

10. 控制反转是什么 ？

控制反转（Inversion of Control，简称IoC）是一种软件设计原则，用于实现组件之间的解耦和松散耦合。在传统的程序设计中，组件通常负责自己的创建和管理依赖关系，这导致了较高的耦合性。而控制反转则将这种责任反转，由外部容器负责管理和注入组件的依赖关系。

IoC的核心思想是反转依赖关系，即由组件自己去创建和管理依赖的方式变成由外部容器（IoC容器）来创建和管理组件的依赖。这使得组件不再关心如何获取依赖，而是通过外部容器将依赖关系注入。

控制反转的实现方式主要有两种：

1、依赖注入（Dependency Injection，DI）

依赖注入是控制反转的一种具体实现方式。通过依赖注入，组件的依赖关系由外部容器负责注入，通常是通过构造函数、属性或方法传递依赖关系。

2、服务定位器（Service Locator）

服务定位器是另一种实现控制反转的方式。在服务定位器中，组件通过查询一个中央的服务定位器来获取依赖，而不是直接依赖注入。然而，服务定位器容易引入全局状态和难以追踪的问题，因此通常依赖注入更受推荐。

控制反转有助于提高代码的可测试性、可维护性和灵活性。通过将依赖关系的创建和管理交给外部容器，组件可以更专注于自身的职责，同时使得系统更容易进行单元测试和替换组件。依赖注入是IoC的一种实际应用，已经成为现代软件开发中的常见实践。

11. 依赖注入有哪些著名的框架？

1、Microsoft.Extensions.DependencyInjection (DI容器的一部分)

Microsoft.Extensions.DependencyInjection 是.NET Core和ASP.NET Core 的官方依赖注入容器。它提供了轻量级、灵活的依赖注入框架，通常用于.NET Core和ASP.NET Core 应用程序。

2、Autofac

Autofac 是一个功能强大的 IoC（Inversion of Control）容器，也是一个.NET 依赖注入框架。它提供了灵活的配置选项，支持属性注入、构造函数注入等。Autofac 是一个流行的选择，被广泛用于各种.NET 应用程序。

3、Ninject

Ninject 是一个轻量级的依赖注入框架，专注于简化和优化依赖注入的过程。它支持构造函数注入、属性注入等，具有直观的 API。

4、Unity

Unity 是由 Microsoft支持的一个开源 IoC 容器。它提供了一种用于管理对象生命周期和解决依赖关系的方式。Unity 支持构造函数注入、方法注入等。

5、Castle Windsor

Castle Windsor 是一个成熟的 IoC 容器，支持.NET Framework。它提供了强大的功能，包括 XML 和代码配置、AOP（Aspect-Oriented Programming）等。

这些框架各有优势和适用场景，选择其中一个取决于项目的具体需求和个人或团队的偏好。在.NET Core和ASP.NET Core中，Microsoft.Extensions.DependencyInjection 是官方推荐的首选框架，因为它集成在.NET Core平台中，并提供了足够的功能满足大多数应用程序的需求。

12. 介绍一些 ABP.NEXT？

ABP.NEXT 是一种用于构建企业级应用程序的开发框架。它是基于ASP.NET Core构建的，旨在提供一整套工具和模块，以简化和加速企业应用程序的开发。以下是一些关于 ABP.NEXT 的主要特点和组成部分：

1、模块化设计

ABP.NEXT 采用模块化设计，使开发者能够将应用程序分解为独立的、可重用的模块。每个模块可以包含领域实体、服务、用户界面和其他相关组件。

2、多租户支持

ABP.NEXT 提供了多租户支持，使得一个应用程序可以为多个租户提供服务，并在同一个实例中管理不同租户的数据和配置。

3、领域驱动设计（DDD）

ABP.NEXT 支持领域驱动设计的概念，包括实体、聚合根、仓储等。这有助于构建更具可维护性和可扩展性的企业级应用程序。

4、身份认证和授权

ABP.NEXT 提供了身份认证和授权的解决方案，包括集成的身份系统、角色管理和权限控制。它支持常见的身份提供者，如 IdentityServer，并提供了集成的用户管理系统。

5、集成的用户界面

ABP.NEXT 集成了一些现代化的用户界面组件，包括 Angular 和 Blazor 框架。这些组件可以用于快速搭建用户界面，提供了一致的用户体验。

6、持久化支持

ABP.NEXT 支持多种数据库提供程序，包括Entity Framework Core、Dapper等。这使得开发者可以选择最适合他们需求的持久化技术。

7、开发者友好的工具

ABP.NEXT 提供了一系列开发者友好的工具，包括代码生成器、调试工具、模块管理等，以提高开发效率。

8、跨平台和跨框架

ABP.NEXT 基于ASP.NET Core 构建，因此可以在多个平台上运行，支持跨平台开发。同时，由于集成了Angular 和 Blazor 等框架，可以选择适合自己的前端技术栈。

13. 什么是 dot net core的 startup class？

在ASP.NET Core中，Startup类是一个重要的类，用于配置应用程序的服务和请求处理管道。Startup类包含两个主要方法：ConfigureServices 和 Configure。

ConfigureServices 方法：

ConfigureServices 方法用于配置应用程序的服务容器，也就是依赖注入容器。在这个方法中，你可以注册应用程序所需的服务，例如数据库上下文、身份认证服务、业务逻辑服务等。

public void ConfigureServices(IServiceCollection services)
{
  // 注册服务
  services.AddMvc();
  services.AddScoped<IMyService, MyService>();
  // 其他服务的注册...
}

Configure 方法：

Configure 方法用于配置应用程序的请求处理管道。在这个方法中，你可以定义中间件并配置它们的顺序。中间件用于处理请求和响应，例如路由、身份认证、日志记录等。

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
  // 根据环境配置中间件
  if (env.IsDevelopment())
  {
      app.UseDeveloperExceptionPage();
  }
  else
  {
      app.UseExceptionHandler("/Home/Error");
      app.UseHsts();
  }

  // 配置路由等中间件
  app.UseMvc(routes =>
  {
      routes.MapRoute(
          name: "default",
          template: "{controller=Home}/{action=Index}/{id?}");
  });
}

总体而言，Startup类的目的是集中配置应用程序的服务和中间件，以确保应用程序在启动时进行正确的初始化。ConfigureServices和Configure方法是在应用程序启动时由ASP.NET Core运行时调用的，它们定义了应用程序的整体行为和配置。

14. startup class 的 configure 方法有什么作用？

Startup类中的 Configure 方法用于配置应用程序的请求处理管道（request pipeline）。请求处理管道是一系列的中间件，它们按照顺序处理HTTP请求和生成HTTP响应。Configure 方法允许你定义中间件并指定它们的顺序，以满足应用程序的需求。

具体而言，Configure 方法有以下几个主要作用：

1、异常处理

// 在 Configure 方法中，你可以配置中间件来处理异常。例如，在开发环境中，你可以使用 UseDeveloperExceptionPage 中间件来显示详细的错误信息，而在生产环境中，可以使用 UseExceptionHandler 中间件来处理异常并显示适当的错误页面。

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

2、路由

// UseMvc 中间件用于配置和启用MVC框架的路由系统。在 Configure 方法中，你可以定义应用程序的路由规则，以确保请求被正确地路由到相应的控制器和动作方法。

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
  app.UseMvc(routes =>
  {
      routes.MapRoute(
          name: "default",
          template: "{controller=Home}/{action=Index}/{id?}");
  });
}

3、静态文件服务

// UseStaticFiles 中间件用于提供静态文件，例如CSS、JavaScript和图像。在 Configure 方法中，你可以启用并配置静态文件服务。

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
  app.UseStaticFiles();
}

4、认证和授权

// UseAuthentication 和 UseAuthorization 中间件用于处理身份认证和授权。在 Configure 方法中，你可以配置这些中间件以确保应用程序的安全性。

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
  app.UseAuthentication();
  app.UseAuthorization();
}

总体而言，Configure 方法是配置应用程序请求处理管道的关键地方，通过在这里添加和配置中间件，你可以定制应用程序的行为，以满足不同的需求和场景。

15. 什么是中间件（Middleware）？

中间件（Middleware）是在ASP.NET Core应用程序中处理HTTP请求和生成HTTP响应的组件。中间件是构建请求处理管道（Request Pipeline）的基本单元，它们按照添加的顺序依次处理请求和响应。中间件可以执行一系列的操作，例如路由、身份认证、异常处理、日志记录等。

在ASP.NET Core中，中间件是通过使用 Use 方法添加到请求处理管道中的。以下是一些常见的中间件及其功能：

1、UseStaticFiles

// 提供对静态文件的访问，例如CSS、JavaScript和图像。
app.UseStaticFiles();

2、UseRouting

// 启用路由，用于映射HTTP请求到处理程序（控制器和动作方法）。
app.UseRouting();

3、UseAuthentication 和 UseAuthorization

// 处理身份认证和授权。
app.UseAuthentication();
app.UseAuthorization();

4、UseMvc

// 启用MVC框架，用于处理和响应HTTP请求。
app.UseMvc();

5、UseDeveloperExceptionPage 和 UseExceptionHandler

// 用于处理开发环境和生产环境中的异常。
if (env.IsDevelopment())
{
  app.UseDeveloperExceptionPage();
}
else
{
  app.UseExceptionHandler("/Home/Error");
  app.UseHsts();
}

6、UseCors

// 配置跨域资源共享（CORS）中间件，允许或拒绝跨域请求。
app.UseCors();

中间件可以在请求处理管道的不同阶段执行操作，例如在请求到达控制器之前或在响应发送到客户端之前。中间件提供了一种可插拔的方式，允许开发者构建和定制请求处理管道，以满足应用程序的需求。中间件的添加顺序很重要，因为它决定了它们在管道中的执行顺序。

16. 中间件的使用场景有哪些？

中间件在ASP.NET Core应用程序中的使用场景非常多样，可以用于处理请求和生成响应的不同方面。以下是一些中间件的常见使用场景：

1、静态文件服务

// 使用 UseStaticFiles 中间件来提供对静态文件（如CSS、JavaScript、图像）的访问。
app.UseStaticFiles();

2、身份认证和授权

// 使用 UseAuthentication 和 UseAuthorization 中间件来处理身份认证和授权，确保只有经过身份验证的用户可以访问受保护的资源。
app.UseAuthentication();
app.UseAuthorization();

3、路由

// 使用 UseRouting 中间件启用路由，用于映射HTTP请求到相应的处理程序（控制器和动作方法）。
app.UseRouting();

4、异常处理

// 使用 UseExceptionHandler 中间件来处理异常，并返回适当的错误页面或错误响应。
app.UseExceptionHandler("/Home/Error");

5、CORS

// 使用 UseCors 中间件配置跨域资源共享（CORS），允许或拒绝跨域请求。
app.UseCors();

6、HTTPS重定向

// 使用 UseHttpsRedirection 中间件将HTTP请求重定向到HTTPS，以确保安全连接。
app.UseHttpsRedirection();

7、日志记录

// 自定义中间件可以用于记录请求和响应信息，以便进行日志记录和监控。
app.Use(async (context, next) =>
{
  // 记录请求信息
  LogRequest(context);
  // 调用下一个中间件
  await next();
  // 记录响应信息
  LogResponse(context);
});

8、压缩

// 使用 UseResponseCompression 中间件来启用响应压缩，减小传输的数据量。
app.UseResponseCompression();

这些只是中间件的一些常见使用场景，实际上中间件可以用于几乎任何你想要在请求处理管道中执行的操作。通过组合和自定义中间件，开发者可以灵活地构建适用于其应用程序需求的请求处理管道。

17. 列举官方常用的中间件？

ASP.NET Core 提供了一系列官方的中间件，用于处理请求和生成响应。以下是一些常用的官方中间件：

1、UseStaticFiles

// 提供对静态文件（如CSS、JavaScript、图像）的访问。
app.UseStaticFiles();

2、UseRouting

// 启用路由，用于映射HTTP请求到相应的处理程序（控制器和动作方法）。
app.UseRouting();

3、UseEndpoints

// 配置终结点路由，用于映射终结点（endpoint）到控制器和动作方法。
app.UseEndpoints(endpoints =>
{
  endpoints.MapControllers();
});

4、UseAuthentication 和 UseAuthorization

// 处理身份认证和授权。
app.UseAuthentication();
app.UseAuthorization();

5、UseExceptionHandler

// 处理异常，并返回适当的错误页面或错误响应。
app.UseExceptionHandler("/Home/Error");

6、UseCors

// 配置跨域资源共享（CORS）中间件，允许或拒绝跨域请求。
app.UseCors();

7、UseHsts

// 启用HTTP严格传输安全性（HTTP Strict Transport Security）以确保安全连接。
app.UseHsts();

8、UseHttpsRedirection

// 将HTTP请求重定向到HTTPS，以确保安全连接。
app.UseHttpsRedirection();

9、UseResponseCompression

// 启用响应压缩，减小传输的数据量。
app.UseResponseCompression();

10、UseMiddleware

// 使用自定义中间件，通过提供中间件实现的委托进行配置。
app.UseMiddleware<MyCustomMiddleware>();

这些中间件是ASP.NET Core框架中的一部分，可以通过在 Startup 类的 Configure 方法中添加和配置它们来使用。它们提供了丰富的功能，覆盖了常见的开发需求，同时也允许开发者编写自定义中间件以满足特定的需求。

18. 中间件的执行顺序？

在ASP.NET Core中，中间件的执行顺序是按照它们在 Startup 类的 Configure 方法中注册的顺序执行的。中间件是按照注册的顺序形成一个管道（pipeline），每个请求都会经过这个管道并依次执行注册的中间件。

以下是一般情况下中间件执行的顺序：

1、顺序注册

中间件的注册是有序的，按照在 Configure 方法中的代码顺序注册。例如：

public void Configure(IApplicationBuilder app)
{
    app.UseMiddleware1();
    app.UseMiddleware2();
    app.UseMiddleware3();
    // ...
}

2、首先注册的先执行

先注册的中间件会在管道中较早的位置，因此会先于后注册的中间件执行。在上述例子中，UseMiddleware1 将在 UseMiddleware2 和 UseMiddleware3 之前执行。

3、Terminator中间件

通常，在管道中的最后一个中间件是一个终结中间件，它不会调用下一个中间件，即使有其他中间件在它之后注册。这个终结中间件通常是处理请求的最终步骤，例如返回 HTTP 响应。

4、Map和UseWhen中间件

使用 Map 和 UseWhen 方法可以根据请求路径或条件为中间件创建分支，这可能影响中间件的执行顺序。根据路径或条件的匹配情况，不同的中间件可能会在不同的分支中执行。

总体而言，中间件按照注册的顺序依次执行，但特殊情况和使用 Map、UseWhen 等方法可以在管道中创建分支，从而影响中间件的执行流程。

19. application builder 的 use 和 run 方法有什么区别？

Use 和 Run 方法都是用于添加中间件到 ASP.NET Core 应用程序的请求处理管道中，但它们之间存在一些关键的区别。

Use 方法：

// Use 方法用于添加中间件，并且该中间件可以处理请求并将控制权传递给管道中的下一个中间件。通常，Use 方法用于构建一个处理管道，中间件在处理请求时可以执行一些操作，然后调用 next 参数将控制权传递给下一个中间件。这样的中间件通常是处理请求、修改请求或响应的中间件。

app.Use(async (context, next) =>
{
  // 执行某些操作前
  // ...
  // 将控制权传递给下一个中间件
  await next();
  // 执行某些操作后
  // ...
});

Run 方法：

// Run 方法用于添加最终中间件，它会终止请求处理管道，不再将控制权传递给下一个中间件。一旦 Run 方法被执行，请求处理管道将不再继续执行后续的中间件，直接返回响应。通常，Run 方法用于定义应用程序的终点，例如返回一个特定的响应或执行最终的操作。

app.Run(context =>
{
  // 处理请求
  return context.Response.WriteAsync("Hello, World!");
});

总的来说，Use 方法通常用于构建中间件处理管道，其中中间件可以选择将控制权传递给下一个中间件。而 Run 方法用于定义应用程序的最终处理逻辑，它不会将控制权传递给下一个中间件，而是终止请求处理管道。

20. dot net core 管道里面的 map 拓展有什么作用?

在ASP.NET Core中，Map 方法是一个用于分支处理管道的拓展方法。它允许你根据请求的路径进行条件分支，选择不同的中间件处理不同的请求。Map 方法接受一个路径参数，并且在满足该路径条件时，执行指定的中间件。

具体来说，Map 方法有两种重载形式：

1、Map(PathString path, Action<IApplicationBuilder> configuration)

// 这个重载允许你为满足指定路径条件的请求配置一个子管道，子管道中可以包含一系列中间件。这样，对于满足路径条件的请求，将使用子管道中的中间件进行处理。

app.Map("/branch", branch =>
{
  branch.Run(async context =>
  {
      await context.Response.WriteAsync("This is a branch.");
  });
});

// 在上述例子中，对于路径为 "/branch" 的请求，将执行子管道中的中间件，返回相应的响应。

2、MapWhen(Func<HttpContext, bool> predicate, Action<IApplicationBuilder> configuration)

// 这个重载允许你根据自定义的条件谓词动态选择是否应用指定的子管道。predicate 参数是一个函数，根据请求上下文返回一个布尔值，如果为 true，则应用子管道。

app.MapWhen(context => context.Request.Query.ContainsKey("branch"), branch =>
{
  branch.Run(async context =>
  {
      await context.Response.WriteAsync("This is a conditional branch.");
  });
});

// 在上述例子中，对于满足自定义条件的请求（查询参数中包含 "branch"），将执行子管道中的中间件。

通过使用 Map 方法，你可以根据不同的路径或条件，将请求分发给不同的中间件处理，从而实现对请求的分支处理。这对于构建具有不同功能区域的应用程序或实现条件性的中间件执行非常有用。

21. dot net core 里面的路径是如何处理的？

在ASP.NET Core中，请求的路径是通过中间件处理管道中的路由系统进行处理的。路由系统负责将传入的HTTP请求映射到相应的处理程序（通常是控制器和动作方法），从而确定如何处理该请求。

以下是ASP.NET Core中路径处理的一般流程：

1、UseRouting 中间件

// 在 Startup 类的 Configure 方法中，通过添加 app.UseRouting() 中间件来启用路由系统。

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
  app.UseRouting();
  // 其他中间件的配置...
}

2、配置终结点（Endpoints）

// 使用 UseEndpoints 中间件配置路由终结点，将请求映射到处理程序。这是基于终结点的路由配置方式，取代了之前版本的 UseMvc。

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

上述代码配置了一个默认的控制器路由，将请求映射到名为 “default” 的路由规则，如果没有匹配的路由，将使用默认的控制器、动作和可选的参数。

3、控制器和动作方法：

// 创建控制器和动作方法，它们处理具体的HTTP请求。路由系统将请求映射到相应的控制器和动作方法。
public class HomeController : Controller
{
  public IActionResult Index()
  {
      return View();
  }
}

在上述例子中，Index 方法处理默认路由匹配的请求。

4、路由参数

// 路由系统还支持从URL中提取参数，例如在路由模式中定义的参数。例如，在路由模式 {controller}/{action}/{id?} 中，id 是一个可选的参数，可以从请求的URL中提取。

public class MyController : Controller
{
  public IActionResult Details(int? id)
  {
      // 使用 id 处理请求...
      return View();
  }
}

上述例子中，Details 方法接受一个可选的 id 参数，该参数将从请求的URL中提取。

通过配置路由系统，你可以定义应用程序中的 URL 结构，将请求映射到相应的控制器和动作方法。这种灵活的路由系统使得在ASP.NET Core 应用程序中定义清晰而富有表达力的 URL 成为可能。

22. dot net core 工程里面有哪些常见的工程文件？

在一个典型的ASP.NET Core工程中，可以找到一些常见的工程文件和文件夹。以下是一些常见的文件和文件夹：

1、项目文件 (*.csproj)

项目文件是工程的核心，它包含了项目的元数据、引用、编译选项等信息。通常以 .csproj 扩展名结尾。

2、启动文件 (Program.cs)

Program.cs 文件包含 Main 方法，是应用程序的入口点。它创建 WebHostBuilder，用于配置和启动应用程序。

3、启动配置 (Startup.cs)

Startup.cs 文件包含了应用程序的配置信息，包括中间件的添加、服务的配置等。它定义了应用程序的启动过程。

4、应用设置 (appsettings.json)

appsettings.json 文件包含应用程序的配置信息，如数据库连接字符串、日志设置等。可以有不同的环境特定版本，例如 appsettings.Development.json。

5、静态文件 (wwwroot)

wwwroot 文件夹用于存放静态文件，例如 CSS、JavaScript、图像等。这些文件可以被直接访问而无需经过处理。

6、视图文件 (Views)

Views 文件夹包含 MVC 框架中的视图文件，通常是以 .cshtml 扩展名结尾的 Razor 视图文件。

7、控制器文件 (Controllers)

Controllers 文件夹包含 MVC 框架中的控制器文件，用于处理 HTTP 请求并返回相应的响应。

8、模型文件 (Models)

Models 文件夹包含应用程序中使用的数据模型，用于表示数据库实体或其他数据结构。

9、中间件和配置 (Startup.cs)：

Startup.cs 文件中的 Configure 方法包含中间件的配置，定义了请求处理管道的各个阶段。

10、依赖注入配置 (Startup.cs)

Startup.cs 文件中的 ConfigureServices 方法包含了应用程序的依赖注入配置，注册了服务。

11、测试文件夹 (Tests)

Tests 文件夹通常包含单元测试和集成测试的相关文件，用于测试应用程序的各个部分。

这些文件和文件夹是一个典型的ASP.NET Core工程中常见的组成部分。具体的工程结构可能因项目类型、框架版本等而有所不同，但通常包含类似的元素。

23. 依赖注入实现原理？

依赖注入（Dependency Injection，简称DI）是一种设计模式，用于将组件的依赖关系从组件本身解耦，并由外部系统（通常是一个容器）提供这些依赖关系。在ASP.NET Core中，依赖注入是一个重要的特性，它的实现原理涉及到以下几个关键的组成部分：

1、服务容器（Service Container）

服务容器是负责管理和提供应用程序中所有服务的组件。在 ASP.NET Core中，服务容器通过 IServiceProvider 接口来定义。IServiceProvider 接口包括获取服务的方法，例如 GetService 和 GetRequiredService。

2、服务注册（Service Registration）

// 服务注册是将应用程序中的服务类型与具体实现关联起来的过程。在ASP.NET Core中，服务注册通常在 Startup.cs 文件的 ConfigureServices 方法中完成，使用 IServiceCollection 接口提供的方法进行注册。

public void ConfigureServices(IServiceCollection services)
{
  services.AddScoped<IMyService, MyService>();
  // 其他服务的注册...
}

上述例子中，IMyService 接口与 MyService 类型关联，表示当应用程序需要 IMyService 时，会提供一个 MyService 类型的实例。

3、服务的生命周期（Service Lifetime）：

// 注册服务时，需要指定服务的生命周期，即服务在容器中的存在时间。ASP.NET Core提供了以下生命周期选项：

Transient： 每次请求服务时都会创建一个新的实例。
Scoped： 在同一作用域（例如一个HTTP请求）内，服务是唯一的，但在不同作用域中会有不同的实例。
Singleton： 在整个应用程序生命周期内只创建一个实例。

services.AddTransient<IMyTransientService, MyTransientService>();
services.AddScoped<IMyScopedService, MyScopedService>();
services.AddSingleton<IMySingletonService, MySingletonService>();

4、服务解析和注入

// 在应用程序的其他地方，需要使用到某个服务时，可以通过构造函数注入、方法注入等方式进行服务解析。ASP.NET Core的依赖注入容器会负责提供相应的服务实例。

public class MyController : Controller
{
  private readonly IMyService _myService
  public MyController(IMyService myService)
  {
      _myService = myService;
  }
  // 控制器中使用 _myService...
}

在上述例子中，MyController 控制器通过构造函数注入 IMyService，容器会在创建控制器实例时自动提供 IMyService 的实例。

依赖注入的实现原理涉及到服务容器的设计和管理、服务注册的方式、生命周期管理等方面。ASP.NET Core 的依赖注入框架是可扩展的，允许开发者自定义服务的注册和解析行为。这种解耦和可扩展性使得依赖注入成为ASP.NET Core 应用程序中组织代码和实现松耦合的重要工具。

24. ASP.NET Core项目如何设置IP地址和端口号？

在ASP.NET Core项目中，你可以通过配置文件或代码的方式设置IP地址和端口号。以下是两种常见的设置方式：

1、通过配置文件设置

在项目的 appsettings.json 或其他环境特定的配置文件中，你可以添加配置项来指定IP地址和端口号。例如：

{
    "AppSettings": {
        "IpAddress": "127.0.0.1",
        "Port": 5000
    }
}

然后，在 Startup.cs 文件的 ConfigureServices 方法中读取配置项，并将其用于设置WebHostBuilder的属性：

public void ConfigureServices(IServiceCollection services)
{
  // 读取配置
  var ipAddress = Configuration["AppSettings:IpAddress"];
  var port = Convert.ToInt32(Configuration["AppSettings:Port"]);
  // 设置WebHostBuilder属性
  services.Configure<WebHostOptions>(options =>
  {
    options.Listen(IPAddress.Parse(ipAddress), port);
  });
  // 其他服务的配置...
}

这样，你就可以在配置文件中轻松指定IP地址和端口号。

2、通过代码设置

在 Startup.cs 文件的 Configure 方法中，你可以直接通过代码设置IP地址和端口号：

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
  var ipAddress = "127.0.0.1";
  var port = 5000;
  app.UseUrls($"http://{ipAddress}:{port}");
  // 其他中间件的配置...
}

使用 UseUrls 方法来设置应用程序监听的地址和端口。在上述例子中，应用程序将监听 http://127.0.0.1:5000。

无论你选择哪种方式，都可以根据需要设置 IP 地址和端口号。这些设置将影响应用程序在本地开发环境或生产环境中的监听地址和端口。

本系列文章题目摘自网络，答案重新梳理