[Avots] ASP.NET Core (7) Sistēmas pirmkoda padziļināta analīze

ASP.NET Core (VI) DI manuāli iegūst objektu injicēšanas metodi
https://www.itsvse.com/thread-9595-1-1.html

ASP.NET Core (pieci) ir balstīts uz CAP sadalītajiem darījumiem
https://www.itsvse.com/thread-9593-1-1.html

ASP.NET Core(4) filtra vienotā ModelState modeļa validācija
https://www.itsvse.com/thread-9589-1-1.html

ASP.NET Core (iii) Dinamiski izveidojiet instances, izmantojot ActivatorUtilities
https://www.itsvse.com/thread-9488-1-1.html

ASP.NET kodols (2) Restartējiet lietojumprogrammu pēc koda
https://www.itsvse.com/thread-9480-1-1.html

ASP.NET Core (1) izmanto Redis kešatmiņu
https://www.itsvse.com/thread-9393-1-1.html

asp.net Pamata avota koda adrese
https://www.itsvse.com/thread-9394-1-1.html

publiskais IHost Build()
{
    ja (_hostBuilt)
    {
        izmet jaunu InvalidOperationException(SR. BuildCalled);
    }
    _hostBuilt = patiess;

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

    atgriešanās _appServices.GetRequiredService<IHost>();
}

privāts IConfiguration _hostConfiguration;
IConfigurationBuilder configBuilder = jauns ConfigurationBuilder()

privātā HostingEnvironment _hostingEnvironment;
_hostingEnvironment = jauns HostingEnvironment()
{
    ApplicationName = _hostConfiguration[HostDefaults.ApplicationKey],
    EnvironmentName = _hostConfiguration[HostDefaults.EnvironmentKey] ?? Vide.Ražošana,
    ContentRootPath = ResolveContentRootPath(_hostConfiguration[HostDefaults.ContentRootKey], AppContext.BaseDirectory),
};

privāts HostBuilderContext _hostBuilderContext;
_hostBuilderContext = jauns HostBuilderContext(Properties)
{
    HostingEnvironment = _hostingEnvironment,
    Konfigurācija = _hostConfiguration
};

IConfigurationBuilder configBuilder = jauns ConfigurationBuilder()
                . SetBasePath(_hostingEnvironment.ContentRootPath)
                . AddConfiguration(_hostConfiguration, shouldDisposeConfiguration: true);
_appConfiguration = configBuilder.Build();
            _hostBuilderContext.Konfigurācija = _appConfiguration;

var pakalpojumi = jauns ServiceCollection();

celtnieks. ConfigureServices((konteksts, pakalpojumi) => pakalpojumi. AddHostedService<GenericWebHostService>());

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

            var serverAddressesFeature = Server.Features.Get<IServerAddressesFeature>();
            var adreses = serverAddressesFeature?. Adreses;
            if (adreses != null && !adreses. IsReadOnly && adreses. Skaits == 0)
            {
                var urls = Konfigurācija[WebHostDefaults.ServerUrlsKey];
                ja (!virkne. IsNullOrEmpty(urls))
                {
                    serverAddressesFeature!. PreferHostingUrls = WebHostUtilities.ParseBool(Konfigurācija, WebHostDefaults.PreferHostingUrlsKey);

                    foreach (var vērtība url. Split('; ', StringSplitOptions.RemoveEmptyEntries))
                    {
                        adreses. Pievienot(vērtība);
                    }
                }
            }

            PieprasītDeleģēt? pieteikums = nulle;

            izmēģināt
            {
                var konfigurēt = Options.ConfigureApplication;

                if (konfigurēt == null)
                {
                    Throw new InvalidOperationException($"Nav konfigurēta lietojumprogramma. Lūdzu, norādiet lietojumprogrammu, izmantojot IWebHostBuilder.UseStartup, IWebHostBuilder.Configure, vai norādot startēšanas montāžu, izmantojot {nameof(WebHostDefaults.StartupAssemblyKey)} tīmekļa resursdatora konfigurācija.");
                }

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

                foreach (var filtrs StartupFilters.Reverse())
                {
                    konfigurēt = filtrēt. Konfigurēt(konfigurēt);
                }

                konfigurēt(veidotājs);

                Pieprasījumu konveijera izveide
                lietojumprogramma = celtnieks. Būvēt ();
            }
            nozveja (izņēmums, piemēram)
            {
                Logger.ApplicationError (ex);

                ja (! Options.WebHostOptions.CaptureStartupErrors)
                {
                    mest;
                }

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

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

            var httpApplication = jauns HostingApplication(lietojumprogramma, Logger, DiagnosticListener, HttpContextFactory);

            gaidīt Server.StartAsync(httpApplication, cancellationToken);

            if (adreses != null)
            {
                foreach (var adrese adresēs)
                {
                    LifetimeLogger.ListeningOnAddress(adrese);
                }
            }

            if (Logger.IsEnabled(LogLevel.Debug))
            {
                foreach (var montāža Options.WebHostOptions.GetFinalHostingStartupAssemblies())
                {
                    Logger.StartupAssemblyLoaded(montāža);
                }
            }

            if (Options.HostingStartupExceptions != null)
            {
                foreach (var izņēmums Options.HostingStartupExceptions.InnerExceptions)
                {
                    Logger.HostingStartupAssemblyError(izņēmums);
                }
            }
        }

var webhostBuilder = jauns GenericWebHostBuilder(veidotājs, webHostBuilderOptions);

šis IWebHostBuilder hostBuilder
if (hostBuilder ir ISupportsStartup supportsStartup)
{
    atgriezties atbalstaStartup.UseStartup(startupType);
}

piemērs ?? = ActivatorUtilities.CreateInstance(jauns HostServiceProvider(webHostBuilderContext), startupType);
konteksts. Rekvizīti[_startupKey] = instance;

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

iekšējais statiskais ConfigureServicesBuilder FindConfigureServicesDelegate([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Tips startupType, virkne environmentName)
        {
            var servicesMethod = FindMethod(startupType, "Configure{0}Services", environmentName, typeof(IServiceProvider), required: false)
                ?? FindMethod(startupType, "Configure{0}Services", environmentName, typeof(void), required: false);
            atgriezt jaunu ConfigureServicesBuilder(servicesMethod);

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

iekšējais statiskais ConfigureContainerBuilder FindConfigureContainerDelegate([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Tips startupType, string environmentName)
        {
            var configureMethod = FindMethod(startupType, "Configure{0}Container", environmentName, typeof(void), required: false);
            atgriezt jaunu ConfigureContainerBuilder(configureMethod);
        }

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

iekšējais statiskais ConfigureBuilder FindConfigureDelegate([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Tips startupType, string environmentName)
{
    var configureMethod = FindMethod(startupType, "Configure{0}", environmentName, typeof(void), required: true)!;
    atgriezt jaunu ConfigureBuilder(configureMethod);
}

privātā klase ConfigureBuilder
        {
            publiskais ConfigureBuilder(MethodInfo konfigurēt)
            {
                MethodInfo = konfigurēt;
            }

            public MethodInfo MethodInfo { get; }

            publiskā darbības<IApplicationBuilder> veidošana(objekta instance)
            {
                return (applicationBuilder) => Invoke(instance, applicationBuilder);
            }

            private void Invoke(objekta instance, IApplicationBuilder veidotājs)
            {
                var serviceProvider = veidotājs. Lietojumprogrammu pakalpojumi;
                var parameterInfos = MethodInfo.GetParameters();
                var parametri = jauns objekts[parameterInfos.Length];
                for (var indekss = 0; indekss < parametrsInfos.Length; indekss++)
                {
                    var parameterInfo = parameterInfos[indekss];
                    if (parameterInfo.ParameterType == typeof(IApplicationBuilder))
                    {
                        parametri[indekss] = veidotājs;
                    }
                    citādi
                    {
                        izmēģināt
                        {
                            parameters[index] = serviceProvider.GetRequiredService(parameterInfo.ParameterType);
                        }
                        nozveja (izņēmums, piemēram)
                        {
                            Izmest jaunu InvalidOperationException(
                                Resources.FormatMiddlewareFilter_ServiceResolutionFail (
                                    parametrsInfo.ParameterType.FullName,
                                    parameterInfo.Name,
                                    MethodInfo.Name,
                                    MethodInfo.DeclaringType.FullName),
                                piem.);
                        }
                    }
                }
                MethodInfo.Invoke(instance, parametri);
            }
        }

/// <summary>
        Palaiž lietojumprogrammu un atgriež uzdevumu, kas tiek pabeigts tikai tad, kad tiek aktivizēts marķieris vai aktivizēta izslēgšana.
        /// </summary>
        <param name="host">Palaist <see cref="IHost"/>.</param>
        <param name="token">marķieris, kas aktivizē izslēgšanu.</param>
        <returns><skatīt cref="Uzdevums"/>, kas apzīmē asinhrono darbību.</returns>
        publiskais statiskais asinhronais uzdevums RunAsync(šis IHost resursdators, CancellationToken marķieris = noklusējums)
        {
            izmēģināt
            {
                gaidīt saimnieku. StartAsync(marķieris). ConfigureAwait(nepatiess);

                gaidīt saimnieku. WaitForShutdownAsync(marķieris). ConfigureAwait(nepatiess);
            }
            Noslēgumā
            {
                if (resursdators ir IAsyncDisposable asyncDisposable)
                {
                    gaidiet asyncDisposable.DisposeAsync(). ConfigureAwait(nepatiess);
                }
                citādi
                {
                    saimnieks. Iznīcināt ();
                }

            }
        }

pakalpojumi. AddSingleton<IHost>(_ =>
            {
                atgriezt jaunu Internal.Host(_appServices,
                    _appServices.GetRequiredService<IHostApplicationLifetime>(),
                    _appServices.GetRequiredService<ILogger<Internal.Host>>(),
                    _appServices.GetRequiredService<IHostLifetime>(),
                    _appServices.GetRequiredService<IOptions<HostOptions>>());
            });

public async Task StartAsync(CancellationToken cancellationToken = noklusējums)
        {
            _logger. Sākums();

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

            gaidīt _hostLifetime.WaitForStartAsync(combinedCancellationToken). ConfigureAwait(nepatiess);

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

            foreach (IHostedService hostedService _hostedServices)
            {
                Ugunsgrēks IHostedService.Start
                gaidīt hostedService.StartAsync(combinedCancellationToken). ConfigureAwait(nepatiess);

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

            Ugunsgrēks IHostApplicationLifetime.Started
            _applicationLifetime.PaziņotSākts();

            _logger. Sākts();
        }