.NET Core 3.0之深入源碼理解Startup的注冊及運行

 

寫在前面

開發.NET Core應用，直接映入眼簾的就是Startup類和Program類，它們是.NET Core應用程序的起點。通過使用Startup，可以配置化處理所有向應用程序所做的請求的管道，同時也可以減少.NET應用程序對單一服務器的依賴性，使我們在更大程度上專注於面向多服務器為中心的開發模式。

目錄：

• Startup討論
  • Starup所承擔的角色
  • Startup編寫規范
  • ConfigureServices
  • Configure
  • 擴展Startup方法
• 深入源碼查看Startup是如何注冊和執行的
  • UseStartup源碼
  • 創建Startup實例
  • ConfigureServices和Configure

Startup討論

Starup所承擔的角色

Startup作為一個概念是ASP.NET Core程序中所必須的，Startup類本身可以使用多種修飾符(public、protect，private、internal)，作為ASP.NET Core應用程序的入口，它包含與應用程序相關配置的功能或者說是接口。

雖然在程序里我們使用的類名就是Startup，但是需要注意的是，Startup是一個抽象概念，你完全可以名稱成其他的，比如MyAppStartup或者其他的什么名稱，只要你在Program類中啟動你所定義的啟動類即可。

當然如果不想寫Startup，可以在Program類中配置服務和請求處理管道，請參見評論區5樓，非常感謝Emrys耐心而又全面的指正。

以下是基於ASP.NET Core Preview 3模板中提供的寫法：

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

不管你命名成什么，只要將webBuilder.UseStartup<>()中的泛型類配置成你定義的入口類即可;

Startup編寫規范

下面是ASP.NET Core 3.0 Preview 3模板中Startup的寫法：

// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
        app.UseHsts();
    }

    app.UseHttpsRedirection();

    app.UseRouting(routes =>
    {
        routes.MapControllers();
    });

    app.UseAuthorization();
}

通過以上代碼可以知道，Startup類中一般包括

• 構造函數：通過我們以前的開發經驗，我們可以知道，該構造方法可以包括多個對象
  • IConfiguration：表示一組鍵/值應用程序配置屬性。
  • IApplicationBuilder：是一個包含與當前環境相關的屬性和方法的接口。它用於獲取應用程序中的環境變量。
  • IHostingEnvironment：是一個包含與運行應用程序的Web宿主環境相關信息的接口。使用這個接口方法，我們可以改變應用程序的行為。
  • ILoggerFactory：是為ASP.NET Core中的日志記錄系統提供配置的接口。它還創建日志系統的實例。
• ConfigureServices
• Configure

Startup在創建服務時，會執行依賴項注冊服務，以便在應用程序的其它地方使用這些依賴項。ConfigureServices 用於注冊服務，Configure 方法允許我們向HTTP管道添加中間件和服務。這就是ConfigureServices先於Configure 之前調用的原因。

ConfigureServices

該方法時可選的，非強制約束，它主要用於對依賴注入或ApplicationServices在整個應用中的支持，該方法必須是public的，其典型模式是調用所有 Add{Service} 方法，主要場景包括實體框架、認證和 MVC 注冊服務：

services.AddDbContext<ApplicationDbContext>(options =>options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
services.AddDefaultIdentity<IdentityUser>().AddDefaultUI(UIFramework.Bootstrap4).AddEntityFrameworkStores<ApplicationDbContext>();
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
// Add application services.此處主要是注冊IOC服務
services.AddTransient<IEmailSender, AuthMessageSender>();
services.AddTransient<ISmsSender, AuthMessageSender>();

Configure

該方法主要用於定義應用程序對每個HTTP請求的響應方式，即我們可以控制ASP.NET管道，還可用於在HTTP管道中配置中間件。請求管道中的每個中間件組件負責調用管道中的下一個組件，或在適當情況下使鏈發生短路。 如果中間件鏈中未發生短路，則每個中間件都有第二次機會在將請求發送到客戶端前處理該請求。

該方法接受IApplicationBuilder作為參數，同時還可以接收其他一些可選參數，如IHostingEnvironment和ILoggerFactory。

一般而言，只要將服務注冊到configureServices方法中時，都可以在該方法中使用。

app.UseDeveloperExceptionPage();
app.UseHsts();
app.UseHttpsRedirection();
app.UseRouting(routes =>
{
    routes.MapControllers();
});
app.UseAuthorization();

擴展Startup方法

使用IStartupFilter來對Startup功能進行擴展，在應用的Configure中間件管道的開頭或末尾使用IStartupFilter來配置中間件。IStartupFilter有助於確保當庫在應用請求處理管道的開端或末尾添加中間件的前后運行中間件。

以下是IStartupFilter的源代碼，通過源代碼我們可以知道，該接口有一個Action<IApplicationBuilder>類型，並命名為Configure的方法。由於傳入參數類型和返回類型一樣，這就保證了擴展的傳遞性及順序性，具體的演示代碼，可以參數MSDN

using System;
using Microsoft.AspNetCore.Builder;

namespace Microsoft.AspNetCore.Hosting
{
  public interface IStartupFilter
  {
      Action<IApplicationBuilder> Configure(Action<IApplicationBuilder> next);
  }
}

Startup是如何注冊和執行的

此段文字，只是我想深入了解其內部機制而寫的，如果本身也不了解，其實是不影響我們正常編寫.NET Core應用的。

UseStartup源碼

ASP.NET Core通過調用IWebHostBuilder.UseStartup方法，傳入Startup類型，注意開篇就已經說過Startup是一個抽象概念，我們看下源代碼：

/// <summary>
 /// Specify the startup type to be used by the web host.
 /// </summary>
 /// <param name="hostBuilder">The <see cref="IWebHostBuilder"/> to configure.</param>
 /// <param name="startupType">The <see cref="Type"/> to be used.</param>
 /// <returns>The <see cref="IWebHostBuilder"/>.</returns>
 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));
                });
            }
        });
}

/// <summary>
/// Specify the startup type to be used by the web host.
/// </summary>
/// <param name="hostBuilder">The <see cref="IWebHostBuilder"/> to configure.</param>
/// <typeparam name ="TStartup">The type containing the startup methods for the application.</typeparam>
/// <returns>The <see cref="IWebHostBuilder"/>.</returns>
public static IWebHostBuilder UseStartup<TStartup>(this IWebHostBuilder hostBuilder) where TStartup ： class
{
    return hostBuilder.UseStartup(typeof(TStartup));
}

創建Startup實例

/// <summary>
/// Adds a delegate for configuring additional services for the host or web application. This may be called
/// multiple times.
/// </summary>
/// <param name="configureServices">A delegate for configuring the <see cref="IServiceCollection"/>.</param>
/// <returns>The <see cref="IWebHostBuilder"/>.</returns>
public IWebHostBuilder ConfigureServices(Action<IServiceCollection> configureServices)
{
    if (configureServices == null)
    {
        throw new ArgumentNullException(nameof(configureServices));
    }

    return ConfigureServices((_, services) => configureServices(services));
}

/// <summary>
/// Adds a delegate for configuring additional services for the host or web application. This may be called
/// multiple times.
/// </summary>
/// <param name="configureServices">A delegate for configuring the <see cref="IServiceCollection"/>.</param>
/// <returns>The <see cref="IWebHostBuilder"/>.</returns>
public IWebHostBuilder ConfigureServices(Action<WebHostBuilderContext, IServiceCollection> configureServices)
{
    _configureServices += configureServices;
    return this;
}

關於ConfigureServices的定義及注冊方式，是在IWebHostBuilder.ConfigureServices實現的，同時可以注意一下25行代碼，向大家說明了多次注冊Startup的ConfigureServices方法時，會合並起來的根源。此處抽象委托用的也非常多。

該類里面還有Build方法，我就不貼出代碼了，只需要知道，主進程在此處開始了。接下來一個比較重要的方法，是BuildCommonServices，它向當前ServiceCollection中添加一些公共框架級服務，以下是部分代碼，具體代碼請查看WebHostBuilder。

try
{
    var startupType = StartupLoader.FindStartupType(_options.StartupAssembly, _hostingEnvironment.EnvironmentName);

    if (typeof(IStartup).GetTypeInfo().IsAssignableFrom(startupType.GetTypeInfo()))
    {
        services.AddSingleton(typeof(IStartup), startupType);
    }
    else
    {
        services.AddSingleton(typeof(IStartup), sp =>
        {
            var hostingEnvironment = sp.GetRequiredService<IHostEnvironment>();
            var methods = StartupLoader.LoadMethods(sp, startupType, hostingEnvironment.EnvironmentName);
            return new ConventionBasedStartup(methods);
        });
    }
}
catch (Exception ex)
{
    var capture = ExceptionDispatchInfo.Capture(ex);
    services.AddSingleton<IStartup>(_ =>
    {
        capture.Throw();
        return null;
    });
}

由此可見，如果我們的Startup類直接實現IStartup，它可以並且將直接注冊為IStartup的實現類型。只不過ASP.NET Core模板代碼並沒有實現IStartup，它更多的是一種約定，並通過DI調用委托，依此調用Startup內的構造函數還有另外兩個方法。

同時上述代碼還展示了如何創建Startup類型，就是用到了靜態方法StartupLoader.LoadMethods類生成StartupMethods實例。

ConfigureServices和Configure

當WebHost初始化時，框架會去查找相應的方法，這里，我們主要查看源代碼，其中的核心方法是StartupLoader.FindMethods

private static MethodInfo FindMethod(Type startupType, string methodName, string environmentName, Type returnType = null, bool required = true)
{
    var methodNameWithEnv = string.Format(CultureInfo.InvariantCulture, methodName, environmentName);
    var methodNameWithNoEnv = string.Format(CultureInfo.InvariantCulture, methodName, "");

    var methods = startupType.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static);
    var selectedMethods = methods.Where(method => method.Name.Equals(methodNameWithEnv, StringComparison.OrdinalIgnoreCase)).ToList();
    if (selectedMethods.Count > 1)
    {
        throw new InvalidOperationException(string.Format("Having multiple overloads of method '{0}' is not supported.", methodNameWithEnv));
    }
    if (selectedMethods.Count == 0)
    {
        selectedMethods = methods.Where(method => method.Name.Equals(methodNameWithNoEnv, StringComparison.OrdinalIgnoreCase)).ToList();
        if (selectedMethods.Count > 1)
        {
            throw new InvalidOperationException(string.Format("Having multiple overloads of method '{0}' is not supported.", methodNameWithNoEnv));
        }
    }

    var methodInfo = selectedMethods.FirstOrDefault();
    if (methodInfo == null)
    {
        if (required)
        {
            throw new InvalidOperationException(string.Format("A public method named '{0}' or '{1}' could not be found in the '{2}' type.",
                methodNameWithEnv,
                methodNameWithNoEnv,
                startupType.FullName));

        }
        return null;
    }
    if (returnType != null && methodInfo.ReturnType != returnType)
    {
        if (required)
        {
            throw new InvalidOperationException(string.Format("The '{0}' method in the type '{1}' must have a return type of '{2}'.",
                methodInfo.Name,
                startupType.FullName,
                returnType.Name));
        }
        return null;
    }
    return methodInfo;
}

它查找的第一個委托是ConfigureDelegate，該委托將用於構建應用程序的中間件管道。FindMethod完成了大部分工作，具體的代碼請查看StartupLoader。此方法根據傳遞給它的methodName參數在Startup類中查找響應的方法。

我們知道，Startup的定義更多的是約定，所以會去查找Configure和ConfigureServices。當然，通過源代碼我還知道，除了提供標准的“Configure”方法之外，我們還可以通過環境配置找到響應的Configure和ConfigureServices。根本來說，我們最終查找到的是ConfigureContainerDelegate。

接下來，一個比較重要的方法是LoadMethods

public static StartupMethods LoadMethods(IServiceProvider hostingServiceProvider, Type startupType, string environmentName)
{
    var configureMethod = FindConfigureDelegate(startupType, environmentName);

    var servicesMethod = FindConfigureServicesDelegate(startupType, environmentName);
    var configureContainerMethod = FindConfigureContainerDelegate(startupType, environmentName);

    object instance = null;
    if (!configureMethod.MethodInfo.IsStatic || (servicesMethod != null && !servicesMethod.MethodInfo.IsStatic))
    {
        instance = ActivatorUtilities.GetServiceOrCreateInstance(hostingServiceProvider, startupType);
    }

    // The type of the TContainerBuilder. If there is no ConfigureContainer method we can just use object as it's not
    // going to be used for anything.
    var type = configureContainerMethod.MethodInfo != null ? configureContainerMethod.GetContainerType() : typeof(object);

    var builder = (ConfigureServicesDelegateBuilder) Activator.CreateInstance(
        typeof(ConfigureServicesDelegateBuilder<>).MakeGenericType(type),
        hostingServiceProvider,
        servicesMethod,
        configureContainerMethod,
        instance);

    return new StartupMethods(instance, configureMethod.Build(instance), builder.Build());
}

該方法通過查找對應的方法，由於Startup並未在DI中注冊，所以會調用GetServiceOrCreateInstance創建一個Startup實例，此時構造函數也在此得到解析。

通過一系列的調用，最終到達了ConfigureServicesBuilder.Invoke里面。Invoke方法使用反射來獲取和檢查在Startup類上定義的ConfigureServices方法所需的參數。

private IServiceProvider InvokeCore(object instance, IServiceCollection services)
{
    if (MethodInfo == null)
    {
        return null;
    }

    // Only support IServiceCollection parameters
    var parameters = MethodInfo.GetParameters();
    if (parameters.Length > 1 ||
        parameters.Any(p => p.ParameterType != typeof(IServiceCollection)))
    {
        throw new InvalidOperationException("The ConfigureServices method must either be parameterless or take only one parameter of type IServiceCollection.");
    }

    var arguments = new object[MethodInfo.GetParameters().Length];

    if (parameters.Length > 0)
    {
        arguments[0] = services;
    }

    return MethodInfo.Invoke(instance, arguments) as IServiceProvider;
}

最后我們來看一下ConfigureBuilder類，它需要一個Action<IApplicationBuilder>委托變量，其中包含每個IStartupFilter的一組包裝的Configure方法，最后一個是Startup.Configure方法的委托。此時，所調用的配置鏈首先命中的是AutoRequestServicesStartupFilter.Configure方法。並將該委托鏈作為下一個操作，之后會調用ConventionBasedStartup.Configure方法。這將在其本地StartupMethods對象上調用ConfigureDelegate。

private void Invoke(object instance, IApplicationBuilder builder)
{
    // Create a scope for Configure, this allows creating scoped dependencies
    // without the hassle of manually creating a scope.
    using (var scope = builder.ApplicationServices.CreateScope())
    {
        var serviceProvider = scope.ServiceProvider;
        var parameterInfos = MethodInfo.GetParameters();
        var parameters = new object[parameterInfos.Length];
        for (var index = 0; index < parameterInfos.Length; index++)
        {
            var parameterInfo = parameterInfos[index];
            if (parameterInfo.ParameterType == typeof(IApplicationBuilder))
            {
                parameters[index] = builder;
            }
            else
            {
                try
                {
                    parameters[index] = serviceProvider.GetRequiredService(parameterInfo.ParameterType);
                }
                catch (Exception ex)
                {
                    throw new Exception(string.Format(
                        "Could not resolve a service of type '{0}' for the parameter '{1}' of method '{2}' on type '{3}'.",
                        parameterInfo.ParameterType.FullName,
                        parameterInfo.Name,
                        MethodInfo.Name,
                        MethodInfo.DeclaringType.FullName), ex);
                }
            }
        }
        MethodInfo.Invoke(instance, parameters);
    }
}

Startup.Configure方法會調用ServiceProvider所解析的相應的參數，該方法還可以使用IApplicationBuilder將中間件添加到應用程序管道中。最終的RequestDelegate是從IApplicationBuilder構建並返回的，至此WebHost初始化完成。