【ASP.NET Core】运行原理(1):创建WebHost

最新推荐文章于 2023-09-20 21:30:00 发布
最新推荐文章于 2023-09-20 21:30:00 发布
阅读量214 收藏 1
点赞数
文章标签： json
原文链接：http://www.cnblogs.com/neverc/p/7988226.html
版权

本系列将分析ASP.NET Core运行原理

本节将分析WebHost.CreateDefaultBuilder(args).UseStartup<Startup>().Build();代码。

源代码参考.NET Core 2.0.0

问题概要

  1. Hosting中有哪2个ServiceProvider，各自如何创建，以及有哪些ServiceCollection。
  2. 什么时候执行Startup的ConfigureServices 和 Configure方法
  3. 什么时候注册和使用的Server
  4. 手工模拟一个DefaultWebHost环境

WebHost.CreateDefaultBuilder(args)

该方法为WebHost类的静态方法，内部创建1个WebHostBuilder。

  1. 参数args将作为配置项
  2. 添加了Kestrel、Configuration、Logging、IISIntegration中间件，同时配置ContentRoot和DefaultServiceProvider
public static IWebHostBuilder CreateDefaultBuilder(string[] args)
{
    var builder = new WebHostBuilder()
        .UseKestrel()
        .UseContentRoot(Directory.GetCurrentDirectory())
        .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();
        })
        .UseIISIntegration()
        .UseDefaultServiceProvider((context, options) =>
        {
            options.ValidateScopes = context.HostingEnvironment.IsDevelopment();
        });
    return builder;
}

UseKestrel

在UseKestrel()方法中，注册了3个服务到List<Action<WebHostBuilderContext, IServiceCollection>>字段上。(以供后续注册)

public static IWebHostBuilder UseKestrel(this IWebHostBuilder hostBuilder)
{
    return hostBuilder.ConfigureServices((Action<IServiceCollection>) (services =>
    {
        services.AddSingleton<ITransportFactory, LibuvTransportFactory>();
        services.AddTransient<IConfigureOptions<KestrelServerOptions>, KestrelServerOptionsSetup>();
        services.AddSingleton<IServer, KestrelServer>();
    }));
}

public IWebHostBuilder ConfigureServices(Action<WebHostBuilderContext, IServiceCollection> configureServices)
{
    this._configureServicesDelegates.Add((_, services) => configureServices(services));
    return (IWebHostBuilder) this;
}

UseContentRoot

UseContentRoot方法则是添加到IConfiguration字段上,这个字段在构造函数初始化
this._config = (IConfiguration) new ConfigurationBuilder().AddEnvironmentVariables("ASPNETCORE_").Build();

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

ConfigureAppConfiguration

ConfigureAppConfiguration方法是添加到List<Action<WebHostBuilderContext, IConfigurationBuilder>>字段上
在外部添加了
AddJsonFile("appsettings.json")、AddJsonFile(string.Format("appsettings.{0}.json", (object) hostingEnvironment.EnvironmentName))
AddEnvironmentVariables()
AddCommandLine(args)

public IWebHostBuilder ConfigureAppConfiguration(Action<WebHostBuilderContext, IConfigurationBuilder> configureDelegate)
{
    this._configureAppConfigurationBuilderDelegates.Add(configureDelegate);
    return (IWebHostBuilder) this;
}

ConfigureLogging

ConfigureLogging注册Log到ServiceCollection上
在外部添加了3个ILoggerProvider
logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
logging.AddConsole();
logging.AddDebug();

public static IWebHostBuilder ConfigureLogging(this IWebHostBuilder hostBuilder, Action<WebHostBuilderContext, ILoggingBuilder> configureLogging)
{
    return hostBuilder.ConfigureServices((context, services) => services.AddLogging(builder => configureLogging(context, builder));
}

public IWebHostBuilder ConfigureServices(Action<WebHostBuilderContext, IServiceCollection> configureServices)
{
    this._configureServicesDelegates.Add(configureServices);
    return (IWebHostBuilder) this;
}

UseDefaultServiceProvider

UseDefaultServiceProvider配置和替换服务

var options = new ServiceProviderOptions { ValidateScopes = context.HostingEnvironment.IsDevelopment()};
services.Replace(ServiceDescriptor.Singleton<IServiceProviderFactory<IServiceCollection>>((IServiceProviderFactory<IServiceCollection>) new DefaultServiceProviderFactory(options)));

UseStartup

UseStartup相当于注册了一个IStartup服务。

public static IWebHostBuilder UseStartup(this IWebHostBuilder hostBuilder, Type startupType)
{
    string name = startupType.GetTypeInfo().Assembly.GetName().Name;
    return hostBuilder.UseSetting(WebHostDefaults.ApplicationKey, name).ConfigureServices((Action<IServiceCollection>) (services =>
    {
    if (typeof (IStartup).GetTypeInfo().IsAssignableFrom(startupType.GetTypeInfo()))
        ServiceCollectionServiceExtensions.AddSingleton(services, typeof (IStartup), startupType);
    else
        ServiceCollectionServiceExtensions.AddSingleton(services, typeof (IStartup), (Func<IServiceProvider, object>) (sp =>
        {
        IHostingEnvironment requiredService = sp.GetRequiredService<IHostingEnvironment>();
        return (object) new ConventionBasedStartup(StartupLoader.LoadMethods(sp, startupType, requiredService.EnvironmentName));
        }));
    }));
}

根据Startup是否继承IStartup，来决定注册的方式。未继承的时候，会使用ConventionBasedStartup来封装自定义的Startup。

Build

Build方法是WebHostBuilder最终的目的，将构造一个WebHost返回。

同时初始化WebHost对象，WebHostBuilder.Build代码：

public IWebHost Build()
{
    var hostingServices = BuildCommonServices(out var hostingStartupErrors);
    var applicationServices = hostingServices.Clone();
    var hostingServiceProvider = hostingServices.BuildServiceProvider();

    AddApplicationServices(applicationServices, hostingServiceProvider);

    var host = new WebHost(
        applicationServices,
        hostingServiceProvider,
        _options,
        _config,
        hostingStartupErrors);

    host.Initialize();

    return host;
}

在Build方法中，BuildCommonServices最为重要,将构造第一个ServiceCollection。这里我们称为hostingServices。
将包含hostEnv、Config、ApplicationBuilder、Logging、StartupFilter、Startup、Server。参考BuildCommonServices

private IServiceCollection BuildCommonServices(out AggregateException hostingStartupErrors)
{
    if (!this._options.PreventHostingStartup)
    {
        foreach (string hostingStartupAssembly in (IEnumerable<string>) this._options.HostingStartupAssemblies)
        {
            foreach (HostingStartupAttribute customAttribute in Assembly.Load(new AssemblyName(hostingStartupAssembly)).GetCustomAttributes<HostingStartupAttribute>())
                ((IHostingStartup) Activator.CreateInstance(customAttribute.HostingStartupType)).Configure((IWebHostBuilder) this);
        }
    }
    ServiceCollection services = new ServiceCollection();
    // hostEnv
    _hostingEnvironment.Initialize(this._options.ApplicationName, this.ResolveContentRootPath(this._options.ContentRootPath, AppContext.BaseDirectory), this._options);
    services.AddSingleton<IHostingEnvironment>(this._hostingEnvironment);
    // config
    IConfigurationBuilder configurationBuilder = new ConfigurationBuilder().SetBasePath(this._hostingEnvironment.ContentRootPath).AddInMemoryCollection(this._config.AsEnumerable());
    foreach (Action<WebHostBuilderContext, IConfigurationBuilder> configurationBuilderDelegate in this._configureAppConfigurationBuilderDelegates)
        configurationBuilderDelegate(this._context, configurationBuilder);
    IConfigurationRoot configurationRoot = configurationBuilder.Build();
    services.AddSingleton<IConfiguration>((IConfiguration) configurationRoot);
    services.AddOptions();
    // application
    services.AddTransient<IApplicationBuilderFactory, ApplicationBuilderFactory>();
    services.AddTransient<IHttpContextFactory, HttpContextFactory>();
    services.AddScoped<IMiddlewareFactory, MiddlewareFactory>();
    // log
    services.AddLogging();
    services.AddTransient<IStartupFilter, AutoRequestServicesStartupFilter>();
    services.AddTransient<IServiceProviderFactory<IServiceCollection>, DefaultServiceProviderFactory>();
    // 配置的StartupType
    if (!string.IsNullOrEmpty(this._options.StartupAssembly))
    {
        Type startupType = StartupLoader.FindStartupType(this._options.StartupAssembly, this._hostingEnvironment.EnvironmentName);
        if (typeof (IStartup).GetTypeInfo().IsAssignableFrom(startupType.GetTypeInfo()))
            ServiceCollectionServiceExtensions.AddSingleton(services, typeof (IStartup), startupType);
        else
            ServiceCollectionServiceExtensions.AddSingleton(services, typeof (IStartup), new ConventionBasedStartup(StartupLoader.LoadMethods(startupType)));
    }
    // UseStartup、UseKestrel、ConfigureLogging
    foreach (Action<WebHostBuilderContext, IServiceCollection> servicesDelegate in this._configureServicesDelegates)
        servicesDelegate(this._context, (IServiceCollection) services);
    return (IServiceCollection) services;
}

当 hostingServices 创建完成后，会马上拷贝一份applicationServices提供给WebHost使用，同时创建第一个ServiceProvider hostingServiceProvider。

host.Initialize()该方法则是初始化WebHost

  1. 生成第二个ServiceProvider _applicationServices(微软的内部字段命名，感觉不太规范);
  2. 初始化Server，读取绑定的地址。
  3. 创建Application管道，生成RequestDelegate。
public void Initialize()
{
    _startup = _hostingServiceProvider.GetService<IStartup>();
    _applicationServices = _startup.ConfigureServices(_applicationServiceCollection);
    EnsureServer();
    var builderFactory = _applicationServices.GetRequiredService<IApplicationBuilderFactory>();
    var builder = builderFactory.CreateBuilder(Server.Features);
    builder.ApplicationServices = _applicationServices;

    var startupFilters = _applicationServices.GetService<IEnumerable<IStartupFilter>>();
    Action<IApplicationBuilder> configure = _startup.Configure;
    foreach (var filter in startupFilters.Reverse())
    {
        configure = filter.Configure(configure);
    }
    configure(builder);

    this._application = builder.Build();    // RequestDelegate
}

WebHost.Run

创建完 WebHost 之后，便调用它的 Run 方法，而 Run 方法会去调用 WebHost 的 StartAsync 方法

  1. 调用Server.Start，将Initialize方法创建的Application管道传入以供处理消息
  2. 执行HostedServiceExecutor.StartAsync方法
public static void Run(this IWebHost host)
{
    host.RunAsync(cts.Token, "Application started. Press Ctrl+C to shut down.").GetAwaiter().GetResult();
}

private static async Task RunAsync(this IWebHost host, CancellationToken token, string shutdownMessage)
{
    await host.StartAsync(token);
    var hostingEnvironment = host.Services.GetService<IHostingEnvironment>();
    Console.WriteLine($"Hosting environment: {hostingEnvironment.EnvironmentName}");
    Console.WriteLine($"Content root path: {hostingEnvironment.ContentRootPath}");
    var serverAddresses = host.ServerFeatures.Get<IServerAddressesFeature>()?.Addresses;

    if (serverAddresses != null)
        foreach (var address in serverAddresses)
            Console.WriteLine($"Now listening on: {address}");

    if (!string.IsNullOrEmpty(shutdownMessage))
        Console.WriteLine(shutdownMessage);
}

public virtual async Task StartAsync(CancellationToken cancellationToken = default (CancellationToken))
{
    Initialize();
    _applicationLifetime = _applicationServices.GetRequiredService<IApplicationLifetime>() as ApplicationLifetime;
    _hostedServiceExecutor = _applicationServices.GetRequiredService<HostedServiceExecutor>();
    var httpContextFactory = _applicationServices.GetRequiredService<IHttpContextFactory>();
    var hostingApp = new HostingApplication(_application, _logger, diagnosticSource, httpContextFactory);
    await Server.StartAsync(hostingApp, cancellationToken).ConfigureAwait(false);

    _applicationLifetime?.NotifyStarted();
    await _hostedServiceExecutor.StartAsync(cancellationToken).ConfigureAwait(false);
}

问题解答

  1. hostingServices(WebHostBuilder) 和 _applicationServices(WebHost)。区别是_applicationServices中比hostingServices多处Startup方法注册的服务。
  2. 都是WebHost中执行的。ConfigureServices在_applicationServices生成前，Configure在_applicationServices生成后。
  3. 最初的注册在WebHostBuilder的UseKestrel，使用在WebHost的Run方法

手工模拟一个DefaultWebHost环境

new WebHostBuilder()
    .UseKestrel()                                       // 使用Kestrel服务器
    .UseContentRoot(Directory.GetCurrentDirectory())    // 配置根目录 会在ConfigurationBuilder、 IHostingEnvironment(后续其他中间件) 和 WebHostOptions(WebHost)用到。
    .ConfigureAppConfiguration((context, builder) => builder.AddJsonFile("appsetting.json", true, true))    // 添加配置源
    .ConfigureLogging(builder => builder.AddConsole())  // 添加日志适配器
    .UseStartup<Startup>()                              // 选择Startup
    .Build().Run();                                     // 生成WebHost 并 启动

本文链接：http://neverc.cnblogs.com/p/7988226.html

转载于:https://www.cnblogs.com/neverc/p/7988226.html

denaoderenhuan8776
关注
ASP .NET Core 的运行机制和启动（转）
ppp17的博客
05-07 2173
ASP .NET Core 的运行机制和启动
【ASP.NET Core】配置应用程序地址的N多种方法
pythonxxoo的博客
06-06 751
下面又到了老周误人子弟的时间，今天要误大伙的话题是：找找有多少种方法可以设置 ASP.NET Core 应用的地址，即 URL。精彩马上开始！这是一个扩展方法，参数是可变个数的字符串数组。所以，每传一个参数就代表一个 URlL。例如 就这样，咱们就轻松地设置了三个地址。程序运行后，访问任意一个地址均可。这也是一个扩展方法，key 是“urls”，可以通过 WebHostDefaults.ServerUrlsKey 静态字段获得，value 是URL 的值，多个 URL 用分号隔开。注意，URL 开头不能有空
任务24：WebHost的配置
weixin_30388677的博客
08-06 236
24 任务24：WebHost的配置 创建HelloCore的项目 我们新建一个空的mvc项目 我们在这里调用COnfigureAppConfiguration方法更改默认的配置。为读取settings.json这个文件。 从CommandLine读取配置信息 引入configuration的命名空间，然后在Configure方法里面，加上ICon...
.NET5中 Host.CreateDefaultBuilder(args)详解
qbc12345678的博客
02-17 3525
.NET5阅读心得之CreateDefaultBuilder(args)使用
[探索 .NET 6]02 比较 WebApplicationBuilder 和 Host
dotNET跨平台
01-24 1463
这是『探索 .NET 6』系列的第二篇文章：01 揭开 ConfigurationManager 的面纱02 比较 WebApplicationBuilder 和 Host在 .NET 中...
C# 依赖注入IServiceCollection的AddSingleton方法使用
热门推荐
皮皮君的博客
05-22 1万+
AddSingleton(IServiceCollection, Type, Func<IServiceProvider,Object>)方法 这个方法是通过提供一个Func<IServiceProvider,Object>的delegate委托来实现服务的获取。具体怎么用，下面给一个简单例子: using System; using Microsoft.Extensions.DependencyInjection; class Program { interface I
【ASP.NET Core】运行原理[1]:创建WebHost
dianshanpang3778的博客
03-06 313
本系列将分析ASP.NET Core运行原理 【ASP.NET Core】运行原理[1]:创建WebHost 【ASP.NET Core】运行原理[2]:启动WebHost 【ASP.NET Core】运行原理[3]:认证 本节将分析WebHost.CreateDefaultBuilder(args).UseStartup<Startup>().Build()...
.NET Core 源码深度解析：配置文件与依赖注入揭秘
本文将详细探讨这两个主题，以及它们在ASP.NET Core框架中的实现。 配置文件在.NET Core中的作用是存储应用的设置和参数，使得开发者可以根据不同的环境动态调整应用行为。常见的配置文件类型有JSON、XML和...
.NET Core源码探索：配置加载与依赖注入解析
我们将从ASP.NET Core项目的启动流程入手，逐步解析源码，以便更深入地理解这些核心机制。 首先，ASP.NET Core项目的启动始于`Program.cs`文件中的`Main`方法，这是程序的入口点。在`Main`方法中，`...
深入理解asp-net-core机制
08-19
本篇文章将深入探讨ASP.NET Core的核心机制，帮助开发者理解其背后的运作原理。 首先，我们要了解ASP.NET Core的基石——Kestrel服务器。Kestrel是一个轻量级的HTTP服务器，它负责接收HTTP请求并将其转发给ASP.NET ...
.Net Core中Host的作用和用法
最新发布
weixin_57062986的博客
09-20 843
我们可以通过调用ConfigureHostConfiguration方法来配置Host的配置，通过调用ConfigureAppConfiguration方法来配置应用程序的配置，通过调用ConfigureServices方法来配置依赖项，以及通过调用ConfigureLogging方法来配置日志记录等。根据应用程序的需求，选择适合的主机模型来构建和托管应用程序。3.在ASP.NET Core 3.0及之后的版本中，建议使用Generic Host来构建新的应用程序，因为它提供了更多的功能和扩展性。
简述.NET6 Minimal API的使用方式
farway000的博客
12-06 1052
前言随着.Net6的发布，微软也改进了对之前ASP.NET Core构建方式，使用了新的Minimal API模式。之前默认的方式是需要在Startup中注册IOC和中间件相关，但...
ASP.NET Core 系列[1]：ASP.NET Core 初识
weixin_34323858的博客
10-14 114
ASP.NET Core 是一个跨平台的高性能开源框架，是一个用于连接到互联网的基于云的现代应用程序。 ASP.NET Core用于构建如 Web 应用、物联网（IoT）应用和移动后端应用，这些应用可以在 .NET Core或 .NET Framework上运行，你可以在 Windows、Mac 和 Linux 上跨平台的开发和运行你的 ASP.NET Core 应用。 ASP.NET Co...
Asp.Net Core轻松入门之WebHost的配置
weixin_34413357的博客
12-14 466
在本篇文章中，我来讲一讲如何利用WebHost来加载配置文件和设置启动的Url 在前面的文章中讲过，ASP.Net Core应用程序会自动加载appsettings.json中的配置文件，那么如果配置文件不是写在appsettings.json中的如何来加载呢？ 本文介绍利用WebHost从json文件加载和从命令行加载两种方式。 首先 新建一个A...
ASP.NET Core 运行原理解剖[2]:Hosting补充之配置介绍
weixin_33836223的博客
08-28 304
在上一章中，我们介绍了 ASP.NET Core 的启动过程，主要是对 WebHost 源码的探索。而本文则是对上文的一个补充，更加偏向于实战，详细的介绍一下我们在实际开发中需要对 Hosting 做一些配置时经常用到的几种方式。 目录 本系列文章从源码分析的角度来探索 ASP.NET Core 的运行原理，分为以下几个章节： ASP.NET Core 运行原理解剖[1]:Hosting ASP....
asp.net core 系列 16 Web主机 IWebHostBuilder
weixin_34279184的博客
01-25 550
一.概述 在asp.net core中，Host主机负责应用程序启动和生存期管理。host主机包括Web 主机(IWebHostBuilder)和通用主机(IHostBuilder)。Web 主机是适用于托管 Web 应用；通用主机（ASP.NET Core 2.1 或更高版本）是适用于托管非 Web 应用；在未来的版本中，通用主机将适用于托管任何类型的应用，包括 Web 应用...
ASP.NET Core基础（四）——IHostBuilder
catshitone的专栏
04-20 3152
此文是在官方文档的基础上做的个人笔记，一些简单的内容就没用再列出来了，参考官方文档：https://docs.microsoft.com/zh-cn/aspnet/core/fundamentals/host/generic-host?view=aspnetcore-5.0 主机封装了应用的所有资源，例如：HTTP服务器实现（Kestrel）、中间件、Logging、DI、Configuration等。 主机分为两种： .Net 通用主机IHostBuilder：（推荐使用）。Program.cs的C.
ASP.Net Core的UseStartup加载Start类过程
皮皮君的博客
05-22 1848
UseStartup加载Start类过程 这个过程主要是利用了依赖注入原理。 WebHostBuilder类有一个扩展WebHostBuilderExtensions，在这个扩展中对WebHostBuilder的方法进行了扩展，里面就包含UseStartup()方法，这个方法里将Start服务添加进去: /// <summary> /// Specify the startup type to be used by the web host. //
.NET Core 3.0之深入源码理解Startup的注册及运行
FK2015139136的博客
04-20 1759
写在前面 开发.NET Core应用，直接映入眼帘的就是Startup类和Program类，它们是.NET Core应用程序的起点。通过使用Startup，可以配置化处理所有向应用程序所做的请求的管道，同时也可以减少.NET应用程序对单一服务器的依赖性，使我们在更大程度上专注于面向多服务器为中心的开发模式。 目录： Startup讨论 Starup所承担的角色 S...
ASP.NET Core 修改默认端口：从UseUrls到host.json配置
"asp.net core 修改默认端口的几种方法" ASP.NET Core 是微软推出的高性能、跨平台的开源框架，用于构建Web应用。默认情况下，ASP.NET Core 的开发服务器Kestrel会监听5000端口。但在实际开发或部署过程中，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值