c# - 防止懒惰调用异步委托时缓存异常

Question

我需要一个简单的AsyncLazy<T>，它的行为完全一样Lazy<T>，但正确地支持处理异常并避免缓存它们。

具体来说，我遇到的问题如下：

我可以这样写一段代码：

public class TestClass
{
    private int i = 0;

    public TestClass()
    {
        this.LazyProperty = new Lazy<string>(() =>
        {
            if (i == 0)
                throw new Exception("My exception");

            return "Hello World";

        }, LazyThreadSafetyMode.PublicationOnly);
    }

    public void DoSomething()
    {
        try
        {
            var res = this.LazyProperty.Value;
            Console.WriteLine(res);
            //Never gets here
        }
        catch { }
        i++;       
        try
        {
            var res1 = this.LazyProperty.Value;
            Console.WriteLine(res1);
            //Hello World
        }
        catch { }

    }

    public Lazy<string> LazyProperty { get; }

}

注意LazyThreadSafetyMode.PublicationOnly的使用。

如果初始化方法在任何线程上引发异常，则该异常会从该线程的 Value 属性中传播出去。不缓存异常。

然后我通过以下方式调用它。

TestClass _testClass = new TestClass();
_testClass.DoSomething();

它的工作方式与您预期的完全一样，其中第一个结果因发生异常而被省略，结果保持未缓存，随后读取该值的尝试成功返回“Hello World”。

然而不幸的是，如果我将代码更改为这样的：

public Lazy<Task<string>> AsyncLazyProperty { get; } = new Lazy<Task<string>>(async () =>
{
    if (i == 0)
        throw new Exception("My exception");

    return await Task.FromResult("Hello World");
}, LazyThreadSafetyMode.PublicationOnly);

代码在第一次调用时失败，随后对该属性的调用被缓存（因此永远无法恢复）。

这在某种程度上是有道理的，因为我怀疑异常实际上从来没有冒泡到任务之外，但是我无法确定的是一种通知Lazy<T>任务/对象初始化失败并且不应该被缓存的方法。

任何人都可以提供任何输入？

编辑：

感谢您的回答伊万。我已经成功地通过您的反馈获得了一个基本示例，但事实证明我的问题实际上比上面的基本示例更复杂，毫无疑问，这个问题会影响其他类似情况的人。

因此，如果我将我的财产签名更改为这样的东西（根据 Ivans 的建议）

this.LazyProperty = new Lazy<Task<string>>(() =>
{
    if (i == 0)
        throw new NotImplementedException();

    return DoLazyAsync();
}, LazyThreadSafetyMode.PublicationOnly);

然后像这样调用它。

await this.LazyProperty.Value;

代码有效。

但是，如果您有这样的方法

this.LazyProperty = new Lazy<Task<string>>(() =>
{
    return ExecuteAuthenticationAsync();
}, LazyThreadSafetyMode.PublicationOnly);

然后它本身调用另一个 Async 方法。

private static async Task<AccessTokenModel> ExecuteAuthenticationAsync()
{
    var response = await AuthExtensions.AuthenticateAsync();
    if (!response.Success)
        throw new Exception($"Could not authenticate {response.Error}");

    return response.Token;
}

延迟缓存错误再次出现，并且可以重现该问题。

这是重现问题的完整示例：

this.AccessToken = new Lazy<Task<string>>(() =>
{
    return OuterFunctionAsync(counter);
}, LazyThreadSafetyMode.PublicationOnly);

public Lazy<Task<string>> AccessToken { get; private set; }

private static async Task<bool> InnerFunctionAsync(int counter)
{
    await Task.Delay(1000);
    if (counter == 0)
        throw new InvalidOperationException();
    return false;
}

private static async Task<string> OuterFunctionAsync(int counter)
{
    bool res = await InnerFunctionAsync(counter);
    await Task.Delay(1000);
    return "12345";
}

try
{
    var r = await this.AccessToken.Value;
}
catch (Exception ex) { }

counter++;

try
{
    //Retry is never performed, cached task returned.
    var r1 = await this.AccessToken.Value;

}
catch (Exception ex) { }

标签： c#.netasynchronouslazy-loadinglazy-evaluation

Answer 1

问题是如何Lazy<T>定义“失败”干扰如何Task<T>定义“失败”。

对于Lazy<T>“失败”的初始化，它必须引发异常。这是完全自然且可接受的，尽管它是隐式同步的。

对于Task<T>“失败”，异常被捕获并放置在任务上。这是异步代码的正常模式。

将两者结合会导致问题。如果直接引发异常，则Lazy<T>部分Lazy<Task<T>>只会“失败”，并且async模式Task<T>不会直接传播异常。所以async工厂方法总是会出现（同步）“成功”，因为它们返回一个Task<T>. 至此，该Lazy<T>部分实际上已完成；它的值已生成（即使Task<T>尚未完成）。

您可以轻松构建自己的AsyncLazy<T>类型。您不必仅针对该一种类型依赖 AsyncEx：

public sealed class AsyncLazy<T>
{
  private readonly object _mutex;
  private readonly Func<Task<T>> _factory;
  private Lazy<Task<T>> _instance;

  public AsyncLazy(Func<Task<T>> factory)
  {
    _mutex = new object();
    _factory = RetryOnFailure(factory);
    _instance = new Lazy<Task<T>>(_factory);
  }

  private Func<Task<T>> RetryOnFailure(Func<Task<T>> factory)
  {
    return async () =>
    {
      try
      {
        return await factory().ConfigureAwait(false);
      }
      catch
      {
        lock (_mutex)
        {
          _instance = new Lazy<Task<T>>(_factory);
        }
        throw;
      }
    };
  }

  public Task<T> Task
  {
    get
    {
      lock (_mutex)
        return _instance.Value;
    }
  }

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

  public ConfiguredTaskAwaitable<T> ConfigureAwait(bool continueOnCapturedContext)
  {
    return Task.ConfigureAwait(continueOnCapturedContext);
  }
}