重新整理 .net core 实践篇———

前言

本来想整理到<<重新整理.net core 计1400篇>>里面去，但是后来一想，整理 .net core 实践篇是偏于实践，故而分开。

因为是重新整理，那么就从配置开始整理。以下只是个人理解，如有错误，望请指点谢谢。

正文

在我们创建好一个应用的时候，那么出现在我们视野的是一个这样的东西:

public class Program

{

	public static void Main(string[] args)

	{

		CreateHostBuilder(args).Build().Run();

	}

	public static IHostBuilder CreateHostBuilder(string[] args) =>

		Host.CreateDefaultBuilder(args)

			.ConfigureWebHostDefaults(webBuilder =>

			{

				webBuilder.UseStartup<Startup>();

			});

}

看到这种:

CreateHostBuilder(args).Build().Run();

显然是建设者模式。

那么前面的基本就是在做一个构建。

既然是一个建设者模式，那么就来看一下这个的构建器是什么?

是一个叫做IHOSTBUILDER 的东西哈，而显然从命名上看这是一个接口哈。那么看下这个接口是啥:

跟配置相关得到也就是那几个Configure开头的那4个东西。

后面两个UseServiceProviderFactory后面系列再说。

//

// 摘要:

//     Sets up the configuration for the remainder of the build process and application.

//     This can be called multiple times and the results will be additive. The results

//     will be available at Microsoft.Extensions.Hosting.HostBuilderContext.Configuration

//     for subsequent operations, as well as in Microsoft.Extensions.Hosting.IHost.Services.

//

// 参数:

//   configureDelegate:

//     The delegate for configuring the Microsoft.Extensions.Configuration.IConfigurationBuilder

//     that will be used to construct the Microsoft.Extensions.Configuration.IConfiguration

//     for the application.

//

// 返回结果:

//     The same instance of the Microsoft.Extensions.Hosting.IHostBuilder for chaining.

IHostBuilder ConfigureAppConfiguration(Action<HostBuilderContext, IConfigurationBuilder> configureDelegate);

这个函数的大致意思是说构件一个IConfigurationBuilder，这个the remainder of the build process and application.的配置。

// 摘要:

//     Enables configuring the instantiated dependency container. This can be called

//     multiple times and the results will be additive.

//

// 参数:

//   configureDelegate:

//     The delegate which configures the builder.

//

// 类型参数:

//   TContainerBuilder:

//     The type of builder.

//

// 返回结果:

//     The same instance of the Microsoft.Extensions.Hosting.IHostBuilder for chaining.

IHostBuilder ConfigureContainer<TContainerBuilder>(Action<HostBuilderContext, TContainerBuilder> configureDelegate);

依赖容器相关的哈。

ConfigureHostConfiguration 和 ConfigureServices 这两个就不贴了，分别是一些坏境配置和服务配置。

那么启动一下，看下他们的执行顺序是否和我们代码的书写顺序是否相同，也就是说不管我如何调换顺序他们的执行都是按照某种规则。

那么这里加上log，通过log的方式来查看执行顺序，如下:

public class Program

{

	public static void Main(string[] args)

	{

		CreateHostBuilder(args).Build().Run();

	}

	public static IHostBuilder CreateHostBuilder(string[] args) =>

		Host.CreateDefaultBuilder(args)

			.ConfigureAppConfiguration((builder) =>

			{

				Console.WriteLine("ConfigureAppConfiguration");

			}).ConfigureServices(builder =>

			{

				Console.WriteLine("ConfigureServices");

			}).ConfigureHostConfiguration(builder =>

			{

				Console.WriteLine("ConfigureHostConfiguration");

			})

			.ConfigureWebHostDefaults(webBuilder =>

			{

				Console.WriteLine("ConfigureWebHostDefaults");

				webBuilder.UseStartup<Startup>();

			});

}

startup.cs

public class Startup

{

	public IConfiguration Configuration { get; }

	public Startup(IConfiguration configuration)

	{

		Console.WriteLine("Startup");

		Configuration = configuration;

	}

	// This method gets called by the runtime. Use this method to add services to the container.

	// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940

	public void ConfigureServices(IServiceCollection services)

	{

		Console.WriteLine("Startup.ConfigureServices");

		services.AddControllers();

	}

	// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.

	public void Configure(IApplicationBuilder app, IWebHostEnvironment env)

	{

		Console.WriteLine("Startup.Configure");

		if (env.IsDevelopment())

		{

			app.UseDeveloperExceptionPage();

		}

		app.UseRouting();

		app.UseEndpoints(endpoints =>

		{

			endpoints.MapGet("/", async context =>

			{

				await context.Response.WriteAsync("Hello World!");

			});

		});

	}

}

这里可以发现执行顺序和我们的代码的书写顺序并不是一致的。

那么我们再次做一个小小的调换，那么会怎么样呢？

public static IHostBuilder CreateHostBuilder(string[] args) =>

	Host.CreateDefaultBuilder(args)

		.ConfigureWebHostDefaults(webBuilder =>

		{

			Console.WriteLine("ConfigureWebHostDefaults");

			webBuilder.UseStartup<Startup>();

		})

		.ConfigureServices(builder =>

		{

			Console.WriteLine("ConfigureServices");

		})

		.ConfigureAppConfiguration((builder) =>

		{

			Console.WriteLine("ConfigureAppConfiguration");

		})

		.ConfigureHostConfiguration(builder =>

		{

			Console.WriteLine("ConfigureHostConfiguration");

		});

}

发现变化的只有Startup.ConfigureServices 和 ConfigureServices。

这个时候我们大体猜出来了这个启动顺序是按照某种执行顺序执行，且Startup.ConfigureServices 和 ConfigureServices 是同一种类型，并且他们的执行顺序和他们的注册顺序保持一致。

执行顺序如下：

先看一下CreateDefaultBuilder:

public static IHostBuilder CreateDefaultBuilder(string[] args)

{

	var builder = new HostBuilder();

	builder.UseContentRoot(Directory.GetCurrentDirectory());

	builder.ConfigureHostConfiguration(config =>

	{

		config.AddEnvironmentVariables(prefix: "DOTNET_");

		if (args != null)

		{

			config.AddCommandLine(args);

		}

	});

	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() && !string.IsNullOrEmpty(env.ApplicationName))

		{

			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) =>

	{

		var isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);

		// IMPORTANT: This needs to be added *before* configuration is loaded, this lets

		// the defaults be overridden by the configuration.

		if (isWindows)

		{

			// Default the EventLogLoggerProvider to warning or above

			logging.AddFilter<EventLogLoggerProvider>(level => level >= LogLevel.Warning);

		}

		logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));

		logging.AddConsole();

		logging.AddDebug();

		logging.AddEventSourceLogger();

		if (isWindows)

		{

			// Add the EventLogLoggerProvider on windows machines

			logging.AddEventLog();

		}

	})

	.UseDefaultServiceProvider((context, options) =>

	{

		var isDevelopment = context.HostingEnvironment.IsDevelopment();

		options.ValidateScopes = isDevelopment;

		options.ValidateOnBuild = isDevelopment;

	});

	return builder;

}

那么先看下ConfigureWebDefaults 到底干了什么。

internal static void ConfigureWebDefaults(IWebHostBuilder builder)

{

	builder.ConfigureAppConfiguration((ctx, cb) =>

	{

		if (ctx.HostingEnvironment.IsDevelopment())

		{

			StaticWebAssetsLoader.UseStaticWebAssets(ctx.HostingEnvironment, ctx.Configuration);

		}

	});

	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>();

		if (string.Equals("true", hostingContext.Configuration["ForwardedHeaders_Enabled"], StringComparison.OrdinalIgnoreCase))

		{

			services.Configure<ForwardedHeadersOptions>(options =>

			{

				options.ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto;

				// Only loopback proxies are allowed by default. Clear that restriction because forwarders are

				// being enabled by explicit configuration.

				options.KnownNetworks.Clear();

				options.KnownProxies.Clear();

			});

			services.AddTransient<IStartupFilter, ForwardedHeadersStartupFilter>();

		}

		services.AddRouting();

	})

	.UseIIS()

	.UseIISIntegration();

}

ConfigureWebDefaults 配置了一些必要的组件。

CreateDefaultBuilder 和 ConfigureWebDefaults 两者可以看到其实就是做一些默认配置让我们的服务能够启动起来。

而后续的配置也就是注册的顺序执行，只是我们的执行顺序晚点罢了。

那么再整理一下，也就是说从原理的执行顺序来说是这样的。

ConfigureHostConfiguration

ConfigureAppConfiguration

ConfigureServices

ConfigureLogging

Configure

以上都是推论。那么直接看源码,因为是构建者模式，所以直接看build。

public IHost Build()

{

	if (_hostBuilt)

	{

		throw new InvalidOperationException("Build can only be called once.");

	}

	_hostBuilt = true;

	BuildHostConfiguration();

	CreateHostingEnvironment();

	CreateHostBuilderContext();

	BuildAppConfiguration();

	CreateServiceProvider();

	return _appServices.GetRequiredService<IHost>();

}

上面的顺序和猜想是一致的。

这里看下BuildHostConfiguration:

private List<Action<IConfigurationBuilder>> _configureHostConfigActions = new List<Action<IConfigurationBuilder>>();

private void BuildHostConfiguration()

{

	var configBuilder = new ConfigurationBuilder()

		.AddInMemoryCollection(); // Make sure there's some default storage since there are no default providers

	foreach (var buildAction in _configureHostConfigActions)

	{

		buildAction(configBuilder);

	}

	_hostConfiguration = configBuilder.Build();

}

那么其实我们按照这种配置，那么其实我们的ConfigureHostConfiguration全部方法都是在_configureHostConfigActions 中，到了builder 的时候就按照我们的注册顺序执行。

那么这里就能解释ConfigureWebHostDefaults 不管顺序都是在最前面，而里面startup的顺序确不一样。

代码解释一波:

public static IHostBuilder ConfigureWebHostDefaults(this IHostBuilder builder, Action<IWebHostBuilder> configure)

{

	return builder.ConfigureWebHost(webHostBuilder =>

	{

		WebHost.ConfigureWebDefaults(webHostBuilder);

		configure(webHostBuilder);

	});

}

ConfigureWebHostDefaults 立即执行，那么log自然就先打印出来了，而其他几个都是延迟执行的。他们的执行顺序和注册顺序有关。

最后再解释一下，webBuilder.UseStartup(); 到底做了什么?

public static IWebHostBuilder UseStartup(this IWebHostBuilder hostBuilder, Type startupType)

{

	var startupAssemblyName = startupType.GetTypeInfo().Assembly.GetName().Name;

	hostBuilder.UseSetting(WebHostDefaults.ApplicationKey, startupAssemblyName);

	// Light up the GenericWebHostBuilder implementation

	if (hostBuilder is ISupportsStartup supportsStartup)

	{

		return supportsStartup.UseStartup(startupType);

	}

	return hostBuilder

		.ConfigureServices(services =>

		{

			if (typeof(IStartup).GetTypeInfo().IsAssignableFrom(startupType.GetTypeInfo()))

			{

				services.AddSingleton(typeof(IStartup), startupType);

			}

			else

			{

				services.AddSingleton(typeof(IStartup), sp =>

				{

					var hostingEnvironment = sp.GetRequiredService<IHostEnvironment>();

					return new ConventionBasedStartup(StartupLoader.LoadMethods(sp, startupType, hostingEnvironment.EnvironmentName));

				});

			}

		});

}

解释一下IsAssignableFrom:

bool res = {TypeA}.IsAssignableFrom({TypeB}) ;

如果TypeA和TypeB类型一样则返回true；

如果TypeA是TypeB的父类则返回true;

如果TypeB实现了接口TypeA则返回true;

可以看到这里做的是一个IStartup 到 Startup的一个依赖注入，且是单例模式，所以肯定的是Startup 里面的方法会在ConfigureHostConfiguration、ConfigureAppConfiguration之后执行，因为其在ConfigureServices 才开始注入依赖的。

结

因为是应用篇，单纯是一些应用需要知道的，所以比较粗糙，具体的详细在原理篇介绍了。上述只是个人的理解，如果错误，望请指点，谢谢。

巴特西

重新整理 .net core 实践篇————配置应用[一]

前言

正文

结

最新文章

热门文章