[Kilde] ASP.NET Kjerne (7) Grundig analyse av rammeverkets kildekode

ASP.NET Core (VI) DI henter manuelt metoden for å injisere objekter
https://www.itsvse.com/thread-9595-1-1.html

ASP.NET Core (fem) er basert på CAP-distribuerte transaksjoner
https://www.itsvse.com/thread-9593-1-1.html

ASP.NET Core(4)-filteret enhetlig ModelState-modellvalidering
https://www.itsvse.com/thread-9589-1-1.html

ASP.NET Core (iii) Opprett instanser dynamisk ved hjelp av ActivatorUtilities
https://www.itsvse.com/thread-9488-1-1.html

ASP.NET Core (2) Start applikasjonen på nytt via kode
https://www.itsvse.com/thread-9480-1-1.html

ASP.NET Core (1) bruker Redis-caching
https://www.itsvse.com/thread-9393-1-1.html

asp.net Kjernekildekodeadresse
https://www.itsvse.com/thread-9394-1-1.html

offentlig IHost Build()
{
    hvis (_hostBuilt)
    {
        kast ny InvalidOperationException(SR. BuildCalled);
    }
    _hostBuilt = sant;

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

    returner _appServices.GetRequiredService<IHost>();
}

privat IConfiguration _hostConfiguration;
IConfigurationBuilder configBuilder = ny ConfigurationBuilder()

privat HostingEnvironment _hostingEnvironment;
_hostingEnvironment = nytt HostingEnvironment()
{
    ApplicationName = _hostConfiguration[HostDefaults.ApplicationKey],
    EnvironmentName = _hostConfiguration[HostDefaults.EnvironmentKey] ?? Miljøer. Produksjon,
    ContentRootPath = ResolveContentRootPath(_hostConfiguration[HostDefaults.ContentRootKey], AppContext.BaseDirectory),
};

privat HostBuilderContext _hostBuilderContext;
_hostBuilderContext = ny HostBuilderContext(Properties)
{
    HostingEnvironment = _hostingEnvironment,
    Konfigurasjon = _hostConfiguration
};

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

var services = ny ServiceCollection();

Byggmester. ConfigureServices((context, services) => services. AddHostedService<GenericWebHostService>());

offentlig asynkron OppgavestartAsync (CancellationToken cancellationToken)
        {
            HostingEventSource.Log.HostStart();

            var serverAddressesFeature = Server.Features.Get<IServerAddressesFeature>();
            var addresses = serverAddressesFeature?. Adresser;
            hvis (adresser != null && !adresser. IsReadOnly && adresser. Antall == 0)
            {
                var urls = Configuration[WebHostDefaults.ServerUrlsKey];
                hvis (!streng. IsNullOrEmpty(urls))
                {
                    serverAddressesFeature!. PreferHostingUrls = WebHostUtilities.ParseBool(Configuration, WebHostDefaults.PreferHostingUrlsKey);

                    foreach (VAR-verdi i URL-er. Split('; ', StringSplitOptions.RemoveEmptyEntries))
                    {
                        adresser. Add(verdi);
                    }
                }
            }

            RequestDelegate? anvendelse = null;

            Prøv
            {
                var configure = Options.ConfigureApplication;

                hvis (konfigurer == null)
                {
                    kast ny InvalidOperationException($"Ingen applikasjon konfigurert. Vennligst spesifiser en applikasjon via IWebHostBuilder.UseStartup, IWebHostBuilder.Configure, eller spesifiser oppstartsassemblen via {nameof(WebHostDefaults.StartupAssemblyKey)} i konfigurasjon av webvert.");
                }

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

                foreach (var filter i StartupFilters.Reverse())
                {
                    Konfigurer = Filter. Konfigurer (konfigurerer);
                }

                konfigurere(bygger);

                Bygg forespørselspipelinen
                Applikasjon = bygger. Build();
            }
            catch (Unntak f.eks.)
            {
                Logger.ApplicationError(f.eks);

                hvis (! Options.WebHostOptions.CaptureStartupErrors)
                {
                    kaste;
                }

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

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

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

            await Server.StartAsync(httpApplication, cancellationToken);

            hvis (adresser != null)
            {
                Foreach (VAR-adresse i adresser)
                {
                    LifetimeLogger.ListeningOnAddress(adresse);
                }
            }

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

            hvis (Options.HostingStartupExceptions != null)
            {
                foreach (var-unntak i Options.HostingStartupExceptions.InnerExceptions)
                {
                    Logger.HostingStartupAssemblyError(unntak);
                }
            }
        }

var webhostBuilder = ny GenericWebHostBuilder(builder, webHostBuilderOptions);

denne IWebHostBuilder hostBuilder
hvis (hostBuilder er ISupportsStartup støtterStartup)
{
    return supportsStartup.UseStartup(startupType);
}

Instans ?? = ActivatorUtilities.CreateInstance(ny HostServiceProvider(webHostBuilderContext), startupType);
Kontekst. Egenskaper[_startupKey] = instans;

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

intern statisk ConfigureServicesBuilder FinnConfigureServicesDelegate([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Skriv startupType, streng miljøNavn)
        {
            var servicesMethod = FindMethod(startupType, "Configure{0}Services", environmentName, typeof(IServiceProvider), krevd: false)
                ?? FindMethod(startupType, "Configure{0}Services", environmentName, typeof(void), påkrevd: false);
            returner ny ConfigureServicesBuilder(servicesMethod);

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

intern statisk ConfigureContainerBuilder FinnConfigureContainerDelegate([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Type startupType, string miljøNavn)
        {
            var configureMethod = FindMethod(startupType, "Configure{0}Container", environmentName, typeof(void), required: false);
            returner ny ConfigureContainerBuilder(configureMethod);
        }

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

intern statisk ConfigureBuilder FinnConfigureDelegate([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Skriv startupType, strengmiljøNavn)
{
    var configureMethod = FindMethod(startupType, "Configure{0}", environmentName, typeof(void), kreves: true)!;
    returnere ny ConfigureBuilder(configureMethod);
}

privat klasse ConfigureBuilder
        {
            offentlig ConfigureBuilder(MethodInfo configure)
            {
                MethodInfo = konfigurere;
            }

            public MethodInfo MethodInfo { get; }

            offentlig Action<IApplicationBuilder> Build (objektinstans)
            {
                return (applicationBuilder) => Invoke (instans, applicationBuilder);
            }

            privat void Invoke (objektinstans, IApplicationBuilder builder)
            {
                var serviceProvider = builder. applikasjonstjenester;
                var parameterInfos = MethodInfo.GetParameters();
                var-parametere = nytt objekt[parameterInfos.Length];
                for (var-indeks = 0; indeks < parameterInfos.Lengde; indeks++)
                {
                    var parameterInfo = parameterInfos[index];
                    hvis (parameterInfo.ParameterType == typeof(IApplicationBuilder))
                    {
                        parametere[indeks] = bygger;
                    }
                    ellers
                    {
                        Prøv
                        {
                            parameters[index] = serviceProvider.GetRequiredService(parameterInfo.ParameterType);
                        }
                        catch (Unntak f.eks.)
                        {
                            kast ny InvalidOperationException(
                                Resources.FormatMiddlewareFilter_ServiceResolutionFail(
                                    parameterInfo.ParameterType.FullName,
                                    parameterInfo.Name,
                                    MethodInfo.Name,
                                    MethodInfo.DeclaringType.FullName),
                                f.eks.);
                        }
                    }
                }
                MethodInfo.Invoke(instans, parametere);
            }
        }

/// <summary>
        Kjører en applikasjon og returnerer en oppgave som kun fullføres når tokenet utløses eller nedstengning utløses.
        /// </summary>
        <param name="host"><se cref="IHost"/> å kjøre.</param>
        <param name="token">Tokenen som utløser nedstengning.</param>
        <returns><se cref="Oppgave"/> som representerer den asynkrone operasjonen.</returns>
        offentlig statisk asynkron Task RunAsync (denne IHost-verten, CancellationToken token = standard)
        {
            Prøv
            {
                Vent på vert. StartAsync (token). ConfigureAwait (falsk);

                Vent på vert. WaitForShutdownAsync(token). ConfigureAwait (falsk);
            }
            Endelig
            {
                hvis (verten er IAsyncDisposable asyncDisposable)
                {
                    await asyncDisposable.DisposeAsync(). ConfigureAwait (falsk);
                }
                ellers
                {
                    vert. Dispone();
                }

            }
        }

tjenester. AddSingleton<IHost>(_ =>
            {
                returner ny intern. Vert(_appServices,
                    _appServices.GetRequiredService<IHostApplicationLifetime>(),
                    _appServices.GetRequiredService<ILogger<Internal.Host>>(),
                    _appServices.GetRequiredService<IHostLifetime>(),
                    _appServices.GetRequiredService<IOptions<HostOptions>>());
            });

offentlig asynkron OppgavestartAsynk (CancellationToken cancellationToken = standard)
        {
            _logger. Start();

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

            vent _hostLifetime.WaitForStartAsync(combinedCancellationToken). ConfigureAwait (falsk);

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

            foreach (IHostedService hostet Service i _hostedServices)
            {
                Brann IHostedService.Start
                await hostedService.StartAsync(combinedCancellationToken). ConfigureAwait (falsk);

                hvis (hostedService er BackgroundService backgroundService)
                {
                    _ = HandleBackgroundException(backgroundService);
                }
            }

            Fire IHostApplicationLifetime.Startet
            _applicationLifetime. NotifyStarted();

            _logger. Start();
        }