using System;

using System.Collections.Generic;

using System.Threading.Tasks;

public class Program

{

    public static async Task Main()

    {

        var transport = new Transport

        {

            Vehichle = new Vehichle { Id = "1234" },

            Stops = new List<Stop>

            {

                new Stop { Id = "a1" },

                new Stop { Id = "b2" },

                new Stop { Id = "c3" },

            }

        };

​

        await IntegrateDataAsync(transport);

        var json = Newtonsoft.Json.JsonConvert.SerializeObject(transport, Newtonsoft.Json.Formatting.Indented);

        Console.WriteLine(json);

    }

    private static async Task IntegrateDataAsync(Transport transport)

    {

        var collector = new AsyncCollector();

        // The data fetch and assignment is wrapped inside a delegate

        // which gets passed to the helper Async function.

        collector.Register(async () =>

        {

            transport.Vehichle.Name = await GetVehichleNameAsync(transport.Vehichle.Id);

        });

        if (transport.Stops != null)

        {

            foreach (var s in transport.Stops)

                collector.Register(async () => s.Description = await GetStopDescriptionAsync(s.Id));

        }

        await collector.WhenAll();

    }

    private static Task<string> GetVehichleNameAsync(string vehicleId) => Task.FromResult($"A vehichle: {vehicleId}");

    private static Task<string> GetStopDescriptionAsync(string stopId) => Task.FromResult($"A stop: {stopId}");

    #region Models

    class Transport

    {

        public Vehichle Vehichle { get; set; }

        public List<Stop> Stops { get; set; }

    }

​

    class Vehichle

    {

        public string Id { get; set; }

        public string Name { get; set; }

    }

​

    class Stop

    {

        public string Id { get; set; }

        public DateTime Time { get; set; }

        public string Description { get; set; }

    }

    #endregion

    #region Async collector

    class AsyncCollector

    {

        public IReadOnlyList<Task> Tasks => _tasks.AsReadOnly();

​

        private readonly List<Task> _tasks = new List<Task>();

​

        public void Register(Func<Task> asyncDelegate) =>

            this.Register(asyncDelegate, out _);

​

        public void Register(Func<Task> asyncDelegate, out Task registeredTask)

        {

            registeredTask = Async(asyncDelegate);

            _tasks.Add(registeredTask);

        }

​

        public async Task WhenAll(bool clearAfterwards = true)

        {

            try { await Task.WhenAll(_tasks); }

            finally { if (clearAfterwards) _tasks.Clear(); }

        }

​

        public void Clear() => _tasks.Clear();

​

        private async Task Async(Func<Task> asyncDelegate) =>

            await asyncDelegate().ConfigureAwait(false);

    }

    #endregion

}