캐싱을 관리하기 위해 클래스에서 SRP를 위반하지 않는 방법은 무엇입니까?

참고 : 코드 샘플은 C #으로 작성되었지만 중요하지 않습니다. 더 적합한 태그를 찾을 수 없기 때문에 C #을 태그로 넣었습니다. 이것은 코드 구조에 관한 것입니다.

Clean Code를 읽고 더 나은 프로그래머가 되려고 노력하고 있습니다.

나는 종종 특히 기능에서 단일 책임 원칙 (클래스와 함수가 한 가지만 수행해야 함)을 따르는 데 어려움을 겪고 있습니다. 어쩌면 내 문제는 "한 가지"가 잘 정의되어 있지 않지만 여전히 ...

예 : 데이터베이스에 Fluffies 목록이 있습니다. 우리는 플러피가 무엇인지 상관하지 않습니다. 나는 수업이 fluffies를 복구하기를 원합니다. 그러나 일부 논리에 따라 플러 프가 변경 될 수 있습니다. 일부 논리에 따라이 클래스는 캐시에서 데이터를 반환하거나 데이터베이스에서 최신을 가져옵니다. 우리는 그것이 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()나에게 괜찮아 보인다. 사용자가 몇 개의 플러 프를 요청하면 제공합니다. 필요한 경우 DB에서 복구하려고하지만 플 루프를 얻는 것의 일부로 간주 될 수 있습니다 (물론 다소 주관적입니다).

NeedsReload()옳은 것 같습니다. 플러피를 다시로드해야하는지 확인합니다. UpdateNextLoad는 괜찮습니다. 다음 재 장전 시간을 업데이트합니다. 그것은 확실히 하나의 것입니다.

그러나 나는 LoadFluffies()한 가지로 설명 할 수없는 것을 느낍니다 . 데이터베이스에서 데이터를 가져오고 다음 재로드를 예약합니다. 다음 재로드 시간을 계산하는 것이 데이터를 얻는 것의 일부라고 주장하기는 어렵습니다. 그러나 더 나은 방법을 찾을 수는 없습니다 (함수의 이름을 바꾸면 LoadFluffiesAndScheduleNextLoad문제가 더 분명해집니다).

SRP에 따라 실제로이 클래스를 작성하는 우아한 솔루션이 있습니까? 내가 너무 장난이 되나요?

아니면 내 수업이 실제로 한 가지 일을하지 않습니까?

이 클래스가 실제로 보이는 것처럼 사소한 것이라면 SRP 위반에 대해 걱정할 필요가 없습니다. 그렇다면 3 줄 함수에 2 줄이 있고 다른 1 줄이 다른 것을하면 어떻게됩니까? 예,이 사소한 기능은 SRP를 위반하므로 어떻게해야합니까? 무슨 상관이야? 상황이 더 복잡해지면 SRP 위반이 문제가되기 시작합니다.

이 특별한 경우의 문제는 아마도 수업이 우리가 보여준 몇 줄보다 더 복잡하다는 사실에서 비롯된 것입니다.

특히, 문제는 아마도이 클래스가 캐시를 관리 할뿐만 아니라 GetFluffiesFromDb()메소드 의 구현도 포함한다는 사실에있을 것입니다 . 따라서 SRP 위반은 게시 한 코드에 표시되는 몇 가지 사소한 방법이 아니라 클래스에 있습니다.

따라서 Decorator Pattern을 사용하여이 일반 범주에 속하는 모든 종류의 사례를 처리하는 방법에 대한 제안이 있습니다.

/// 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()그 사소한 물건이기 때문에, 시간 확인 및 업데이트를 수행하는 코드를 포함하는 것을 두려워하지 않습니다. 이 메커니즘의 역할은 시스템 설계 수준에서 중요하지 않은 작은 개별 방법 수준이 아닌 시스템 설계 수준에서 SRP를 처리하고 처리하는 것입니다.

수업 자체는 괜찮아 보이지만, LoadFluffies()그 이름이 광고하는 것과 정확히 일치하지는 않습니다. 간단한 해결책 중 하나는 이름을 변경하고 GetFluffies에서 명시 적 재로드를 적절한 설명이있는 함수로 옮기는 것입니다. 같은 것

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

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

(Patrick이 말한 것처럼 다른 작은 SRP 순종 함수로 구성되어 있기 때문에) 나에게도 깨끗해 보이며, 특히 중요한 부분이 분명합니다.

수업이 한 가지 일을하고 있다고 생각합니다. 시간이 초과 된 데이터 캐시입니다. LoadFluffies는 여러 곳에서 호출하지 않는 한 쓸모없는 추상화처럼 보입니다. LoadFluffies에서 두 줄을 가져 와서 GetFluffies의 NeedsReload 조건에 넣는 것이 좋습니다. 이렇게하면 GetFluffies의 구현이 훨씬 더 명확 해지고 여전히 코드가 깨끗해집니다. 단일 책임 서브 루틴을 작성하여 단일 목표, 데이터베이스에서 캐시 된 데이터 검색을 달성하기 때문입니다. 업데이트 된 get fluffies 방법은 다음과 같습니다.

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"를 제공해야하므로 내부 구현이 자유 롭습니다.

cahing 메커니즘을 확장하려면 데이터 소스를 볼 수있는 클래스를 만들 수 있습니다.

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