caching the result from a [n async] factory method iff it doesn’t throw

by

Does this get anywhere near your requirements?

The behaviour falls somewhere between ExecutionAndPublication and PublicationOnly.

While the initializer is in-flight all calls to Value will be handed the same task (which is cached temporarily but could subsequently succeed or fail); if the initializer succeeds then that completed task is cached permanently; if the initializer fails then the next call to Value will create a completely new initialization task and the process begins again!

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

More Related Contents:

  1. Benefits of using async and await keywords
  2. Why use async and return await, when you can return Task directly?
  3. Should I worry about “This async method lacks ‘await’ operators and will run synchronously” warning
  4. is using an an `async` lambda with `Task.Run()` redundant?
  5. How and when to use ‘async’ and ‘await’
  6. Can’t specify the ‘async’ modifier on the ‘Main’ method of a console app
  7. When correctly use Task.Run and when just async-await
  8. If async-await doesn’t create any additional threads, then how does it make applications responsive?
  9. Task vs Thread differences [duplicate]
  10. How to use HttpWebRequest (.NET) asynchronously?
  11. Await on a completed task same as task.Result?
  12. How can I limit Parallel.ForEach?
  13. Best way in .NET to manage queue of tasks on a separate (single) thread
  14. Enforce an async method to be called once
  15. Task continuation on UI thread
  16. Asynchronous Task.WhenAll with timeout
  17. My C# application is returning 0xE0434352 to Windows Task Scheduler but it is not crashing
  18. Async and await – difference between console, Windows Forms and ASP.NET
  19. Good introduction to the .NET Reactive Framework [closed]
  20. Why would try/finally rather than a “using” statement help avoid a race condition?
  21. Can .NET Task instances go out of scope during run?
  22. Converting async/await to Task.ContinueWith
  23. How to Async Files.ReadAllLines and await for results?
  24. Is it possible to get successful results from a Task.WhenAll when one of the tasks fails? [duplicate]
  25. Can I cancel StreamReader.ReadLineAsync with a CancellationToken?
  26. Await and SynchronizationContext in a managed component hosted by an unmanaged app
  27. Task chaining (wait for the previous task to completed)
  28. Sessions in Asynchronous design
  29. Timeout pattern on task-based asynchronous method in C#
  30. How can I run both of these methods ‘at the same time’ in .NET 4.5?

Leave a Comment