¿Cómo evitar violar el SRP en una clase para administrar el almacenamiento en caché?

Si esta clase realmente fuera tan trivial como parece, entonces no habría necesidad de preocuparse por violar el SRP. Entonces, ¿qué sucede si una función de 3 líneas tiene 2 líneas haciendo una cosa y otra línea haciendo otra? Sí, esta función trivial viola el SRP, ¿y qué? ¿A quien le importa? La violación del SRP comienza a convertirse en un problema cuando las cosas se complican.

Su problema en este caso particular probablemente se debe al hecho de que la clase es más complicada que las pocas líneas que nos ha mostrado.

Específicamente, el problema probablemente reside en el hecho de que esta clase no solo administra el caché, sino que también probablemente contiene la implementación del método GetFluffiesFromDb() . Por lo tanto, la violación del SRP está en la clase, no en los pocos métodos triviales que se muestran en el código que usted publicó.

Entonces, aquí hay una sugerencia sobre cómo manejar todo tipo de casos que se encuentran dentro de esta categoría general, con la ayuda de Decorator Patrón .

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

y se utiliza de la siguiente manera:

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

Tenga en cuenta que CachingFluffiesProvider.GetFluffies() no teme contener el código que comprueba y actualiza el tiempo, porque eso es algo trivial. Lo que hace este mecanismo es abordar y manejar el SRP a nivel de diseño del sistema, donde sea importante, no a nivel de pequeños métodos individuales, donde no importa de todos modos.

Tu clase en sí me parece bien, pero tienes razón en que LoadFluffies() no hace exactamente lo que el nombre anuncia. Una solución simple sería cambiar el nombre y mover la recarga explícita de GetFluffies a una función con una descripción adecuada. Algo como

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

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

se ve limpio para mí (también porque, como dice Patrick: está compuesto de otras funciones minúsculas que obedecen a SRP), y sobre todo también está claro, lo que a veces es igual de importante.

Creo que tu clase está haciendo una cosa; Es un caché de datos con un tiempo de espera. LoadFluffies parece una abstracción inútil a menos que lo llames desde múltiples lugares. Creo que sería mejor tomar las dos líneas de LoadFluffies y ponerlas en el condicional NeedsReload en GetFluffies. Esto haría que la implementación de GetFluffies sea mucho más obvia y aún sea un código limpio, ya que está componiendo subrutinas de responsabilidad única para lograr un solo objetivo, una recuperación en caché de datos de la base de datos. A continuación se muestra el método actualizado de obtener fluffies.

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

    return m_Cache;
}

Tus instintos son correctos. Tu clase, por pequeña que sea, está haciendo demasiado. Debe separar la lógica de almacenamiento en caché de actualización temporizada en una clase completamente genérica. Luego cree una instancia específica de esa clase para administrar Fluffies, algo como esto (no compilado, el código de trabajo se deja como un ejercicio para el lector):

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

Una ventaja adicional es que ahora es muy fácil probar TimedRefreshCache.

Su clase está bien, SRP se trata de una clase que no es una función, toda la clase es responsable de proporcionar los "Fluffies" desde el "Origen de datos" para que esté libre en la implementación interna.

Si desea expandir el mecanismo de generación de llamadas, puede crear una clase responsable de ver la fuente de datos

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