[Πηγή] ASP.NET Πυρήνας (7) Σε βάθος ανάλυση του πηγαίου κώδικα πλαισίου

ASP.NET Πυρήνας (VI) Το DI λαμβάνει χειροκίνητα τη μέθοδο έγχυσης αντικειμένων
https://www.itsvse.com/thread-9595-1-1.html

ASP.NET Ο πυρήνας (πέντε) βασίζεται σε κατανεμημένες συναλλαγές της ΚΓΠ
https://www.itsvse.com/thread-9593-1-1.html

ASP.NET Επικύρωση ενοποιημένου μοντέλου ModelState φίλτρου Core(4)
https://www.itsvse.com/thread-9589-1-1.html

ASP.NET Πυρήνας (iii) Δημιουργήστε δυναμικά παρουσίες χρησιμοποιώντας το ActivatorUtilities
https://www.itsvse.com/thread-9488-1-1.html

ASP.NET Πυρήνας (2) Επανεκκινήστε την εφαρμογή με κωδικό
https://www.itsvse.com/thread-9480-1-1.html

Το ASP.NET Core (1) χρησιμοποιεί προσωρινή αποθήκευση Redis
https://www.itsvse.com/thread-9393-1-1.html

asp.net Διεύθυνση πηγαίου κώδικα πυρήνα
https://www.itsvse.com/thread-9394-1-1.html

δημόσιο IHost Build()
{
    αν (_hostBuilt)
    {
        ρίξτε νέο InvalidOperationException(SR. BuildCalled);
    }
    _hostBuilt = αληθές;

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

    επιστροφή _appServices.GetRequiredService<IHost>();
}

ιδιωτική _hostConfiguration απεικόνισης.
IConfigurationBuilder configBuilder = νέο ConfigurationBuilder()

ιδιωτικό HostingEnvironment _hostingEnvironment;
_hostingEnvironment = νέο HostingEnvironment()
{
    ΌνομαΕφαρμογής = _hostConfiguration[HostDefaults.ApplicationKey],
    ΌνομαΠεριβάλλοντος = _hostConfiguration[HostDefaults.EnvironmentKey] ?? Περιβάλλοντα.Παραγωγή,
    ContentRootPath = ResolveContentRootPath(_hostConfiguration[HostDefaults.ContentRootKey], AppContext.BaseDirectory),
};

ιδιωτικό HostBuilderContext _hostBuilderContext;
_hostBuilderContext = νέο HostBuilderContext(Ιδιότητες)
{
    Περιβάλλον φιλοξενίας = _hostingEnvironment,
    Διαμόρφωση = _hostConfiguration
};

IConfigurationBuilder configBuilder = νέο ConfigurationBuilder()
                . SetBasePath(_hostingEnvironment.ΔιαδρομήΡίζαςΠεριεχομένου)
                . AddConfiguration(_hostConfiguration, shouldDisposeConfiguration: true);
_appConfiguration = configBuilder.Build();
            _hostBuilderContext.Διαμόρφωση = _appConfiguration;

var services = νέα ServiceCollection();

οικοδόμος. ConfigureServices((context, services) => services. AddHostedService<GenericWebHostService>());

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

            var serverAddressesFeature = Server.Features.Get<IServerAddressesFeature>();
            var addresses = serverAddressesFeature?. Διευθύνσεις;
            if (διευθύνσεις != null &&& !addresses. IsReadOnly & διευθύνσεις. Πλήθος == 0)
            {
                var urls = Διαμόρφωση[WebHostDefaults.ServerUrlsKey];
                αν (!string. IsNullOrEmpty(urls))
                {
                    serverAddressesFeature!. PreferHostingUrls = WebHostUtilities.ParseBool(Διαμόρφωση, WebHostDefaults.PreferHostingUrlsKey);

                    foreach (τιμή var σε διευθύνσεις URL. Split('; ', StringSplitOptions.RemoveEmptyEntries))
                    {
                        διευθύνσεις. Add(τιμή);
                    }
                }
            }

            ΑίτημαΑντιπρόσωπος; εφαρμογή = null;

            Δοκιμάστε
            {
                var configure = Επιλογές.ΔιαμόρφωσηΕφαρμογή;

                αν (διαμόρφωση == null)
                {
                    ρίξτε νέο InvalidOperationException($"Δεν έχει ρυθμιστεί η εφαρμογή. Προσδιορίστε μια εφαρμογή μέσω των IWebHostBuilder.UseStartup, IWebHostBuilder.Configure ή καθορίζοντας τη συγκρότηση εκκίνησης μέσω του {nameof(WebHostDefaults.StartupAssemblyKey)} στο διαμόρφωση του κεντρικού υπολογιστή ιστού.");
                }

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

                foreach (φίλτρο var στο StartupFilters.Reverse())
                {
                    configure = φίλτρο. Ρύθμιση παραμέτρων(διαμόρφωση);
                }

                configure(κατασκευαστής);

                Δημιουργία της διοχέτευσης αίτησης
                εφαρμογή = οικοδόμος. Build();
            }
            αλιεύματα (Εξαίρεση π.χ.)
            {
                Logger.ApplicationError(π.χ.);

                αν (! Options.WebHostOptions.CaptureStartupErrors)
                {
                    ρίζω;
                }

                var showDetailedErrors = HostingEnvironment.IsDevelopment() || Επιλογές.WebHostOptions.DetailedErrors;

                εφαρμογή = ErrorPageBuilder.BuildErrorPageApplication(HostingEnvironment.ContentRootFileProvider, Καταγραφέας, showDetailedErrors, π.χ.);
            }

            var httpApplication = νέα HostingApplication(application, Logger, DiagnosticListener, HttpContextFactory);

            περιμένετε Server.StartAsync(httpApplication, cancellationToken);

            if (διευθύνσεις != null)
            {
                foreach (διεύθυνση var στις διευθύνσεις)
                {
                    LifetimeLogger.ListeningOnAddress(διεύθυνση);
                }
            }

            αν (Logger.IsEnabled(LogLevel.Debug))
            {
                foreach (var assembly στο Options.WebHostOptions.GetFinalHostingStartupAssemblies())
                {
                    Logger.StartupAssemblyLoaded(συναρμολόγηση);
                }
            }

            αν (Options.HostingStartupExceptions != null)
            {
                foreach (εξαίρεση var στο Options.HostingStartupExceptions.InnerExceptions)
                {
                    Logger.HostingStartupAssemblyError(εξαίρεση);
                }
            }
        }

var webhostBuilder = νέο GenericWebHostBuilder(κατασκευαστής, webHostBuilderOptions);

αυτό το IWebHostBuilder hostBuilder
if (το hostBuilder είναι ISupportsStartup supportsStartup)
{
    return supportsStartup.UseStartup(startupType);
}

παράδειγμα ?? = ActivatorUtilities.CreateInstance(νέο HostServiceProvider(webHostBuilderContext), startupType);
πλαίσιο. Ιδιότητες[_startupKey] = στιγμιότυπο;

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

εσωτερική στατική ConfigureServicesBuilder FindConfigureServicesDelegate([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Πληκτρολογήστε startupType, συμβολοσειρά environmentName)
        {
            var servicesMethod = FindMethod(startupType; "Configure{0}Services", environmentName, typeof(IServiceProvider); required: false)
                ?? FindMethod(startupType; "Configure{0}Services", environmentName, typeof(void), απαιτείται: false);
            επιστροφή νέου ConfigureServicesBuilder(servicesMethod);

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

εσωτερική στατική ConfigureContainerBuilder FindConfigureContainerDeleggate([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Τύπος startupType, συμβολοσειρά environmentName)
        {
            var configureMethod = FindMethod(startupType, "Configure{0}Container", environmentName, typeof(void), απαιτείται: false);
            επιστροφή νέου ConfigureContainerBuilder(configureMethod);
        }

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

εσωτερική στατική ConfigureBuilder FindConfigureDelegate([DynamicallyAccessedMembers(StartupLinkerOptions.Accessibility)] Τύπος startupType, συμβολοσειρά environmentName)
{
    var configureMethod = FindMethod(startupType, "Configure{0}", environmentName, typeof(void), required: true)!;
    επιστροφή νέου ConfigureBuilder(configureMethod);
}

ιδιωτική τάξη ConfigureBuilder
        {
            public ConfigureBuilder(Ρύθμιση παραμέτρων MethodInfo)
            {
                MethodInfo = διαμόρφωση;
            }

            public MethodInfo MethodInfo { get; }

            public Action<IApplicationBuilder> Build(παρουσία αντικειμένου)
            {
                return (applicationBuilder) => Invoke(instance, applicationBuilder);
            }

            private void Invoke(παρουσία αντικειμένου, IApplicationBuilder builder)
            {
                var serviceProvider = οικοδόμος. Υπηρεσίες εφαρμογών;
                var parameterInfos = MethodInfo.GetParameters();
                var παράμετροι = νέο αντικείμενο[parameterInfos.Length];
                για (δείκτης var = 0; δείκτης < παράμετροςInfos.Length; ευρετήριο++)
                {
                    var parameterInfo = parameterInfos[index];
                    if (parameterInfo.ParameterType == typeof(IApplicationBuilder))
                    {
                        parameters[index] = οικοδόμος;
                    }
                    αλλιώς
                    {
                        Δοκιμάστε
                        {
                            παράμετροι[index] = serviceProvider.GetRequiredService(parameterInfo.ParameterType);
                        }
                        αλιεύματα (Εξαίρεση π.χ.)
                        {
                            ρίξε νέο InvalidOperationException(
                                Resources.FormatMiddlewareFilter_ServiceResolutionFail(
                                    παράμετροςInfo.ParameterType.FullName,
                                    parameterInfo.Name,
                                    MethodInfo.Name,
                                    MethodInfo.DeclaringType.FullName),
                                πρώην);
                        }
                    }
                }
                MethodInfo.Invoke(στιγμιότυπο, παράμετροι);
            }
        }

/// <summary>
        Εκτελεί μια εφαρμογή και επιστρέφει μια εργασία που ολοκληρώνεται μόνο όταν ενεργοποιείται το διακριτικό ή ενεργοποιείται ο τερματισμός λειτουργίας.
        /// </summary>
        <param name="host">Το <see cref="IHost"/> να εκτελεστεί.</param>
        <param name="token">Το διακριτικό για την ενεργοποίηση του τερματισμού λειτουργίας.</param>
        <returns>Το <see cref="Task"/> που αντιπροσωπεύει την ασύγχρονη λειτουργία.</returns>
        δημόσια στατική ασύγχρονη εργασία RunAsync(αυτός ο κεντρικός υπολογιστής IHost, διακριτικό CancellationToken = προεπιλογή)
        {
            Δοκιμάστε
            {
                περιμένουν τον οικοδεσπότη. StartAsync(διακριτικό). ConfigureAwait(false);

                περιμένουν τον οικοδεσπότη. WaitForShutdownAsync(διακριτικό). ConfigureAwait(false);
            }
            Τελικά
            {
                if (ο κεντρικός υπολογιστής είναι IAsyncDisposable asyncDisposable)
                {
                    wait asyncDisposable.DisposeAsync(). ConfigureAwait(false);
                }
                αλλιώς
                {
                    οικοδεσπότης. Απόρριψη();
                }

            }
        }

υπηρεσιών. AddSingleton<IHost>(_ =>
            {
                επιστροφή νέου Internal.Host(_appServices,
                    _appServices.GetRequiredService<IHostApplicationLifetime>(),
                    _appServices.GetRequiredService<ILogger<Internal.Host>>(),
                    _appServices.GetRequiredService<IHostLifetime>(),
                    _appServices.GetRequiredService<IOptions<HostOptions>>());
            });

public async Task StartAsync(CancellationToken cancellationToken = προεπιλογή)
        {
            _logger. Έναρξη();

            χρησιμοποιώντας var combinedCancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _applicationLifetime.ApplicationStopping);
            CancellationToken combinedCancellationToken = combinedCancellationTokenSource.Token;

            περιμένετε _hostLifetime.WaitForStartAsync(combinedCancellationToken). ConfigureAwait(false);

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

            foreach (IHostedService hostedService in _hostedServices)
            {
                Πυρκαγιά IHostedService.Έναρξη
                await hostedService.StartAsync(combinedCancellationToken). ConfigureAwait(false);

                if (hostedService είναι BackgroundService backgroundService)
                {
                    _ = HandleBackgroundException(backgroundService);
                }
            }

            Πυρκαγιά IHostApplicationLifetime.Started
            _applicationLifetime.NotifyStarted();

            _logger. Started();
        }