همگام سازی MemoryCache در تمامی instance ها

[Route("api/[controller]")]
[ApiController]
public class PublisherController : ControllerBase
{
    private readonly IRedisPublisher _redisPublisher;

    public PublisherController(IRedisPublisher redisPublisher)
    {
        _redisPublisher = redisPublisher;
    }
    [HttpGet]
    public async Task<IActionResult> Get()
    {
        await _redisPublisher.PublishMessage();
        return Ok();
    }
}

public interface IRedisPublisher
{
    Task PublishMessage();
}

public class RedisPublisher : IRedisPublisher
{
    private readonly IDatabaseAsync _databaseAsync;
    public RedisPublisher(IConnectionMultiplexer redisCachingProvider)
    {
        _databaseAsync = redisCachingProvider.GetDatabase();
    }
    public async Task PublishMessage()
    {
        var updatedData = new MemoryCacheDataDto
        {
            CacheKey = "user_information",
            Data = 20
        };
        var redisChannelData = System.Text.Json.JsonSerializer.Serialize(updatedData);
        await _databaseAsync.PublishAsync(RedisChannelConstant.MemoryCache, redisChannelData);
    }
}

public class RedisSubscriberHostedService : BackgroundService
{
    private readonly IMemoryCache _memoryCache;
    private readonly ILogger<RedisSubscriberHostedService> _logger;
    private readonly ISubscriber _subscriber;
    public RedisSubscriberHostedService(IConnectionMultiplexer connectionMultiplexer, IMemoryCache memoryCache, ILogger<RedisSubscriberHostedService> logger)
    {
        _memoryCache = memoryCache;
        _logger = logger;
        _subscriber = connectionMultiplexer.GetSubscriber();
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        await _subscriber.SubscribeAsync(RedisChannelConstant.MemoryCache, (a, updatedData) =>
         {
             var data = System.Text.Json.JsonSerializer.Deserialize<MemoryCacheDataDto>(updatedData);
             _memoryCache.Remove(data.CacheKey);
             _memoryCache.Set(data.CacheKey, data.Data);
             _logger.LogInformation($"MemoryCache update. Key:{data.CacheKey}");
         });
    }
    public override async Task StopAsync(CancellationToken cancellationToken)
    {
        await _subscriber.UnsubscribeAsync(RedisChannelConstant.MemoryCache);
        await base.StopAsync(cancellationToken);
    }
}

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }
    public IConfiguration Configuration { get; set; }
    public void ConfigureServices(IServiceCollection services)
    {
        services.RegisterMultiplexer(Configuration);
        services.AddSingleton<IRedisPublisher, RedisPublisher>();
        services.AddControllers();
        services.AddMemoryCache();
        services.AddHostedService<RedisSubscriberHostedService>();
    }
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        app.UseRouting();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapDefaultControllerRoute();
            endpoints.MapGet("/", async context =>
            {
                await context.Response.WriteAsync("Hello World!");
            });
        });
    }
}

public static class StartupExtension
{
    public static void RegisterMultiplexer(this IServiceCollection services, IConfiguration configuration)
    {
        var multiplexer = ConnectionMultiplexer.Connect(new ConfigurationOptions
        {
            EndPoints =
            {
                $"{configuration.GetValue<string>("RedisCache:Host")}:{configuration.GetValue<int>("RedisCache:Port")}"
            }
        });
        services.AddSingleton<IConnectionMultiplexer>(multiplexer);
    }
}

public static class RedisChannelConstant
{
    public const string MemoryCache = "memory_cache";
}

public class MemoryCacheDataDto
{
    public string CacheKey { get; set; }
    public object Data { get; set; }
}