.NET 8: MemoryCache SlidingExpiration sem acessar

Um cacheItem só será removido ao acessá-lo em um timepoint t1 > t0 + x'. Isso significa que se eu não acessar mais o item depois desse ponto, ele também nunca será removido do cache.

Essa não é uma afirmação totalmente correta. Conforme explicado no link de uma das respostas, qualquer atividade no cache pode causar o despejo, por exemplo adicionar um novo item ao cache, ou até mesmo ler outra chave:

Não queríamos um cronômetro sempre em execução em um site ocioso. Qualquer atividade no cache ( Get, Set, Remove ) pode acionar uma verificação em segundo plano para itens expirados. Um cronômetro no CancellationTokenSource (CancelAfter) também removeria a entrada e acionaria uma verificação de itens expirados.

Veja os usos do StartScanForExpiredItemsIfNeededno código-fonte - ele é chamado em vários métodos como Remove, e .SetEntryTryGetValueEntryExpired

Por exemplo, você pode brincar com o seguinte:

// some setup
var sc = new ServiceCollection();
sc.AddMemoryCache(opts =>
{
    opts.ExpirationScanFrequency = TimeSpan.FromMilliseconds(200);
});
var sp = sc.BuildServiceProvider();
var cache = sp.GetRequiredService<IMemoryCache>();
// eviction "debugger"
PostEvictionDelegate OnCacheItemRemoved = (key, value, reason, state) => Console.WriteLine($"{key} {value} {reason} {state}");
// entry to be evicted
var options = new MemoryCacheEntryOptions()
    {
        SlidingExpiration = TimeSpan.FromMilliseconds(100),
    }
    .RegisterPostEvictionCallback(OnCacheItemRemoved);
cache.Set("1", 1, options);
// some other entry
cache.Set("not1", 1);

for (int i = 0; i < 20; i++)
{
    await Task.Delay(50);
    Console.WriteLine(i);
    // uncommenting any of the following lines 
    // triggers expiration in the Release mode:

    // cache.Set("1" + i, 1, options);
    // cache.Get<int>("not1");
    // cache.TryGetValue("notPresent", out _);
}

Não há muito que você possa fazer aqui, exceto alguma abordagem hacky como:

• criando um cronômetro e acessando alguma chave (por exemplo, uma fictícia) ou chamando MemoryCache.Compactmanualmente (ou seja, algo como (cache as MemoryCache)?.Compact(0.01)) quando ela expirar
• adicionando alguma entrada de cache fictícia com expiração absoluta (e lendo-a na expiração).

Abaixo está um exemplo de código que inicia um cronômetro para verificar itens expirados, o que pode atender às suas necessidades.

Os itens expirarão do cache a cada 5 segundos - você pode alterar o período alterando as duas linhas:

cache_opts.ExpirationScanFrequency = TimeSpan.FromSeconds( 5 );

cache_check_timer = new System.Timers.Timer( 5000 );

No exemplo, um cache de memória é criado e três itens são adicionados, cada um dos quais expirará se não for acessado dentro do intervalo de expiração deslizante:

using Microsoft.Extensions.Caching.Memory;
using System;
using System.Threading;
using System.Threading.Tasks;
using System.Timers;

namespace InMemoryNetCore
{

   class Program
   {

      private static System.Timers.Timer? cache_check_timer;

      private static IMemoryCache? cache;

      public static void Main( string[] args )
      {

         String in_str;


         // Create a memory cache ...
         // Important - set the minimum length of time between successive scans for expired items (default is one minute) ...

         var cache_opts = new MemoryCacheOptions();

         cache_opts.ExpirationScanFrequency = TimeSpan.FromSeconds( 5 );

         cache = new MemoryCache( cache_opts );


         // Create a timer with a five second interval ...

         cache_check_timer = new System.Timers.Timer( 5000 );

         cache_check_timer.AutoReset = true;

         cache_check_timer.Elapsed += cache_check;

         cache_check_timer.Start();


         // Create cache item which executes call back function

         var cacheEntryOptions = new MemoryCacheEntryOptions()
             .SetPriority( Microsoft.Extensions.Caching.Memory.CacheItemPriority.Normal )
             .SetSlidingExpiration( TimeSpan.FromSeconds( 5 ) )
             .RegisterPostEvictionCallback( callback: cache_item_removed );


         // add cache Item with options of callback

         cache.Set( 1, "Cache Item 1", cacheEntryOptions );

         cache.Set( 2, "Cache Item 2", cacheEntryOptions );

         cache.Set( 3, "Cache Item 3", cacheEntryOptions );


         // Get user input to terminate program ...

         in_str = String.Empty;

         while ( !"QUIT".Equals( in_str ) )
         {

            Console.Write( "Enter QUIT to end: " );

            in_str = Console.ReadLine();

         }


         // Stop and dispose of timer ...

         cache_check_timer.Stop();
         
         cache_check_timer.Dispose();


         Console.WriteLine( "\nProgram ended" );

      }

      // Used to issue a Get request to the cache using a key value that we
      // know does not exist - only to invoke the internal scan for expired items ...
      private static void cache_check( object? sender, ElapsedEventArgs e )
      {

         //Console.WriteLine( "Here in cache_check" );
         //Console.WriteLine( "Timer event was raised at {0:HH:mm:ss.fff}", e.SignalTime );

         if ( cache is not null )
         {

            // Issue a Get for a key that does not exist ...

           _ = cache.Get( -1 );

         }

      }


      // Callback when cached items are removed ...
      private static void cache_item_removed( object key, object? value, EvictionReason reason, object? state )
      {

         Console.Write( "\nCache key: " + key + " removed from cache due to: " + reason );

      }

   }

}