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

services.AddScoped<IMyService, MyService>();

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

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

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

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

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

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...
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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();
      // 在执行操作之后执行一些操作
  }
}

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

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

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

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

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

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");
      }
  }
}

app.UseMiddleware<CustomExceptionHandlerMiddleware>();

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;
  }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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?}");
  });
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// 这个重载允许你根据自定义的条件谓词动态选择是否应用指定的子管道。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"），将执行子管道中的中间件。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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);
  });
  // 其他服务的配置...
}

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

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