Önbelleğe almayı yönetmek için bir sınıftaki SRP'yi ihlal etmekten nasıl kaçınılır?

Not: Kod örneği c # ile yazılmıştır, ancak bu önemli olmamalıdır. Daha uygun bir tane bulamadığım için etiket olarak c # koydum. Bu kod yapısı ile ilgilidir.

Temiz Kod okuyorum ve daha iyi bir programcı olmaya çalışıyorum.

Kendimi genellikle Tek Sorumluluk Prensibine (sınıflar ve işlevler sadece bir şey yapmalıdır), özellikle işlevlerde takip etmekte zorlanırım. Belki benim sorunum "tek bir şey" iyi tanımlanmış değil, ama yine de ...

Bir örnek: Bir veritabanında Fluffies listesi var. Bir Fluffy'nin ne olduğu umrumda değil. Bir sınıfın tüyleri düzeltmesini istiyorum. Ancak, kabartmalar bazı mantığa göre değişebilir. Bazı mantığa bağlı olarak, bu sınıf verileri önbellekten döndürür veya veritabanından en son verileri alır. Tüyleri yönettiğini söyleyebiliriz ve bu bir şeydir. Basitleştirmek için, yüklenen verilerin bir saat boyunca iyi olduğunu ve daha sonra yeniden yüklenmesi gerektiğini varsayalım.

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()bana iyi geliyor. Kullanıcı bazı kabarıklıklar ister, biz bunları sağlıyoruz. Gerekirse onları DB'den kurtaracak, ancak bu tüyleri elde etmenin bir parçası olarak düşünülebilir (elbette, bu biraz özneldir).

NeedsReload()doğru görünüyor. Fluffies'i yeniden yüklememiz gerekip gerekmediğini kontrol eder. UpdateNextLoad iyidir. Bir sonraki yeniden yükleme süresini günceller. bu kesinlikle tek bir şey.

Ancak, neyin LoadFluffies()tek bir şey olarak tanımlanamayacağını hissediyorum . Veritabanından veri alıyor ve bir sonraki yeniden yüklemeyi planlıyor. Bir sonraki yeniden yükleme için sürenin hesaplanmasının veri almanın bir parçası olduğunu iddia etmek zor. Bununla birlikte, bunu yapmak için daha iyi bir yol bulamıyorum (işlevi yeniden adlandırmak LoadFluffiesAndScheduleNextLoaddaha iyi olabilir, ancak sorunu daha açık hale getirir).

Bu sınıfı gerçekten SRP'ye göre yazmak için zarif bir çözüm var mı? Çok bilgiç miyim?

Ya da belki de sınıfım gerçekten tek bir şey yapmıyor?

Eğer bu sınıf göründüğü kadar önemsiz olsaydı, o zaman SRP'yi ihlal etme konusunda endişelenmenize gerek olmazdı. Peki ya 3 satırlı bir işlevin bir işi yapan 2 satır ve başka bir şey yapan başka bir 1 satırı varsa? Evet, bu önemsiz işlev SRP'yi ihlal ediyor, peki ne olacak? Kimin umrunda? SRP'nin ihlali, işler daha karmaşık hale geldiğinde sorun olmaya başlar.

Bu özel durumdaki probleminiz büyük olasılıkla sınıfın bize gösterdiğiniz birkaç satırdan daha karmaşık olmasından kaynaklanmaktadır.

Özellikle, sorun büyük olasılıkla bu sınıfın sadece önbelleği yönetmesi değil, aynı zamanda GetFluffiesFromDb()yöntemin uygulanmasını da içermesidir . Dolayısıyla, SRP'nin ihlali sınıftadır, yayınladığınız kodda gösterilen birkaç önemsiz yöntemde değil.

İşte, bu genel kategoriye giren her türlü vakanın Dekoratör Kalıbı yardımıyla nasıl ele alınacağına dair bir öneri .

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

ve aşağıdaki gibi kullanılır:

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

CachingFluffiesProvider.GetFluffies()Bu, önemsiz şeyler olduğu için zaman kontrolünü ve güncellemeyi yapan kodu içermekten nasıl korkmadığını unutmayın . Bu mekanizmanın yaptığı, SRP'nin önemsiz olduğu küçük bireysel yöntemler düzeyinde değil, sistem tasarım düzeyinde ele alınması ve ele alınmasıdır.

Sınıfınızın kendisi bana iyi geliyor, ama haklısınız, LoadFluffies()tam olarak adın reklamını yapmıyor. Basit bir çözüm, adı değiştirmek ve açık yeniden yüklemeyi GetFluffies'ten uygun bir açıklamaya sahip bir işleve taşımak olacaktır. Gibi bir şey

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

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

bana temiz görünüyor (çünkü Patrick'in dediği gibi: diğer küçük SRP'ye itaatkâr işlevlerden oluşuyor) ve özellikle de bazen de önemli olan açık.

Sınıfınızın bir şey yaptığını düşünüyorum; zaman aşımı olan bir veri önbelleğidir. LoadFluffies, birden fazla yerden çağırmadıkça işe yaramaz bir soyutlama gibi görünüyor. LoadFluffies iki satır almak ve GetFluffies NeedsReload koşullu koymak daha iyi olacağını düşünüyorum. Bu, GetFluffies'in uygulanmasını çok daha açık hale getirecektir ve tek bir hedefi gerçekleştirmek için tek sorumluluk altprogramları oluşturduğunuzdan, db'den verilerin önbelleğe alınmış bir şekilde elde edilmesinden dolayı temiz koddur. Aşağıda güncellenen fluffies yöntemi verilmiştir.

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

    return m_Cache;
}

İçgüdülerin doğru. Sınıfınız, küçük olsa da, çok fazla şey yapıyor. Zamanlı yenileme önbellek mantığını tamamen genel bir sınıfa ayırmalısınız. Ardından, Fluffies'ı yönetmek için bu sınıfın belirli bir örneğini oluşturun, böyle bir şey (derlenmemiş, çalışma kodu okuyucu için bir alıştırma olarak bırakılır):

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

Ek bir avantaj, TimedRefreshCache'i test etmenin artık çok kolay olmasıdır.

Sınıfınız iyi, SRP bir işlev değil bir sınıf hakkında, tüm sınıf "Veri Kaynağı" "Fluffies" sağlamaktan sorumludur, bu yüzden dahili uygulamada özgürsünüz.

Cahing mekanizmasını genişletmek istiyorsanız, veri kaynağını izlemek için sorumlu sınıf oluşturabilirsiniz

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