Question

我需要一些建议，告诉我应该使用什么样的模式将数据推送/拉入我的应用程序。

我正在编写一个规则引擎，需要在内存中保存大量数据才能足够高效。我有一些相当矛盾的要求;

引擎始终必须等待所有数据完全预加载才能正常运行。
仅按需提取和缓存数据会导致引擎运行时间过长，无法运行。
外部事件可能会触发重新加载数据的特定部分的需要。

基本上，我认为我需要将数据推送到应用程序中。

我当前“模式”的简化版本看起来像这样（在psuedo-C＃中用记事本写的）：

// This interface is implemented by all classes that needs the data
interface IDataSubscriber 
{
    void RegisterData(Entity data);
}

// This interface is implemented by the data access class
interface IDataProvider
{
    void EnsureLoaded(Key dataKey);
    void RegisterSubscriber(IDataSubscriber subscriber);
}


class MyClassThatNeedsData : IDataSubscriber
{
    IDataProvider _provider;

    MyClassThatNeedsData(IDataProvider provider) 
    {
        _provider = provider;
        _provider.RegisterSubscriber(this);
    }

    public void RegisterData(Entity data) 
    {
        // Save data for later
        StoreDataInCache(data);
    }

    void UseData(Key key)
    {
        // Make sure that the data has been stored in cache
        _provider.EnsureLoaded(key);

        Entity data = GetDataFromCache(key);
    }
}

class MyDataProvider : IDataProvider
{
    List<IDataSubscriber> _subscribers;

    // Make sure that the data for key has been loaded to all subscribers
    public void EnsureLoaded(Key key)
    {
        if (HasKeyBeenMarkedAsLoaded(key))
            return;

        PublishDataToSubscribers(key);

        MarkKeyAsLoaded(key);
    }

    // Force all subscribers to get a new version of the data for key
    public void ForceReload(Key key)
    {
        PublishDataToSubscribers(key);

        MarkKeyAsLoaded(key);
    }

    void PublishDataToSubscribers(Key key)
    {
        Entity data = FetchDataFromStore(key);

        foreach(var subscriber in _subscribers)
        {
            subscriber.RegisterData(data);
        }
    }
}

// This class will be spun off on startup and should make sure that all data is 
// preloaded as quickly as possible
class MyPreloadingThread 
{
    IDataProvider _provider;

    MyPreloadingThread(IDataProvider provider)
    {
        _provider = provider;
    }

    void RunInBackground()
    {
        IEnumerable<Key> allKeys = GetAllKeys();

        foreach(var key in allKeys) 
        {
            _provider.EnsureLoaded(key);
        }
    }
}

我有一种感觉，虽然这不一定是做到这一点的最佳方式。只是解释它的事实似乎需要两页感觉就像一个迹象......

有什么想法吗？那里有任何模式我应该看看？

Answer 1

毫不含糊地说，它应该是

并发模式之一（例如active object）
生产者 - 消费者模式（队列）
延迟加载（按需数据）
lazy unload pattern
策略模式（实现数据访问算法）
多线程访问受保护资源（缓存）

我的投票 - active object共享队列（总线）+懒惰模式+缓存

Answer 2

您可以从简单的事情开始，例如基于Gateway pattern的解决方案。然后，您可以尝试通过添加Cash来提高性能。

数据访问模式，结合推拉？

2 个答案: