Asp.net core 笔记（GPT摘的）

什么是ASP.NET Core？

ASP.NET Core 是一个跨平台的开源框架，用于构建现代云应用程序、Web 应用程序和服务。它是 .NET Core 的一部分，具有高性能和可扩展性，并可以在 Windows、Linux 和 macOS 等多种操作系统上运行。

ASP.NET Core 是一个全面的 Web 开发框架，包括 MVC （Model-View-Controller）、控制器、视图、路由、过滤器、模型绑定等组件。它还提供了丰富的缓存、身份验证、日志记录、配置以及异常处理的支持。除此之外，ASP.NET Core 还支持 Docker 容器，并且可以轻松地集成到 DevOps 流程中。

ASP.NET Core 使用 C# 或 F# 等语言进行编码，使用 Visual Studio 或者跨平台的 Visual Studio Code 进行开发。它采用基于中间件的请求处理管道，这使得应用程序具有轻量级和高灵活性的特点，可以根据不同需求进行自定义开发。

怎么在asp.net core中开启session？

1.安装Microsoft.AspNetCore.Session包

Install-Package Microsoft.AspNetCore.Session

2.在Startup.cs文件的ConfigureServices方法中添加Session服务：

services.AddDistributedMemoryCache();  // 可选。将Session数据存储在内存中
services.AddSession(options =>
{
    options.Cookie.Name = ".MyApp.Session";
    options.IdleTimeout = TimeSpan.FromMinutes(30);
});

3.在Startup.cs文件的Configure方法中使用Session中间件：

app.UseSession();

现在，您已经成功启用了ASP.NET Core中的Session功能。您可以从任何控制器或视图中使用HttpContext.Session来访问Session对象。例如：

HttpContext.Session.SetString("SessionKeyName", "value");
var value = HttpContext.Session.GetString("SessionKeyName");

什么是中间件？

在计算机科学中，中间件（Middleware）是指位于客户端和服务器端之间的一组软件组件，用于处理应用程序和操作系统之间的请求和响应。中间件可以执行许多不同的任务，例如身份验证、缓存、日志记录、安全性等。

在 Web 应用程序中，中间件还可以用于处理 HTTP 请求和响应。当客户端发送 HTTP 请求时，它将首先被中间件拦截，并且可以对请求进行修改或者在响应返回给客户端前对响应进行修改。以 ASP.NET Core 为例，中间件可以在 Startup 类的 Configure 方法中注册，例如：

public void Configure(IApplicationBuilder app)
{
    app.UseAuthentication(); // 身份验证中间件
    app.UseAuthorization(); // 授权中间件
    app.UseRouting(); // 路由中间件
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers(); // 控制器中间件
    });
}

在上面的代码中，我们可以看到 app 对象调用了多个中间件方法。例如 UseAuthentication 和 UseAuthorization 中间件用于处理 HTTP 身份验证和授权，在请求处理之前检查用户是否已经得到授权。而 UseRouting 中间件则用于路由，决定哪些控制器应该处理请求，最后一个 UseEndpoints 则是将处理结果返回给客户端的终端中间件。

总的来说，中间件提供了一种灵活、可扩展且可重用的方法来处理应用程序中的各种任务。在每个 HTTP 请求上下文中，都可以使用不同的中间件组合来满足特定的需求，从而实现更高效、更安全、更易于管理的 Web 应用程序。

Applicationbuilder的Use和Run⽅法有什么区别？

Use 和 Run 都是 ASP.NET Core 中间件注册方法的一部分，都可以用于向请求处理管道添加中间件。虽然这两个方法的作用相似，但它们之间有一些重要的区别。

Use 方法可以将一个或多个中间件添加到请求管道中，并让多个中间件共同参与请求处理。每个中间件可以拦截请求、处理请求、修改响应，然后将请求传递给下一个中间件。在管道中从头到尾依次执行所有的中间件，最后由 ASP.NET Core 框架处理 HTTP 响应。Use 方法是最常用的方法。

app.UseMiddleware<CustomMiddleware>();

上面的代码使用 UseMiddleware 方法将一个名为 CustomMiddleware 的自定义中间件添加到了请求管道中。

Run 方法只能在请求管道的末尾添加一个中间件。这个方法只接收 HttpContext 对象作为参数，而不是像 Use 那样接收一个 Func 委托，它的作用是直接将响应发送回客户端。如果请求已经被前面添加的中间件处理完成，而且不需要在管道内继续执行其他任何操作，那么就应该使用 Run 方法。

app.Run(async context =>
{
    await context.Response.WriteAsync("Hello, World!");
});

上面的代码使用 Run 方法将一个可以直接发送字符串 "Hello, World!" 的中间件添加到了请求管道的末尾。

在使用 Use 方法时，多个中间件可以顺序连续地运行，而 Run 方法只能用于一个终端中间件。简而言之，Use 方法可以添加多个中间件，而 Run 方法只能添加一个。

什么是 taghelper？

TagHelper 是一种用于 ASP.NET Core 视图的标记扩展机制。它们可以让我们以一种更自然的方式定义HTML标签，从而使视图更具可读性和更容易维护。

使用 TagHelper 后，我们可以将 C# 代码与 HTML 结合起来，从而创建类似于 HTML 自定义标签的自定义元素和属性。

例如，假设我们有一个控制器方法返回 List<Person> 的列表，并想在视图中呈现每个人的姓名和年龄。使用传统的 Razor 视图技术，我们可能会编写以下代码：

<ul>
@foreach (var person in Model)
{
    <li>@person.Name (@person.Age)</li>
}
</ul>

而在利用 TagHelper 后，我们可以使用类似于以下代码的方式更清晰地表达到同样的效果：

<ul>
<people-list items="@Model"></people-list>
</ul>

其中，people-list 就是我们自定义的 Tag Helper 名称，items 则是我们自定义的属性名。当 Razor 引擎渲染该视图时，TagHelper 将生成对应的 HTML 标签并将属性值设置为我们指定的对象集合。

总之，TagHelper 是 ASP.NET Core 中的一种标记扩展机制，它可以方便我们为视图添加自定义的 HTML 元素和属性，从而让视图更可读、更易于维护。

如何使taghelper在元素这⼀层上失效?

如果您想在元素层面上禁用 Tag Helper，则可以使用asp-*的特性前缀来更改属性名或将其重命名为非 Tag Helper 属性。比如，如果您有一个带有 asp-for 属性的标签：

<div asp-for="PropertyName"></div>

要使此虚拟元素上的Tag Helper失效，可以通过以下方式重命名此属性，如下所示：

<div data-asp-for="PropertyName" asp-for=""></div>

这里的 data-asp-for 是自定义的HTML属性，它不是 ASP.NET Core 的 Tag Helper，而且我们将 asp-for 重命名为空字符串。在这种情况下，由于没有 asp-for 属性，ASP.NET Core 将忽略所有应用于该元素的 asp-for 相关 Tag Helper。

另一种方法是在 _ViewImports.cshtml 文件中引入 Microsoft.AspNetCore.Mvc.TagHelpers 命名空间，并将 ! 字符添加到 Tag Helper 名称前面，以禁用标记辅助工具。如下所示：

@using Microsoft.AspNetCore.Mvc.TagHelpers

@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
@removeTagHelper Microsoft.AspNetCore.Mvc.TagHelpers.AnchorTagHelper
@removeTagHelper Microsoft.AspNetCore.Mvc.TagHelpers.CacheTagHelper
@removeTagHelper Microsoft.AspNetCore.Mvc.TagHelpers.EnvironmentTagHelper
@removeTagHelper Microsoft.AspNetCore.Mvc.TagHelpers.LaundryTagHelper

@!addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers

这里的 @removeTagHelper 标记指定了需要禁用的标记辅助工具。它们的名称前面必须加上 Microsoft.AspNetCore.Mvc.TagHelpers 命名空间，后跟 Tag Helper 名称。最后的 @!addTagHelper 标记指定使用的所有标记辅助程序，其中 ! 字符在第一个 addTagHelper 标记中将其禁用。

ASP.NET Core Filter的注册⽅式有哪些？

ASP.NET Core中Filter的注册方式有以下几种：

全局注册：在Startup.cs文件的ConfigureServices()方法中使用services.AddControllersWithViews(options => options.Filters.Add(new SampleFilter()))将Filter添加到全局。
控制器级别注册：在控制器类上使用[ControllerAttribute]或派⽣的[ApiControllerAttribute]，或者在控制器类上使用[TypeFilter]或[ServiceFilter]，然后将它们附加到Filter类。
Action级别注册：在⼀个指定操作的属性中使⽤ [ActionFilter]、[ResultFilter] 或 [AuthorizationFilter] 属性，或使用 [TypeFilter] 或 [ServiceFilter]
全局过滤器工厂注册（通过IServiceCollection）：只需在启动时注册所需的全局Filter工厂。通过使用全局Filter工厂，可以动态地基于应用程序状态确定要过滤的内容。例如，此策略可用于创建一个基于环境变量的FilterFactory，以提供替代性或调试/诊断功能。

这些是ASP.NET Core中Filter注册的主要方式。
以下是其中的几种方法示例：

注册全局过滤器

使用 AddMvc() 方法或 AddControllers() 方法，在 Startup.cs 文件中注册全局过滤器：

services.AddMvc(options =>
{
    options.Filters.Add(new CustomActionFilter());
});

在此示例中，我们向 Filters 集合中添加 CustomActionFilter 过滤器。

在控制器级别应用过滤器

在控制器级别上使用 [TypeFilter] 特性将过滤器应用于整个控制器类。例如：

[TypeFilter(typeof(CustomActionFilter))]
public class HomeController : Controller
{
    // ......
}

在此示例中，我们使用 TypeFilter 特性把 CustomActionFilter 过滤器应用到了 HomeController 控制器上。

在操作方法级别应用过滤器

在操作方法级别上使用 [ServiceFilter] 特性将过滤器应用于单个操作方法。例如：

public class HomeController : Controller
{
    [ServiceFilter(typeof(CustomActionFilter))]
    public IActionResult Index()
    {
        // ......
    }
}

在此示例中，我们为 Index() 操作方法使用了 ServiceFilter 特性，并指定了要应用的过滤器类型 CustomActionFilter。

实现 IFilterFactory 接口

实现 IFilterFactory 接口并配置 DI 容器来生产过滤器实例。例如：

public class CustomActionFilterFactory : IFilterFactory
{
    public bool IsReusable => true;

    public IFilterMetadata CreateInstance(IServiceProvider serviceProvider)
    {
        var filter = new CustomActionFilter();

        // do any additional initialization here...

        return filter;
    }
}

在此示例中，我们实现了 IFilterFactory 接口并重写了 CreateInstance() 方法来创建过滤器实例 CustomActionFilter。然后，我们使用 DI 容器将其注入到所需的其他服务中。

使用特定类型的构造函数注入

在 Filter 的构造函数中声明依赖项，并让 DI 容器解析和注入这些依赖项。例如：

public class CustomActionFilter : ActionFilterAttribute
{
    private readonly IService _service;

    public CustomActionFilter(IService service)
    {
        _service = service;
    }

    // ......
}

在上述示例中，我们在 CustomActionFilter 构造函数中定义了一个名为 IService 的参数，并由 DI 容器自动解析和注入该服务。

ASP.NET Core 如何和读取配置⽂件中的内容？

在ASP.NET Core中，可以使用IConfiguration接口来读取配置文件中的内容。该接口提供了一种方便的方式来访问应用程序的配置数据，无论这些数据存储在哪里。以下是一些步骤：

在项目中添加 Microsoft.Extensions.Configuration.Json 包引用。这个包提供了JSON格式的配置。
在 ASP.NET Core 应用程序中加载配置文件。在 Startup.ConfigureServices 方法中添加以下代码：

public void ConfigureServices(IServiceCollection services)
{
    // Adds IConfiguration to the service container.
    services.AddSingleton(Configuration);
}

其中，Configuration 是一个 IConfiguration 对象，它可以作为类的构造函数参数进行注入，如下所示：

private readonly IConfiguration _config;

public MyController(IConfiguration config)
{
    _config = config;
}

创建一个 appsettings.json 文件，并将其添加到 ASP.NET Core 项目中。文件内容如下：

{
   "Database": {
       "ConnectionString": "Server=(local);Database=myDataBase;Trusted_Connection=True;"
   },
   "Logging":
   {
       "IncludeScopes": false,
       "LogLevel":
       {
           "Default": "Information",
           "Microsoft": "Warning",
           "System": "Warning"
       }
   }
}

在通过IConfiguration对象访问配置信息时，使用类似于字典的方式读取 appsettings.json 文件中的配置项。例如，在控制器类中，使用以下代码读取 Database 配置节：

var connectionString = _config["Database:ConnectionString"];

这里我们使用 : 分隔符来访问属性的子级。

此外，您还可以在配置文件中定义数组和嵌套对象。例如，以下示例展示了如何在配置文件中定义一个名为 AllowedHosts 的数组：

{
    "AllowedHosts": [ "*.example.com", "localhost" ]
}

然后，您可以通过以下方式将该数组读取到控制器类中：

var allowedHosts = _config.GetSection("AllowedHosts").Get<string[]>();

总之，ASP.NET Core 通过 IConfiguration 接口提供了一种方便的方式来访问应用程序的配置数据，无论这些数据存储在哪里。

ASP.NET Core有哪些好的功能？

ASP.NET Core 是一款跨平台的开源 Web 开发框架，它具有以下几个好的功能：

跨平台：ASP.NET Core 可以在 Windows、Linux 和 macOS 等各种操作系统上运行，这为 Web 应用程序的部署带来了更大的灵活性。
高性能：ASP.NET Core 采用了一些新技术和优化措施，如 Kestrel Web 服务器、异步编程模型等，使应用程序的性能得到了显著提升。
模块化设计：ASP.NET Core 提供了丰富的中间件和服务，使得我们可以根据需要选择和组合不同的模块，从而实现功能强大、灵活可扩展的应用程序。
统一的项目结构：ASP.NET Core 的项目结构与 ASP.NET MVC 相比得到了简化，并且支持多种开发模式，如 Web API、MVC、Razor Pages 等，可以让我们更加方便地创建不同类型的 Web 应用程序。
内置依赖注入容器：ASP.NET Core 内置了一个轻量级的依赖注入容器，使得我们可以更轻松地管理对象之间的依赖关系，并增强了应用程序的可测试性。
跨站请求伪造（CSRF）保护：ASP.NET Core 在设计上将许多安全性保护措施纳入了框架中，其中包括自动支持 CSRF 防御，让我们可以更轻松地编写安全的 Web 应用程序。

总之，ASP.NET Core 具有跨平台、高性能、模块化设计、统一的项目结构、内置依赖注入容器以及安全性保护等多个好的功能。这些功能使得 ASP.NET Core 成为一个非常流行的 Web 开发框架，适合用于构建各种类型的 Web 应用程序。

什么是ASP.NET Core的startup 类？

在 ASP.NET Core 中，startup 类是应用程序的启动类，它包含了应用程序的配置信息和请求处理管道(pipeline) 的配置。ASP.NET Core 应用程序在启动时会自动创建 Startup 类型的实例，并通过调用其 Configure 和 ConfigureServices 方法来进行初始化配置。

Startup 类是一个C#类，通常命名为 Startup.cs ，它需要包含以下两个方法：

Configure()：这个方法在应用程序启动时被调用，用于配置请求处理管道。一般需要配置中间件、路由、身份验证、错误页面等。
ConfigureServices()：这个方法也是在应用程序启动时被调用，用于添加和配置服务。例如添加数据库上下文、指定依赖注入容器服务等。

除此之外，我们还可以通过构造函数和属性来获取和配置应用程序所需的其他服务和环境变量。Startup 类的主要作用是将各种组件添加到应用程序管道和服务容器中，构建完整的应用程序处理流程，让 HTTP 请求能够顺利地得到处理并返回响应。

以下是一个简单的 Startup 类的示例：

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public IConfiguration Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddControllers();
        services.AddSingleton<IMyService, MyService>();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        
        app.UseHttpsRedirection();

        app.UseRouting();

        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
        });
    }
}

在这个示例中，我们在 ConfigureServices 方法中添加了控制器服务和单例模式的 MyService 服务。在 Configure 方法中，我们使用了一系列内置的中间件和约定，配置了请求处理管道。其中包括开发者异常页面、Https重定向、路由、身份验证和授权，并最后注册了控制器终点。

总之，Startup 类是 ASP.NET Core 应用程序启动时必要的类，它通过配置请求处理管道和服务容器来构建完整的应用程序处理流程。

ASP.NET Core管道⾥⾯的map拓展有什么作⽤？

在 ASP.NET Core 管道中，Map() 拓展可以将请求管道分支到一个新的中间件处理程序。它主要用于条件处理，比如在特定请求路径或者基于其他一些标准来使用中间件。

具体来说，Map() 拓展会接收一个 PathString 类型的参数，该参数指定了相对 URL 的前缀。当收到请求时，会检查请求的路径是否以这个前缀开头，如果是，则将请求管道分支到 Map() 方法所包含的中间件处理程序上。

例如，下面的代码使用 Map() 拓展仅仅在 /api 路径下处理 Web API 请求：

app.Map("/api", api =>
{
    api.UseMvc();
});

上述代码中，Map() 拓展被用于创建一个中间件分支来处理 /api 下的请求，然后使用 UseMvc() 将请求交给 MVC 中间件处理。

此外，还有其他类似的拓展，比如使用 MapWhen() 拓展可以根据条件分支到不同的中间件处理程序上。总之，这些拓展都提供了方便的方法来组织和管理 ASP.NET Core 应用程序的请求管道。

ASP.NET Core⾥⾯的路径是如何处理的?

在ASP.NET Core 应用程序中，路径处理是由请求管道中的中间件负责的。当应用程序接收到一个请求时，请求管道会将该请求传递给每个中间件以便它们能够对请求进行处理。

一般来说，在 ASP.NET Core 中可以通过 Use* 系列拓展方法添加中间件到请求管道中，并使用这些中间件来处理请求。在请求被每个中间件逐一处理之前，ASP.NET Core 会针对这些请求做出以下处理：

解析 URL 和路径参数 - 从请求 URI 中解析出路径和任何查询字符串参数并使它们可供后续中间件使用。
静态文件服务 - 如果请求匹配到了已发布的静态文件，则 ASP.NET Core 可以直接返回该文件而不需要进一步的处理。这种情况下，请求进入到了静态文件中间件并被快速地处理。
路由 - 如果请求不是一个静态文件请求，则它将继续通过路由中间件，以确定哪个控制器和操作应该处理该请求。
控制器执行 - 执行得到的控制器的操作处理请求。
其他 - 在上述基本处理之后，请求会进入其他中间件进行进一步处理，比如身份验证、授权、CORS 等等。

总的来说，ASP.NET Core 中处理路径的方式是通过向请求管道添加中间件来实现的，每个中间件处理请求时都可以访问其路径和任何查询字符串参数。这种方法提供了轻便且高度可定制的方式，使得 ASP.NET Core 能够适合各种 Web 应用程序和 API 的需要。

依赖注⼊后的服务⽣命周期描述？

依赖注入(DI)是一种设计模式，它通过将对象的依赖关系委托给某个外部框架或类来管理组件之间的依赖关系。在应用程序中使用依赖注入可以使代码更加可测试、可重用和可维护。

在依赖注入后，服务的生命周期可能会受到不同的影响，具体取决于DI容器或框架的实现方式。通常来说，服务的生命周期主要有三种：

瞬时（Transient）生命周期：每次请求都会创建一个新的服务实例。这种情况下，DI容器只负责创建和释放服务实例，并不对其进行管理。
作用域（Scoped）生命周期：在一个请求范围内，服务实例是单例的，也就是说，同一个请求中多次请求该服务时，返回的都是同一个实例。在ASP.NET Core中，可以通过IServiceScopeFactory创建作用域，以保证在同一个请求范围内获取到的服务实例是相同的。
单例（Singleton）生命周期：服务实例唯一，整个应用程序生命周期内只创建一次。在ASP.NET Core中，可以通过DI容器注册服务为单例生命周期，以确保整个应用程序范围内获取到的服务实例是唯一的。

需要注意的是，在DI中，如果某个服务依赖其他服务，那么被依赖的服务的生命周期也会受到影响。如果一个服务有多个依赖项，那么它们的生命周期可能是不同的，这时候需要谨慎地选择正确的生命周期范围来保证系统的正确性和可伸缩性。

ASP.NET Core内置容器的特点？

ASP.NET Core内置容器是一种轻量级的依赖注入框架，提供了对应用程序中对象的创建、绑定以及生命周期管理等支持。下面是ASP.NET Core内置容器的特点：

轻量级：ASP.NET Core内置容器非常轻巧，并且不需要其他第三方库或工具支持。这使得它可以很方便地集成到应用程序中，而不会造成额外的开销。
开箱即用：内置容器是默认情况下的依赖注入框架，直接使用ASP.NET Core项目模板所创建的Web应用程序已经自动配置了内置容器。这减少了应用程序的配置和初始化成本。
支持服务生命周期管理：内置容器支持“瞬时”、“作用域”和“单例”等多种生命周期管理方式。这使得开发人员可以根据需要选择最适合的生命周期，从而达到更好的性能和可维护性。
灵活性：内置容器提供了多种注册服务的方式，包括基于接口、基于委托、基于实例等多种方式。这使得开发人员可以采用不同的方式注册服务，以满足不同层次组件之间的依赖关系。
可测试性：通过将依赖关系注入到应用程序中，可以将组件解耦，从而提高应用程序的可测试性。内置容器支持自动注入和手动注入两种方式，使得开发人员可以根据需要选择最适合的方法，更好地进行单元测试等工作。

综上所述，ASP.NET Core内置容器是一个简单易用的依赖注入框架，它提供了一种轻量级的方式来管理对象之间的依赖关系，并且具备灵活性、可测试性以及良好的性能和可维护性。

ASP.NET Core中如何读取静态⽂件？

在ASP.NET Core中，可以使用以下几种方式来读取静态文件：

使用静态文件中间件：可以通过在应用程序的Startup类中调用UseStaticFiles方法来启用静态文件中间件。这个中间件会根据请求路径自动查找匹配的静态文件，并且返回给客户端。例如，在Startup类的Configure方法中添加以下代码：

app.UseStaticFiles();

使用托管文件：可以将静态文件放置在wwwroot目录下，并直接通过相对路径来访问。例如，如果有一个名为“test.txt”的文本文件在wwwroot目录下，可以通过以下方式来读取它：

string filePath = Path.Combine(env.WebRootPath, "test.txt");
string fileContent = System.IO.File.ReadAllText(filePath);

其中，env是IWebHostEnvironment类型的一个变量，它需要通过依赖注入来获取。

使用FileProvider：可以使用IFileProvider接口来访问静态文件。可以通过构造函数或者依赖注入来获取IFileProvider实例，并且可以使用该实例来访问静态文件。例如：

var provider = new PhysicalFileProvider(Directory.GetCurrentDirectory());
var fileInfo = provider.GetFileInfo("test.txt");
var fileContent = string.Empty;
using (var streamReader = new StreamReader(fileInfo.CreateReadStream()))
{
    fileContent = streamReader.ReadToEnd();
}

以上就是ASP.NET Core中读取静态文件的几种方式。可以根据实际需求选择最适合的方式。

ASP.NET Core项⽬如何设置IP地址和端⼝号？

在ASP.NET Core项目中可以通过配置来设置IP地址和端口号，具体步骤如下：

打开 appsettings.json 文件，如果不存在则新建一个。
在该文件中添加以下内容以指定要监听的 IP 和端口号：
```
{
  "Kestrel": {
    "Endpoints": {
      "Http": {
        "Url": "http://0.0.0.0:5000"
      }
    }
  }
}
```
其中，0.0.0.0表示监听所有可用的网络接口，5000表示端口号。

在代码中获取配置信息，然后将其应用到WebHostBuilder中。示例代码如下：

public class Program
{
    public static void Main(string[] args)
    {
        var config = new ConfigurationBuilder()
            .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
            .Build();

        var host = new WebHostBuilder()
            .UseKestrel()
            .UseConfiguration(config)
            .UseStartup<Startup>()
            .Build();

        host.Run();
    }
}

通过以上配置，ASP.NET Core项目就可以监听指定IP和端口号了。需要注意的是，如果同时存在命令行参数启动的方式，则命令行参数会覆盖配置文件中的设置。

对ASP.NET Core kestrel的理解

Kestrel是ASP.NET Core中的一种跨平台Web服务器，它是用C#实现的，基于libuv库构建。Kestrel作为ASP.NET Core的默认Web服务器，可在Windows、Linux和macOS等多个操作系统上运行。Kestrel通过使用异步I/O模型使网络吞吐量得到最大化，并支持HTTP/2协议和WebSocket通讯。

Kestrel提供了以下特性：

高性能：Kestrel是基于异步编程模型实现的，可以处理大量的并发请求，极大地提高了应用程序的性能。
跨平台：Kestrel可以在多个操作系统上运行，包括Windows、Linux和macOS等操作系统。
可扩展：Kestrel可以与其他服务器，例如IIS等集成使用，也可以作为反向代理服务器来使用。
安全性：Kestrel支持HTTPS加密协议，可以保证数据传输的安全性。同时，还提供了防止常见web攻击如XSS、CSRF、点击劫持等安全组件来增强Web应用程序的安全性。
开源：Kestrel是ASP.NET Core开源项目的一部分，其代码可以在GitHub上进行查看和贡献。

总之，Kestrel是一个灵活、高性能、跨平台且可扩展的Web服务器，是ASP.NET Core Web应用程序的理想选择之一。

对Autofac的理解？

Autofac是一个轻量级的依赖注入/反转控制容器（DI/IOC容器），用于.NET应用程序。它提供了一种框架，可以在应用程序中管理对象之间的依赖关系和生命周期。

通俗地讲，Autofac可以帮助我们解决项目中各个组件之间的依赖问题，使得组件与组件之间解耦，有利于代码的复用、测试和维护。通过使用Autofac，我们可以将对象的创建工作委托给Autofac容器来完成，从而实现了对对象的管理和维护。

Autofac的核心特点包括：

可扩展性：Autofac允许开发人员编写自己的模块或者扩展Autofac库，并且支持AOP等高级特性。
灵活性：Autofac允许开发人员从多个注册位置添加或删除对象的组件树或属性。还支持命名实例、泛型注册等功能。
配置简单：使用Autofac非常简单，只需要定义好注册信息，然后启动容器即可。同时，Autofac还提供了丰富的配置方式，包括XML文件、Json文件、Module类等方式，开发人员可以根据需求选择适合自己的方式。
性能优越：Autofac通过使用高效的依赖图，保证了对象的快速加载、生命周期管理以及高效的垃圾回收。同时，它还支持异步操作，可以提高应用程序的处理能力。

总之，Autofac是一个非常强大的DI/IOC容器，在.NET生态系统中得到了广泛的应用。它为开发人员提供了高度可配置、灵活、扩展性强以及性能优越的特点。

以下是使用Autofac进行依赖注入的示例代码：

//创建Autofac容器
var builder = new ContainerBuilder();

//注册接口与实现类之间的关系
builder.RegisterType<MyService>().As<IMyService>();

//注册控制器类
builder.RegisterControllers(typeof(MvcApplication).Assembly);

//生成Autofac容器
var container = builder.Build();

//将MVC的DependencyResolver替换为AutofacDependencyResolver
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

在上述示例代码中，我们首先使用ContainerBuilder创建了一个Autofac容器。然后使用RegisterType方法将IMyService和MyService实现类之间建立起了关系。还使用了RegisterControllers方法注册了MVC应用程序中的所有控制器。最后使用Build方法生成Autofac容器。

最后，我们使用AutofacDependencyResolver将MVC的DependencyResolver替换成Autofac容器，从而启用Autofac进行依赖注入。

Core WebApi特性路由？

在Asp.Net Core WebAPI中，特性路由是一种将API请求路由到控制器动作的机制，它通过在控制器方法上应用属性路由特性来实现。特性路由将路由模板直接定义在控制器的操作方法上，而不是使用传统的基于配置文件的路由方式。

使用特性路由有以下几点好处：

控制器和操作方法更加清晰明了：开发人员可以直接在操作方法上看到路由的具体路径和参数，易于理解和维护。
支持更多灵活的URL格式：通过特性路由，我们可以更灵活地定义URL路径和查询字符串参数，在满足需求的同时保持URL的简洁性。
更好的路由匹配性能：由于特性路由是在编译时生成的，所以相对于传统的基于配置文件的路由方式，特性路由的路由匹配速度更快，性能更好。

以下是一个使用特性路由的示例代码：

[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    // GET api/products
    [HttpGet]
    public ActionResult<IEnumerable<string>> Get()
    {
        return new string[] { "product1", "product2" };
    }

    // GET api/products/5
    [HttpGet("{id}")]
    public ActionResult<string> Get(int id)
    {
        return "product";
    }

    // POST api/products
    [HttpPost]
    public void Post([FromBody] string value)
    {
    }

    // PUT api/products/5
    [HttpPut("{id}")]
    public void Put(int id, [FromBody] string value)
    {
    }

    // DELETE api/products/5
    [HttpDelete("{id}")]
    public void Delete(int id)
    {
    }
}

在上述示例代码中，我们使用[Route]特性指定了API路径，如api/products。其中[HttpGet("{id}")]指定了GET操作方法的路径模板，并将路由参数名设置为"id"。这样，在请求URL为http://localhost:5000/api/products/5时，将会触发控制器的Get方法，并传入路由参数"id"的值为5。

请求Web CoreApi的时候，为什么会发⽣跨域问题？

在Web API中，跨域问题通常是因为浏览器的安全机制所导致的。浏览器限制在不同源之间发送Ajax请求。跨域请求（即不同源之间的请求）是属于一种安全策略，用以保护用户的信息和数据安全。

默认情况下，浏览器会阻止从一个源发出的Ajax请求到另一个源站点。例如，如果Web应用程序正在运行在http://localhost:5000上，尝试使用JavaScript从http://www.example.com/api/products发送HTTP GET请求就会被阻止。

解决跨域问题主要有以下几种方法：

使用CORS（跨源资源共享）机制：通过在服务器响应头中添加Access-Control-Allow-Origin等相关CORS信息，允许特定源或所有源跨域请求API。
使用代理服务器：浏览器先向自己的服务器发送AJAX请求，再由代理服务器将请求发送至API服务器，最后将结果返回给浏览器，避免直接跨域请求。
JSONP（JSON with Padding）：使用script标签向指定域名下的JS文件发送请求，并通过回调函数接收API响应结果。

以上方法均可以解决跨域问题，但具体实现方式和适用场景也可能有所不同。开发人员需要根据实际情况选择合适的跨域解决方案。

aspnet core 如何鉴权授权？

ASP.NET Core提供了多种鉴权授权的方式，具体包括：

基于角色的身份验证（Role-Based Authentication）：可以将用户分配到不同的角色中，控制用户访问应用程序的权限，并在代码中使用用户所属角色对不同的操作进行授权。
基于声明的身份验证（Claim-Based Authentication）：使用基于声明的方法，通过向用户颁发声明来实现用户授权。声明是关于用户的属性和权利的陈述。
OAuth2/OpenID Connect：OAuth2用于授权，使用户可以允许第三方应用程序代表他们调用受保护的资源，而OpenID Connect建立在OAuth2之上，提供了身份验证功能，允许应用程序使用身份验证和访问令牌来获取用户信息。
策略授权（Policy-Based Authorization）：通过定义策略来为应用程序中的操作和资源授权，策略与声明相关联。

ASP.NET Core支持的认证方式有Cookie认证、JWT认证、API Key认证等，这些认证方式都可以结合上述的鉴权授权方式进行使用。

EFCore查询的性能如何调优？

EFCore是一个功能强大的ORM框架，但在查询性能方面有一些限制。以下是一些可以帮助你提高EFCore查询性能的调优技巧：

1.尽量减少数据库的访问次数

每次通过EFCore从数据库中获取数据都会涉及到网络交互和SQL执行的开销。因此，尽可能地减少数据库的IO操作可以显著提高查询性能。

可以通过以下方法来实现这个目标：

使用Include进行联接查询以获取关联的对象，避免执行多个查询。
对于包含大量数据的表，使用分页技术来获取部分结果，而不是一次性获取整个结果集。

避免在LINQ查询中使用复杂的Lambda表达式

复杂的Lambda表达式可能会导致EFCore生成低效的SQL语句，并且可能增加映射和过滤器的计算成本。如果可能，请将复杂的Lambda表达式分解为单独的变量，以更好地组合和重用它们。

使用AsNoTracking()方法来禁用跟踪

默认情况下，EFCore使用跟踪来保存返回的实体对象，以便在更新或删除时自动检测变化。但是，这种跟踪可能会导致内存泄漏、性能问题和意外的行为。使用AsNoTracking()方法可禁用跟踪，从而提高查询性能。

优化数据库架构

通过优化数据库的架构和索引来改善查询性能。例如：

对于经常使用的列，创建索引以加速WHERE语句。
根据访问模式将相关数据分割到多个表或架构中。
避免在实体中嵌入大型文本或二进制数据，而是将它们存储在单独的表中，并使用必要时进行联接。

使用第三方库进行查询

如果您需要执行复杂查询（例如，在非关系型数据源中执行JOIN等操作），EFCore可能无法提供所需的灵活性。在这种情况下，可以使用第三方库（例如Dapper）来直接执行SQL查询，并将结果映射为对象。

EFCore 如何通过数据⽣成实体和DbContext?

EFCore通过Scaffolding（也称为反向工程）从数据库生成实体和DbContext。可以使用以下步骤进行操作：

1.打开Visual Studio，选择“文件”> “新建”> “项目”，然后选择.NET Core或.NET Standard项目类型。

2.在“新增项目”对话框中，选择“ASP.NET Core Web应用程序”，设置名称和位置，然后单击“创建”。

3.在下一个屏幕上，选择“API”作为项目模板，并选择要使用的身份验证方法（例如无身份验证），然后单击“创建”

4.现在，安装EFCore NuGet包，以及你需要连接到的数据库的适当驱动程序包。

5.在解决方案资源管理器中，右键单击项目，并选择“NuGet包管理器”> “程序包管理器控制台”。

6.在控制台中输入以下命令，“Microsoft.EntityFrameworkCore.Tools.DotNet”将安装EFCore数据工具（已安装它则可跳过此步骤）：

Install-Package Microsoft.EntityFrameworkCore.Tools.DotNet

使用以下命令在控制台中执行反向工程(scaffold-dbcontext)，以从数据库生成实体和DbContext：

Scaffold-DbContext "connection-string" Microsoft.EntityFrameworkCore.SqlServer -OutputDir Models

这里的 "connection-string"是应该替换为你的数据库连接字符串，而 "Microsoft.EntityFrameworkCore.SqlServer" 是指定使用SQL Server数据库，在不同的数据库上，需要使用不同的数据库提供程序。

完成后，在Models文件夹中看到从数据库生成的实体和DbContext文件。

这样，你就成功地使用EFCore数据工具从数据库生成了实体和DbContext。在需要时，可以修改这些文件，并使用迁移更新数据库结构。

EF SaveChanges的原理

在Entity Framework Core中，SaveChanges方法用于将所有在DbContext中跟踪的实体更改保存到数据库中。它的工作原理如下：

DbContext中的每个代表更改的实体都被标记为Added、Modified或Deleted。
当调用SaveChanges时，EF Core会迭代所有标记为更改状态（Added、Modified或Deleted）的实体。
对于每个实体，它会检查其状态，并自动生成一个相应的SQL语句，以便将更改保存到数据库中。
EF Core会将生成的SQL语句“打包”成一个事务，以确保所有更改都成功提交或回滚。
如果成功，则返回受影响记录的行数；否则抛出异常并回滚所有更改。

需要注意的是，如果实体被标记为Modified状态，则必须手动更新属性的值，否则SaveChanges将无法检测到更改并保存到数据库中。

此外，SaveChanges还可以在不使用追踪实例的情况下用于执行原始SQL查询。可以通过从DbContext对象访问Database属性来获取DbConnection对象，并使用ExecuteSqlInterpolated方法执行此类查询。但是，这种用法非常不推荐。因为它打破了EF Core的映射和跟踪机制，可能导致意想不到的结果和行为。

EFCore中EntityState的理解

在EF Core中，EntityState用来表示实体在DbContext中的状态。它是一个枚举类型，包含以下5个成员：

Added：实体已经被添加到DbContext中，但还未保存到数据库。
Unchanged：实体没有任何变化，与数据库中的记录相同。
Modified：实体被修改，并准备好保存更改到数据库。
Deleted：实体已经被标记为删除，并准备好从数据库中删除。
Detached：实体没有被跟踪，不属于DbContext中的对象图。

一般情况下，实体的状态由DbContext自动管理，当我们向DbContext中添加一个新的实体时，这个实体会默认被标记为Added状态；当我们从数据库中查询到一个实体时，它会被标记为Unchanged状态；当我们修改了实体的属性值时，它会被标记为Modified状态；当我们删除一个实体时，它会被标记为Deleted状态。

我们也可以手动设置实体的状态，来告诉EF Core如何对它进行操作。例如，当我们想手动将一个实体标记为已删除时，可以使用DbContext的Remove方法删除该实体后，将其状态设置为Deleted，这样EF Core就会将该实体从数据库中删除。或者，当我们想要重新附加一个实体并使其保持为原始状态时，可以使用DbContext的Attach方法将实体附加到DbContext并将其状态设置为Unchanged。

需要注意的是，EF Core中EntityState的掌握程度与我们使用EF Core进行开发的效率和质量密切相关。因此，在编写代码时，需要深入理解它的含义和作用，并善加利用它来管理实体的状态。

什么是导航属性和引⽤属性

在Entity Framework中，导航属性和引用属性都是用于建立实体之间关系的属性。

导航属性

导航属性是一个实体类型中用于表示与其他实体类型之间关联的属性。它通常用于描述两个实体之间的一对多、多对一或多对多关系。例如，一个学生可以有多个课程，而每个课程只能属于一个学生。在这种情况下，Student实体类型会包含一个Courses 导航属性，指向课程实体类型，并反过来，Course实体类型也会包含一个Student导航属性，指向学生实体类型。

引用属性

引用属性是一个实体类型中用于表示与另一个实体类型之间1:1关系的属性。如果一个实体类型中只有一个与其他实体类型相关联的实体，那么你可以使用引用属性。例如，如果你有一个Order实体类型和一个Customer实体类型，则Order实体类型应该具有一个Customer引用属性，指向Customer实体类型。这样，你就可以轻松地从Order对象访问与之相关联的Customer对象。
以下是在C#中定义导航属性和引用属性的示例代码：