[Quelle] ASP.NET Core (7) Tiefgehende Analyse des Framework-Quellcodes

ASP.NET Core (VI) DI erhält manuell die Methode zum Einschleusen von Objekten
https://www.itsvse.com/thread-9595-1-1.html

ASP.NET Core (fünf) basiert auf CAP-verteilten Transaktionen
https://www.itsvse.com/thread-9593-1-1.html

ASP.NET Core(4)-Filter einheitliche ModelState-Modellvalidierung
https://www.itsvse.com/thread-9589-1-1.html

ASP.NET Core (iii) Erstellen Sie Instanzen dynamisch mit ActivatorUtilities
https://www.itsvse.com/thread-9488-1-1.html

ASP.NET Core (2) Die Anwendung per Code neu starten
https://www.itsvse.com/thread-9480-1-1.html

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

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

öffentlicher IHost Build()
{
    wenn (_hostBuilt)
    {
        Werfe neue InvalidOperationException(SR. BuildCalled);
    }
    _hostBuilt = wahr;

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

    zurückgeben _appServices.GetRequiredService<IHost>();
}

private IConfiguration _hostConfiguration;
IConfigurationBuilder configBuilder = neuer ConfigurationBuilder()

private HostingEnvironment _hostingEnvironment;
_hostingEnvironment = neue HostingEnvironment()
{
    ApplicationName = _hostConfiguration[HostDefaults.ApplicationKey],
    EnvironmentName = _hostConfiguration[HostDefaults.EnvironmentKey] ?? Umgebungen. Produktion,
    ContentRootPath = ResolveContentRootPath(_hostConfiguration[HostDefaults.ContentRootKey], AppContext.BaseDirectory),
};

private HostBuilderContext _hostBuilderContext;
_hostBuilderContext = neuer HostBuilderContext(Properties)
{
    HostingEnvironment = _hostingEnvironment,
    Konfiguration = _hostConfiguration
};

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

var services = neuer ServiceCollection();

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

öffentlich asynchron Task StartAsync(CancellationToken cancellationToken)
        {
            HostingEventSource.Log.HostStart();

            var serverAddressesFeature = Server.Features.Get<IServerAddressesFeature>();
            var addresses = serverAddressesFeature?. Adressen;
            wenn (adressiert != null && !adressen. IsReadOnly && Adressen. Anzahl == 0)
            {
                var urls = Configuration[WebHostDefaults.ServerUrlsKey];
                wenn (!string. IsNullOrEmpty(urls))
                {
                    serverAddressesFeature!. PreferHostingUrls = WebHostUtilities.ParseBool(Konfiguration, WebHostDefaults.PreferHostingUrlsKey);

                    foreach (VAR-Wert in URLs. Split('; ', StringSplitOptions.RemoveEmptyEntries))
                    {
                        Adressen. Add(Value);
                    }
                }
            }

            RequestDelegate? Anwendung = null;

            Versuch es
            {
                var configure = Options.ConfigureApplication;

                wenn (configure == null)
                {
                    neue InvalidOperationException($" Keine Anwendung konfiguriert. Bitte geben Sie eine Anwendung über IWebHostBuilder.UseStartup, IWebHostBuilder.Conconfigure an oder geben Sie die Start-Assembler über {nameof(WebHostDefaults.StartupAssemblyKey)} in der Webhost-Konfiguration.");
                }

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

                foreach (varfilter in StartupFilters.Reverse())
                {
                    konfigurieren = filtern. Konfigurieren(konfigurieren);
                }

                konfigurieren(Bauer);

                Baue die Anfragepipeline
                Anwendung = Bauer. Build();
            }
            catch (Ausnahme z. B.)
            {
                Logger.ApplicationError(ex);

                wenn (! Options.WebHostOptions.CaptureStartupErrors)
                {
                    werfen;
                }

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

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

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

            await Server.StartAsync(httpApplication, cancellationToken);

            wenn (adressiert != null)
            {
                foreach (VAR-Adresse in Adressen)
                {
                    LifetimeLogger.ListeningOnAddress(Adresse);
                }
            }

            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(Ausnahme);
                }
            }
        }

var webhostBuilder = neuer GenericWebHostBuilder(builder, webHostBuilderOptions);

dieser IWebHostBuilder hostBuilder
if (hostBuilder ist ISupportsStartup unterstütztStartup)
{
    return unterstütztStartup.UseStartup(startupType);
}

Instanz ?? = ActivatorUtilities.CreateInstance(neuer HostServiceProvider(webHostBuilderContext), startupType);
Kontext. Eigenschaften[_startupKey] = Instanz;

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

interne statische ConfigureServicesBuilder FindConfigureServicesDelegate([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Geben Sie startupType, String ein environmentName)
        {
            var servicesMethod = FindMethod(startupType, "Configure{0}Services", environmentName, typeof(IServiceProvider), erforderlich: false)
                ?? FindMethod(startupType, "Configure{0}Services", environmentName, typeof(void), erforderlich: false);
            neue ConfigureServicesBuilder(servicesMethod) zurückgeben;

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

interne statische ConfigureContainerBuilder FindConfigureContainerDelegate([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Typ: startupType, String environmentName)
        {
            var configureMethod = FindMethod(startupType, "Configure{0}Container", environmentName, typeof(void), erforderlich: false);
            den neuen ConfigureContainerBuilder (configureMethod) zurückgeben;
        }

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

interne statische ConfigureBuilder FindConfigureDelegate([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Geben Sie startupType, String-environmentName)
{
    var configureMethod = FindMethod(startupType, "Configure{0}", environmentName, typeof(void), erforderlich: true)!;
    gibt neuen ConfigureBuilder (configureMethod) zurück;
}

Privatklasse ConfigureBuilder
        {
            public ConfigureBuilder(MethodInfo configure)
            {
                MethodInfo = konfigurieren;
            }

            public MethodInfo MethodInfo { get; }

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

            private void Invoke (Objektinstanz, IApplicationBuilder builder)
            {
                var serviceProvider = builder. ApplicationServices;
                var parameterInfos = MethodInfo.GetParameters();
                var parameters = neues Objekt[parameterInfos.Length];
                für (Var-Index = 0; Index < parameterInfos.Length; index++)
                {
                    var parameterInfo = parameterInfos[index];
                    wenn (parameterInfo.ParameterType == typeof(IApplicationBuilder))
                    {
                        Parameter[index] = Erbauer;
                    }
                    oder
                    {
                        Versuch es
                        {
                            parameters[index] = serviceProvider.GetRequiredService(parameterInfo.ParameterType);
                        }
                        catch (Ausnahme z. B.)
                        {
                            neue InvalidOperationException(
                                Resources.FormatMiddlewareFilter_ServiceResolutionFail(
                                    parameterInfo.ParameterType.FullName,
                                    parameterInfo.Name,
                                    MethodInfo.Name,
                                    MethodInfo.DeclaringType.FullName),
                                z.B.);
                        }
                    }
                }
                MethodInfo.Invoke (Instanz, Parameter);
            }
        }

/// <summary>
        Führt eine Anwendung aus und gibt eine Aufgabe zurück, die nur abgeschlossen wird, wenn das Token ausgelöst oder das Herunterfahren ausgelöst wird.
        /// </summary>
        <param name="host">Die <siehe cref="IHost"/> zu laufen.</param>
        <param name="token">Der Token zum Auslösen des Shutdowns.</param>
        <returns>Das <siehe cref="Task"/>, das die asynchrone Operation darstellt.</returns>
        öffentlich statisch asynchron Task RunAsync (dieser IHost-Host, CancellationToken = Standard)
        {
            Versuch es
            {
                Warte auf den Gastgeber. StartAsync (Token). ConfigureAwait (falsch);

                Warte auf den Gastgeber. WaitForShutdownAsync(Token). ConfigureAwait (falsch);
            }
            Endlich
            {
                if (Host ist IAsyncDisposable asyncDisposable)
                {
                    await asyncDisposable.DisposeAsync(). ConfigureAwait (falsch);
                }
                oder
                {
                    Host. Entsorgen();
                }

            }
        }

Dienstleistungen. AddSingleton<IHost>(_ =>
            {
                neue Interne.Host(_appServices zurückgeben,
                    _appServices.GetRequiredService<IHostApplicationLifetime>(),
                    _appServices.GetRequiredService<ILogger<Internal.Host>>(),
                    _appServices.GetRequiredService<IHostLifetime>(),
                    _appServices.GetRequiredService<IOptions<HostOptions>>());
            });

public async Task StartAsync(CancellationToken cancellationToken = default)
        {
            _logger. Start();

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

            warten _hostLifetime.WartenForStartAsync(kombinierteCancellationToken). ConfigureAwait (falsch);

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

            foreach (IHostedService hostete Service in _hostedServices)
            {
                Feuer IHostedService.Start
                await hostedService.StartAsync (combinedCancellationToken). ConfigureAwait (falsch);

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

            Feuer IHostApplicationLifetime. Gestartet
            _applicationLifetime.NotifyStarted();

            _logger. Gestartet();
        }