Task.WaitAny degenerierter Fall Verhalten

Question

ich keine Dokumentation für das Verhalten von Task.WaitAny() unter den folgenden Szenarien finden:

1. ein leeres Array von Aufgaben gegeben.
2. Angesichts einer Reihe von Aufgaben, von denen eine bereits abgeschlossen ist.
3. Angesichts einer Reihe von Aufgaben, die alle bereits abgeschlossen haben. (Wahrscheinlich zurück, die erste oder die letzte je nach Implementierung Detail # 3 einen beliebigen Index Kommissionierung, aber nicht garantiert.)

Meine Vermutung wäre, dass 2 & 3 sofort zurückkehren würde, und ich würde sorta erwarten 1 bis Rückkehr wahr?

Answer 1

Einige kurze Komponententests scheinen dies zu bestätigen ... die folgenden alle passieren. Wenn jemand eine formelle Dokumentation dieses Verhaltens finden kann, würde ich mich freuen, es zu sehen. (Selbst wenn ich meine Fähigkeit verbessern sollte, es beim nächsten Mal selbst zu finden!)

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Threading.Tasks; 
using NUnit.Framework; 
using System.Threading; 

namespace TANTest.Threading 
{ 
    [TestFixture] 
    public class MetaTaskTests 
    { 
    private const int SafeTimeOutMillisecs = 1000; 

    [Test, Timeout(SafeTimeOutMillisecs)] 
    public void Meta_NewTaskCompletes() 
    { 
     var task = new Task(() => { }); 
     task.Start(); 
     Thread.Sleep(10); 

     Assert.That(task.IsCompleted, Is.True); 
    } 

    [Test, Timeout(SafeTimeOutMillisecs)] 
    public void Meta_EmptySetOfTasks_WaitsProceed() 
    { 
     var tasks = new List<Task>(); 
     Task.WaitAny(tasks.ToArray()); 
     Task.WaitAll(tasks.ToArray()); 
    } 

    [Test, Timeout(SafeTimeOutMillisecs)] 
    public void Meta_EmptySetOfTasks_WaitsGiveExpectedOutputs() 
    { 
     var tasks = new List<Task>(); 
     Assert.That(Task.WaitAny(tasks.ToArray(), TimeSpan.FromMilliseconds(100)), Is.EqualTo(-1)); 
     Assert.That(Task.WaitAll(tasks.ToArray(), TimeSpan.FromMilliseconds(100)), Is.True); 
    } 

    [Test, Timeout(SafeTimeOutMillisecs)] 
    public void Meta_SetOfCompletedTasks_WaitsProceed() 
    { 
     var tasks = new List<Task> 
     { 
     new Task(() => { }), 
     new Task(() => { }) 
     }; 

     tasks.ForEach(task => task.Start()); 
     Thread.Sleep(10); 

     Task.WaitAny(tasks.ToArray()); 
     Task.WaitAll(tasks.ToArray()); 
    } 

    [Test, Timeout(SafeTimeOutMillisecs)] 
    public void Meta_SetOfCompletedTasks_WaitsGiveExpectedOutputs() 
    { 
     var tasks = new List<Task> 
     { 
     new Task(() => { }), 
     new Task(() => { }) 
     }; 

     tasks.ForEach(task => task.Start()); 
     Thread.Sleep(10); 

     Assert.That(Task.WaitAny(tasks.ToArray(), TimeSpan.FromMilliseconds(100)), Is.GreaterThan(-1)); 
     Assert.That(Task.WaitAll(tasks.ToArray(), TimeSpan.FromMilliseconds(100)), Is.True); 
    } 

    [Test, Timeout(SafeTimeOutMillisecs)] 
    public void Meta_SetOfUnstartedTasks_WaitsDontProceed() 
    { 
     var tasks = new List<Task> 
     { 
     new Task(() => { }), 
     new Task(() => { }) 
     }; 

     Thread.Sleep(10); 

     Assert.That(Task.WaitAny(tasks.ToArray(), TimeSpan.FromMilliseconds(100)), Is.EqualTo(-1)); 
     Assert.That(Task.WaitAll(tasks.ToArray(), TimeSpan.FromMilliseconds(100)), Is.False); 
    } 


    [Test, Timeout(SafeTimeOutMillisecs)] 
    public void Meta_SetOfTasksWithOneCompleted_AnyProceedsAndOutputsIndex() 
    { 
     var tasks = new List<Task> 
     { 
     new Task(() => { }), 
     new Task(() => { }) 
     }; 

     tasks.First().Start(); 
     Thread.Sleep(10); 

     Assert.That(Task.WaitAny(tasks.ToArray()), Is.GreaterThan(-1)); 
    } 

    [Test, Timeout(SafeTimeOutMillisecs)] 
    public void Meta_SetOfTasksWithOneCompleted_AllTimesOutWithExpectedOutput() 
    { 
     var tasks = new List<Task> 
     { 
     new Task(() => { }), 
     new Task(() => { }) 
     }; 

     tasks.First().Start(); 
     Thread.Sleep(10); 

     Assert.That(Task.WaitAll(tasks.ToArray(), TimeSpan.FromMilliseconds(100)), Is.False); 
    } 
    } 
}