ApplicationBuilderExtensions.cs

Go to the documentation of this file.

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Net;
using System.Threading;
using System.Threading.Tasks;

namespace Cyberboss.AspNetCore.AsyncInitializer
{
    public static class ApplicationBuilderExtensions
    {
        public static void UseAsyncInitialization<TDependency>(this IApplicationBuilder applicationBuilder, Func<TDependency, CancellationToken, Task> asyncInitializer)
        {
            if (applicationBuilder == null)
                throw new ArgumentNullException(nameof(applicationBuilder));
            if (asyncInitializer == null)
                throw new ArgumentNullException(nameof(asyncInitializer));
            
            applicationBuilder.UseAsyncInitialization((cancellationToken) => asyncInitializer(applicationBuilder.ApplicationServices.GetRequiredService<TDependency>(), cancellationToken));
        }

        public static void UseAsyncInitialization(this IApplicationBuilder applicationBuilder, Func<CancellationToken, Task> asyncInitializer)
        {
            if (applicationBuilder == null)
                throw new ArgumentNullException(nameof(applicationBuilder));
            if (asyncInitializer == null)
                throw new ArgumentNullException(nameof(asyncInitializer));

            var applicationLifetime = applicationBuilder.ApplicationServices.GetRequiredService<IApplicationLifetime>();
            Task initializationTask = null;
            var tcs = new TaskCompletionSource<object>();

            async Task AsyncProcess()
            {
                using (applicationBuilder.ApplicationServices.CreateScope())
                    await asyncInitializer(applicationLifetime.ApplicationStopping).ConfigureAwait(false);
            }

            applicationLifetime.ApplicationStarted.Register(() =>
            {
                initializationTask = AsyncProcess();
                tcs.SetResult(null);
            });

            var applicationStopping = applicationLifetime.ApplicationStopping;
            applicationBuilder.Use(async (context, next) =>
            {
                await tcs.Task.ConfigureAwait(false);
                if(!initializationTask.IsCompleted || applicationStopping.IsCancellationRequested)
                {
                    context.Response.StatusCode = (int)HttpStatusCode.ServiceUnavailable;
                    return;
                }
                await initializationTask.ConfigureAwait(false);
                await next().ConfigureAwait(false);
            });
        }
    }
}