[Šaltinis] ASP.NET Core (7) Išsami sistemos šaltinio kodo analizė

ASP.NET Core (VI) DI rankiniu būdu gauna objektų įpurškimo būdą
https://www.itsvse.com/thread-9595-1-1.html

"ASP.NET Core" (penki) yra pagrįstas BŽŪP paskirstytais sandoriais
https://www.itsvse.com/thread-9593-1-1.html

ASP.NET Core(4) filtro vieningas ModelState modelio tikrinimas
https://www.itsvse.com/thread-9589-1-1.html

ASP.NET Core (iii) Dinamiškai kurkite egzempliorius naudodami "ActivatorUtilities"
https://www.itsvse.com/thread-9488-1-1.html

ASP.NET Core (2) Iš naujo paleiskite programą pagal kodą
https://www.itsvse.com/thread-9480-1-1.html

ASP.NET Core (1) naudoja Redis talpyklą
https://www.itsvse.com/thread-9393-1-1.html

asp.net Pagrindinis šaltinio kodo adresas
https://www.itsvse.com/thread-9394-1-1.html

viešasis IHost Build()
{
    jei (_hostBuilt)
    {
        pateikti naują InvalidOperationException(SR. BuildCalled);
    }
    _hostBuilt = teisinga;

    BuildHostConfiguration();
    CreateHostingEnvironment();
    CreateHostBuilderContext();
    BuildAppConfiguration();
    CreateServiceProvider();

    grąžinti _appServices.GetRequiredService<IHost>();
}

privatus IConfiguration _hostConfiguration;
IConfigurationBuilder configBuilder = naujas ConfigurationBuilder()

privatus HostingEnvironment _hostingEnvironment;
_hostingEnvironment = nauja HostingEnvironment()
{
    ApplicationName = _hostConfiguration[HostDefaults.ApplicationKey],
    EnvironmentName = _hostConfiguration[HostDefaults.EnvironmentKey] ?? Aplinkos.Gamyba,
    ContentRootPath = ResolveContentRootPath(_hostConfiguration[HostDefaults.ContentRootKey], AppContext.BaseDirectory),
};

privatus HostBuilderContext _hostBuilderContext;
_hostBuilderContext = naujas HostBuilderContext(Properties)
{
    HostingEnvironment = _hostingEnvironment,
    Konfigūracija = _hostConfiguration
};

IConfigurationBuilder configBuilder = naujas ConfigurationBuilder()
                . SetBasePath(_hostingEnvironment.ContentRootPath)
                . AddConfiguration(_hostConfiguration, shouldDisposeConfiguration: true);
_appConfiguration = configBuilder.Build();
            _hostBuilderContext.Konfigūracija = _appConfiguration;

var paslaugos = naujas ServiceCollection();

statybininkas. ConfigureServices((kontekstas, paslaugos) => paslaugos. AddHostedService<GenericWebHostService>());

public async Task StartAsync(CancellationToken cancellationToken)
        {
            HostingEventSource.Log.HostStart();

            var serverAddressesFeature = Server.Features.Get<IServerAddressesFeature>();
            var addresses = serverAddressesFeature?. Adresai;
            if (adresai != null && !adresai. IsReadOnly && adresai. Skaičius == 0)
            {
                var urls = Konfigūracija[WebHostDefaults.ServerUrlsKey];
                Jei (!eilutė. IsNullOrEmpty(urls))
                {
                    serverAddressesFeature!. PreferHostingUrls = WebHostUtilities.ParseBool(Konfigūracija, WebHostDefaults.PreferHostingUrlsKey);

                    foreach (var reikšmė url. Split('; ', StringSplitOptions.RemoveEmptyEntries))
                    {
                        adresai. Pridėtinė (vertė);
                    }
                }
            }

            RequestDelegate? taikymas = nulinis;

            Pabandykite
            {
                var configure = Options.ConfigureApplication;

                if (konfigūruoti == null)
                {
                    mesti naują InvalidOperationException($"Nesukonfigūruota jokia programa. Nurodykite programą naudodami IWebHostBuilder.UseStartup, IWebHostBuilder.Configure, arba nurodykite paleisties rinkinį per {nameof(WebHostDefaults.StartupAssemblyKey)} žiniatinklio prieglobos konfigūracija.");
                }

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

                foreach (var filtras StartupFilters.Reverse())
                {
                    konfigūruoti = filtras. Konfigūruoti(konfigūruoti);
                }

                konfigūruoti (kūrėjas);

                Užklausų srauto kūrimas
                programa = statybininkas. Statyti ();
            }
            laimikis (išimtis ex)
            {
                Logger.ApplicationError(ex);

                jei (! Options.WebHostOptions.CaptureStartupErrors)
                {
                    mesti;
                }

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

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

            var httpApplication = nauja HostingApplication(programa, Logger, DiagnosticListener, HttpContextFactory);

            laukti Server.StartAsync(httpApplication, cancellationToken);

            if (adresai != null)
            {
                foreach (var adresas adresuose)
                {
                    LifetimeLogger.ListeningOnAddress(adresas);
                }
            }

            if (Logger.IsEnabled(LogLevel.Debug))
            {
                foreach (var asamblėja Options.WebHostOptions.GetFinalHostingStartupAssemblies())
                {
                    Logger.StartupAssemblyLoaded(surinkimas);
                }
            }

            if (Options.HostingStartupExceptions != null)
            {
                foreach (var išimtis Options.HostingStartupExceptions.InnerExceptions)
                {
                    Logger.HostingStartupAssemblyError(išimtis);
                }
            }
        }

var webhostBuilder = naujas GenericWebHostBuilder(kūrėjas, webHostBuilderOptions);

tai IWebHostBuilder hostBuilder
if (hostBuilder yra ISupportsStartup supportsStartup)
{
    grįžti palaikoStartup.UseStartup(startupType);
}

pavyzdys ?? = ActivatorUtilities.CreateInstance(naujas HostServiceProvider(webHostBuilderContext), startupType);
kontekste. Ypatybės[_startupKey] = egzempliorius;

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

vidinis statinis ConfigureServicesBuilder FindConfigureServicesDelegate([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Tipas startupType, string environmentName)
        {
            var servicesMethod = FindMethod(startupType, "Configure{0}Services", environmentName, typeof(IServiceProvider), required: false)
                ?? FindMethod(startupType, "Configure{0}Services", environmentName, typeof(void), būtina: false);
            grąžinti naują ConfigureServicesBuilder(servicesMethod);

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

vidinis statinis ConfigureContainerBuilder FindConfigureContainerDelegate([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Tipas startupType, string environmentName)
        {
            var configureMethod = FindMethod(startupType, "Configure{0}Container", environmentName, typeof(void), required: false);
            grąžinti naują ConfigureContainerBuilder(configureMethod);
        }

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

vidinis statinis ConfigureBuilder FindConfigureDelegate([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Tipas startupType, string environmentName)
{
    var configureMethod = FindMethod(startupType, "Configure{0}", environmentName, typeof(void), required: true)!;
    grąžinti naują ConfigureBuilder(configureMethod);
}

privačios klasės ConfigureBuilder
        {
            viešasis ConfigureBuilder(MethodInfo konfigūruoti)
            {
                MethodInfo = konfigūruoti;
            }

            viešas MethodInfo MethodInfo { gauti; }

            viešasis veiksmo<IApplicationBuilder> kūrimas(objekto egzempliorius)
            {
                return (applicationBuilder) => Invoke(instance, applicationBuilder);
            }

            private void Invoke(objekto egzempliorius, IApplicationBuilder kūrimo priemonė)
            {
                var serviceProvider = kūrėjas. "ApplicationServices";
                var parameterInfos = MethodInfo.GetParameters();
                var parametrai = naujas objektas[parameterInfos.Length];
                for (var indeksas = 0; indekso < parametrasInfos.Length; indeksas++)
                {
                    var parameterInfo = parameterInfos[index];
                    if (parameterInfo.ParameterType == typeof(IApplicationBuilder))
                    {
                        parametrai[indeksas] = kūrėjas;
                    }
                    kitaip
                    {
                        Pabandykite
                        {
                            parameters[index] = serviceProvider.GetRequiredService(parameterInfo.ParameterType);
                        }
                        laimikis (išimtis ex)
                        {
                            mesti naują InvalidOperationException(
                                Resources.FormatMiddlewareFilter_ServiceResolutionFail(
                                    parametrasInfo.ParameterType.FullName,
                                    parameterInfo.Name,
                                    MethodInfo.Name,
                                    MethodInfo.DeclaringType.FullName),
                                ex);
                        }
                    }
                }
                MethodInfo.Invoke(egzempliorius, parametrai);
            }
        }

/// <summary>
        Paleidžia programą ir pateikia užduotį, kuri baigiama tik suaktyvinus atpažinimo ženklą arba suaktyvinus išjungimą.
        /// </summary>
        <param name="host">The <see cref="IHost"/> paleisti.</param>
        <param name="token">Atpažinimo ženklas, skirtas suaktyvinti išjungimą.</param>
        <returns><žr. cref="Užduotis"/>, kuris reiškia asinchroninę operaciją.</returns>
        viešasis statinis asinchroninis Užduotis RunAsync(šis IHost pagrindinis kompiuteris, CancellationToken atpažinimo ženklas = numatytasis)
        {
            Pabandykite
            {
                laukia šeimininko. StartAsync(atpažinimo ženklas). ConfigureAwait(klaidinga);

                laukia šeimininko. WaitForShutdownAsync(atpažinimo ženklas). ConfigureAwait(klaidinga);
            }
            Pabaigoje
            {
                if (pagrindinis kompiuteris yra IAsyncDisposable asyncDisposable)
                {
                    laukti asyncDisposable.DisposeAsync(). ConfigureAwait(klaidinga);
                }
                kitaip
                {
                    šeimininkas. Išmesti();
                }

            }
        }

paslaugų. AddSingleton<IHost>(_ =>
            {
                grąžinti naują Internal.Host(_appServices,
                    _appServices.GetRequiredService<IHostApplicationLifetime>(),
                    _appServices.GetRequiredService<ILogger<Internal.Host>>(),
                    _appServices.GetRequiredService<IHostLifetime>(),
                    _appServices.GetRequiredService<IOptions<HostOptions>>());
            });

public async Task StartAsync(CancellationToken cancellationToken = default)
        {
            _logger. Pradžia();

            naudojant var combinedCancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _applicationLifetime.ApplicationStopping);
            CancellationToken combinedCancellationToken = combinedCancellationTokenSource.Token;

            laukti _hostLifetime.WaitForStartAsync(combinedCancellationToken). ConfigureAwait(klaidinga);

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

            foreach (IHostedService hostedService _hostedServices)
            {
                Gaisras IHostedService.Start
                laukti hostedService.StartAsync(combinedCancellationToken). ConfigureAwait(klaidinga);

                if (hostedService yra BackgroundService backgroundService)
                {
                    _ = HandleBackgroundException(backgroundService);
                }
            }

            Gaisras IHostApplicationLifetime.Started
            _applicationLifetime.PraneštiPradėta();

            _logger. Pradėta();
        }