Як уникнути порушення SRP в класі для кешування кешування?

Примітка: Зразок коду написаний c #, але це не має значення. Я поставив c # як тег, тому що не можу знайти більш підходящого. Йдеться про структуру коду.

Я читаю «Чистий код» і намагаюся стати кращим програмістом.

Мені часто буває важко дотримуватися принципу єдиної відповідальності (класи та функції повинні виконувати лише одне), особливо у функціях. Можливо, моя проблема полягає в тому, що "одна річ" недостатньо визначена, але все ж ...

Приклад: у мене є список Fluffies в базі даних. Нам не байдуже, що таке Пухнастий. Я хочу, щоб клас відновив пухнастики. Однак пушинки можуть змінюватися за певною логікою. Залежно від певної логіки, цей клас поверне дані з кешу або отримає останні дані з бази даних. Можна сказати, що вона управляє пухнастиками, і це одне. Щоб зробити це просто, скажімо, що завантажені дані корисні протягом години, а потім вони повинні бути перезавантажені.

class FluffiesManager
{
    private Fluffies m_Cache;
    private DateTime m_NextReload = DateTime.MinValue;
    // ...
    public Fluffies GetFluffies()
    {
        if (NeedsReload())
            LoadFluffies();

        return m_Cache;
    }

    private NeedsReload()
    {
        return (m_NextReload < DateTime.Now);
    }

    private void LoadFluffies()
    {
        GetFluffiesFromDb();
        UpdateNextLoad();
    }

    private void UpdateNextLoad()
    {
        m_NextReload = DatTime.Now + TimeSpan.FromHours(1);
    }
    // ...
}

GetFluffies()мені здається нормальним. Користувач просить трохи пушинок, ми їх надаємо. Якщо потрібно, відновіть їх із БД, але це може вважатися частиною отримання пухнастиків (звичайно, це дещо суб'єктивно).

NeedsReload()здається, що теж. Перевіряє, чи потрібно нам перезавантажувати пушинки. UpdateNextLoad добре. Оновляється час для наступного перезавантаження. це однозначно одна річ.

Однак я відчуваю, що LoadFluffies()робити не можна охарактеризувати як одну єдину річ. Він отримує дані з Бази даних і планує наступне перезавантаження. Важко заперечити, що обчислення часу для наступного перезавантаження є частиною отримання даних. Однак я не можу знайти кращого способу це зробити (перейменування функції на LoadFluffiesAndScheduleNextLoadкраще, але це просто робить проблему більш очевидною).

Чи є елегантне рішення дійсно написати цей клас відповідно до SRP? Я занадто педантичний?

А може, мій клас насправді не займається однією справою?

Якби цей клас справді був настільки тривіальним, як здається, тоді не потрібно було б турбуватися про порушення СРП. Що робити, якщо у 3-рядковій функції 2 рядки роблять одне, а в іншому 1 рядок - інша справа? Так, ця тривіальна функція порушує СРП, і що? Кого хвилює? Порушення СРП починає ставати проблемою, коли справи ускладнюються.

Ваша проблема в цьому конкретному випадку, ймовірно, випливає з того, що клас складніший, ніж кілька рядків, які ви нам показали.

Зокрема, проблема, ймовірно, полягає в тому, що цей клас не тільки управляє кешем, але й, ймовірно, містить реалізацію GetFluffiesFromDb()методу. Отже, порушення SRP полягає в класі, а не в декількох тривіальних методах, які показані в опублікованому вами коді.

Отже, ось вам пропозиція про те, як вирішувати всі види справ, які належать до цієї загальної категорії, за допомогою шаблону декораторів .

/// Provides Fluffies.
interface FluffiesProvider
{
    Fluffies GetFluffies();
}

/// Implements FluffiesProvider using a database.
class DatabaseFluffiesProvider : FluffiesProvider
{
    public override Fluffies GetFluffies()
    {
        ... load fluffies from DB ...
        (the entire implementation of "GetFluffiesFromDb()" goes here.)
    }
}

/// Decorates FluffiesProvider to add caching.
class CachingFluffiesProvider : FluffiesProvider
{
    private FluffiesProvider decoree;
    private DateTime m_NextReload = DateTime.MinValue;
    private Fluffies m_Cache;

    public CachingFluffiesProvider( FluffiesProvider decoree )
    {
        Assert( decoree != null );
        this.decoree = decoree;
    }

    public override Fluffies GetFluffies()
    {
        if( DateTime.Now >= m_NextReload ) 
        {
             m_Cache = decoree.GetFluffies();
             m_NextReload = DatTime.Now + TimeSpan.FromHours(1);
        }
        return m_Cache;
    }
}

і він використовується наступним чином:

FluffiesProvider provider = new DatabaseFluffiesProvider();
provider = new CachingFluffiesProvider( provider );
...go ahead and use provider...

Зауважте, як CachingFluffiesProvider.GetFluffies()не боїться містити код, який робить час перевірки та оновлення, адже це дрібниці. Цей механізм робить - вирішувати та керувати СРП на рівні проектування системи, де це важливо, а не на рівні крихітних окремих методів, де це все одно не має значення.

Ваш клас мені здається прекрасним, але ви маєте рацію в тому, LoadFluffies()що не саме те, що рекламує назва. Одним простим рішенням було б змінити ім'я та перемістити явне перезавантаження з GetFluffies, у функцію з відповідним описом. Щось на зразок

public Fluffies GetFluffies()
{
  MakeSureTheFluffyCacheIsUpToDate();
  return m_Cache;
}

private void MakeSureTheFluffyCacheIsUpToDate()
{
  if( !NeedsReload )
    return;
  GetFluffiesFromDb();
  SetNextReloadTime();
}

для мене виглядає чистою (ще й тому, що, як каже Патрік: він складається з інших крихітних функцій, слухняних SRP), а особливо також зрозумілого, що іноді так само важливо.

Я вважаю, що ваш клас займається однією справою; це кеш даних з тайм-аутом. LoadFluffies видається марною абстракцією, якщо ви не називаєте її з кількох місць. Я думаю, що було б краще взяти два рядки з LoadFluffies і помістити їх в умовно NeedsReload в GetFluffies. Це зробило б реалізацію GetFluffies набагато більш очевидною і досі чистим кодом, оскільки ви складаєте підпрограми єдиної відповідальності для досягнення єдиної мети, кешованого пошуку даних з db. Нижче наведено оновлений метод отримання пуху.

public Fluffies GetFluffies()
{
    if (NeedsReload()) {
        GetFluffiesFromDb();
        UpdateNextLoad();
    }

    return m_Cache;
}

Ваші інстинкти правильні. Ваш клас, хоч і малий, але занадто багато робить. Вам слід відокремити логіку кешованого часу оновлення на абсолютно загальний клас. Потім створіть конкретний екземпляр цього класу для управління Fluffies, щось подібне (не компілюється, робочий код залишається як вправа для читача):

public class TimedRefreshCache<T> {
    T m_Value;
    DateTime m_NextLoadTime;
    Func<T> m_producer();
    public CacheManager(Func<T> T producer, Interval timeBetweenLoads) {
          m_nextLoadTime = INFINITE_PAST;
          m_producer = producer;
    }
    public T Value {
        get {
            if (m_NextLoadTime < DateTime.Now) {
                m_Value = m_Producer();
                m_NextLoadTime = ...;
            }
            return m_Value;
        }
    }
}

public class FluffyCache {
    private TimedRefreshCache m_Cache 
        = new TimedRefreshCache<Fluffy>(GetFluffiesFromDb, interval);
    private Fluffy GetFluffiesFromDb() { ... }
    public Fluffy Value { get { return m_Cache.Value; } }
}

Додатковою перевагою є те, що перевірити TimedRefreshCache зараз дуже просто.

Ваш клас добре, SRP - це про клас, а не про функцію, весь клас відповідає за надання "Fluffies" з "Джерела даних", щоб ви були вільні у внутрішній реалізації.

Якщо ви хочете розширити механізм кешування, ви можете створити клас, відповідальний для перегляду джерела даних

public class ModelWatcher
{

    private static Dictionary<Type, DateTime> LastUpdate;

    public static bool IsUpToDate(Type entityType, DateTime lastRead) {
        if (LastUpdate.ContainsKey(entityType)) {
            return lastRead >= LastUpdate[entityType];
        }
        return true;
    }

    //call this method whenever insert/update changed to any entity
    private void OnDataSourceChanged(Type changedEntityType) {
        //update Date & Time
        LastUpdate[changedEntityType] = DateTime.Now;
    }
}
public class FluffyManager
{
    private DateTime LastRead = DateTime.MinValue;

    private List<Fluffy> list;



    public List<Fluffy> GetFluffies() {

        //if first read or not uptodated
        if (list==null || !ModelWatcher.IsUpToDate(typeof(Fluffy),LastRead)) {
            list = ReadFluffies();
        }
        return list;
    }
    private List<Fluffy> ReadFluffies() { 
    //read code
    }
}