การเรียกใช้บริการ async หลายตัวพร้อมกัน

ฉันมีบริการ async REST ไม่กี่รายการซึ่งไม่ได้ขึ้นอยู่กับกันและกัน นั่นคือในขณะที่ "รอ" คำตอบจาก Service1 ฉันสามารถโทร Service2, Service3 และอื่น ๆ

ตัวอย่างเช่นอ้างถึงรหัสด้านล่าง:

var service1Response = await HttpService1Async();
var service2Response = await HttpService2Async();

// Use service1Response and service2Response

ตอนนี้service2Responseไม่ได้ขึ้นอยู่กับservice1Responseพวกเขาและสามารถดึงข้อมูลได้อย่างอิสระ ดังนั้นฉันไม่จำเป็นต้องรอการตอบรับจากบริการแรกเพื่อเรียกบริการที่สอง

ฉันไม่คิดว่าฉันสามารถใช้Parallel.ForEachที่นี่ได้เนื่องจากไม่ใช่การทำงานของ CPU bound

ในการเรียกการดำเนินการสองอย่างนี้แบบขนานฉันสามารถใช้งานได้Task.WhenAllไหม ปัญหาหนึ่งที่ฉันเห็นการใช้Task.WhenAllคือมันไม่ส่งคืนผลลัพธ์ ในการรับผลลัพธ์ฉันสามารถโทรtask.ResultหลังจากโทรTask.WhenAllได้เนื่องจากงานทั้งหมดเสร็จสมบูรณ์แล้วและสิ่งที่ฉันต้องใช้ในการตอบกลับคืออะไร?

รหัสตัวอย่าง:

var task1 = HttpService1Async();
var task2 = HttpService2Async();

await Task.WhenAll(task1, task2)

var result1 = task1.Result;
var result2 = task2.Result;

// Use result1 and result2

รหัสนี้ดีกว่ารหัสแรกในแง่ของประสิทธิภาพไหม วิธีอื่นใดที่ฉันสามารถใช้ได้

ปัญหาหนึ่งที่ฉันเห็นโดยใช้ Task.WhenAll คือมันไม่ส่งคืนผลลัพธ์

แต่มันไม่ส่งกลับผลลัพธ์ พวกเขาทั้งหมดจะอยู่ในประเภททั่วไปดังนั้นจึงไม่มีประโยชน์เสมอไปที่จะใช้ผลลัพธ์เมื่อคุณต้องการค้นหารายการในอาร์เรย์ที่สอดคล้องกับสิ่งTaskที่คุณต้องการผลลัพธ์และอาจนำไปใช้กับมัน ประเภทที่แท้จริงดังนั้นจึงอาจไม่ใช่วิธีที่ง่ายที่สุด / อ่านง่ายที่สุดในบริบทนี้ แต่เมื่อคุณต้องการได้ผลลัพธ์ทั้งหมดจากทุกงานและประเภททั่วไปเป็นประเภทที่คุณต้องการจะปฏิบัติต่อพวกเขามันยอดเยี่ยมมาก .

ในการเรียกผลลัพธ์ฉันสามารถเรียก task.Result หลังจากการเรียก Task.WhenAll เนื่องจากงานทั้งหมดเสร็จสมบูรณ์แล้วและสิ่งที่ฉันต้องใช้ในการตอบสนองคืออะไร?

ใช่คุณสามารถทำได้ คุณสามารถทำได้await( awaitจะแกะข้อยกเว้นในงานที่ผิดพลาดใด ๆ ในขณะที่Resultจะส่งข้อยกเว้นรวม แต่ไม่เช่นนั้นจะเหมือนกัน)

รหัสนี้ดีกว่ารหัสแรกในแง่ของประสิทธิภาพไหม

จะดำเนินการทั้งสองการดำเนินงานในเวลาเดียวกันมากกว่าหนึ่งและอื่น ๆ ไม่ว่าจะดีขึ้นหรือแย่ลงนั้นขึ้นอยู่กับว่าการดำเนินการพื้นฐานเหล่านั้นคืออะไร หากการดำเนินการพื้นฐานคือ "อ่านไฟล์จากดิสก์" การทำแบบขนานนั้นน่าจะช้ากว่าเนื่องจากมีเพียงหนึ่งหัวดิสก์และสามารถอยู่ในที่เดียวในเวลาใดก็ตาม มันกระโดดไปมาระหว่างสองไฟล์จะช้ากว่าการอ่านไฟล์หนึ่งและอีกไฟล์หนึ่ง ในทางกลับกันหากการดำเนินการ "ดำเนินการตามคำขอเครือข่าย" (ตามที่เป็นอยู่ในกรณีนี้) พวกเขาจะมีแนวโน้มที่จะเร็วขึ้น (อย่างน้อยถึงจำนวนคำขอพร้อมกัน) เนื่องจากคุณสามารถรอการตอบกลับได้ จากคอมพิวเตอร์เครือข่ายอื่น ๆ ที่เร็วพอ ๆ กันเมื่อมีคำขอเครือข่ายอื่น ๆ ที่รอดำเนินการอยู่ ถ้าคุณอยากรู้ว่ามัน '

วิธีอื่นใดที่ฉันสามารถใช้ได้

ถ้ามันไม่สำคัญว่าคุณรู้ทุกข้อยกเว้นโยนหมู่ทั้งหมดของการดำเนินงานที่คุณทำในแบบคู่ขนานมากกว่าแค่เป็นคนแรกที่คุณสามารถเพียงแค่awaitงานโดยไม่WhenAllได้ทั้งหมด สิ่งเดียวที่WhenAllทำให้คุณมีAggregateExceptionข้อยกเว้นทุกข้อจากงานที่มีข้อผิดพลาดทุกอย่างแทนที่จะขว้างเมื่อคุณทำภารกิจที่ผิดพลาดครั้งแรก มันง่ายเหมือน:

var task1 = HttpService1Async();
var task2 = HttpService2Async();

var result1 = await task1;
var result2 = await task2;

ต่อไปนี้เป็นวิธีการขยายซึ่งใช้ SemaphoreSlim และอนุญาตให้ตั้งค่าระดับสูงสุดของการขนาน

    /// <summary>
    /// Concurrently Executes async actions for each item of <see cref="IEnumerable<typeparamref name="T"/>
    /// </summary>
    /// <typeparam name="T">Type of IEnumerable</typeparam>
    /// <param name="enumerable">instance of <see cref="IEnumerable<typeparamref name="T"/>"/></param>
    /// <param name="action">an async <see cref="Action" /> to execute</param>
    /// <param name="maxDegreeOfParallelism">Optional, An integer that represents the maximum degree of parallelism,
    /// Must be grater than 0</param>
    /// <returns>A Task representing an async operation</returns>
    /// <exception cref="ArgumentOutOfRangeException">If the maxActionsToRunInParallel is less than 1</exception>
    public static async Task ForEachAsyncConcurrent<T>(
        this IEnumerable<T> enumerable,
        Func<T, Task> action,
        int? maxDegreeOfParallelism = null)
    {
        if (maxDegreeOfParallelism.HasValue)
        {
            using (var semaphoreSlim = new SemaphoreSlim(
                maxDegreeOfParallelism.Value, maxDegreeOfParallelism.Value))
            {
                var tasksWithThrottler = new List<Task>();

                foreach (var item in enumerable)
                {
                    // Increment the number of currently running tasks and wait if they are more than limit.
                    await semaphoreSlim.WaitAsync();

                    tasksWithThrottler.Add(Task.Run(async () =>
                    {
                        await action(item).ContinueWith(res =>
                        {
                            // action is completed, so decrement the number of currently running tasks
                            semaphoreSlim.Release();
                        });
                    }));
                }

                // Wait for all tasks to complete.
                await Task.WhenAll(tasksWithThrottler.ToArray());
            }
        }
        else
        {
            await Task.WhenAll(enumerable.Select(item => action(item)));
        }
    }

ตัวอย่างการใช้งาน:

await enumerable.ForEachAsyncConcurrent(
    async item =>
    {
        await SomeAsyncMethod(item);
    },
    5);

คุณสามารถใช้

Parallel.Invoke(() =>
{
    HttpService1Async();
},
() =>
{   
    HttpService2Async();
});

หรือ

Task task1 = Task.Run(() => HttpService1Async());
Task task2 = Task.Run(() => HttpService2Async());

//If you wish, you can wait for a particular task to return here like this:
task1.Wait();