In production environments, IIS application pools can recycle for various reasons - memory thresholds, scheduled restarts, or configuration changes. When this happens, your carefully warmed-up ASP.NET MVC application becomes cold again, leading to slow initial responses.

For IIS 8.0 and later, you can leverage the Application Initialization module:

<applicationInitialization 
    remapManagedRequestsTo="~/Warmup.html" 
    skipManagedModules="false">
    <add initializationPage="/Home/Warmup" />
</applicationInitialization>

Configure this in your web.config's <system.webServer> section.

Create a dedicated warm-up endpoint in your MVC application:

public class WarmupController : Controller
{
    public ActionResult Index()
    {
        // Preload critical paths
        var task1 = Task.Run(() => new HomeController().Index());
        var task2 = Task.Run(() => new ProductsController().List());
        
        // Warm up EF context
        using (var db = new ApplicationDbContext())
        {
            db.Database.ExecuteSqlCommand("SELECT 1");
        }
        
        return Content("Application warmed up successfully");
    }
}

Use Application_Start in Global.asax to trigger warm-up:

protected void Application_Start()
{
    AreaRegistration.RegisterAllAreas();
    FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
    RouteConfig.RegisterRoutes(RouteTable.Routes);
    BundleConfig.RegisterBundles(BundleTable.Bundles);
    
    // Trigger warm-up
    Task.Run(() => WarmupApplication());
}

private void WarmupApplication()
{
    try 
    {
        var client = new WebClient();
        client.DownloadString($"{Request.Url.Scheme}://{Request.Url.Authority}/Warmup");
    }
    catch (Exception ex)
    {
        Logger.Error("Warmup failed", ex);
    }
}

Combine warm-up with health checks for better monitoring:

public class HealthCheckController : ApiController
{
    [HttpGet]
    [Route("api/health")]
    public IHttpActionResult Get()
    {
        try
        {
            // Database check
            using (var db = new ApplicationDbContext())
            {
                db.Database.ExecuteSqlCommand("SELECT 1");
            }
            
            // Cache check
            var cache = MemoryCache.Default;
            cache.Set("healthcheck", DateTime.UtcNow, 
                new CacheItemPolicy { SlidingExpiration = TimeSpan.FromMinutes(1) });
                
            return Ok(new { Status = "Healthy", Time = DateTime.UtcNow });
        }
        catch (Exception ex)
        {
            return InternalServerError(ex);
        }
    }
}

For additional protection, set up a scheduled task that hits your warm-up endpoint:

$url = "http://yourapp.com/Warmup"
$interval = New-TimeSpan -Minutes 5

while ($true) {
    try {
        Invoke-WebRequest -Uri $url -UseBasicParsing | Out-Null
        Start-Sleep -Seconds $interval.TotalSeconds
    }
    catch {
        Write-Host "Warmup request failed: $_"
    }
}

When implementing warm-up strategies:

• Limit warm-up duration to avoid timeout issues
• Prioritize critical paths over less important routes
• Consider using async patterns to avoid thread starvation
• Monitor warm-up times to detect degradation

When an IIS application pool recycles (either due to idle timeout, memory thresholds, or scheduled recycling), the next request suffers from the "cold start" penalty. For ASP.NET MVC applications, this means:

• JIT compilation of application assemblies
• Cache repopulation
• Database connection pool warmup
• Initialization of singleton services

Here are three proven techniques to handle automatic warmup after app pool recycling:

1. Application Initialization Module

IIS 8+ includes the Application Initialization module which can be configured in web.config:

<system.webServer>
  <applicationInitialization 
    remapManagedRequestsTo="Startup.htm" 
    skipManagedModules="false">
    <add initializationPage="/Warmup" />
  </applicationInitialization>
</system.webServer>

Create a dedicated warmup controller:

public class WarmupController : Controller
{
    [HttpGet]
    public ActionResult Index()
    {
        // Warmup logic here
        System.Web.HttpRuntime.Cache.Insert("Warmup", DateTime.Now);
        return Content("Application warmed up");
    }
}

2. Auto-Start Feature with ASP.NET 4+

Leverage the auto-start feature in Global.asax.cs:

public class MvcApplication : System.Web.HttpApplication
{
    private static readonly object WarmupLock = new object();
    private static bool IsWarmedUp = false;

    protected void Application_Start()
    {
        WarmupApplication();
    }

    private void WarmupApplication()
    {
        lock (WarmupLock)
        {
            if (!IsWarmedUp)
            {
                // Execute warmup routines
                PreloadViews();
                InitializeCaches();
                WarmupDatabase();
                
                IsWarmedUp = true;
            }
        }
    }

    private void PreloadViews()
    {
        var views = new[] { "Home/Index", "Account/Login" };
        foreach (var view in views)
        {
            ViewEngines.Engines.FindPartialView(ControllerContext, view);
        }
    }
}

3. External Ping Service

For cloud deployments, create a simple Azure Function or AWS Lambda that periodically hits your health check endpoint:

public async Task<HttpResponseMessage> Run(
    [TimerTrigger("0 */5 * * * *")] TimerInfo timer)
{
    using (var client = new HttpClient())
    {
        var response = await client.GetAsync("https://yourapp.com/healthcheck");
        return response;
    }
}

Implement telemetry to verify warmup effectiveness:

public class WarmupTelemetryModule : IHttpModule
{
    public void Init(HttpApplication context)
    {
        context.BeginRequest += (sender, e) =>
        {
            if (HttpRuntime.Cache["WarmupComplete"] == null)
            {
                // Log cold start event
                Telemetry.TrackEvent("ColdStartDetected");
            }
        };
    }
}

For complex applications, implement a warmup pipeline:

public interface IWarmupTask
{
    Task ExecuteAsync();
}

public class WarmupOrchestrator
{
    private readonly IEnumerable<IWarmupTask> _tasks;

    public WarmupOrchestrator(IEnumerable<IWarmupTask> tasks)
    {
        _tasks = tasks;
    }

    public async Task WarmupAsync()
    {
        var warmupTasks = _tasks.Select(t => t.ExecuteAsync());
        await Task.WhenAll(warmupTasks);
    }
}

// Example task
public class DatabaseWarmupTask : IWarmupTask
{
    public async Task ExecuteAsync()
    {
        using (var db = new AppDbContext())
        {
            await db.Users.FirstOrDefaultAsync();
        }
    }
}