更新:在@usr 指出我错误地假设 Lazy<T> 后进行了大量修改的默认线程安全模式是 LazyThreadSafetyMode.PublicationOnly ...

我想通过 async 延迟计算一个值工厂方法(即它返回 Task<T> )并在成功时将其缓存。在异常(exception)情况下，我希望我可以使用它。然而，我不想成为 the exception caching behavior 的牺牲品。那Lazy<T>处于默认模式 ( LazyThreadSafetyMode.ExecutionAndPublication )

Exception caching: When you use factory methods, exceptions are cached. That is, if the factory method throws an exception the first time a thread tries to access the Value property of the Lazy object, the same exception is thrown on every subsequent attempt. This ensures that every call to the Value property produces the same result and avoids subtle errors that might arise if different threads get different results. The Lazy stands in for an actual T that otherwise would have been initialized at some earlier point, usually during startup. A failure at that earlier point is usually fatal. If there is a potential for a recoverable failure, we recommend that you build the retry logic into the initialization routine (in this case, the factory method), just as you would if you weren’t using lazy initialization.

Stephen Toub has an AsyncLazy class and writeup这似乎是正确的:

public class AsyncLazy<T> : Lazy<Task<T>>
{
    public AsyncLazy(Func<Task<T>> taskFactory) :
        base(() => Task.Factory.StartNew(() => taskFactory()).Unwrap())
    { }

    public TaskAwaiter<T> GetAwaiter() { return Value.GetAwaiter(); }
}

然而，这实际上与默认行为相同 Lazy<T> - 如果出现问题，将不会重试。

我正在寻找 Task<T>兼容等效于 Lazy<T>(Func<T>, LazyThreadSafetyMode.PublicationOnly) ，即它应该按照指定的方式运行:-

Alternative to locking In certain situations, you might want to avoid the overhead of the Lazy object's default locking behavior. In rare situations, there might be a potential for deadlocks. In such cases, you can use the Lazy(LazyThreadSafetyMode) or Lazy(Func, LazyThreadSafetyMode) constructor, and specify LazyThreadSafetyMode.PublicationOnly. This enables the Lazy object to create a copy of the lazily initialized object on each of several threads if the threads call the Value property simultaneously. The Lazy object ensures that all threads use the same instance of the lazily initialized object and discards the instances that are not used. Thus, the cost of reducing the locking overhead is that your program might sometimes create and discard extra copies of an expensive object. In most cases, this is unlikely. The examples for the Lazy(LazyThreadSafetyMode) and Lazy(Func, LazyThreadSafetyMode) constructors demonstrate this behavior.

IMPORTANT

When you specify PublicationOnly, exceptions are never cached, even if you specify a factory method.

有没有整箱，Nito.AsyncEx或可能适合这里的类似结构？如果做不到这一点，任何人都可以看到一种优雅的方式来控制“正在进行的尝试”位(我同意每个调用者以与 Lazy<T>( ..., (LazyThreadSafetyMode.PublicationOnly) 相同的方式进行自己的尝试)并且还没有仍然有那个和缓存管理整齐地封装？

最佳答案

这是否符合您的要求？

行为介于 ExecutionAndPublication 和 PublicationOnly 之间。

当初始化程序正在运行时，所有对 Value 的调用都将被交给相同的任务(临时缓存但随后可能成功或失败)；如果初始化成功，那么完成的任务将被永久缓存；如果初始化器失败，那么下一次调用 Value 将创建一个全新的初始化任务，并且该过程将重新开始!

public sealed class TooLazy<T>
{
    private readonly object _lock = new object();
    private readonly Func<Task<T>> _factory;
    private Task<T> _cached;

    public TooLazy(Func<Task<T>> factory)
    {
        if (factory == null) throw new ArgumentNullException("factory");
        _factory = factory;
    }

    public Task<T> Value
    {
        get
        {
            lock (_lock)
            {
                if ((_cached == null) ||
                    (_cached.IsCompleted && (_cached.Status != TaskStatus.RanToCompletion)))
                {
                    _cached = Task.Run(_factory);
                }
                return _cached;
            }
        }
    }
}

关于c# - 缓存来自 [n async] 工厂方法的结果，前提是它不抛出，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/33872588/