Session and cache

Hi Arya

Please find below example for your reference.

1. Storing Session

Session must be explicitly enabled in your Program.cs before it can be used. 

Step A: Configure Program.cs

var builder = WebApplication.CreateBuilder(args);

// Add services for Session
builder.Services.AddDistributedMemoryCache(); // Required for Session
builder.Services.AddSession(options => {
    options.IdleTimeout = TimeSpan.FromMinutes(20); // Session timeout
    options.Cookie.HttpOnly = true;
    options.Cookie.IsEssential = true;
});

var app = builder.Build();

// Enable Session Middleware (must be after UseRouting and before MapControllers)
app.UseSession(); 
app.MapDefaultControllerRoute();
app.Run();

Step B: Usage in a Controller

public class HomeController : Controller {
    public IActionResult Index() {
        // Storing a value
        HttpContext.Session.SetString("UserName", "JohnDoe");
        return View();
    }

    public IActionResult Welcome() {
        // Retrieving a value
        string name = HttpContext.Session.GetString("UserName") ?? "Guest";
        return Content($"Welcome, {name}");
    }
}

2. Storing Cache (Shared/Global)

Use IMemoryCache for high-speed, server-side storage of frequently accessed data. 

Step A: Configure Program.cs

builder.Services.AddMemoryCache();

Step B: Usage in a Controller

public class ProductsController : Controller {
    private readonly IMemoryCache _cache;

    public ProductsController(IMemoryCache cache) {
        _cache = cache;
    }

    public IActionResult GetTime() {
        string cacheKey = "ServerTime";

        // Try to get data; if not found, create it
        if (!_cache.TryGetValue(cacheKey, out DateTime cachedTime)) {
            cachedTime = DateTime.Now;
            
            var options = new MemoryCacheEntryOptions()
                .SetAbsoluteExpiration(TimeSpan.FromMinutes(5)) // Hard expiry
                .SetSlidingExpiration(TimeSpan.FromMinutes(2)); // Reset expiry if accessed

            _cache.Set(cacheKey, cachedTime, options);
        }

        return Content($"Time: {cachedTime}");
    }
}

Comparison:

Hope this helps.

1. Session Storage

Session stores data per user across multiple requests.

In ASP.NET Core (Modern approach)

Setup in Program.cs:

var builder = WebApplication.CreateBuilder(args);

// Add session services

builder.Services.AddDistributedMemoryCache();

builder.Services.AddSession(options =>

{

options.IdleTimeout = TimeSpan.FromMinutes(30);

options.Cookie.HttpOnly = true;

options.Cookie.IsEssential = true;

});

var app = builder.Build();

app.UseSession(); // Enable session middleware

app.MapControllers();

app.Run();

Using Session in Controller:

public class HomeController : Controller

{

public IActionResult Index()

{

// Store simple values

HttpContext.Session.SetString("Username", "John");

HttpContext.Session.SetInt32("UserId", 123);

// Store complex objects (serialize to JSON)

var user = new { Name = "John", Age = 30 };

HttpContext.Session.SetString("UserObject",

JsonSerializer.Serialize(user));

return View();

}

public IActionResult GetSession()

{

// Retrieve values

var username = HttpContext.Session.GetString("Username");

var userId = HttpContext.Session.GetInt32("UserId");

// Retrieve complex objects

var userJson = HttpContext.Session.GetString("UserObject");

var user = JsonSerializer.Deserialize(userJson);

return Content($"User: {username}, ID: {userId}");

}

}

In ASP.NET Framework (Legacy)

// Store in session

Session["Username"] = "John";

Session["UserId"] = 123;

// Retrieve from session

string username = Session["Username"]?.ToString();

int? userId = Session["UserId"] as int?;

2. Cache Storage

Cache stores data globally for all users, great for performance optimization.

In-Memory Cache (ASP.NET Core)

Setup in Program.cs:

builder.Services.AddMemoryCache();

Using IMemoryCache:

public class ProductService

{

private readonly IMemoryCache _cache;

public ProductService(IMemoryCache cache)

{

_cache = cache;

}

public List GetProducts()

{

string cacheKey = "ProductList";

// Try to get from cache

if (!_cache.TryGetValue(cacheKey, out List products))

{

// If not in cache, fetch from database

products = FetchFromDatabase();

// Set cache options

var cacheOptions = new MemoryCacheEntryOptions()

.SetSlidingExpiration(TimeSpan.FromMinutes(5))

.SetAbsoluteExpiration(TimeSpan.FromHours(1))

.SetPriority(CacheItemPriority.Normal);

// Store in cache

_cache.Set(cacheKey, products, cacheOptions);

}

return products;

}

public void RemoveCache()

{

_cache.Remove("ProductList");

}

}

Session:

• User-specific data

• Expires when session ends

• Stored per user

• Good for: user preferences, shopping carts, authentication tokens

Cache:

• Application-wide data

• Shared across all users

• Configurable expiration

• Good for: database query results, API responses, static data

Both help improve performance by reducing database calls and storing frequently accessed data in memory