Post History

One way to do this is to launch a Task at application startup as soon as possible (the DI is configured). The only hard part is to make DI available in the prewarm functionality.

The following implementation is based [on this article](https://anduin.aiursoft.com/post/2020/10/14/fire-and-forget-in-aspnet-core-with-dependency-alive).

```c#
/// <summary>
/// Credit: https://anduin.aiursoft.com/post/2020/10/14/fire-and-forget-in-aspnet-core-with-dependency-alive
/// </summary>
public class FireAndForgetService
{
	private readonly ILogger<FireAndForgetService> _logger;
	private readonly IServiceScopeFactory _scopeFactory;

	public FireAndForgetService(
		ILogger<FireAndForgetService> logger,
		IServiceScopeFactory scopeFactory)
	{
		_logger = logger;
		_scopeFactory = scopeFactory;
	}

	public void Fire<T>(Action<T> bullet, Action<Exception> handler = null)
	{
		_logger.LogInformation("Fired a new action.");
		Task.Run(() =>
		{
			using var scope = _scopeFactory.CreateScope();
			var dependency = scope.ServiceProvider.GetRequiredService<T>();
			try
			{
				bullet(dependency);
			}
			catch (Exception e)
			{
				_logger.LogError(e, "Fire and forget crashed!");
				handler?.Invoke(e);
			}
			finally
			{
				dependency = default;
			}
		});
	}

	public void FireAsync<T>(Func<T, Task> bullet, Action<Exception> handler = null)
	{
		_logger.LogInformation("Fired a new async action.");
		Task.Run(async () =>
		{
			using var scope = _scopeFactory.CreateScope();
			var dependency = scope.ServiceProvider.GetRequiredService<T>();
			try
			{
				await bullet(dependency);
			}
			catch (Exception e)
			{
				_logger.LogError(e, "Cannon crashed!");
				handler?.Invoke(e);
			}
			finally
			{
				dependency = default;
			}
		});
	}
}

// this goes in Startup.ConfigureServices
services.AddSingleton<FireAndForgetService>();

// this goes in Program.cs

private static void PreWarmCache(IServiceProvider services, NLog.Logger _logger)
{
	try
	{
		var cannon = services.GetRequiredService<FireAndForgetService>();

		cannon.FireAsync<IListOfValuesProviderService>(async (lovProvider) =>
		{
			_ = await lovProvider.GetAll<Employee>(default);
		});
	}
	catch (Exception exc)
	{
		// log error
	}
	
}

public async static Task Main(string[] args)
{
	try
	{
		var host = CreateHostBuilder(args).Build();

		using (var scope = host.Services.CreateScope())
		{
			await host.MigrateDatabaseAsync<ApplicationDbContext>();

			var services = scope.ServiceProvider;

			PreWarmCache(services, _logger);
		}

		await host.RunAsync();
	}
	catch (Exception ex)
	{
		// log error
		throw;
	}
}


```

Note that `cannon.FireAsync` is not awaited and it does not block the application startup.