Encapsulate a task to record duration of an async function

Question

If I start with a full console app:

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;

namespace ConsoleApplication3
{
  internal class Program
  {
     private static void Main(string[] args)
     {
        var tas = new List<TaskAuditor<string>>();

        // I want to await these when they actually run so another thread can use it while
        // wait for (example) my EF/SQL to run Async
        tas.Add(new TaskAuditor<string>(await GetName(string.Empty, 1)));
        tas.Add(new TaskAuditor<string>(await GetName(string.Empty, 2)));

        var running = new Task<String>[2];

        foreach (var ta in tas)
        {
           running[0] = ta.Start();
        }

        var runningCount = tas.Count;

        while (runningCount > 0)
        {
           var idx = Task.WaitAny(running);
           runningCount--;

           var task = running[idx];

           var ta = tas.FirstOrDefault(t => t.Task == task);

           Console.WriteLine(ta.Duration.ToString());
        }

        foreach (var ta in tas)
        {
           Console.WriteLine(ta.Task.Result);
        }
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
     }

     public async Task<string> GetName(string constr, int id)
     {
        string result = id.ToString();

        // EF/SQL Async goes here
        if (string.IsNullOrWhiteSpace(constr))
        {
           await Task.Delay(1000 * id);
        }

        return result;
     }
  }

  public class TaskAuditor<T>
  {
     private Task<T> _task;
     private Stopwatch _sw = new Stopwatch();

     public TaskAuditor(Task<T> task)
     {
        _task = task;
     }

     public Task<T> Start()
     {
        _sw.Start();
        _task.Start();
        _sw.Stop();
        return _task;
     }

     public TimeSpan? Duration()
     {
        TimeSpan? result = null;
        if (!_sw.IsRunning)
        {
           result = _sw.Elapsed;
        }
        return result;
     }

     public Task<T> Task
     {
        get
        {
           return _task;
        }
     }
  }
}

DotNetFiddle Sample.

The problem is that I need to await the method and it turns into an Async nightmare I can't quite figure out.

Answer 1

First, your auditor needs some work. As I describe on my blog, you can't call Start on a Promise Task. If you want to represent an operation that results in a task, then use Func<Task<T>>. The next problem is that you're stopping the stopwatch before the task actually completes:

public class TaskAuditor<T>
{
  private Func<Task<T>> _func;
  private Stopwatch _sw = new Stopwatch();

  public TaskAuditor(Func<Task<T>> func)
  {
    _func = func;
  }

  public async Task<T> StartAsync()
  {
    _sw.Start();
    try
    {
      return await _func();
    }
    finally
    {
      _sw.Stop();
    }
  }

  public TimeSpan? Duration()
  {
    TimeSpan? result = null;
    if (!_sw.IsRunning)
    {
       result = _sw.Elapsed;
    }
    return result;
  }
}

Next, your calling method should use modern conveniences like Task.WhenAll, and a separate method to handle the result as they each complete instead of trying to pull the results out of a list:

private static async Task<string> ProcessAsync(TaskAuditor<string> auditor)
{
  try
  {
    return await auditor.StartAsync();
  }
  finally
  {
    Console.WriteLine(auditor.Duration().ToString());
  }
}

private static async Task MainAsync()
{
  var tas = new List<TaskAuditor<string>>();
  tas.Add(new TaskAuditor<string>(() => GetName(string.Empty, 1)));
  tas.Add(new TaskAuditor<string>(() => GetName(string.Empty, 2)));

  var running = tas.Select(ta => ProcessAsync(ta));
  var results = await Task.WhenAll(running);
  foreach (var result in results)
  {
    Console.WriteLine(result);
  }
}

This also keeps the code asynchronous up to the point where it can't be asynchronous, namely, Main:

private static void Main()
{
  MainAsync().Wait();
  Console.WriteLine("Press any key to exit.");
  Console.ReadKey();
}