TaskListProcessor

The TaskListProcessor addresses common challenges in .NET concurrent programming, providing a structured approach to running concurrent tasks with different return types.

Understanding these technical concepts will help you grasp how TaskListProcessor enhances concurrent task management in .NET applications.

The WhenAllWithLoggingAsync method enhances the standard Task.WhenAll with robust error handling and centralized logging capabilities.

public static async Task WhenAllWithLoggingAsync(IEnumerable<Task> tasks, ILogger logger)
{
  ArgumentNullException.ThrowIfNull(logger);
  try
  {
    await Task.WhenAll(tasks);
  }
  catch (Exception ex)
  {
    logger.LogError(ex, "TLP: An error occurred while executing one or more tasks.");
  }
}

The GetTaskResultAsync method wraps async calls with telemetry features, measuring execution time and providing performance metrics.

public async Task GetTaskResultAsync<T>(string taskName, Task<T> task) where T : class
{
  var sw = new Stopwatch();
  sw.Start();
  var taskResult = new TaskResult { Name = taskName };
  try
  {
    taskResult.Data = await task;
    sw.Stop();
    Telemetry.Add(GetTelemetry(taskName, sw.ElapsedMilliseconds));
  }
  catch (Exception ex)
  {
    sw.Stop();
    Telemetry.Add(GetTelemetry(taskName, sw.ElapsedMilliseconds, "Exception", ex.Message));
    taskResult.Data = null;
  }
  finally
  {
    TaskResults.Add(taskResult);
  }
}

The TaskResult class is a cornerstone within the TaskListProcessor architecture, designed to encapsulate the outcome of asynchronous tasks with unified structure.

public class TaskResult<T> : ITaskResult
{
  public TaskResult()
  {
    Name = "UNKNOWN";
    Data = null;
  }

  public TaskResult(string name, T data)
  {
    Name = name;
    Data = data;
  }
  public T? Data { get; set; }
  public string Name { get; set; }
}

The WeatherService class simulates real-world external service calls with artificial latency and potential failures for comprehensive testing scenarios.

Let's examine a practical implementation that demonstrates fetching weather forecasts for multiple cities concurrently, simulating a real-world travel dashboard.

var loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
var logger = loggerFactory.CreateLogger<Program>();
var weatherService = new WeatherService();
var weatherCities = new TaskListProcessing.TaskListProcessor();
var cities = new List<string> { "London", "Paris", "New York", "Tokyo", "Sydney", "Chicago", "Dallas", "Wichita" };
var tasks = new List<Task>();

foreach (var city in cities)
{
  tasks.Add(weatherCities.GetTaskResultAsync(city, weatherService.GetWeather(city)));
}

await TaskListProcessing.TaskListProcessor.WhenAllWithLoggingAsync(tasks, logger);

Telemetry:
Chicago: Task completed in 602 ms with ERROR Exception: Random failure occurred fetching weather data.
Paris: Task completed in 723 ms with ERROR Exception: Random failure occurred fetching weather data.
Dallas: Task completed in 1,009 ms
Sydney: Task completed in 1,318 ms
Tokyo: Task completed in 1,921 ms
London: Task completed in 2,789 ms

Results:
Dallas: City: Dallas, Date: 2023-11-10, Temp (F): 40, Summary: Cool
Sydney: City: Sydney, Date: 2023-11-10, Temp (F): 116, Summary: Sweltering
Tokyo: City: Tokyo, Date: 2023-11-10, Temp (F): 75, Summary: Warm
London: City: London, Date: 2023-11-10, Temp (F): 16, Summary: Chilly

The latest enhancement introduces the CityThingsToDo service, showcasing the power and flexibility of our architecture to seamlessly integrate different service types and return types.

var thingsToDoService = new CityThingsToDoService();
var weatherService = new WeatherService();
var cityDashboards = new TaskListProcessorGeneric();
var cities = new List<string> { "London", "Paris", "New York", "Tokyo", "Sydney", "Chicago", "Dallas", "Wichita" };
var tasks = new List<Task>();

foreach (var city in cities)
{
  tasks.Add(cityDashboards.GetTaskResultAsync($"{city} Weather", weatherService.GetWeather(city)));
  tasks.Add(cityDashboards.GetTaskResultAsync($"{city} Things To Do", thingsToDoService.GetThingsToDoAsync(city)));
}

await cityDashboards.WhenAllWithLoggingAsync(tasks, logger);

In the realm of .NET, orchestrating concurrent asynchronous tasks is a common challenge with the potential to become a transformative learning journey.