Question

我正在使用Silverlight的Reactive框架，并希望实现以下目标。

我尝试为Silverlight客户端创建一个典型的数据提供程序，它也利用了MS Ent Lib中提供的缓存框架。这些方案要求我必须在访问WCF数据客户端之前检查缓存中的键值对。

通过使用Rx扩展Amb，我能够从缓存或WCF数据客户端中提取数据，无论哪个先返回，但如果值在缓存中，如何阻止WCF客户端执行调用？ / p>

我还想考虑比赛条件，例如：如果第一个订阅者请求某些数据并且提供者正在从WCF数据客户端获取数据（异步），我该如何防止后续异步请求执行相同的操作（在此阶段，尚未填充缓存）。

Answer 1

我有完全相同的问题。我使用带有以下签名的扩展方法解决了它：

IObservable<R> FromCacheOrFetch<T, R>(
    this IObservable<T> source,
    Func<T, R> cache,
    Func<IObservable<T>, IObservable<R>> fetch,
    IScheduler scheduler) where R : class

实际上，这样做是在source observable中获取并返回一个可以将每个输入值与其输出值匹配的observable。

要获取每个输出值，它将首先检查缓存。如果缓存中存在该值，则使用该值。如果不是，它会在不在缓存中的值上启动fetch函数。如果所有值都在缓存中，那么fetch函数将永远不会被旋转 - 因此没有服务连接设置惩罚等等。

我会给你代码，但它是基于使用Maybe<T> monad的扩展方法略有不同的版本 - 所以你可能会发现你需要摆弄实现。

这是：

    public static IObservable<R> FromCacheOrFetch<T, R>(this IObservable<T> source, Func<T, R> cache, Func<IObservable<T>, IObservable<R>> fetch, IScheduler scheduler)
        where R : class
    {
        return source.FromCacheOrFetch<T, R>(t => cache(t).ToMaybe(null), fetch, scheduler);
    }

    public static IObservable<R> FromCacheOrFetch<T, R>(this IObservable<T> source, Func<T, Maybe<R>> cache, Func<IObservable<T>, IObservable<R>> fetch, IScheduler scheduler)
    {
        var results = new Subject<R>();

        var disposables = new CompositeDisposable();

        var loop = new EventLoopScheduler();
        disposables.Add(loop);

        var sourceDone = false;
        var pairsDone = true;
        var exception = (Exception)null;

        var fetchIn = new Subject<T>();
        var fetchOut = (IObservable<R>)null;
        var pairs = (IObservable<KeyValuePair<int, R>>)null;

        var lookup = new Dictionary<T, int>();
        var list = new List<Maybe<R>>();
        var cursor = 0;

        Action checkCleanup = () =>
        {
            if (sourceDone && pairsDone)
            {
                if (exception == null)
                {
                    results.OnCompleted();
                }
                else
                {
                    results.OnError(exception);
                }
                loop.Schedule(() => disposables.Dispose());
            }
        };

        Action dequeue = () =>
        {
            while (cursor != list.Count)
            {
                var mr = list[cursor];
                if (mr.HasValue)
                {
                    results.OnNext(mr.Value);
                    cursor++;
                }
                else
                {
                    break;
                }
            }
        };

        Action<KeyValuePair<int, R>> nextPairs = kvp =>
        {
            list[kvp.Key] = Maybe<R>.Something(kvp.Value);
            dequeue();
        };

        Action<Exception> errorPairs = ex =>
        {
            fetchIn.OnCompleted();
            pairsDone = true;
            exception = ex;
            checkCleanup();
        };

        Action completedPairs = () =>
        {
            pairsDone = true;
            checkCleanup();
        };

        Action<T> sourceNext = t =>
        {
            var mr = cache(t);
            list.Add(mr);
            if (mr.IsNothing)
            {
                lookup[t] = list.Count - 1;
                if (fetchOut == null)
                {
                    pairsDone = false;
                    fetchOut = fetch(fetchIn.ObserveOn(Scheduler.ThreadPool));
                    pairs = fetchIn.Select(x => lookup[x]).Zip(fetchOut, (i, r2) => new KeyValuePair<int, R>(i, r2));
                    disposables.Add(pairs.ObserveOn(loop).Subscribe(nextPairs, errorPairs, completedPairs));
                }
                fetchIn.OnNext(t);
            }
            else
            {
                dequeue();
            }
        };

        Action<Exception> errorSource = ex =>
        {
            sourceDone = true;
            exception = ex;
            fetchIn.OnCompleted();
            checkCleanup();
        };

        Action completedSource = () =>
        {
            sourceDone = true;
            fetchIn.OnCompleted();
            checkCleanup();
        };

        disposables.Add(source.ObserveOn(loop).Subscribe(sourceNext, errorSource, completedSource));

        return results.ObserveOn(scheduler);
    }

示例用法如下所示：

您将获得要获取的索引的来源：

IObservable<X> source = ...

你将拥有一个可以从缓存中获取值的函数和一个可以放入它们的操作（两者都应该是线程安全的）：

Func<X, Y> getFromCache = x => ...;
Action<X, Y> addToCache = (x, y) => ...;

然后你可以实际调用从数据库或服务中获取数据：

Func<X, Y> getFromService = x => ...;

然后你可以这样定义fetch：

Func<IObservable<X>, IObservable<Y>> fetch =
    xs => xs.Select(x =>
    {
        var y = getFromService(x);
        addToCache(x, y);
        return y;
    });

最后，您可以通过调用以下内容来进行查询：

IObservable<Y> results =
    source.FromCacheOrFetch(
        getFromCache,
        fetch,
        Scheduler.ThreadPool);

当然，您需要订阅结果才能进行计算。

Answer 2

显然Amb不是正确的方法，因为每次都会遇到缓存和服务。如果缓存是未命中，EntLib会返回什么？

请注意，Observable.Timeout是一个合理的选择：

cache(<paramters>).Timeout(TimeSpan.FromSeconds(1), service<paramters>);

但显然，如果您想要从EntLib处理返回并执行相应的操作，那么超时并不是一个好主意。

我不明白为什么这必然是Reactive Extensions问题。

Answer 3

一种简单的方法，可能不如@ Enigmativity的解决方案那么全面，可能有以下几点：

public IObservable<T> GetCachedValue<TKey, TResult>(TKey key, Func<TKey, TResult> getFromCache, Func<TKey, TResult> getFromSource)
{
    return getFromCache(<key>).Concat(getFromSource(<key>).Take(1);
}

这只是一个松散的想法，你需要添加：

将项目添加到缓存的机制，或假设getFromSource缓存结果
某种线程安全措施，以防止同一个未缓存密钥在源上发生多次点击（如果需要）
getFromCache需要返回Observable.Empty（）。

但如果你想要一些简单的东西，那就不是一个好的开始。

Rx Amb扩展

3 个答案: