Кэш REDIS и C#

SET user:1000 "Информация о пользователе"
HSET user:1001 name "Иван" age "30" country "Россия"
LPUSH notifications:1000 "Новое сообщение" "Обновление системы"

// Стандартный MemoryCache в .NET
MemoryCache cache = new MemoryCache("MyCache");
cache.Add("key", "value", DateTimeOffset.Now.AddMinutes(30));

// Redis через StackExchange.Redis
IDatabase db = connection.GetDatabase();
db.StringSet("key", "value", TimeSpan.FromMinutes(30));

// Сохранение пользователя как хеша
db.HashSet("user:1001", new HashEntry[] { 
    new HashEntry("name", "Иван"),
    new HashEntry("email", "ivan@example.com"),
    new HashEntry("visits", 42)
});

// Добавление элементов в список последних действий
db.ListRightPush("user:1001:actions", "logged_in");
db.ListRightPush("user:1001:actions", "updated_profile");
// Получение последних 5 действий
var recentActions = db.ListRange("user:1001:actions", -5, -1);

// Добавление тегов к статье
db.SetAdd("article:1000:tags", "csharp", "redis", "performance");
// Нахождение общих тегов для двух статей
var commonTags = db.SetCombine(SetOperation.Intersect, 
    "article:1000:tags", "article:1001:tags");

// Добавление игроков с их счетом
db.SortedSetAdd("leaderboard", "player1", 1000);
db.SortedSetAdd("leaderboard", "player2", 2500);
// Получение топ-10 игроков
var topPlayers = db.SortedSetRangeByRankWithScores("leaderboard", 0, 9, Order.Descending);

// Подписка на канал
subscriber.Subscribe("notifications", (channel, message) => {
    Console.WriteLine($"Получено сообщение: {message}");
});
 
// Публикация сообщения
db.Publish("notifications", "Привет, мир!");

Install-Package StackExchange.Redis

public class RedisConnectionHelper
{
    static RedisConnectionHelper()
    {
        RedisConnectionHelper.lazyConnection = new Lazy<ConnectionMultiplexer>(() =>
        {
            return ConnectionMultiplexer.Connect("localhost");
        });
    }
 
    private static Lazy<ConnectionMultiplexer> lazyConnection;
 
    public static ConnectionMultiplexer Connection
    {
        get
        {
            return lazyConnection.Value;
        }
    }
}

var options = "localhost,abortConnect=false,connectTimeout=3000,password=secret";
var connection = ConnectionMultiplexer.Connect(options);

public void ConfigureServices(IServiceCollection services)
{
    // Регистрируем ConnectionMultiplexer как singleton
    services.AddSingleton<IConnectionMultiplexer>(sp =>
    {
        var configuration = ConfigurationOptions.Parse(Configuration.GetConnectionString("Redis"));
        return ConnectionMultiplexer.Connect(configuration);
    });
 
    // Регистрируем сервис для работы с Redis
    services.AddSingleton<IRedisCacheService, RedisCacheService>();
}

public class ProductController : Controller
{
    private readonly IRedisCacheService _cacheService;
 
    public ProductController(IRedisCacheService cacheService)
    {
        _cacheService = cacheService;
    }
 
    public async Task<IActionResult> GetProduct(int id)
    {
        // Пытаемся получить из кеша
        var product = await _cacheService.GetAsync<Product>($"product:{id}");
        if (product != null)
            return Ok(product);
 
        // Если нет в кеше, получаем из базы данных
        product = await _dbService.GetProductByIdAsync(id);
 
        // Кешируем результат на 1 час
        await _cacheService.SetAsync($"product:{id}", product, TimeSpan.FromHours(1));
 
        return Ok(product);
    }
}

// Получаем базу данных
IDatabase db = connection.GetDatabase();
 
// Сохраняем строку
db.StringSet("mykey", "Hello, Redis!");
 
// Получаем строку
string value = db.StringGet("mykey");
 
// Устанавливаем время жизни
db.StringSet("tempkey", "I will expire", TimeSpan.FromMinutes(5));
 
// Проверяем существование ключа
bool exists = db.KeyExists("mykey");
 
// Удаляем ключ
db.KeyDelete("mykey");

// Асинхронное сохранение
await db.StringSetAsync("asynckey", "Async value");
 
// Асинхронное получение
string asyncValue = await db.StringGetAsync("asynckey");
 
// Пакетные операции для повышения производительности
var batch = db.CreateBatch();
var task1 = batch.StringSetAsync("batch1", "value1");
var task2 = batch.StringSetAsync("batch2", "value2");
var task3 = batch.StringSetAsync("batch3", "value3");
batch.Execute();
await Task.WhenAll(task1, task2, task3);

// Сохраняем отдельные поля
db.HashSet("user:1001", "name", "Анна");
db.HashSet("user:1001", "email", "anna@example.com");
 
// Сохраняем все поля одновременно
db.HashSet("user:1002", new HashEntry[] {
    new HashEntry("name", "Борис"),
    new HashEntry("email", "boris@example.com"),
    new HashEntry("age", 32)
});
 
// Получаем одно поле
string name = db.HashGet("user:1001", "name");
 
// Получаем все поля
HashEntry[] allFields = db.HashGetAll("user:1001");
 
// Удаляем поле
db.HashDelete("user:1001", "age");
 
// Проверяем существование поля
bool hasEmail = db.HashExists("user:1001", "email");

public class RedisCacheService : IRedisCacheService
{
    private readonly IDatabase _db;
    private readonly JsonSerializerOptions _options;
 
    public RedisCacheService(IConnectionMultiplexer redis)
    {
        _db = redis.GetDatabase();
        _options = new JsonSerializerOptions
        {
            PropertyNamingPolicy = JsonNamingPolicy.CamelCase
        };
    }
 
    public async Task<T> GetAsync<T>(string key) where T : class
    {
        var value = await _db.StringGetAsync(key);
        if (value.IsNull)
            return null;
 
        return JsonSerializer.Deserialize<T>(value, _options);
    }
 
    public async Task SetAsync<T>(string key, T value, TimeSpan? expiry = null) where T : class
    {
        var serialized = JsonSerializer.Serialize(value, _options);
        await _db.StringSetAsync(key, serialized, expiry);
    }
}

ITransaction transaction = db.CreateTransaction();
Task<bool> t1 = transaction.StringSetAsync("counter", "1");
Task<bool> t2 = transaction.SetAddAsync("users:active", "user:1001");
bool committed = transaction.Execute();

var batch = db.CreateBatch();
var tasks = new List<Task>();
for (int i = 0; i < 1000; i++)
{
    tasks.Add(batch.StringSetAsync($"key:{i}", $"value:{i}"));
}
batch.Execute();
await Task.WhenAll(tasks);

var config = new ConfigurationOptions
{
    EndPoints = { "localhost:6379" },
    CommandMap = CommandMap.Create(new HashSet<string>
    { // Включаем мультиплексинг
    }, false),
};

// MessagePack часто быстрее JSON
using MessagePack;
 
[MessagePackObject]
public class User
{
    [Key(0)]
    public string Name { get; set; }
    
    [Key(1)]
    public int Age { get; set; }
}
 
// Сериализация
byte[] bytes = MessagePackSerializer.Serialize(user);
db.StringSet("user:1001", bytes);
 
// Десериализация
byte[] data = db.StringGet("user:1001");
User user = MessagePackSerializer.Deserialize<User>(data);

var options = ConfigurationOptions.Parse("localhost:6379");
options.ConnectTimeout = 5000; // 5 секунд
options.SyncTimeout = 10000; // 10 секунд
options.ConnectRetry = 3; // количество повторных попыток
options.ReconnectRetryPolicy = new ExponentialRetry(5000); // Экспоненциальная задержка

private readonly CircuitBreakerPolicy _circuitBreaker = Policy
    .Handle<RedisConnectionException>()
    .CircuitBreaker(
        exceptionsAllowedBeforeBreaking: 3,
        durationOfBreak: TimeSpan.FromSeconds(30)
    );
 
public async Task<T> GetWithResilienceAsync<T>(string key) where T : class
{
    return await _circuitBreaker.ExecuteAsync(async () => 
    {
        var value = await _db.StringGetAsync(key);
        if (value.IsNull)
            return null;
        return JsonSerializer.Deserialize<T>(value);
    });
}

// Получение статистики подключения
ConnectionMultiplexerStats stats = connection.GetCounters();
 
// Профилирование команд
connection.RegisterProfiler(new RedisProfiler());
 
// Обработка событий
connection.ConnectionFailed += (sender, e) => 
{
    Logger.Error($"Redis connection failed: {e.Exception.Message}");
};

var sentinelOptions = ConfigurationOptions.Parse("sentinel-1:26379,sentinel-2:26379");
sentinelOptions.ServiceName = "mymaster"; // Имя группы мастер-реплика
sentinelOptions.CommandMap = CommandMap.Sentinel;
sentinelOptions.TieBreaker = ""; // Отключаем tie-breaker для Sentinel
 
var sentinelConnection = ConnectionMultiplexer.Connect(sentinelOptions);
var masterConnection = sentinelConnection.GetServer(sentinelOptions.EndPoints[0])
    .SentinelGetMasterAddressByName("mymaster");

public async Task<Product> GetProductByIdAsync(int id)
{
    string cacheKey = $"product:{id}";
    
    // Пробуем получить из кеша
    var cachedProduct = await _redis.StringGetAsync(cacheKey);
    if (!cachedProduct.IsNull)
    {
        return JsonSerializer.Deserialize<Product>(cachedProduct);
    }
    
    // Если в кеше нет, получаем из базы данных
    var product = await _dbContext.Products
        .Include(p => p.Category)
        .Include(p => p.Reviews)
        .FirstOrDefaultAsync(p => p.Id == id);
    
    if (product != null)
    {
        // Кешируем результат на 30 минут
        await _redis.StringSetAsync(
            cacheKey, 
            JsonSerializer.Serialize(product), 
            TimeSpan.FromMinutes(30)
        );
    }
    
    return product;
}

public async Task UpdateProductAsync(Product product)
{
    // Обновляем в БД
    _dbContext.Products.Update(product);
    await _dbContext.SaveChangesAsync();
    
    // Инвалидируем кеш
    await _redis.KeyDeleteAsync($"product:{product.Id}");
}

public async Task ProcessPayment(string orderId)
{
    string lockKey = $"lock:order:{orderId}";
    string lockValue = Guid.NewGuid().ToString();
    
    // Пытаемся получить блокировку
    bool acquired = await _redis.StringSetAsync(
        lockKey, 
        lockValue, 
        TimeSpan.FromSeconds(30), 
        When.NotExists
    );
    
    if (!acquired)
    {
        throw new ConcurrencyException("Заказ уже обрабатывается");
    }
    
    try
    {
        // Выполняем критическую операцию
        await _paymentService.ProcessAsync(orderId);
    }
    finally
    {
        // Атомарно освобождаем блокировку, только если это наша блокировка
        string script = @"
            if redis.call('get', KEYS[1]) == ARGV[1] then
                return redis.call('del', KEYS[1])
            else
                return 0
            end
        ";
        
        await _redis.ScriptEvaluateAsync(
            script,
            new RedisKey[] { lockKey },
            new RedisValue[] { lockValue }
        );
    }
}

// Настройка в Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    services.AddStackExchangeRedisCache(options =>
    {
        options.Configuration = "localhost:6379";
        options.InstanceName = "MyApp:";
    });
    
    services.AddSession(options =>
    {
        options.IdleTimeout = TimeSpan.FromMinutes(30);
        options.Cookie.HttpOnly = true;
        options.Cookie.IsEssential = true;
    });
}
 
// Использование в контроллере
public IActionResult AddToCart(int productId)
{
    // Получаем текущую корзину из сессии
    var cart = HttpContext.Session.Get<ShoppingCart>("Cart") ?? new ShoppingCart();
    
    // Модифицируем корзину
    cart.AddItem(productId);
    
    // Сохраняем обратно в сессию
    HttpContext.Session.Set("Cart", cart);
    
    return RedirectToAction("Index");
}

// Увеличиваем счетчик просмотров статьи
await _redis.StringIncrementAsync($"article:{articleId}:views");
 
// Добавляем оценку пользователя и пересчитываем рейтинг
await _redis.SortedSetAddAsync(
    $"product:{productId}:ratings", 
    userId, 
    rating
);
 
// Получаем средний рейтинг
double avgRating = await _redis.SortedSetScoreAsync(
    $"product:{productId}:ratings", 
    "avg"
) ?? 0;
 
// Получаем топ-5 лучших продуктов
var topProducts = await _redis.SortedSetRangeByScoreAsync(
    "products:ratings", 
    order: Order.Descending, 
    take: 5
);

public class RedisCacheMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IDatabase _redis;
    
    public RedisCacheMiddleware(RequestDelegate next, IConnectionMultiplexer redis)
    {
        _next = next;
        _redis = redis.GetDatabase();
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        // Только для GET-запросов
        if (context.Request.Method != "GET")
        {
            await _next(context);
            return;
        }
        
        string cacheKey = $"api:{context.Request.Path}{context.Request.QueryString}";
        
        // Проверяем кеш
        var cachedResponse = await _redis.StringGetAsync(cacheKey);
        if (!cachedResponse.IsNull)
        {
            context.Response.ContentType = "application/json";
            await context.Response.WriteAsync(cachedResponse);
            return;
        }
        
        // Запоминаем оригинальный поток ответа
        var originalBody = context.Response.Body;
        
        try
        {
            // Создаем новый поток для чтения ответа
            using var memStream = new MemoryStream();
            context.Response.Body = memStream;
            
            // Продолжаем выполнение запроса
            await _next(context);
            
            // Если статус успешный, кешируем ответ
            if (context.Response.StatusCode == 200)
            {
                memStream.Position = 0;
                using var reader = new StreamReader(memStream);
                var responseBody = await reader.ReadToEndAsync();
                
                await _redis.StringSetAsync(
                    cacheKey, 
                    responseBody, 
                    TimeSpan.FromMinutes(5)
                );
                
                memStream.Position = 0;
                await memStream.CopyToAsync(originalBody);
            }
        }
        finally
        {
            context.Response.Body = originalBody;
        }
    }
}

public async Task<bool> CheckRateLimitAsync(string clientIp, int maxRequests, TimeSpan period)
{
    string key = $"ratelimit:{clientIp}";
    
    var tran = _redis.CreateTransaction();
    var countTask = tran.StringIncrementAsync(key);
    var expireTask = tran.KeyExpireAsync(key, period);
    await tran.ExecuteAsync();
    
    long requestCount = await countTask;
    
    return requestCount <= maxRequests;
}

// В контроллере или middleware
if (!await _rateLimit.CheckRateLimitAsync(
    HttpContext.Connection.RemoteIpAddress.ToString(),
    100,  // Максимум 100 запросов
    TimeSpan.FromMinutes(1)  // За 1 минуту
))
{
    return StatusCode(429, "Too Many Requests");
}

// Добавление задачи в очередь
await _redis.ListRightPushAsync("tasks:email", JsonSerializer.Serialize(new EmailTask 
{
    To = "user@example.com",
    Subject = "Ваш заказ отправлен",
    Body = "Детали заказа...",
    Priority = 2
}));
 
// Обработчик задач (в отдельном процессе или сервисе)
while (true)
{
    // Извлекаем задачу с блокировкой до 5 секунд
    var taskJson = await _redis.ListLeftPopAsync("tasks:email", TimeSpan.FromSeconds(5));
    
    if (taskJson.IsNull)
        continue;
        
    var task = JsonSerializer.Deserialize<EmailTask>(taskJson);
    
    try 
    {
        await _emailService.SendAsync(task.To, task.Subject, task.Body);
    }
    catch (Exception ex)
    {
        // При ошибке возвращаем задачу в очередь или в отдельную очередь для ошибок
        await _redis.ListRightPushAsync("tasks:email:failed", taskJson);
        _logger.LogError(ex, "Ошибка при отправке email");
    }
}

// Планирование задачи на конкретное время
var executeAt = DateTimeOffset.Now.AddHours(1).ToUnixTimeSeconds();
await _redis.SortedSetAddAsync("scheduled:tasks", taskId, executeAt);
 
// В сервисе-обработчике
while (true)
{
    var now = DateTimeOffset.Now.ToUnixTimeSeconds();
    
    // Извлекаем все задачи, время выполнения которых наступило
    var dueTasks = await _redis.SortedSetRangeByScoreAsync(
        "scheduled:tasks", 
        0, 
        now, 
        Exclude.None, 
        Order.Ascending, 
        0, 
        10
    );
    
    if (dueTasks.Length == 0)
    {
        await Task.Delay(1000);
        continue;
    }
    
    foreach (var taskId in dueTasks)
    {
        // Атомарно удаляем задачу из очереди отложенных
        bool removed = await _redis.SortedSetRemoveAsync("scheduled:tasks", taskId);
        
        if (removed)
        {
            // Задача успешно удалена, можно выполнять
            await ProcessTask(taskId.ToString());
        }
    }
}

// Добавляем местоположения магазинов
await _redis.GeoAddAsync("stores", 
    new GeoEntry(37.7749, -122.4194, "store:1"),  // Сан-Франциско
    new GeoEntry(40.7128, -74.0060, "store:2"),   // Нью-Йорк
    new GeoEntry(34.0522, -118.2437, "store:3")   // Лос-Анджелес
);
 
// Находим ближайшие магазины к пользователю
var nearbyStores = await _redis.GeoRadiusAsync(
    "stores",
    37.7833, -122.4167,  // Координаты пользователя
    50, GeoUnit.Kilometers,
    order: Order.Ascending,
    options: GeoRadiusOptions.WithDistance,
    count: 5
);
 
foreach (var store in nearbyStores)
{
    Console.WriteLine($"Магазин {store.Member}: {store.Distance} км");
}

// Настройка подписки в фоновом сервисе
public async Task StartListeningAsync(CancellationToken cancellationToken)
{
    var subscriber = _redis.GetSubscriber();
    
    await subscriber.SubscribeAsync("notifications:system", (channel, message) => {
        _notificationService.BroadcastToClients(message.ToString());
    });
    
    await subscriber.SubscribeAsync($"notifications:user:{userId}", (channel, message) => {
        _notificationService.SendToUser(userId, message.ToString());
    });
    
    // Предотвращаем завершение задачи
    await Task.Delay(Timeout.Infinite, cancellationToken);
}
 
// Отправка уведомления
public async Task NotifySystemEvent(string message)
{
    var subscriber = _redis.GetSubscriber();
    await subscriber.PublishAsync("notifications:system", message);
}

// Отмечаем дни активности пользователя (1 бит на день)
await _redis.StringSetBitAsync($"user:{userId}:active:2023-11", dayOfMonth - 1, true);
 
// Проверяем, был ли пользователь активен в конкретный день
bool wasActive = await _redis.StringGetBitAsync($"user:{userId}:active:2023-11", dayOfMonth - 1);
 
// Подсчитываем количество дней активности
long activeDays = await _redis.StringBitCountAsync($"user:{userId}:active:2023-11");
 
// Находим пересечение активных дней для группы пользователей
await _redis.StringBitOperationAsync(
    Bitwise.And,
    "team:active:2023-11",
    new RedisKey[] { "user:1:active:2023-11", "user:2:active:2023-11", "user:3:active:2023-11" }
);

public async Task SaveProduct(Product product)
{
    // Сначала сохраняем в Redis
    await _redis.StringSetAsync(
        $"product:{product.Id}",
        JsonSerializer.Serialize(product)
    );
    
    // Затем в основную БД
    _dbContext.Products.Update(product);
    await _dbContext.SaveChangesAsync();
}

public async Task SaveProductWithDelay(Product product)
{
    // Сохраняем в Redis
    await _redis.StringSetAsync($"product:{product.Id}", JsonSerializer.Serialize(product));
    
    // Добавляем в очередь на запись в БД
    await _redis.ListRightPushAsync("db:write:queue", JsonSerializer.Serialize(new 
    {
        Type = "Product",
        Id = product.Id,
        Action = "Update",
        Timestamp = DateTime.UtcNow
    }));
}
 
// В фоновом сервисе
private async Task ProcessWriteQueue()
{
    while (!_cancellationToken.IsCancellationRequested)
    {
        var item = await _redis.ListLeftPopAsync("db:write:queue");
        if (!item.IsNull)
        {
            var writeOperation = JsonSerializer.Deserialize<dynamic>(item);
            await ProcessDatabaseWrite(writeOperation);
        }
        else
        {
            await Task.Delay(100);
        }
    }
}

// При обновлении продукта
public async Task UpdateProduct(Product product)
{
    // Обновляем в БД
    _dbContext.Products.Update(product);
    await _dbContext.SaveChangesAsync();
    
    // Инвалидируем прямые ключи
    await _redis.KeyDeleteAsync($"product:{product.Id}");
    
    // Инвалидируем зависимые ключи
    await _redis.KeyDeleteAsync($"category:{product.CategoryId}:products");
    await _redis.KeyDeleteAsync("products:featured");
    
    // Оповещаем другие экземпляры приложения
    await _redis.PublishAsync("cache:invalidate", $"product:{product.Id}");
}

public async Task<List<Product>> GetCategoryProducts(int categoryId)
{
    // Получаем текущую версию для категории
    long version = await _redis.StringGetAsync($"category:{categoryId}:version") ?? 1;
    
    // Формируем ключ с версией
    string cacheKey = $"category:{categoryId}:products:v{version}";
    
    var cachedData = await _redis.StringGetAsync(cacheKey);
    if (!cachedData.IsNull)
        return JsonSerializer.Deserialize<List<Product>>(cachedData);
        
    // Получаем из БД и кешируем
    var products = await _dbContext.Products
        .Where(p => p.CategoryId == categoryId)
        .ToListAsync();
        
    await _redis.StringSetAsync(cacheKey, JsonSerializer.Serialize(products), TimeSpan.FromHours(1));
    
    return products;
}
 
// При изменении категории увеличиваем версию
public async Task UpdateCategory(Category category)
{
    // Обновление в БД
    // ...
    
    // Инкрементируем версию
    await _redis.StringIncrementAsync($"category:{category.Id}:version");
}

// Настройка в redis.conf
// maxmemory 1gb
// maxmemory-policy allkeys-lru
 
// Мониторинг использования памяти из C#
var info = await _redis.GetServer("localhost:6379").InfoAsync();
string usedMemory = info.First(i => i.Key == "used_memory_human").Value;

public async Task<T> GetCompressedAsync<T>(string key) where T : class
{
    var compressedData = await _redis.StringGetAsync(key);
    if (compressedData.IsNull)
        return null;
        
    // Распаковываем
    using var ms = new MemoryStream(compressedData);
    using var zip = new GZipStream(ms, CompressionMode.Decompress);
    using var resultStream = new MemoryStream();
    
    await zip.CopyToAsync(resultStream);
    resultStream.Position = 0;
    
    return JsonSerializer.Deserialize<T>(resultStream);
}
 
public async Task SetCompressedAsync<T>(string key, T value, TimeSpan? expiry = null) where T : class
{
    using var ms = new MemoryStream();
    using (var zip = new GZipStream(ms, CompressionLevel.Optimal, true))
    {
        JsonSerializer.Serialize(zip, value);
    }
    
    await _redis.StringSetAsync(key, ms.ToArray(), expiry);
}

public async Task<bool> UpdateIfNotChanged(string key, string newValue, string expectedValue)
{
    string script = @"
        if redis.call('get', KEYS[1]) == ARGV[1] then
            redis.call('set', KEYS[1], ARGV[2])
            return 1
        else
            return 0
        end
    ";
    
    var result = await _redis.ScriptEvaluateAsync(
        script,
        new RedisKey[] { key },
        new RedisValue[] { expectedValue, newValue }
    );
    
    return (long)result == 1;
}

var options = ConfigurationOptions.Parse("redis1:7000,redis2:7001,redis3:7002");
options.CommandMap = CommandMap.Create(new HashSet<string>() { "CLUSTER" }, available: false);
 
var cluster = ConnectionMultiplexer.Connect(options);
var db = cluster.GetDatabase();
 
// Остальной код работает точно так же, библиотека сама 
// определяет нужную ноду кластера для ключа

var options = ConfigurationOptions.Parse("master:6379,replica1:6379,replica2:6379");
options.AllowAdmin = true;
var connection = ConnectionMultiplexer.Connect(options);
 
// Для записи используем только мастер
var master = connection.GetServer("master:6379");
var db = connection.GetDatabase();
 
// Для чтения можно использовать любой сервер, включая реплики
// Библиотека автоматически распределяет запросы чтения

var sentinelOptions = ConfigurationOptions.Parse("sentinel1:26379,sentinel2:26379,sentinel3:26379");
sentinelOptions.ServiceName = "mymaster"; // имя группы серверов в конфигурации Sentinel
sentinelOptions.TieBreaker = "";
sentinelOptions.CommandMap = CommandMap.Sentinel;
 
using var sentinelConnection = ConnectionMultiplexer.Connect(sentinelOptions);
var sentinels = sentinelConnection.GetEndPoints().Select(e => sentinelConnection.GetServer(e));
 
// Получаем адрес текущего мастера
RedisServer currentMaster = null;
foreach (var sentinel in sentinels)
{
    if (!sentinel.IsConnected)
        continue;
        
    try
    {
        var masterEndpoint = sentinel.SentinelGetMasterAddressByName("mymaster");
        currentMaster = connection.GetServer(masterEndpoint);
        break;
    }
    catch
    {
        continue;
    }
}
 
// Настраиваем обработчик событий переключения мастера
connection.ConfigurationChanged += (s, e) => {
    _logger.LogInformation("Redis configuration changed!");
    // Перенастройка подключений или обновление кеша
};

// Публикация события в поток
string messageId = await _redis.StreamAddAsync(
    "orders:events",
    new NameValueEntry[] {
        new NameValueEntry("type", "created"),
        new NameValueEntry("orderId", "12345"),
        new NameValueEntry("amount", "299.99"),
        new NameValueEntry("timestamp", DateTime.UtcNow.ToString("o"))
    }
);
 
// Чтение событий из потока
StreamEntry[] entries = await _redis.StreamReadAsync("orders:events", "0-0");
foreach (var entry in entries)
{
    string type = entry.Values.FirstOrDefault(v => v.Name == "type").Value;
    string orderId = entry.Values.FirstOrDefault(v => v.Name == "orderId").Value;
    
    // Обработка события
    ProcessOrderEvent(type, orderId);
}

// Создание группы потребителей
await _redis.StreamCreateConsumerGroupAsync("orders:events", "order-processors", "0-0");
 
// Чтение необработанных сообщений группой
StreamEntry[] pendingMessages = await _redis.StreamReadGroupAsync(
    "orders:events",
    "order-processors",
    "consumer-1",
    ">", // Специальный ID для новых сообщений
    10 // Максимальное количество сообщений
);
 
// Подтверждение обработки
foreach (var message in pendingMessages)
{
    try
    {
        await ProcessMessage(message);
        await _redis.StreamAcknowledgeAsync("orders:events", "order-processors", message.Id);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, $"Ошибка обработки сообщения {message.Id}");
    }
}
 
// Получение и повторная обработка зависших сообщений
StreamPendingInfo pending = await _redis.StreamPendingAsync("orders:events", "order-processors");
if (pending.Count > 0)
{
    StreamPendingMessageInfo[] pendingDetails = await _redis.StreamPendingMessagesAsync(
        "orders:events", 
        "order-processors", 
        10, // Количество сообщений
        "consumer-1", // Можно указать конкретного потребителя или null для всех
        10000 // Минимальное время ожидания в миллисекундах
    );
    
    foreach (var msg in pendingDetails)
    {
        // Повторное получение и обработка
        var messageData = await _redis.StreamRangeAsync("orders:events", msg.MessageId, msg.MessageId);
        await ProcessMessage(messageData.First());
        await _redis.StreamAcknowledgeAsync("orders:events", "order-processors", msg.MessageId);
    }
}

// Подключение с аутентификацией
var secureOptions = ConfigurationOptions.Parse("redis-server:6379,password=секретный_пароль");
secureOptions.Ssl = true; // Включаем шифрование TLS
secureOptions.SslHost = "redis.example.com"; // Проверка сертификата по имени хоста
 
var secureConnection = ConnectionMultiplexer.Connect(secureOptions);

// Выполнение ACL команд через C#
await _redis.GetServer("redis-server:6379").ExecuteAsync("ACL", "SETUSER", "readonly", "on", ">password", "~*", "+@read");

// Транзакция (MULTI/EXEC)
var transaction = _redis.CreateTransaction();
var task1 = transaction.StringSetAsync("key1", "value1");
var task2 = transaction.HashSetAsync("hash1", new HashEntry[] { new HashEntry("field1", "value1") });
var task3 = transaction.SetAddAsync("set1", "member1");
bool committed = await transaction.ExecuteAsync();
 
if (committed)
{
    // Все команды выполнены успешно
    bool task1Result = await task1;
    bool task2Result = await task2;
    bool task3Result = await task3;
}
else
{
    // Транзакция не выполнена
}
 
// Пакет (без гарантии атомарности, но с одним сетевым запросом)
var batch = _redis.CreateBatch();
var batchTask1 = batch.StringSetAsync("key2", "value2");
var batchTask2 = batch.HashSetAsync("hash2", new HashEntry[] { new HashEntry("field2", "value2") });
batch.Execute();
 
// Ожидаем завершения операций
await Task.WhenAll(batchTask1, batchTask2);

public class ShardedRedisService
{
    private readonly List<IConnectionMultiplexer> _shardConnections;
    private readonly int _shardCount;
    
    public ShardedRedisService(IConfiguration config)
    {
        _shardCount = config.GetValue<int>("Redis:ShardCount");
        _shardConnections = new List<IConnectionMultiplexer>(_shardCount);
        
        for (int i = 0; i < _shardCount; i++)
        {
            var connection = ConnectionMultiplexer.Connect(
                config.GetConnectionString($"Redis:Shard{i}")
            );
            _shardConnections.Add(connection);
        }
    }
    
    public IDatabase GetShardForKey(string key)
    {
        // Используем консистентное хеширование для определения шарда
        int shardIndex = Math.Abs(key.GetHashCode()) % _shardCount;
        return _shardConnections[shardIndex].GetDatabase();
    }
    
    public async Task<T> GetAsync<T>(string key) where T : class
    {
        var db = GetShardForKey(key);
        var value = await db.StringGetAsync(key);
        return value.IsNull ? null : JsonSerializer.Deserialize<T>(value);
    }
    
    public async Task SetAsync<T>(string key, T value, TimeSpan? expiry = null) where T : class
    {
        var db = GetShardForKey(key);
        await db.StringSetAsync(
            key, 
            JsonSerializer.Serialize(value), 
            expiry
        );
    }
}

// Шардирование по префиксу ключа
public IDatabase GetShardByKeyPrefix(string key)
{
    if (key.StartsWith("user:"))
        return _shardConnections[0].GetDatabase();
    else if (key.StartsWith("product:"))
        return _shardConnections[1].GetDatabase();
    else if (key.StartsWith("order:"))
        return _shardConnections[2].GetDatabase();
    else
        return _shardConnections[3].GetDatabase(); // Все остальное
}
 
// Шардирование по диапазону значений
public IDatabase GetShardByRange(int userId)
{
    if (userId < 10000)
        return _shardConnections[0].GetDatabase();
    else if (userId < 20000)
        return _shardConnections[1].GetDatabase();
    else
        return _shardConnections[2].GetDatabase();
}

public async Task<RedisHealthStatus> CheckRedisHealthAsync()
{
    var status = new RedisHealthStatus();
    
    try
    {
        var server = _connection.GetServer(_connection.GetEndPoints().First());
        var info = await server.InfoAsync();
        
        status.MemoryUsed = info.First(x => x.Key == "used_memory_human").Value;
        status.TotalConnections = int.Parse(info.First(x => x.Key == "connected_clients").Value);
        status.UptimeInSeconds = int.Parse(info.First(x => x.Key == "uptime_in_seconds").Value);
        status.CommandsPerSecond = int.Parse(info.First(x => x.Key == "instantaneous_ops_per_sec").Value);
        status.KeyspaceHits = int.Parse(info.First(x => x.Key == "keyspace_hits").Value);
        status.KeyspaceMisses = int.Parse(info.First(x => x.Key == "keyspace_misses").Value);
        status.IsHealthy = true;
        
        // Расчет hit ratio
        long totalLookups = status.KeyspaceHits + status.KeyspaceMisses;
        status.HitRatio = totalLookups > 0 
            ? (double)status.KeyspaceHits / totalLookups 
            : 0;
        
        // Проверка критических показателей
        if (status.HitRatio < 0.8)
        {
            _logger.LogWarning($"Redis cache hit ratio is low: {status.HitRatio:P}");
        }
    }
    catch (Exception ex)
    {
        status.IsHealthy = false;
        status.ErrorMessage = ex.Message;
        _logger.LogError(ex, "Failed to check Redis health");
    }
    
    return status;
}

[ApiController]
[Route("metrics")]
public class MetricsController : ControllerBase
{
    private readonly IConnectionMultiplexer _redis;
    
    public MetricsController(IConnectionMultiplexer redis)
    {
        _redis = redis;
    }
    
    [HttpGet("redis")]
    public async Task<IActionResult> GetRedisMetrics()
    {
        var sb = new StringBuilder();
        var server = _redis.GetServer(_redis.GetEndPoints().First());
        var info = await server.InfoAsync();
        
        sb.AppendLine("# HELP redis_used_memory Redis used memory in bytes");
        sb.AppendLine("# TYPE redis_used_memory gauge");
        sb.AppendLine($"redis_used_memory {info.First(x => x.Key == "used_memory").Value}");
        
        sb.AppendLine("# HELP redis_connected_clients Redis connected clients");
        sb.AppendLine("# TYPE redis_connected_clients gauge");
        sb.AppendLine($"redis_connected_clients {info.First(x => x.Key == "connected_clients").Value}");
        
        // Другие метрики...
        
        return Content(sb.ToString(), "text/plain");
    }
}

// Реализация механизма скользящего окна для rate limiting
public async Task<bool> CheckRateLimitSlidingWindow(string key, int maxRequests, int windowSeconds)
{
    string script = @"
        local key = KEYS[1]
        local now = tonumber(ARGV[1])
        local windowSize = tonumber(ARGV[2])
        local maxCount = tonumber(ARGV[3])
        
        -- Удаляем устаревшие записи
        redis.call('ZREMRANGEBYSCORE', key, 0, now - windowSize)
        
        -- Получаем текущее количество запросов
        local count = redis.call('ZCARD', key)
        
        -- Проверяем, не превышен ли лимит
        if count < maxCount then
            -- Добавляем новый запрос
            redis.call('ZADD', key, now, now .. '-' .. math.random())
            -- Обновляем TTL ключа
            redis.call('EXPIRE', key, windowSize)
            return 1
        else
            return 0
        end
    ";
    
    int now = (int)DateTimeOffset.UtcNow.ToUnixTimeSeconds();
    var result = await _redis.ScriptEvaluateAsync(
        script,
        new RedisKey[] { key },
        new RedisValue[] { now, windowSeconds, maxRequests }
    );
    
    return (long)result == 1;
}

// Неправильно: утечка соединений
public string GetValue(string key)
{
    var redis = ConnectionMultiplexer.Connect("localhost");
    var db = redis.GetDatabase();
    return db.StringGet(key);
    // Не вызывается Dispose для ConnectionMultiplexer!
}
 
// Правильно: использование синглтона
private static Lazy<ConnectionMultiplexer> _connection = 
    new Lazy<ConnectionMultiplexer>(() => ConnectionMultiplexer.Connect("localhost"));
 
public string GetValue(string key)
{
    var db = _connection.Value.GetDatabase();
    return db.StringGet(key);
}

// Пример с обработкой исключений и повторными попытками
public async Task<string> GetValueWithRetry(string key)
{
    int maxRetries = 3;
    int retryCount = 0;
    TimeSpan delay = TimeSpan.FromMilliseconds(200);
    
    while (true)
    {
        try
        {
            var db = _connection.Value.GetDatabase();
            return await db.StringGetAsync(key);
        }
        catch (RedisConnectionException ex)
        {
            retryCount++;
            if (retryCount > maxRetries)
                throw new CacheException("Не удалось подключиться к Redis после нескольких попыток", ex);
                
            _logger.LogWarning($"Ошибка подключения к Redis: {ex.Message}. Повторная попытка {retryCount}/{maxRetries}");
            await Task.Delay(delay);
            delay = TimeSpan.FromMilliseconds(delay.TotalMilliseconds * 2); // Экспоненциальная задержка
        }
    }
}

// Плохо: сохраняем весь объект с вложенными коллекциями
await _redis.StringSetAsync($"product:{id}", JsonSerializer.Serialize(hugeProductWithCollections));
 
// Лучше: сохраняем только необходимые данные
var productDto = new {
    Id = product.Id,
    Name = product.Name,
    Price = product.Price,
    CategoryId = product.Category?.Id
};
await _redis.StringSetAsync($"product:{id}", JsonSerializer.Serialize(productDto));

// Проблема: счетчик с высокой конкуренцией
await _redis.StringIncrementAsync("global:hitcounter");
 
// Решение: разделить на сегменты
int segment = new Random().Next(0, 100);
await _redis.StringIncrementAsync($"global:hitcounter:{segment}");
 
// При необходимости получения общего значения
long totalHits = 0;
for (int i = 0; i < 100; i++)
{
    totalHits += (long)await _redis.StringGetAsync($"global:hitcounter:{i}") ?? 0;
}

// Распространенное решение: инвалидация через Pub/Sub
// В сервисе, обновляющем данные
await _db.Products.UpdateAsync(product);
await _redis.PublishAsync("cache:invalidate", $"product:{product.Id}");
 
// Подписка в каждом экземпляре приложения
_redis.GetSubscriber().Subscribe("cache:invalidate", (channel, message) => {
    _redis.KeyDeleteAsync(message.ToString());
});

// Плохо для продакшна - блокирует сервер при большом количестве ключей
var keys = _server.Keys(pattern: "user:*");
 
// Лучше - инкрементальное сканирование
var allKeys = new List<RedisKey>();
long cursor = 0;
do
{
    var result = await _server.ExecuteAsync("SCAN", cursor.ToString(), "MATCH", "user:*", "COUNT", "100");
    var innerResult = (RedisResult[])result;
    cursor = long.Parse((string)innerResult[0]);
    var items = (RedisResult[])innerResult[1];
    allKeys.AddRange(items.Select(x => (RedisKey)(string)x));
}
while (cursor != 0);

// Простая проверка здоровья Redis
public async Task<bool> IsRedisHealthy()
{
    try
    {
        var latency = await MeasureLatency();
        var memoryStats = await GetMemoryStats();
        
        // Проверяем критические показатели
        return latency.TotalMilliseconds < 100 && 
               memoryStats.UsedPercentage < 80 &&
               _connection.Value.IsConnected;
    }
    catch
    {
        return false;
    }
}

public class MultiLevelCacheService<T> where T : class
{
    private readonly IMemoryCache _memoryCache;
    private readonly IRedisCacheService _redisCache;
    private readonly IRepository<T> _repository;
    private readonly TimeSpan _memoryCacheDuration;
    private readonly TimeSpan _redisCacheDuration;
 
    public MultiLevelCacheService(
        IMemoryCache memoryCache,
        IRedisCacheService redisCache,
        IRepository<T> repository,
        TimeSpan? memoryCacheDuration = null,
        TimeSpan? redisCacheDuration = null)
    {
        _memoryCache = memoryCache;
        _redisCache = redisCache;
        _repository = repository;
        _memoryCacheDuration = memoryCacheDuration ?? TimeSpan.FromSeconds(30);
        _redisCacheDuration = redisCacheDuration ?? TimeSpan.FromMinutes(10);
    }
 
    public async Task<T> GetByIdAsync(int id)
    {
        string cacheKey = $"{typeof(T).Name.ToLower()}:{id}";
        
        // Проверяем L1 кеш (память)
        if (_memoryCache.TryGetValue(cacheKey, out T cachedItem))
            return cachedItem;
            
        // Проверяем L2 кеш (Redis)
        var redisItem = await _redisCache.GetAsync<T>(cacheKey);
        if (redisItem != null)
        {
            // Помещаем в L1 кеш
            _memoryCache.Set(cacheKey, redisItem, _memoryCacheDuration);
            return redisItem;
        }
        
        // Получаем из основного хранилища
        var item = await _repository.GetByIdAsync(id);
        if (item != null)
        {
            // Сохраняем в обоих уровнях кеша
            _memoryCache.Set(cacheKey, item, _memoryCacheDuration);
            await _redisCache.SetAsync(cacheKey, item, _redisCacheDuration);
        }
        
        return item;
    }
    
    // Метод для инвалидации кеша при обновлении
    public async Task InvalidateCacheAsync(int id)
    {
        string cacheKey = $"{typeof(T).Name.ToLower()}:{id}";
        _memoryCache.Remove(cacheKey);
        await _redisCache.RemoveAsync(cacheKey);
    }
}

public class ShoppingCartService
{
    private readonly IRedisCacheService _redisCache;
    private readonly IPublishService _publishService;
    
    public ShoppingCartService(IRedisCacheService redisCache, IPublishService publishService)
    {
        _redisCache = redisCache;
        _publishService = publishService;
    }
    
    public async Task<ShoppingCart> GetCartAsync(string userId)
    {
        string cartKey = $"cart:{userId}";
        return await _redisCache.GetAsync<ShoppingCart>(cartKey) ?? new ShoppingCart { UserId = userId };
    }
    
    public async Task AddItemToCartAsync(string userId, int productId, int quantity)
    {
        string cartKey = $"cart:{userId}";
        
        // Используем Lua-скрипт для атомарного обновления корзины
        string script = @"
            local cartKey = KEYS[1]
            local productId = ARGV[1]
            local quantity = tonumber(ARGV[2])
            
            local cart = redis.call('GET', cartKey)
            if not cart then
                cart = '{""items"":[]}'
            end
            
            local cartObj = cjson.decode(cart)
            local found = false
            
            for i, item in ipairs(cartObj.items) do
                if item.productId == productId then
                    item.quantity = item.quantity + quantity
                    found = true
                    break
                end
            end
            
            if not found then
                table.insert(cartObj.items, {productId=productId, quantity=quantity})
            end
            
            local newCart = cjson.encode(cartObj)
            redis.call('SET', cartKey, newCart, 'EX', 86400)
            
            return newCart
        ";
        
        var result = await _redisCache.EvaluateScriptAsync<string>(
            script,
            new[] { cartKey },
            new[] { productId.ToString(), quantity.ToString() }
        );
        
        // Оповещаем другие экземпляры приложения об изменении
        await _publishService.PublishAsync("cart:updated", userId);
    }
}

public class CacheInvalidationService : IHostedService
{
    private readonly IConnectionMultiplexer _redis;
    private readonly IMemoryCache _memoryCache;
    
    public CacheInvalidationService(IConnectionMultiplexer redis, IMemoryCache memoryCache)
    {
        _redis = redis;
        _memoryCache = memoryCache;
    }
    
    public Task StartAsync(CancellationToken cancellationToken)
    {
        var subscriber = _redis.GetSubscriber();
        subscriber.Subscribe("cache:invalidate", (channel, message) => {
            _memoryCache.Remove(message.ToString());
        });
        
        return Task.CompletedTask;
    }
    
    public Task StopAsync(CancellationToken cancellationToken)
    {
        return Task.CompletedTask;
    }
}