[Lähde] ASP.NET Ydin (7) Perusteellinen analyysi kehyksen lähdekoodista

ASP.NET Core (VI) DI saa manuaalisesti menetelmän objektien injektioon
https://www.itsvse.com/thread-9595-1-1.html

ASP.NET Core (viisi) perustuu CAP:n hajautettuihin transaktioihin
https://www.itsvse.com/thread-9593-1-1.html

ASP.NET Core(4) -suodatin yhdisti ModelState-mallin validoinnin
https://www.itsvse.com/thread-9589-1-1.html

ASP.NET Core (iii) Luo instansseja dynaamisesti ActivatorUtilitiesin avulla
https://www.itsvse.com/thread-9488-1-1.html

ASP.NET Ydin (2) Käynnistä sovellus uudelleen koodin mukaan
https://www.itsvse.com/thread-9480-1-1.html

ASP.NET Core (1) käyttää Redis-välimuistia
https://www.itsvse.com/thread-9393-1-1.html

asp.net Ydinlähdekoodin osoite
https://www.itsvse.com/thread-9394-1-1.html

julkinen IHost Build()
{
    if (_hostBuilt)
    {
        heitä uusi InvalidOperationException(SR. BuildCalled);
    }
    _hostBuilt = tosi;

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

    return _appServices.GetRequiredService<IHost>();
}

yksityinen IConfiguration _hostConfiguration;
IConfigurationBuilder configBuilder = uusi ConfigurationBuilder()

yksityinen HostingEnvironment _hostingEnvironment;
_hostingEnvironment = uusi HostingEnvironment()
{
    ApplicationName = _hostConfiguration[HostDefaults.ApplicationKey],
    EnvironmentName = _hostConfiguration[HostDefaults.EnvironmentKey] ?? Ympäristöt. Tuotanto,
    ContentRootPath = ResolveContentRootPath(_hostConfiguration[HostDefaults.ContentRootKey], AppContext.BaseDirectory),
};

yksityinen HostBuilderContext _hostBuilderContext;
_hostBuilderContext = uusi HostBuilderContext(Properties)
{
    HostingEnvironment = _hostingEnvironment,
    Konfiguraatio = _hostConfiguration
};

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

var services = uusi ServiceCollection();

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

julkinen asynkroninen tehtävä StartAsync(PeruutusTokenin peruutusToken)
        {
            HostingEventSource.Log.HostStart();

            var serverAddressesFeature = Server.Features.Get<IServerAddressesFeature>();
            var addresses = serverAddressesFeature?. Osoitteet;
            if (addresses != null && !addresses. IsReadOnly && -osoitteet. Lukumäärä == 0)
            {
                var urls = Configuration[WebHostDefaults.ServerUrlsKey];
                if (!string. IsNullOrEmpty(urls))
                {
                    serverAddressesFeature!. PreferHostingUrls = WebHostUtilities.ParseBool(Configuration, WebHostDefaults.PreferHostingUrlsKey);

                    foreach (var-arvo url-osoitteina. Split('; ', StringSplitOptions.RemoveEmptyEntries))
                    {
                        osoitteet. Add(value);
                    }
                }
            }

            RequestDelegate? application = null;

            yritä
            {
                var configure = Options.ConfigureApplication;

                if (configure == null)
                {
                    heitä uusi InvalidOperationException($"Ei sovellusta konfiguroitu. Määritä sovellus IWebHostBuilder.UseStartup, IWebHostBuilder.Configure, tai määritä käynnistyskokoonpano {nameof(WebHostDefaults.StartupAssemblyKey)} kautta web-isäntäkoneen asetus.");
                }

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

                foreach (var-suodatin StartupFilters.Reverse())
                {
                    konfiguroi = suodatin. konfiguroi (konfiguroi);
                }

                configure(builder);

                Rakenna pyyntöputki
                sovellus = rakentaja. Build();
            }
            catch (poikkeus esim.)
            {
                Logger.ApplicationError(ex);

                jos (! Options.WebHostOptions.CaptureStartupErrors)
                {
                    heitto;
                }

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

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

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

            await Server.StartAsync(httpApplication, cancellationToken);

            if (osoitteet != null)
            {
                foreach (VAR-osoite osoitteissa)
                {
                    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 = uusi GenericWebHostBuilder(builder, webHostBuilderOptions);

tämä IWebHostBuilder hostBuilder
if (hostBuilder on ISupportsStartup supportsStartup)
{
    return supportsStartup.UseStartup(startupType);
}

instanssi ?? = ActivatorUtilities.CreateInstance(uusi HostServiceProvider(webHostBuilderContext), startupType);
Konteksti. Properties[_startupKey] = instanssi;

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

sisäinen staattinen ConfigureServicesBuilder FindConfigureServicesDelegate([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Tyyppi startupType, merkkijono environmentName)
        {
            var servicesMethod = FindMethod (startupType, "Configure{0}Services", environmentName, typeof(IServiceProvider), vaaditaan: väärin)
                ?? FindMethod(startupType, "Configure{0}Services", environmentName, typeof(void), vaaditaan: väärin);
            palauttaa uusi ConfigureServicesBuilder(servicesMethod);

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

sisäinen staattinen ConfigureContainerBuilder FindConfigureContainerDelegate([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Tyyppi startupType, merkkijono environmentName)
        {
            var configureMethod = FindMethod(startupType, "Configure{0}Container", environmentName, typeof(void), required: false);
            palauttaa new ConfigureContainerBuilder(configureMethod);
        }

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

sisäinen staattinen ConfigureBuilder FindConfigureDelegate([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Tyyppi startupType, merkkijono ympäristöName)
{
    var configureMethod = FindMethod(startupType, "Configure{0}", environmentName, typeof(void), required: true)!;
    palauttaa new ConfigureBuilder(configureMethod);
}

yksityinen luokka ConfigureBuilder
        {
            public ConfigureBuilder(MethodInfo configure)
            {
                MethodInfo = konfiguroi;
            }

            julkinen MethodInfo MethodInfo { saa; }

            public Action<IApplicationBuilder> Build (objekti-instanssi)
            {
                return (applicationBuilder) => Invoke(instance, applicationBuilder);
            }

            private void Invoke (object instance, IApplicationBuilder builder)
            {
                var serviceProvider = builder. ApplicationServices;
                var parametriInfos = MethodInfo.GetParameters();
                var parameters = new object[parameterInfos.Length];
                kun (var-indeksi = 0; indeksi < parametriInfos.Pituus; indeksi++)
                {
                    var parameterInfo = parameterInfos[index];
                    if (parameterInfo.ParameterType == typeof(IApplicationBuilder))
                    {
                        parametrit[indeksi] = rakentaja;
                    }
                    else
                    {
                        yritä
                        {
                            parameters[index] = serviceProvider.GetRequiredService(parameterInfo.ParameterType);
                        }
                        catch (poikkeus esim.)
                        {
                            heittää uusi InvalidOperationException(
                                Resources.FormatMiddlewareFilter_ServiceResolutionFail(
                                    parameterInfo.ParameterType.FullName,
                                    parameterInfo.Name,
                                    MethodInfo.Name,
                                    MethodInfo.DeclaringType.FullName),
                                ex);
                        }
                    }
                }
                MethodInfo.Invoke (instanssi, parametrit);
            }
        }

/// <summary>
        Käynnistää sovelluksen ja palauttaa tehtävän, joka valmistuu vain, kun token laukaistaan tai sammutus.
        /// </summary>
        <param name="isäntä"> <katso cref="IHost"/> käynnistää.</param>
        <param name="token"> Token, joka laukaisee sammutuksen.</param>
        <returns><see cref="Tehtävä"/>, joka edustaa asynkronista operaatiota.</returns>
        julkinen staattinen asynkroninen tehtävä RunAsync (tämä IHost-isäntä, CancellationToken-token = oletus)
        {
            yritä
            {
                Odota isäntä. StartAsync(token). ConfigureAwait (väärin);

                Odota isäntä. WaitForShutdownAsync(token). ConfigureAwait (väärin);
            }
            vihdoin
            {
                if (isäntä on IAsyncDisposable asyncDisposable)
                {
                    odota asyncDisposable.DisposeAsync(). ConfigureAwait (väärin);
                }
                else
                {
                    isäntä. Dispose();
                }

            }
        }

palveluksia. <IHost>AddSingleton(_ =>
            {
                return new Internal.Host(_appServices,
                    _appServices.GetRequiredService<IHostApplicationLifetime>(),
                    _appServices.GetRequiredService<ILogger<Internal.Host>>(),
                    _appServices.GetRequiredService<IHostLifetime>(),
                    _appServices.GetRequiredService<IOptions<HostOptions>>());
            });

public async Tehtävä StartAsync(CancellationToken cancellationToken = default)
        {
            _logger. Starting();

            käyttäen var combinedCancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _applicationLifetime.ApplicationStopping);
            CancellationToken combinedCancellationToken = combinedCancellationTokenSource.Token;

            odota _hostLifetime.WaitForStartAsync(combinedCancellationToken). ConfigureAwait (väärin);

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

            foreach (IHostedService hostedService vuonna _hostedServices)
            {
                Fire IHostedService.Aloita
                await hostedService.StartAsync(combinedCancellationToken). ConfigureAwait (väärin);

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

            Fire IHostApplicationLifetime.Aloitettu
            _applicationLifetime.NotifyStarted();

            _logger. Started();
        }