using System;

using System.Diagnostics;

using System.Linq;

using System.Runtime.CompilerServices;

using System.Threading;

using System.Threading.Tasks;

​

public class Program

{

    public static async Task Main()

    {

        int executionsCounter = 0;

        int concurrencyCounter = 0;

​

        AsyncExpiringLazy<int> asyncExpiringLazy = new(async () =>

        {

            var executions = Interlocked.Increment(ref executionsCounter);

            var concurrency = Interlocked.Increment(ref concurrencyCounter);

            try

            {

                Print($"**Factory invoked ({executions}), Concurrency: {concurrency}");

                Thread.Sleep(300); // Simulate a blocking operation.

                await Task.Delay(200); // Simulate an I/O-bound operation.

                if (executions == 2) throw new ApplicationException($"Oops! ({executions})");

                return executions;

            }

            finally { Interlocked.Decrement(ref concurrencyCounter); }

        }, _ => TimeSpan.FromMilliseconds(1000));

​

        Task[] workers = Enumerable.Range(1, 24).Select(n => Task.Run(async () =>

        {

            await Task.Delay((n - 1) * 200);

            Print($"Worker #{n} requesting value");

            var stopwatch = Stopwatch.StartNew();

            // Measure the duration of getting the task.

            var task = asyncExpiringLazy.Task;

            var duration1 = stopwatch.ElapsedMilliseconds; stopwatch.Restart();

            // Measure the duration of awaiting the task.

            try { await task; } catch { }

            var duration2 = stopwatch.ElapsedMilliseconds;

            string timeInfo = $" (blocked for {duration1:#,0} msec, awaited for {duration2:#,0} msec)";

            try

            {

                var result = await task;

                Print($"--Worker #{n} received value: {result}{timeInfo}");

            }

            catch (Exception ex)

            {

                Print($"--Worker #{n} failed: {ex.Message}{timeInfo}");

            }

        })).ToArray();

        await Task.WhenAll(workers);

        Print($"Finished");

    }

​

    /// <summary>

    /// Represents the result of an asynchronous operation that is invoked lazily

    /// on demand, and is subject to an expiration policy. Errors are not cached.

    /// Subsequent executions do not overlap. Concurrent observers receive

    /// the result of the same operation.

    /// </summary>

    public class AsyncExpiringLazy<TResult>

    {

        private readonly object _locker = new object();

        private readonly Func<Task<TResult>> _taskFactory;

        private readonly Func<TResult, TimeSpan> _expirationSelector;

        private State _state;

​

        // The mutable state is stored in a record struct for convenience.

        private record struct State(Task<TResult> Task, long ExpirationTimestamp);

​

        public AsyncExpiringLazy(Func<Task<TResult>> taskFactory,

            Func<TResult, TimeSpan> expirationSelector)

        {

            ArgumentNullException.ThrowIfNull(taskFactory);

            ArgumentNullException.ThrowIfNull(expirationSelector);

            _taskFactory = taskFactory;

            _expirationSelector = expirationSelector;

        }

​

        public AsyncExpiringLazy(Func<TResult> valueFactory,

            Func<TResult, TimeSpan> expirationSelector)

        {

            ArgumentNullException.ThrowIfNull(valueFactory);

            ArgumentNullException.ThrowIfNull(expirationSelector);

            _taskFactory = () => System.Threading.Tasks.Task.FromResult(valueFactory());

            _expirationSelector = expirationSelector;

        }

​

        private Task<TResult> GetTask()

        {

            Task<Task<TResult>> newTaskTask;

            Task<TResult> newTask;

            lock (_locker)

            {

                if (_state.Task is not null

                    && _state.ExpirationTimestamp > Environment.TickCount64)

                        return _state.Task; // The task has not expired.

​

                // Either this is the first call, or the task expired or failed.

                newTaskTask = new(_taskFactory);

                newTask = newTaskTask.Unwrap().ContinueWith(task =>

                {

                    State newState = default;

                    try

                    {

                        if (task.IsCompletedSuccessfully)

                        {

                            TimeSpan expiration = _expirationSelector(task.Result);

                            if (expiration > TimeSpan.Zero)

                                newState = new State(task, Environment.TickCount64

                                    + (long)expiration.TotalMilliseconds);

                        }

                    }

                    finally

                    {

                        // In case the task or the selector failed,

                        // or the expiration is not positive, the _state is

                        // updated to default, to trigger a retry later.

                        lock (_locker) _state = newState;

                    }

                    return task;

                }, default, TaskContinuationOptions.DenyChildAttach |

                    TaskContinuationOptions.ExecuteSynchronously,

                    TaskScheduler.Default).Unwrap();

​

                // While the task is running, the expiration is set to never.

                _state = new State(newTask, Int64.MaxValue);

            }

            newTaskTask.RunSynchronously(TaskScheduler.Default);

            return newTask;

        }

​

        public Task<TResult> Task => GetTask();

​

        public TResult Result => GetTask().GetAwaiter().GetResult();

​

        public TaskAwaiter<TResult> GetAwaiter() => GetTask().GetAwaiter();

​

        public ConfiguredTaskAwaitable<TResult> ConfigureAwait(

            bool continueOnCapturedContext)

                => GetTask().ConfigureAwait(continueOnCapturedContext);

​

        public bool ExpireImmediately()

        {

            lock (_locker)

            {

                if (_state.Task is null) return false;

                if (!_state.Task.IsCompleted) return false;

                _state = default;

                return true;

            }

        }

    }

​

    private static void Print(object value)

    {

        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff} {($"[{Thread.CurrentThread.ManagedThreadId}]"),4} > {value}");

    }

}