Come evitare di violare l'SRP in una classe per gestire la memorizzazione nella cache?

Se questa classe fosse davvero banale come sembra, allora non ci sarebbe bisogno di preoccuparsi di violare l'SRP. Quindi cosa succede se una funzione a 3 linee ha 2 linee che fanno una cosa, e un'altra 1 linea che fa un'altra cosa? Sì, questa funzione banale viola l'SRP, e allora? Che importa? La violazione dell'SRP inizia a diventare un problema quando le cose si complicano.

Il tuo problema in questo caso particolare deriva probabilmente dal fatto che la classe è più complicata delle poche righe che ci hai mostrato.

In particolare, il problema sta probabilmente nel fatto che questa classe non solo gestisce la cache, ma probabilmente contiene anche l'implementazione del metodo GetFluffiesFromDb() . Quindi, la violazione dell'SRP è nella classe, non nei pochi metodi banali mostrati nel codice che hai postato.

Quindi, ecco un suggerimento su come gestire tutti i tipi di casi che rientrano in questa categoria generale, con l'aiuto del Decorator modello .

/// 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;
    }
}

e viene utilizzato come segue:

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

Nota come CachingFluffiesProvider.GetFluffies() non ha paura di contenere il codice che controlla e aggiorna il tempo, perché è roba banale. Ciò che questo meccanismo fa è di indirizzare e gestire l'SRP a livello di progettazione del sistema, dove è importante, non a livello di piccoli metodi individuali, dove non importa comunque.

La tua stessa classe mi sembra soddisfacente, ma hai ragione in quanto LoadFluffies() non è esattamente ciò che il nome pubblicizza. Una soluzione semplice sarebbe quella di cambiare il nome e spostare il ricarico esplicito da GetFluffies, in una funzione con una descrizione appropriata. Qualcosa come

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

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

mi sembra pulito (anche perché, come dice Patrick, è composto da altre piccole funzioni obbedienti all'SRP), e soprattutto è chiaro che a volte è altrettanto importante.

Credo che la tua classe stia facendo una cosa; è una cache di dati con un timeout. LoadFluffies sembra un'astrazione inutile a meno che non lo chiami da più punti. Penso che sarebbe meglio prendere le due linee da LoadFluffies e inserirle in NeedsReload condizionale in GetFluffies. Ciò renderebbe l'implementazione di GetFluffies molto più ovvia ed è ancora un codice pulito, poiché si stanno componendo sottoprogrammi di singola responsabilità per raggiungere un singolo obiettivo, un recupero nella cache dei dati dal db. Di seguito è riportato il metodo aggiornato get fluffies.

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

    return m_Cache;
}

I tuoi istinti sono corretti. La tua classe, per quanto piccola, sta facendo troppo. È necessario separare la logica di caching di aggiornamento temporizzato in una classe completamente generica. Quindi crea un'istanza specifica di quella classe per la gestione di Fluffies, qualcosa di simile a questo (non compilato, il codice di lavoro è lasciato come esercizio per il lettore):

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; } }
}

Un ulteriore vantaggio è che ora è molto semplice testare TimedRefreshCache.

La tua classe va bene, SRP parla di una classe non di una funzione, l'intera classe è responsabile della fornitura dei "Fluffies" dalla "Fonte dei dati", quindi sei libero nell'implementazione interna.

Se desideri espandere il meccanismo di cahing, puoi creare classi rispettabili per la visualizzazione dell'origine dati

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
    }
}