using Microsoft.Extensions.Caching.Distributed;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddDistributedMemoryCache();

// alternatively, use Redis, SQL Server, etc

//builder.Services.AddStackExchangeRedisCache(options =>

//{

// options.Configuration = builder.Configuration.GetConnectionString("MyRedisConStr");

// options.InstanceName = "SampleInstance";

//});

var app = builder.Build();

app.MapGet("/sync", async (IDistributedCache cache, CancellationToken abort) =>

{

var timeObject = await cache.GetAsync("sync time cache key", () =>

{

// perform some potentially expensive operation when the cache data is

// unavailable; this could take to databases, http APIs, etc

return new { Time = DateTime.UtcNow }; // this could be a complex object with multiple values

}, CacheOptions.ThirtySeconds, abort);

return $"The time reported (sync getter) is: {timeObject.Time}";

});

app.MapGet("/async", async (IDistributedCache cache, CancellationToken abort) =>

{

var timeObject = await cache.GetAsync("async time cache key", async ct =>

{

// perform some potentially expensive operation when the cache data is

// unavailable; this could take to databases, http APIs, etc

await Task.Delay(2000, ct); // simulate an expensive operation

return new { Time = DateTime.UtcNow }; // this could be a complex object with multiple values

}, CacheOptions.ThirtySeconds, abort);

return $"The time reported (async getter) is: {timeObject.Time}";

});

app.MapGet("/{foo}/{bar}/sync", async (string foo, string bar, IDistributedCache cache, CancellationToken abort) =>

{

// here we show the use of the "state" parameter; this *would* also work without "state" via "captured variables",

// but by using the "state" parameter, we are able to use a static lambda (i.e. one that does not capture per-call

// state, and therefore does not require per-call allocations)

var timeObject = await cache.GetAsync($"{foo}:{bar} sync time cache key", // note we partition the cache by foo/bar via the key

(Foo: foo, Bar: bar), // state values

static state =>

{

// perform some potentially expensive operation when the cache data is

// unavailable; this could take to databases, http APIs, etc

return new { Time = DateTime.UtcNow, state.Foo, state.Bar }; // this could be a complex object with multiple values

}, CacheOptions.ThirtySeconds, abort);

return $"The time reported (sync getter, {timeObject.Foo}/{timeObject.Bar}) is: {timeObject.Time}";

});

app.MapGet("/{foo}/{bar}/async", async (string foo, string bar, IDistributedCache cache, CancellationToken abort) =>

{

// here we show the use of the "state" parameter; this *would* also work without "state" via "captured variables",

// but by using the "state" parameter, we are able to use a static lambda (i.e. one that does not capture per-call

// state, and therefore does not require per-call allocations)

var timeObject = await cache.GetAsync($"{foo}:{bar} async time cache key", // note we partition the cache by foo/bar via the key

(Foo: foo, Bar: bar), // state values

static async (state, ct) =>

{

// perform some potentially expensive operation when the cache data is

// unavailable; this could take to databases, http APIs, etc

await Task.Delay(2000, ct); // simulate an expensive operation

return new { Time = DateTime.UtcNow, state.Foo, state.Bar }; // this could be a complex object with multiple values

}, CacheOptions.ThirtySeconds, abort);

return $"The time reported (async getter, {timeObject.Foo}/{timeObject.Bar}) is: {timeObject.Time}";

});

app.Run();

static class CacheOptions

{

public static DistributedCacheEntryOptions ThirtySeconds { get; } = new() { AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(30) };

}