异步/等待-我是否正确并行运行这些方法？

Question

I have an abstract class called VehicleInfoFetcher which returns information asynchronously from a WebClient via this method:

public override async Task<DTOrealtimeinfo> getVehicleInfo(string stopID);

I'd like to combine the results of two separate instances of this class, running each in parallel before combining the results. This is done within a third class, CombinedVehicleInfoFetcher (also itself a subclass of VehicleInfoFetcher )

Here's my code - but I'm not quite convinced that it's running the tasks in parallel; am I doing it right? Could it be optimized?

 public class CombinedVehicleInfoFetcher : VehicleInfoFetcher
    {
        public HashSet<VehicleInfoFetcher> VehicleInfoFetchers { get; set; }

        public override async Task<DTOrealtimeinfo> getVehicleInfo(string stopID)
        {
            // Create a list of parallel tasks to run
            var resultTasks = new List<Task<DTOrealtimeinfo>>();
            foreach (VehicleInfoFetcher fetcher in VehicleInfoFetchers)
                resultTasks.Add(fetcher.getVehicleInfo(stopID, stopID2, timePointLocal));

            // run each task
            foreach (var task in resultTasks)
                await task;

            // Wait for all the results to come in
            await Task.WhenAll(resultTasks.ToArray());

            // combine the results
            var allRealtimeResults = new List<DTOrealtimeinfo>( resultTasks.Select(t => t.Result)  );
            return combineTaskResults(allRealtimeResults);
        }

        DTOrealtimeinfo combineTaskResults(List<DTOrealtimeinfo> realtimeResults)
        {
             // ...


            return rtInfoOutput;
        }

    }

Edit

Some very helpful answers, here is a re-written example to aid discussion with usr below:

       public override async Task<object> combineResults()
        {
            // Create a list of parallel tasks to run
            var resultTasks= new List<object>();
            foreach (AnotherClass cls in this.OtherClasses)
                resultTasks.Add(cls.getResults() );

            // Point A - have the cls.getResults() methods been called yet?

            // Wait for all the results to come in
            await Task.WhenAll(resultTasks.ToArray());

            // combine the results
             return new List<object>( resultTasks.Select(t => t.Result)  );
        }
    }

Answer 1

Almost all tasks start out already started. Probably, whatever fetcher.getVehicleInfo returns is already started. So you can remove:

        // run each task
        foreach (var task in resultTasks)
            await task;

Task.WhenAll is faster and has better error behavior (you want all exceptions to be propagated, not just the first you happen to stumble upon).

Also, await does not start a task. It waits for completion. You have to arrange for the tasks to be started separately, but as I said, almost all tasks are already started when you get them. This is best-practice as well.

---

To help our discussion in the comments:

 Task Test1() { return new Task(() => {}); } Task Test2() { return Task.Factory.StartNew(() => {}); } Task Test3() { return new FileStream("").ReadAsync(...); } Task Test4() { return new TaskCompletionSource<object>().Task; } 

1. Does not "run" when returned from the method. Must be started. Bad practice.
2. Runs when returned. Does not matter what you do with it, it is already running. Not necessary to add it to a list or store it somewhere.
3. Already runs like (2).
4. The notion of running does not make sense here. This task will never complete although it cannot be explicitly started.