[출처] ASP.NET 핵심 (7) 프레임워크 소스 코드에 대한 심층 분석

ASP.NET 코어(VI) DI는 객체 주입 방식을 수동으로 획득합니다
https://www.itsvse.com/thread-9595-1-1.html

ASP.NET 코어(다섯 개)는 CAP 분산 트랜잭션을 기반으로 합니다
https://www.itsvse.com/thread-9593-1-1.html

ASP.NET 코어(4) 필터 통합 모델스테이트 모델 검증
https://www.itsvse.com/thread-9589-1-1.html

ASP.NET 코어 (iii) ActivatorUtilities를 사용하여 동적으로 인스턴스를 생성합니다
https://www.itsvse.com/thread-9488-1-1.html

ASP.NET 코어 (2) 코드로 애플리케이션을 재시작함
https://www.itsvse.com/thread-9480-1-1.html

ASP.NET 코어(1)는 Redis 캐싱을 사용합니다
https://www.itsvse.com/thread-9393-1-1.html

asp.net 코어 소스 코드 주소
https://www.itsvse.com/thread-9394-1-1.html

공개 IHost 빌드()
{
    만약 (_hostBuilt)
    {
        새로운 InvalidOperationException(SR. BuildCalled);
    }
    _hostBuilt = 참;

    BuildHostConfiguration();
    호스팅 환경 만들기();
    CreateHostBuilderContext();
    BuildAppConfiguration();
    CreateServiceProvider();

    return _appServices.GetRequiredService<IHost>();
}

개인 아이콘 피규_hostConfiguration;
IConfigurationBuilder configBuilder = new ConfigurationBuilder()

private HostingEnvironment _hostingEnvironment;
_hostingEnvironment = 새로운 호스팅환경()
{
    ApplicationName = _hostConfiguration[HostDefaults.ApplicationKey],
    EnvironmentName = _hostConfiguration[HostDefaults.EnvironmentKey] ?? 환경.프로덕션,
    ContentRootPath = ResolveContentRootPath(_hostConfiguration[HostDefaults.ContentRootKey], AppContext.BaseDirectory),
};

private HostBuilderContext _hostBuilderContext;
_hostBuilderContext = new HostBuilderContext(Properties)
{
    HostingEnvironment = _hostingEnvironment,
    구성 = _hostConfiguration
};

IConfigurationBuilder configBuilder = new ConfigurationBuilder()
                . SetBasePath(_hostingEnvironment.ContentRootPath)
                . AddConfiguration(_hostConfiguration, shouldDisposeConfiguration: true);
_appConfiguration = configBuilder.Build();
            _hostBuilderContext.Configuration = _appConfiguration;

var services = new ServiceCollection();

건축가. ConfigureServices((맥락, 서비스) => 서비스. AddHostedService<GenericWebHostService>());

공개 비동기 작업 시작(CancellationToken cancellationToken)
        {
            HostingEventSource.Log.HostStart();

            var serverAddressesFeature = <IServerAddressesFeature>Server.Features.Get();
            var addresses = serverAddressesFeature?. 주소;
            만약 (addresses != null & !addresses. IsReadOnly & 주소. 카운트 == 0)
            {
                var urls = Configuration[WebHostDefaults.ServerUrlsKey];
                만약 (!string. IsNullOrEmpty(urls))
                {
                    서버주소기능!. PreferHostingUrls = WebHostUtilities.ParseBool(Configuration, WebHostDefaults.PreferHostingUrlsKey);

                    foreach(URL의 var 값. 스플릿('; ', StringSplitOptions.RemoveEmptyEntrys))
                    {
                        주소들. 더하기(가치);
                    }
                }
            }

            요청 위임? application = null;

            시도해
            {
                var configure = Options.ConfigureApplication;

                if (구성 == null)
                {
                    throw new InvalidOperationException($"No application configured. IWebHostBuilder.UseStartup, IWebHostBuilder.Configure, 또는 {nameof(WebHostDefaults.StartupAssemblyKey)}에서 시작 어셈블리를 지정하여 애플리케이션을 지정해 주세요. 웹 호스트 구성.");
                }

                var builder = ApplicationBuilderFactory.CreateBuilder(Server.Features);

                foreach (StartupFilters.Reverse()의 var 필터)
                {
                    구성 = 필터. 구성(구성);
                }

                구성(건축가);

                요청 파이프라인을 구축하세요
                응용 = 건축가. Build();
            }
            catch (예외 예)
            {
                Logger.ApplicationError(ex);

                만약 (! Options.WebHostOptions.CaptureStartupErrors)
                {
                    던지기;
                }

                var showDetailedErrors = HostingEnvironment.IsDevelopment() || Options.WebHostOptions.DetailedErrors;

                application = ErrorPageBuilder.BuildErrorPageApplication(HostingEnvironment.ContentRootFileProvider, Logger, showDetailedErrors, ex);
            }

            var httpApplication = new HostingApplication(application, Logger, DiagnosticListener, HttpContextFactory);

            wait, Server.StartAsync(httpApplication, cancellationToken);

            만약 (addresses != null)
            {
                foreach (주소 내 var 주소)
                {
                    LifetimeLogger.ListeningOnAddress(address);
                }
            }

            if (Logger.IsEnabled(LogLevel.Debug))
            {
                foreach (var assembly in Options.WebHostOptions.GetFinalHostingStartupAssemblies())
                {
                    Logger.StartupAssemblyLoaded(assembly);
                }
            }

            if (Options.HostingStartupExceptions != null)
            {
                foreach (var exception in Options.HostingStartupExceptions.InnerExceptions)
                {
                    Logger.HostingStartupAssemblyError(exception);
                }
            }
        }

var webhostBuilder = new GenericWebHostBuilder(builder, webHostBuilderOptions);

이 IWebHostBuilder 호스트빌더
if(hostBuilder는 ISupportsStartup supportsStartup입니다)
{
    return supportsStartup.UseStartup(startupType);
}

인스턴스 ?? = ActivatorUtilities.CreateInstance(new HostServiceProvider(webHostBuilderContext), startupType);
맥락. 속성[_startupKey] = 인스턴스;

var configureServicesBuilder = StartupLoader.FindConfigureServicesDelegate(startupType, context. HostingEnvironment.EnvironmentName);
                var configureServices = configureServicesBuilder.Build(instance);

internal static ConfigureServicesBuilder FindConfigureServicesDelegate([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Type startupTypeType, string environmentName)
        {
            var servicesMethod = FindMethod(startupType, "Configure{0}Services", environmentName, typeof(IServiceProvider), required: false)
                ?? FindMethod(startupType, "Configure{0}Services", environmentName, typeof(void), 필수: false);
            새 ConfigureServicesBuilder(servicesMethod)를 반환;

var configureContainerBuilder = StartupLoader.FindConfigureContainerDelegate(startupType, context. HostingEnvironment.EnvironmentName);

내부 정적 ConfigureContainerBuilder FindConfigureContainerDelegate([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Type startupTypeType, string environmentName)
        {
            var configureMethod = FindMethod(startupType, "Configure{0}Container", environmentName, typeof(void), required: false);
            return new ConfigureContainerBuilder(configureMethod);
        }

configureBuilder = StartupLoader.FindConfigureDelegate(startupType, context. HostingEnvironment.EnvironmentName);

내부 정적 ConfigureBuilder FindConfigureDelegate([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] 유형 startupType, string environmentName)
{
    var configureMethod = FindMethod(startupType, "Configure{0}", environmentName, typeof(void), required: true)!;
    새 ConfigureBuilder(configureMethod)를 반환;
}

개인 클래스 ConfigureBuilder
        {
            public ConfigureBuilder(MethodInfo configure)
            {
                MethodInfo = configure;
            }

            public MethodInfo MethodInfo { get; }

            public Action<IApplicationBuilder> Build(객체 인스턴스)
            {
                return (applicationBuilder) => Invoke(instance, applicationBuilder);
            }

            private void Invoke(object instance, IApplicationBuilder builder)
            {
                var serviceProvider = builder. 애플리케이션서비스;
                var parameterInfos = MethodInfo.GetParameters();
                var parameters = new object[parameterInfos.Length];
                (var 지수 = 0; index < parameterInfos.Length; index++)
                {
                    var parameterInfo = parameterInfos[index];
                    if (parameterInfo.ParameterType == typeof(IApplicationBuilder))
                    {
                        매개변수[index] = 빌더;
                    }
                    그렇지 않으면
                    {
                        시도해
                        {
                            parameters[index] = serviceProvider.GetRequiredService(parameterInfo.ParameterType);
                        }
                        catch (예외 예)
                        {
                            새로운 InvalidOperationException(
                                Resources.FormatMiddlewareFilter_ServiceResolutionFail(
                                    parameterInfo.ParameterType.FullName,
                                    parameterInfo.Name,
                                    MethodInfo.Name,
                                    MethodInfo.DeclaringType.FullName),
                                ex);
                        }
                    }
                }
                MethodInfo.Invoke(인스턴스, 매개변수);
            }
        }

/// <summary>
        애플리케이션을 실행하고, 토큰이 트리거되거나 종료가 발생했을 때만 완료되는 작업을 반환합니다.
        /// </summary>
        <param name="host">The <see cref="IHost"/> 실행 시 사용됩니다.</param>
        <param name="token">종료를 트리거하는 토큰.</param>
        비<returns>동기 연산을 나타내는 <참조 cref="Task"/>.</returns>
        공개 정적 비동기 작업 RunAsync(이 IHost 호스트, CancellationToken 토큰 = 기본값)
        {
            시도해
            {
                주인을 기다려. StartAsync(token). ConfigureAwait(false);

                주인을 기다려. WaitForShutdownAsync(token). ConfigureAwait(false);
            }
            드디어
            {
                만약 (호스트는 IAsyncDisposable asyncDisposable)
                {
                    wait, asyncDisposable.DisposeAsync(). ConfigureAwait(false);
                }
                그렇지 않으면
                {
                    호스트. 처분();
                }

            }
        }

서비스. AddSingleton<IHost>(_ =>
            {
                새 Internal.Host(_appServices,
                    _appServices.GetRequiredService<IHostApplicationLifetime>(),
                    _appServices.GetRequiredService<ILogger<Internal.Host>>(),
                    _appServices.GetRequiredService<IHostLifetime>(),
                    _appServices.GetRequiredService<IOptions<HostOptions>>());
            });

공개 비동기 작업 시작(CancellationToken cancellationToken= default)
        {
            _logger. 스타팅();

            var combinedCancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _applicationLifetime.ApplicationStopping);
            취소토큰 결합 취소토큰 = combinedcancellationTokenSource.Token;

            wait_hostLifetime.WaitForStartAsync(combinedCancellationToken). ConfigureAwait(false);

            combinedCancellationToken.ThrowIfCancellationRequested();
            _hostedServices = Services.GetService<IEnumerable<IHostedService>>();

            foreach (IHostedService 호스팅된 서비스, _hostedServices)
            {
                화재 서비스. 시작
                await hostedService.StartAsync(combinedCancellationToken). ConfigureAwait(false);

                if (hostedService는 BackgroundService backgroundService입니다)
                {
                    _ = HandleBackgroundException(backgroundService);
                }
            }

            해고: IostApplicationLifetime. 시작됨.
            _applicationLifetime.NotifyStarted();

            _logger. 시작();
        }