[Sursă] ASP.NET Core (7) Analiză aprofundată a codului sursă al framework-ului

ASP.NET Core (VI) DI obține manual metoda de injectare a obiectelor
https://www.itsvse.com/thread-9595-1-1.html

ASP.NET Core (cinci) se bazează pe tranzacții distribuite CAP
https://www.itsvse.com/thread-9593-1-1.html

ASP.NET Filtrul Core(4) validare unificată a modelului ModelState
https://www.itsvse.com/thread-9589-1-1.html

ASP.NET Core (iii) Crearea dinamică a instanțelor folosind ActivatorUtilities
https://www.itsvse.com/thread-9488-1-1.html

ASP.NET Nucleu (2) Repornește aplicația prin cod
https://www.itsvse.com/thread-9480-1-1.html

ASP.NET Core (1) folosește cache Redis
https://www.itsvse.com/thread-9393-1-1.html

asp.net Adresa principală a codului sursă
https://www.itsvse.com/thread-9394-1-1.html

Construcția publică IHost()
{
    dacă (_hostBuilt)
    {
        throw new InvalidOperationException(SR. BuildCalled);
    }
    _hostBuilt = adevărat;

    BuildHostConfiguration();
    CreeazăGazdăMediu ();
    CreeazăHostConstructorContext();
    BuildAppConfiguration();
    CreateServiceProvider();

    returnare _appServices.GetRequiredService<IHost>();
}

_hostConfiguration privat de Iconfiguration;
IConfigurationBuilder configBuilder = noul ConfigurationBuilder()

mediu de găzduire privat _hostingEnvironment;
_hostingEnvironment = noul GazdăMediu ()
{
    ApplicationName = _hostConfiguration[HostDefaults.ApplicationKey],
    EnvironmentName = _hostConfiguration[HostDefaults.EnvironmentKey] ?? Medii. Producție,
    ContentRootPath = ResolveContentRootPath(_hostConfiguration[HostDefaults.ContentRootKey], AppContext.BaseDirectory),
};

privat HostBuilderContext _hostBuilderContext;
_hostBuilderContext = noul HostBuilderContext(Properties)
{
    MediuGazdă = _hostingEnvironment,
    Configurație = _hostConfiguration
};

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

var services = noua Colecție de servicii();

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

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

            var serverAddressesFeature = Server.Features.Get<IServerAddressesFeature>();
            var addresses = serverAddressesFeature?. Adrese;
            dacă (adresează != null && !adrese. IsReadOnly & & adrese. Numără == 0)
            {
                var urls = Configuration[WebHostDefaults.ServerUrlsKey];
                if (!string. IsNullOrEmpty(urls))
                {
                    FuncționalitateaAdreseServer!. PreferHostingUrls = WebHostUtilities.ParseBool(Configuration, WebHostDefaults.PreferHostingUrlsKey);

                    Foreach (valoarea var în URL-uri. Split('; ', StringSplitOptions.RemoveEmptyEntrries))
                    {
                        adrese. Adaugă (valoare);
                    }
                }
            }

            RequestDelegate? aplicație = nul;

            încearcă
            {
                var configure = Options.ConfigureApplication;

                if (configure == null)
                {
                    throw new InvalidOperationException($"No application configured. Vă rugăm să specificați o aplicație prin IWebHostBuilder.UseStartup, IWebHostBuilder.Configure sau specificarea asamblării de pornire prin {nameof(WebHostDefaults.StartupAssemblyKey)} în configurația gazdei web.");
                }

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

                foreach (var filter în StartupFilters.Reverse())
                {
                    configure = filtru. Configure(configure);
                }

                configure(builder);

                Construiește pipeline-ul de cereri
                aplicație = constructor. Build();
            }
            catch (excepție ex)
            {
                Logger.ApplicationError(ex);

                dacă (! Opțiuni.WebHostOptions.CaptureStartupErrors)
                {
                    aruncă;
                }

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

                aplicație = ErrorPageBuilder.BuildErrorPageApplication(HostingEnvironment.ContentRootFileProvider, Logger, showDetailedErrors, ex);
            }

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

            await Server.StartAsync(httpApplication, cancellationToken);

            dacă (adresează != nul)
            {
                foreach (adresă var în adrese)
                {
                    LifetimeLogger.ListeningOnAddress (adresă);
                }
            }

            if (Logger.IsEnabled(LogLevel.Debug))
            {
                foreach (var assembly în Options.WebHostOptions.GetFinalHostingStartupAssemblies())
                {
                    Logger.StartupAssemblyLoaded(assembly);
                }
            }

            if (Options.HostingStartupExceptions != null)
            {
                foreach (var exception în Options.HostingStartupExceptions.InnerExceptions)
                {
                    Logger.HostingStartupAssemblyError(exception);
                }
            }
        }

var webhostBuilder = new GenericWebHostBuilder(builder, webHostBuilderOptions);

acest IWebHostBuilder gazdăConstructor
dacă (hostBuilder este ISupportsStartup suportăStartup)
{
    return supportsStartup.UseStartup(startType);
}

instanță ?? = ActivatorUtilities.CreateInstance(noul HostServiceProvider(webHostBuilderContext), startType);
Context. Proprietăți[_startupKey] = instanță;

var configureServicesBuilder = StartupLoader.FindConfigureServicesDelegate(startupType, context. MediuGazdă.NumeÎnconjurător);
                var configureServices = configureServicesBuilder.Build(instance);

intern static ConfigureServicesBuilder FindConfigureServicesDelegate([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Type startType, string environmentName)
        {
            var servicesMethod = FindMethod(startupType, "Configure{0}Services", environmentName, typeof(IServiceProvider), required: false)
                ?? FindMethod(startType, "Configure{0}Services", environmentName, typeof(void), required: false);
            returnează noul ConfigureServicesBuilder(servicesMethod);

var configureContainerBuilder = StartupLoader.FindConfigureContainerDelegate(startupType, context. MediuGazdă.NumeÎnconjurător);

intern static ConfigureContainerBuilder FindConfigureContainerDelegate([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Tip startType, șir environmentName)
        {
            var configureMethod = FindMethod(startupType, "Configure{0}Container", environmentName, typeof(void), required: false);
            return new ConfigureContainerBuilder(configureMethod);
        }

configureBuilder = StartupLoader.FindConfigureDelegate(startupType, context. MediuGazdă.NumeÎnconjurător);

intern static ConfigureBuilder FindConfigureDelegate([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Type startupType, string environmentName)
{
    var configureMethod = FindMethod(startupType, "Configure{0}", environmentName, typeof(void), required: true)!;
    return new ConfigureBuilder(configureMethod);
}

clasa privată ConfigureBuilder
        {
            public ConfigureBuilder(MethodInfo configure)
            {
                MethodInfo = configure;
            }

            public MethodInfo MethodInfo { get; }

            Public<IApplicationBuilder> Action Build (instanță de obiect)
            {
                return (applicationBuilder) => Invoke(instanță, applicationBuilder);
            }

            private void Invoke (instanță de obiect, IApplicationBuilder builder)
            {
                var serviceProvider = builder. Servicii de aplicații;
                var parameterInfos = MethodInfo.GetParameters();
                var parameters = new object[parameterInfos.Length];
                pentru (var index = 0; index < parameterInfos.Length; index++)
                {
                    var parameterInfo = parameterInfos[index];
                    if (parameterInfo.ParameterType == typeof(IApplicationBuilder))
                    {
                        parametri[index] = constructor;
                    }
                    altfel
                    {
                        încearcă
                        {
                            parametri[index] = ServiceProvider.GetRequiredService(parameterInfo.ParameterType);
                        }
                        catch (excepție ex)
                        {
                            throw new InvalidOperationException(
                                Resources.FormatMiddlewareFilter_ServiceResolutionFail(
                                    parameterInfo.ParameterType.FullName,
                                    parameterInfo.Name,
                                    MethodInfo.Name,
                                    MethodInfo.DeclaringType.FullName),
                                ex);
                        }
                    }
                }
                MethodInfo.Invoke(instanță, parametri);
            }
        }

/// <summary>
        Rulează o aplicație și returnează o Sarcină care se finalizează doar când tokenul este declanșat sau când închiderea este declanșată.
        /// </summary>
        <param name="host">The <vezi cref="IHost"/> to run.</param>
        <param name="token">Tokenul care declanșează oprirea.</param>
        <returns><vezi cref="Task"/> care reprezintă operația asincronă.</returns>
        public static async Task RunAsync (this IHost host, CancellationToken token = implicit)
        {
            încearcă
            {
                Așteaptă gazda. StartAsync (token). ConfigureAwait (false);

                Așteaptă gazda. WaitForShutdownAsync(token). ConfigureAwait (false);
            }
            în sfârșit
            {
                if (gazda este IAsyncDisposable asyncDisposable)
                {
                    await asyncDisposable.DisposeAsync(). ConfigureAwait (false);
                }
                altfel
                {
                    gazdă. Elimină();
                }

            }
        }

servicii. <IHost>AddSingleton(_ =>
            {
                returnează noul Intern.Host(_appServices,
                    _appServices.GetRequiredService<IHostApplicationLifetime>(),
                    _appServices.GetRequiredService<ILogger<Internal.Host>>(),
                    _appServices.GetRequiredService<IHostLifetime>(),
                    _appServices.GetRequiredService<IOptions<HostOptions>>());
            });

public async Task StartAsync(CancellationToken cancellationToken = implicit)
        {
            _logger. Starting();

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

            await _hostLifetime.WaitForStartAsync(combinedCancellationToken). ConfigureAwait (false);

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

            foreach (IHostedService găzduit Service în _hostedServices)
            {
                // Fire IHostedService.Start
                await hostedService.StartAsync(combinedCancellationToken). ConfigureAwait (false);

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

            // Fire IHostApplicationLifetime.Started
            _applicationLifetime.NotifyStarted();

            _logger. A început();
        }