对于asp.net–Webapi,Webhost和Owin之间的关系感兴趣的读者，本文将会是一篇不错的选择，我们将详细介绍.netwebservice和webapi，并为您提供关于.NET6-Asp.

对于asp.net – Webapi,Webhost和Owin之间的关系感兴趣的读者，本文将会是一篇不错的选择，我们将详细介绍.net webservice和webapi，并为您提供关于.NET6-Asp.Net Core webapi -从零开始的webapi项目、ASP.NET Core Basic 1-1 WebHost 与项目配置、Asp.Net Core WebApi 和Asp.Net WebApi上传文件、asp.net core 系列 16 Web主机 IWebHostBuilder的有用信息。

• asp.net – Webapi,Webhost和Owin之间的关系（.net webservice和webapi）
• .NET6-Asp.Net Core webapi -从零开始的webapi项目
• ASP.NET Core Basic 1-1 WebHost 与项目配置
• Asp.Net Core WebApi 和Asp.Net WebApi上传文件
• asp.net core 系列 16 Web主机 IWebHostBuilder

asp.net – Webapi,Webhost和Owin之间的关系（.net webservice和webapi）

.NET6-Asp.Net Core webapi -从零开始的webapi项目

 本项目为本人22年毕设项目，后续会不断更新本篇文章，全部内容都会写在这一篇文章里，喜欢的请持续关注。

一、如何创建 Asp.Net Core webapi 项目

二、如何使用 EntityFrameWorkCore DbFirst：

需要用到的程序包：

1.数据库创建好表

2.程序包管理器控制台-执行命令

Scaffold-DbContext "server=localhost;port=3306;user=root;password=a.1234;database=lrms;Persist Security Info=True;" Pomelo.EntityFrameworkCore.MysqL -o Models -f

 3.执行成功后会在项目下生成你指定的的文件夹（这里是命令中的Models），里面会生成对应的表类和一个连接数据库的上下文类（这里是 “数据库名+Context” ）。

ASP.NET Core Basic 1-1 WebHost 与项目配置

.NET Core ASP.NET Core Basic 1-1

本节内容为 WebHost 与项目配置

项目配置文件

我们可以很清楚的发现在我们的文件中含有一个 Json 文件 ——appsettings.json，实际上，这个文件就是我们项目的默认配置文件，它内部含有了默认的一些设置，当然你也可以自己进行添加或者修改。这里我们不展开讲述。我们会在本文的后部分进行讲解如何读取、操作配置文件。

项目主入口 Program

在 ASP.NET Core2.X 的空项目中，你会发现有以下两个类存在 ——StarUp、Program，其中 Program 类里面就是我们 ASP.NET Core 的入口（Main 函数）。我们可以看一下 Program 类

namespace ASP.NET_Core_Study
{
    public class Program
    {
        public static void Main(string[] args)
        {
            CreateWebHostBuilder(args).Build().Run();
        }

        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                .UseStartup<Startup>();
    }
}

我们可以发现，Program 中使用了一个 CreateWebHostBuilder 函数进行程序的初始化，里面就涉及到了我们的 WebHost。

那么什么是 WebHost 呢？你可以简单的理解为就是我们的 Web 项目的服务主机，它是 ASP.NET Core 的核心，它调用了 CreateDefaultBuilder 方法进行创建。而泛型函数使用的 StartUp 则是我们服务的配置类。

当然，WebHost 进行服务主机创建的时候你也可以使用 WebHost.Start() 进行手动的配置与创建。这里我们只针对官方默认的方法进行学习与分析。

首先看到 CreateDefaultBuilder () 的源码，这个你可以在 Github 或者是 ReSharp 的反编译功能查看到，这里我是直接从 GitHub 公开的源码复制

 /// <summary>
        /// Initializes a new instance of the <see cref="WebHostBuilder"/> class with pre-configured defaults.
        /// </summary>
        /// <remarks>
        ///   The following defaults are applied to the returned <see cref="WebHostBuilder"/>:
        ///     use Kestrel as the web server and configure it using the application''s configuration providers,
        ///     set the <see cref="IHostingEnvironment.ContentRootPath"/> to the result of <see cref="Directory.GetCurrentDirectory()"/>,
        ///     load <see cref="IConfiguration"/> from ''appsettings.json'' and ''appsettings.[<see cref="IHostingEnvironment.EnvironmentName"/>].json'',
        ///     load <see cref="IConfiguration"/> from User Secrets when <see cref="IHostingEnvironment.EnvironmentName"/> is ''Development'' using the entry assembly,
        ///     load <see cref="IConfiguration"/> from environment variables,
        ///     load <see cref="IConfiguration"/> from supplied command line args,
        ///     configure the <see cref="ILoggerFactory"/> to log to the console and debug output,
        ///     and enable IIS integration.
        /// </remarks>
        /// <param name="args">The command line args.</param>
        /// <returns>The initialized <see cref="IWebHostBuilder"/>.</returns>
        public static IWebHostBuilder CreateDefaultBuilder(string[] args)
        {
            var builder = new WebHostBuilder();
            if (string.IsNullOrEmpty(builder.GetSetting(WebHostDefaults.ContentRootKey)))
            {
                builder.UseContentRoot(Directory.GetCurrentDirectory());
            }
            if (args != null)
            {
                builder.UseConfiguration(new ConfigurationBuilder().AddCommandLine(args).Build());
            }
            builder.ConfigureAppConfiguration((hostingContext, config) =>
            {
                var env = hostingContext.HostingEnvironment;
                config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                      .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
                if (env.IsDevelopment())
                {
                    var appAssembly = Assembly.Load(new AssemblyName(env.ApplicationName));
                    if (appAssembly != null)
                    {
                        config.AddUserSecrets(appAssembly, optional: true);
                    }
                }
                config.AddEnvironmentVariables();
                if (args != null)
                {
                    config.AddCommandLine(args);
                }
            })
            .ConfigureLogging((hostingContext, logging) =>
            {
                logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
                logging.AddConsole();
                logging.AddDebug();
                logging.AddEventSourceLogger();
            }).
            UseDefaultServiceProvider((context, options) =>
            {
                options.ValidateScopes = context.HostingEnvironment.IsDevelopment();
            });
            ConfigureWebDefaults(builder);
            return builder;
        }

你在这里可以非常清楚的看到，这个函数他会取寻找 appsettings.json 以及 appsettings.{env.EnvironmentName}.json。因此在使用默认的方法进行项目实战时，我们不应该修改这个文件的文件名。并且我们可以发现，这个文件是分两部分的，一部分是我们的发布版本（publish），一部分是我们的开发版本。他们的文件名是不同的，在源码中我们也可以找到这些语句。同时我们的 builder 调用了 UseConfiguration 方法，这是一个参数配置的方法，用于接收我们从控制台输入的一些参数。

并且，我们可以看到他还进行了服务的替换 UseDefaultServiceProvider 以及根目录的设置 UseContentRoo，源码如下

public static IWebHostBuilder UseContentRoot(this IWebHostBuilder hostBuilder, string contentRoot)
{
    if (contentRoot == null)
    throw new ArgumentNullException(nameof (contentRoot));
    return hostBuilder.UseSetting(WebHostDefaults.ContentRootKey, contentRoot);
}

public IWebHostBuilder UseSetting(string key, string value)
{
    this._config[key] = value;
    return (IWebHostBuilder) this;
}

说到这里，我需要引出我们 ASP.NET Core 的两种启动方式。一种是使用我们微软官方的 IIS 进行项目的部署，他的本质是将 dll 注入到 IIS 服务中。当然，我们知道 IIS 是 Windows 上的 Web 服务器，如果我们要进行跨平台的开发，我们可以使用微软开发的 Kestrel，源码中的 ConfigureWebDefaults 函数的源码我们就可以看到相关的操作

internal static void ConfigureWebDefaults(IWebHostBuilder builder)
        {
            builder.UseKestrel((builderContext, options) =>
            {
                options.Configure(builderContext.Configuration.GetSection("Kestrel"));
            })
            .ConfigureServices((hostingContext, services) =>
            {
                // Fallback
                services.PostConfigure<HostFilteringOptions>(options =>
                {
                    if (options.AllowedHosts == null || options.AllowedHosts.Count == 0)
                    {
                        // "AllowedHosts": "localhost;127.0.0.1;[::1]"
                        var hosts = hostingContext.Configuration["AllowedHosts"]?.Split(new[] { '';'' }, StringSplitOptions.RemoveEmptyEntries);
                        // Fall back to "*" to disable.
                        options.AllowedHosts = (hosts?.Length > 0 ? hosts : new[] { "*" });
                    }
                });
                // Change notification
                services.AddSingleton<IOptionsChangeTokenSource<HostFilteringOptions>>(
                            new ConfigurationChangeTokenSource<HostFilteringOptions>(hostingContext.Configuration));

                services.AddTransient<IStartupFilter, HostFilteringStartupFilter>();

                services.AddRouting();
            })
            .UseIIS()
            .UseIISIntegration();
        }

我们可以发现，在这里，它会从配置文件中读取相关的配置进行配置我们启动使用的服务选项。UseKestrel 函数对一些服务进行了注册，以便后续的使用。这里我不打算进行详细的讲解，因为这一节内容只是希望你能够对项目的启动有一个初步的认识，你需要知道的是，目前位置，我们发现了 ASP.NET Core 程序会在实例化 WebHost 之前配置好一切，并且我们可以使用一个开源跨平台的 Web 服务器 Kestrel。

StartUp

StartUp 类是一个配置性质的类，它里面有 Configure (IApplicationBuilder app, IHostingEnvironment env) 以及 ConfigureServices (IServiceCollection services) 方法，这两个方法中 ConfigureServices 是我们的服务配置方法或者说是容器配置，它主要用于配置我们依赖注入的类，而 Configure 方法是我们配置中间件的地方，这两个概念我会在后一两篇文章中进行非常详细的讲解。

总结

本篇文章内容并不是很多，主要是让你知道 ASP.NET Core 其实只是一个简答的控制台程序，只是它调用了一些服务而已。

总体来说我们 ASP.NET Core 的 WebHost 创建的过程是

• 配置好服务器 UseKestrel ()
• 配置好根目录 UseContentRoot ()
• 添加配置文件源 ConfigureAppConfiguration ((context, builder) => builder.AddJsonFile ("appsetting.json", true, true))
• 注册日志记录到控制台 ConfigureLogging (builder => builder.AddConsole ())
• 配置好 StartUp 类，进行依赖注入和中间件的配置 UseStartup<Startup>()
• 生成 WebHost，Build () 返回一个 WebHost 对象
• 运行 WebHost，Run () 将 WebHost 启动

当然 IWebHostBuilder 接口也有一些其他的常见方法，这里我做一个简单的列举

• UseUrls，配置启动的 Ip 地址
• UseSetting，使用新的文件替换默认 appsettings.json
• UseShutdownTimeout，自动关机
• UseEnvironment，配置启动时的环境（生产 Or 开发）

这几个是我经常使用的函数，其他的函数你可以在微软官方 API 文档或者是 ASP.NET Core 的源码中进行学习，并不难。

Reference

Asp.netCore 运行

如果我的文章帮助了您，请您在 github.NETCoreGuide 项目帮我点一个 star，在博客园中点一个关注和推荐。

Github

BiliBili 主页

WarrenRyan''sBlog

博客园

原文出处：https://www.cnblogs.com/WarrenRyan/p/11415963.html

Asp.Net Core WebApi 和Asp.Net WebApi上传文件

 1    public class UpLoadController : ControllerBase
 2     {
 3         private readonly IHostingEnvironment _hostingEnvironment;
 4 
 5         public UpLoadController(IHostingEnvironment hostingEnvironment)
 6         {
 7             _hostingEnvironment = hostingEnvironment;
 8         }        
 9         [HttpPost]
10         public async Task<string> Post([FromForm] IFormCollection formCollection)
11         {
12             string result = "";
13             string webRootPath = _hostingEnvironment.WebRootPath;
14             string contentRootPath = _hostingEnvironment.ContentRootPath;
15 
16             FormFileCollection filelist = (FormFileCollection)formCollection.Files;
17 
18             foreach (IFormFile file in filelist)
19             {
20                 String Tpath = "/" + DateTime.Now.ToString("yyyy-MM-dd") + "/";
21                 string name = file.FileName;
22                 string FileName = DateTime.Now.ToString("yyyyMMddHHmmssfff");
23                 string FilePath = webRootPath + Tpath;
24 
25                 string type = System.IO.Path.GetExtension(name);
26                 DirectoryInfo di = new DirectoryInfo(FilePath);
27 
28 
29                 if (!di.Exists) { di.Create(); }
30 
31                 using (FileStream fs = System.IO.File.Create(FilePath + FileName + type))
32                 {
33                     // 复制文件
34                     file.CopyTo(fs);
35                     // 清空缓冲区数据
36                     fs.Flush();
37                 }
38                 result = "1";
39             }
40             return result;
41         }
42     }

.NetCore WebApi

[HttpPost]
        public async Task<string> Post()
        {
            string result = "";
            HttpFileCollection filelist = HttpContext.Current.Request.Files;
            if (filelist != null && filelist.Count > 0)
            {
                for (int i = 0; i < filelist.Count; i++)
                {
                    HttpPostedFile file = filelist[i];
                    String Tpath = "/" + DateTime.Now.ToString("yyyy-MM-dd") + "/";
                    string filename = file.FileName;
                    string FileName = DateTime.Now.ToString("yyyyMMddHHmmssfff");
                    string FilePath = HttpContext.Current.Server.MapPath("~/" + Tpath);
                    string type = System.IO.Path.GetExtension(filename);
                    DirectoryInfo di = new DirectoryInfo(FilePath);
                    if (!di.Exists) { di.Create(); }
                    try
                    {
                        file.SaveAs(FilePath + FileName+type);
                        result = "1";
                    }
                    catch (Exception ex)
                    {
                        result = "上传文件写入失败：" + ex.Message;
                    }
                }
            }
            else
            {
                result = "上传的文件信息不存在！";
            }
            return result;
        }

Asp.Net WebApi

 前端插件：https://blog.csdn.net/u010075697/article/details/72771594

asp.net core 系列 16 Web主机 IWebHostBuilder

一.概述

         在asp.net core中，Host主机负责应用程序启动和生存期管理。host主机包括Web 主机(IWebHostBuilder)和通用主机(IHostBuilder)。Web 主机是适用于托管 Web 应用；通用主机（ASP.NET Core 2.1 或更高版本）是适用于托管非 Web 应用；在未来的版本中，通用主机将适用于托管任何类型的应用，包括 Web 应用。 通用主机最终将取代 Web 主机。本篇先来了解ASP.NET Core Web主机。

　　1.1 设置Web主机以及执行的任务

　　　　创建使用 IWebHostBuilder 实例的主机。 通常在应用的入口点 Main 方法中执行。 在项目模板中，Main 位于 Program.cs。

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                .UseStartup<Startup>();

　　　　下面详细说下CreateDefaultBuilder 执行的下列任务：

　　　　(1) 将内置的 Kestrel 服务器配置为 Web 服务器。

　　　　(2) 设置content root 内容根路径，并由 Directory.GetCurrentDirectory 返回的路径。

　　　　(3) 通过以下加载主机配置：

　　　　　　前缀为 ASPNETCORE_ 的环境变量（例如，ASPNETCORE_ENVIRONMENT）。

　　　　　　命令行参数。

　　　　(4) 按以下顺序加载应用配置

　　　　　　appsettings.json。

                     appsettings.{Environment}.json。

                     应用在使用入口程序集的 Development 环境中运行时的机密管理器。

                     环境变量。

                     命令行参数。

　　　　(5) 设置console and debug 输出的日志记录。在 appsettings.json 或 appsettings.{Environment}.json 文件的日志记录配置部分(Logging)中指定的日志筛选规则。

　　　　(6)  ASP.NET Core 模块使用IIS托管运行时，CreateDefaultBuilder 会启用 IIS 集成，这会配置应用的基址和端口。 IIS 集成还配置应用以捕获启动错误。

　　　　(7) 如果应用环境为“开发”，请将 ServiceProviderOptions.ValidateScopes 设为 true。

　　1.2 Web主机的扩展配置

　　　　 IWebHostBuilder下的ConfigureAppConfiguration、ConfigureLogging 以及其他方法可重写（第三大点讲）和增强 CreateDefaultBuilder 定义的配置。 下面是一些示例：

　　　　(1) ConfigureAppConfiguration 

　　　　　　ConfigureAppConfiguratio用于指定应用的 IConfiguration。下面的 ConfigureAppConfiguration 调用添加委托，以在 appsettings.xml 文件中添加应用配置。 可多次调用 ConfigureAppConfiguration。具体参照 ”asp.net core 系列 10 配置configuration“ 。

   　　 WebHost.CreateDefaultBuilder(args)
   　　 .ConfigureAppConfiguration((hostingContext, config) =>
   　　 {
       　　 config.AddXmlFile("appsettings.xml", optional: true, reloadOnChange: true);
    　　})

　　　　(2) ConfigureLogging

　　　　　　ConfigureLogging调用添加委托，以将最小日志记录级别 (SetMinimumLevel) 配置为 LogLevel.Warning。 此设置重写 CreateDefaultBuilder 在 appsettings.Development.json 和 appsettings.Production.json 中配置的设置，分别为 LogLevel.Debug 和 LogLevel.Error。 可多次调用 ConfigureLogging。具体参照 “asp.net core 系列 13 日志”。

    　　WebHost.CreateDefaultBuilder(args)
   　　 .ConfigureLogging(logging => 
   　　 {
       　　 logging.SetMinimumLevel(LogLevel.Warning);
   　　 })

　　　　(3) ConfigureKestrel

　　　　　　下面调用 ConfigureKestrel 来重写 CreateDefaultBuilder 在配置 Kestrel 时默认的 30,000,000 字节，大约为28.6MB。MaxRequestBodySize是获取或设置任何请求主体的最大允许大小（以字节为单位）。设置为null时，最大请求正文大小不受限制。

   　　 WebHost.CreateDefaultBuilder(args)
    　　.ConfigureKestrel((context, options) =>
   　　 {
      　　  options.Limits.MaxRequestBodySize = 20000000;
   　　 });

二.主机配置值

　　WebHostBuilder 依赖于以下的方法设置主机配置值：

　　　　 (1)主机生成器配置，其中包括格式 ASPNETCORE_{configurationKey} 的环境变量。 例如 ASPNETCORE_ENVIRONMENT。

　　　　(2)UseContentRoot 和 UseConfiguration 等扩展。

　　　　(3)UseSetting 和关联键。 使用 UseSetting 设置值时，该值设置为无论何种类型的字符串。

　　2.1  Application Key (Name)

　　　　在主机构造期间调用 UseStartup 或 Configure 时，会自动设置 IHostingEnvironment.ApplicationName 属性。 该默认值设置为应用入口点的程序集的名称。 要显式设置值，请使用 WebHostDefaults.ApplicationKey。环境变量：ASPNETCORE_APPLICATIONNAME

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            //应用程序默认名称为：MyNetCoreStudy (也就是项目名称)
            string s = env.ApplicationName;
            //..

　　　　　//显示设置
　　　　　WebHost.CreateDefaultBuilder(args)
    　　.UseSetting(WebHostDefaults.ApplicationKey, "CustomApplicationName")

　　2.2捕获启动错误

　　　　启动错误的捕获。 默认为 false, 启动期间出错,主机退出。当 true 时，主机在启动期间捕获异常并尝试启动服务器。当程序使用 Kestrel 在 IIS 后方运行，默认值是 true。环境变量：ASPNETCORE_CAPTURESTARTUPERRORS

   　　 WebHost.CreateDefaultBuilder(args)
    　　.CaptureStartupErrors(true)

　　2.3 内容根

　　　　设置确定web根目录的基路径。用于搜索的内容文件，比如mvc的视图。默认为应用程序集所在的文件夹。环境变量：ASPNETCORE_CONTENTROOT。

        WebHost.CreateDefaultBuilder(args)
        .UseContentRoot("c:\\<content-root>")

　　2.4 详细错误　　

　　　　确定是否应捕获详细错误。默认值：false。启用为true时，会捕获详细的异常。或当环境设置为 Development时也会捕获详细的异常。 环境变量 ASPNETCORE_DETAILEDERRORS

    WebHost.CreateDefaultBuilder(args)
        .UseSetting(WebHostDefaults.DetailedErrorsKey, "true")

　　2.5 环境　　

　　　　设置应用的环境。默认值：Production。 使用 Visual Studio 时，可能会在 launchSettings.json 文件中设置环境变量。环境变量：ASPNETCORE_ENVIRONMENT

        WebHost.CreateDefaultBuilder(args)
    .UseEnvironment(EnvironmentName.Development)

　　2.6 HTTPS 端口

　　　　设置 HTTPS 重定向端口。 用于强制实施 HTTPS。 环境变量：ASPNETCORE_HTTPS_PORT。

   　　 WebHost.CreateDefaultBuilder(args)
        .UseSetting("https_port", "8080")

　　2.7 服务器 (Kestrel) URL

　　　　指示 IP 地址或主机地址，host启动时侦听。默认： http://localhost:5000。设置为服务器响应的以分号分隔 (;) 的 URL 前缀列表。环境变量：ASPNETCORE_URLS

　　　　WebHost.CreateDefaultBuilder(args)
   　　 .UseUrls("http://*:5000;http://localhost:5001;https://hostname:5002")

三.重写(覆盖)配置

         配置可用于配置 Web 主机。 在下面的示例中，主机配置是根据需要在 hostsettings.json 文件中指定。 命令行参数可能会重写从 hostsettings.json 文件加载的任何配置。 生成的配置（在 config 中）用于通过 UseConfiguration 配置主机。 IWebHostBuilder 配置会添加到应用配置中。

　　 hostsettings.json  { urls: "http://*:5005" }

public static IWebHostBuilder CreateWebHostBuilder(string[] args)
        {
            //IConfiguration的配置主机
            var config = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                //主机配置在hostsettings.json 文件中指定
                .AddJsonFile("hostsettings.json", optional: true)
                // 命令行参数可能会重写从 hostsettings.json 文件加载的任何配置
                .AddCommandLine(args)
                .Build();

            return WebHost.CreateDefaultBuilder(args)
                .UseUrls("http://*:5000")
                //config重写UseUrls
                .UseConfiguration(config)
                .Configure(Handle1);
        }

        private static void Handle1(IApplicationBuilder app)
        {
            app.Run(async context =>
           {
               await context.Response.WriteAsync("Handle1 Test 1");
           });
        }

　　如果在执行 dotnet 运行时从命令提示符传入。 命令行参数，将重写 hostsettings.json 文件中的 urls 值，且服务器侦听端口 8080。

　　dotnet run --urls "http://*:8080"

　　　　启动时，url参数重写的的关系是：UseUrls被hostsettings.json重写, hostsettings.json又被命令行参数重写。

四 .管理主机

         对于启动主机有二种方式：run和start。使用Run 方法启动 Web 应用是阻止调用线程，直到显示关闭主机。使用start方法是非阻止方式运行主机。具体用法请查看官网。

// Runs a web application and block the calling thread until host shutdown.
    CreateWebHostBuilder(args).Build().Run();

     CreateWebHostBuilder(args).Build().Start();
     //非阻止方式，所有必须加上ReadLine，
     Console.ReadLine();

五. IHostingEnvironment 接口

　　IHostingEnvironment 接口提供有关应用的 Web 承载环境的信息，默认是将 IHostingEnvironment 注入到 Startup构造函数，在Configure方法中引用。下面使用构造函数注入获取 IHostingEnvironment 以使用其属性和扩展方法：

public class CustomFileReader
{
    private readonly IHostingEnvironment _env;

    public CustomFileReader(IHostingEnvironment env)
    {
        _env = env;
    }

    public string ReadFile(string filePath)
    {
        //返回IFileProvider，指向 WebRootPath
        var fileProvider = _env.WebRootFileProvider;
        // Process the file here
    }
}

 　　创建自定义中间件时可以将 IHostingEnvironment 注入 Invoke 方法(参考asp.net core 系列 15 中间件)：

public async Task Invoke(HttpContext context, IHostingEnvironment env)
{
    if (env.IsDevelopment())
    {
        // Configure middleware for Development
    }
    else
    {
        // Configure middleware for Staging/Production
    }

    var contentRootPath = env.ContentRootPath;
}

六.IApplicationLifetime 接口

         IApplicationLifetime 用于应用程序在启动和关闭时的活动。 接口上的三个属性是用于注册 Action 方法。用于定义启动和关闭事件标记。

public class Startup
{
    public void Configure(IApplicationBuilder app, IApplicationLifetime appLifetime)
    {
        appLifetime.ApplicationStarted.Register(OnStarted);
        appLifetime.ApplicationStopping.Register(OnStopping);
        appLifetime.ApplicationStopped.Register(OnStopped);

        Console.CancelKeyPress += (sender, eventArgs) =>
        {
            appLifetime.StopApplication();
            // Don''t terminate the process immediately, wait for the Main thread to exit gracefully.
            eventArgs.Cancel = true;
        };
    }

    private void OnStarted()
    {
        // Perform post-startup activities here
    }

    private void OnStopping()
    {
        // Perform on-stopping activities here
    }

    private void OnStopped()
    {
        // Perform post-stopped activities here
    }
}

七. 作用域验证

　　如果应用环境为“开发”，则 CreateDefaultBuilder 将 ServiceProviderOptions.ValidateScopes 设为 true。若将 ValidateScopes 设为 true，默认服务提供程序会执行检查来验证以下内容：

       　　作用域服务不能直接或间接地从根服务提供者解析。

      　　 作用域服务不会直接或间接地注入到单例中(服务的生存期)。

　　WebHost.CreateDefaultBuilder(args)
    　　.UseDefaultServiceProvider((context, options) => {
      　　  options.ValidateScopes = true;
    　　})

　　当true将执行检查，验证作用域服务，永远不会从根提供程序解析(不从顶级容器中获取scoped生命周期服务，所有服务都是注入到容器中IServiceCollection)。 mark：没有完全理解，以后再说。

　参考文献：

　　　　官方文档：ASP.NET Core Web主机

关于asp.net – Webapi,Webhost和Owin之间的关系和.net webservice和webapi的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于.NET6-Asp.Net Core webapi -从零开始的webapi项目、ASP.NET Core Basic 1-1 WebHost 与项目配置、Asp.Net Core WebApi 和Asp.Net WebApi上传文件、asp.net core 系列 16 Web主机 IWebHostBuilder等相关内容，可以在本站寻找。