Какой state-manager использовал?

Опыт работы с State-Management в C#

Как backend-разработчик на C#, я работал с различными подходами к управлению состоянием в зависимости от контекста приложения, масштабируемости требований и конкретных задач. В отличие от frontend-разработки, где state-management часто сводится к управлению состоянием UI, в backend-сфере речь идет преимущественно о состоянии сессий, кэшировании данных, управлении состоянием распределенных систем и обработке долгосрочных операций.

Основные паттерны и технологии state-management в моей практике

1. In-Memory State (Встроенные коллекции и структуры данных)

Для простых сценариев (одноэкземплярные приложения, прототипирование) использовал стандартные коллекции C# с потокобезопасными реализациями:

// Пример потокобезопасного кэша с использованием ConcurrentDictionary
public class SimpleCacheService
{
    private readonly ConcurrentDictionary<string, CachedItem> _cache 
        = new ConcurrentDictionary<string, CachedItem>();
    
    public void AddOrUpdate(string key, object value, TimeSpan expiration)
    {
        _cache[key] = new CachedItem 
        { 
            Value = value, 
            ExpiresAt = DateTime.UtcNow.Add(expiration) 
        };
    }
    
    public bool TryGetValue(string key, out object value)
    {
        if (_cache.TryGetValue(key, out var item) && item.ExpiresAt > DateTime.UtcNow)
        {
            value = item.Value;
            return true;
        }
        value = null;
        return false;
    }
}

2. Распределенный кэш (Distributed Cache)

Для масштабируемых приложений с несколькими экземплярами активно использовал:

• Redis через StackExchange.Redis или библиотеки Microsoft.Extensions.Caching.StackExchangeRedis
• MemoryCache с распределением через IDistributedCache

// Пример использования IDistributedCache с Redis
public class UserSessionService
{
    private readonly IDistributedCache _cache;
    
    public async Task<UserSession> GetSessionAsync(string sessionId)
    {
        var sessionData = await _cache.GetStringAsync($"session:{sessionId}");
        return sessionData != null 
            ? JsonSerializer.Deserialize<UserSession>(sessionData)
            : null;
    }
    
    public async Task UpdateSessionAsync(string sessionId, UserSession session)
    {
        var options = new DistributedCacheEntryOptions
        {
            SlidingExpiration = TimeSpan.FromMinutes(30)
        };
        
        await _cache.SetStringAsync(
            $"session:{sessionId}", 
            JsonSerializer.Serialize(session), 
            options);
    }
}

3. Состояние в рамках Unit of Work и транзакций

При работе с базами данных через Entity Framework Core использовал паттерн Unit of Work для управления состоянием контекста и отслеживания изменений:

public class UnitOfWork : IUnitOfWork, IDisposable
{
    private readonly ApplicationDbContext _context;
    private readonly Dictionary<string, object> _repositories;
    private bool _disposed;
    
    public UnitOfWork(ApplicationDbContext context)
    {
        _context = context;
        _repositories = new Dictionary<string, object>();
    }
    
    public IRepository<T> GetRepository<T>() where T : class
    {
        var typeName = typeof(T).Name;
        if (!_repositories.ContainsKey(typeName))
        {
            _repositories[typeName] = new Repository<T>(_context);
        }
        return (IRepository<T>)_repositories[typeName];
    }
    
    public async Task<int> SaveChangesAsync()
    {
        // Здесь управляем состоянием изменений Entity Framework
        return await _context.SaveChangesAsync();
    }
}

4. State Machines для сложных бизнес-процессов

Для реализации сложных workflow и бизнес-процессов с множеством состояний использовал:

• Stateless (библиотека от Microsoft) для детерминированных конечных автоматов
• MassTransit State Machine для саги-паттерна в распределенных системах

// Пример с использованием Stateless для заказа
public class OrderStateMachine
{
    private readonly StateMachine<OrderState, OrderTrigger> _machine;
    
    public OrderStateMachine()
    {
        _machine = new StateMachine<OrderState, OrderTrigger>(OrderState.Created);
        
        _machine.Configure(OrderState.Created)
            .Permit(OrderTrigger.Submit, OrderState.Submitted)
            .Permit(OrderTrigger.Cancel, OrderState.Cancelled);
        
        _machine.Configure(OrderState.Submitted)
            .Permit(OrderTrigger.Approve, OrderState.Approved)
            .Permit(OrderTrigger.Reject, OrderState.Rejected);
        
        _machine.Configure(OrderState.Approved)
            .Permit(OrderTrigger.Ship, OrderState.Shipped);
    }
    
    public bool TryTransition(OrderTrigger trigger)
    {
        return _machine.CanFire(trigger);
    }
}

5. Orchestration и Saga Pattern

В микросервисных архитектурах для управления распределенным состоянием использовал паттерн Saga:

• Choreography-based sagas (событийный подход)
• Orchestration-based sagas с использованием Azure Durable Functions или Camunda

Критерии выбора подхода

При выборе state-manager я руководствуюсь следующими критериями:

1. Масштабируемость — нужна ли горизонтальная масштабируемость?
2. Согласованность — требования к ACID или подходит eventual consistency?
3. Производительность — важна ли скорость доступа к состоянию?
4. Сложность состояния — простое ключ-значение или сложный граф объектов?
5. Время жизни — временное состояние сессии или персистентные данные?
6. Распределенность — будет ли состояние разделяться между экземплярами приложения?

Рекомендации и лучшие практики

Во всех проектах я придерживаюсь следующих принципов:

• Принцип наименьшего знания — ограничивать видимость состояния минимально необходимой областью
• Иммутабельность где возможно — использование record types и immutable collections
• Явное управление временем жизни — установка TTL для временных данных
• Мониторинг и метрики — отслеживание использования памяти и производительности кэша
• Резервирование и отказоустойчивость — использование кластеров Redis с репликацией

Для большинства современных .NET приложений я предпочитаю сочетание IDistributedCache с Redis для сессий и быстрого доступа к данным, Entity Framework Change Tracking для транзакционного состояния БД и специализированных state machines для сложных бизнес-процессов.