Aktion <Task> Implementierung

Question

Ich brauche zwei Methoden für die Aufgabe zu erstellen, die jeweils ot wird sie ContinueWith ähnlich sein(), aber wird contunuation in Haupt-UI-Thread ausgeführt.

Überlastungs-Methode mit Parametern Action, Action<Task>

Methode gibt Aufgabe (für Überlastungen mit ACTION). Zurückgegebene Aufgabe muss beendet werden, nachdem Hauptaufgabe und Fortsetzung abgeschlossen sind.

Ist es richtig Implementierung Funktion mit Action? Und wie zweiten Fall implementieren mit Action<Task> input mit Returned task must finish only after main Task and continuation

implementiert I

namespace WpfApplication2 
{ 
/// <summary> 
/// Interaction logic for MainWindow.xaml 
/// </summary> 
public partial class MainWindow : Window 
{ 
    public MainWindow() 
    { 
     InitializeComponent(); 
    } 

    private void Button_Click(object sender, RoutedEventArgs e) 
    { 
     TaskScheduler uiScheduler = TaskScheduler.FromCurrentSynchronizationContext(); 
     WorkAsync WA = new WorkAsync(); 
     Action firstaction = new Action(WA.Count); 
     WA.Work(firstaction, uiScheduler); 

     Action<Task> secondaction = new Action<Task>(); //What should be here? 
     WA.Work(secondaction, uiScheduler); 
    } 
    public class WorkAsync 
    { 
     public Task Work(Action input, TaskScheduler uiSchedule) 
     { 
      return Task.Factory.StartNew(input).ContinueWith((e) => { Console.WriteLine("Done"); }, uiSchedule); 
     } 
     public Task Work(Action<Task> input, TaskScheduler uiSchedule) 
     { 
      /// What should be here? 
     } 

     public void Count() 
     { 
      for (int i = 0; i < 10; i++) 
      { 
       System.Threading.Thread.Sleep(1000); 
       Console.WriteLine(i); 
      } 
     } 
    } 
} 

}

Answer 1

Ihre Anforderungen klingen nicht richtig. Das asynchrone Gegenstück von Action ist nicht Action<Task> - es ist Func<Task>. Es gibt eine Reihe von Methoden im Rahmen, um meine obige Aussage zu unterstützen, nämlich Task.Run.

In ähnlicher Weise ist für Action<T> die asynchrone Version Func<T, Task>. Für Action<T1, T2> ist es Func<T1, T2, Task>. Du hast die Idee.

Also, in diesem Sinne wird die Implementierung jetzt:

public Task Work(Func<Task> input, TaskScheduler uiScheduler) 
{ 
    return input().ContinueWith(e => Console.WriteLine("Done"), uiScheduler); 
} 

, die für Anrufe wie diese ermöglichen:

Task myCustomTaskFollowedByConsoleWriteLine = Work(async() => 
{ 
    object result = await SomeIOWorkAsync(); 

    SomeSynchronousCpuBoundWork(result); 
}, 
uiScheduler); 

Sie können nun auch die andere Methode in Bezug auf Work(Func<Task>, TaskScheduler) auszudrücken:

public Task Work(Action input, TaskScheduler uiScheduler) 
{ 
    return Work(() => Task.Run(input), uiScheduler); 
}