Verwenden von Tasks mit bedingten Fortsetzungen

Ich bin ein wenig verwirrt darüber, wie Sie mithilfe von Aufgaben mit bedingten Fortsetzungen.

Wenn ich eine Aufgabe, und dann will ich weiterhin mit Aufgaben, die mit Erfolg und Fehler, und warten dann auf diese zu vervollständigen.

void FunctionThrows() {throw new Exception("faulted");}

static void MyTest()
{

    var taskThrows = Task.Factory.StartNew(() => FunctionThrows());

    var onSuccess = taskThrows.ContinueWith(
                          prev => Console.WriteLine("success"), 
                          TaskContinuationOptions.OnlyOnRanToCompleted);

    var onError = taskThrows.ContinueWith(
                          prev => Console.WriteLine(prev.Exception),
                          TaskContinuationOptions.OnlyOnFaulted);

    //so far, so good



    //this throws because onSuccess was cancelled before it was started
    Task.WaitAll(onSuccess, onError);
}

Ist dies die bevorzugte Art und Weise zu tun, Aufgabe, Erfolg/Misserfolg Verzweigung? Auch, wie soll ich beitreten, um alle diese Aufgaben nehmen wir an, ich habe eine lange Reihe von Fortsetzungen, die jeweils Ihre eigene Fehlerbehandlung.

  //for example
  var task1 = Task.Factory.StartNew(() => ...)
  var task1Error = task1.ContinueWith(  //on faulted
  var task2  = task1.ContinueWith(      //on success
  var task2Error = task2.ContinueWith(  //on faulted
  var task3 = task2.ContinueWith(       //on success
  //etc

Aufrufen WaitAll auf diese unweigerlich wirft, weil einige der Fortsetzungen storniert aufgrund der TaskContinuationOptions und die Berufung Wait auf eine abgebrochene Aufgabe löst.
Wie melde ich mich an diese, ohne die "Eine Aufgabe wurde abgebrochen" Ausnahme"?

InformationsquelleAutor der Frage dan | 2011-04-11

  1. 10

    Ich denke, Ihr Hauptproblem ist, dass du sagst, diese beiden Aufgaben zu "Warten" mit Ihrem Aufruf 

    Task.WaitAll(onSuccess, onError);

    Den onSuccess und onError Fortsetzungen sind setup automatisch für Sie und werden ausgeführt nach Ihre vorhergehende Aufgabe abgeschlossen ist.

    Wenn Sie ersetzen Sie einfach Ihre Task.WaitAll(...) mit taskThrows.Start(); ich glaube, Sie werden die gewünschte Ausgabe erhalten.

    Hier ist ein bisschen ein Beispiel, das ich zusammengestellt habe:

    class Program
{
    static int DivideBy(int divisor) 
    { 
      Thread.Sleep(2000);
      return 10 / divisor; 
    }

    static void Main(string[] args)
    {
        const int value = 0;

        var exceptionTask = new Task<int>(() => DivideBy(value));

        exceptionTask.ContinueWith(result => Console.WriteLine("Faulted ..."), TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.AttachedToParent);
        exceptionTask.ContinueWith(result => Console.WriteLine("Success ..."), TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.AttachedToParent);

        exceptionTask.Start();

        try
        {
            exceptionTask.Wait();
        }
        catch (AggregateException ex)
        {
            Console.WriteLine("Exception: {0}", ex.InnerException.Message);
        }

        Console.WriteLine("Press <Enter> to continue ...");
        Console.ReadLine();
    }
}

    InformationsquelleAutor der Antwort Bryan Ray

  2. 0

    Verwenden Task.WaitAny(onSuccess, onError);

    InformationsquelleAutor der Antwort Dejisys

  3. 0

    Ist das nicht normal?

    Blick auf die MSDN-Dokumentation, die Sie tun es in Ordnung und der Logik, die Sie implementieren, ist der Klang. Das einzige, was Ihnen noch fehlt, ist die Verpackung der WaitAll-Aufruf in eine AggregateException-wrapper in etwa so:

    //Exceptions thrown by tasks will be propagated to the main thread
//while it waits for the tasks. The actual exceptions will be wrapped in AggregateException.
try
{
    //Wait for all the tasks to finish.
    Task.WaitAll(tasks);

    //We should never get to this point
    Console.WriteLine("WaitAll() has not thrown exceptions. THIS WAS NOT EXPECTED.");
}
catch (AggregateException e)
{
    Console.WriteLine("\nThe following exceptions have been thrown by WaitAll(): (THIS WAS EXPECTED)");
    for (int j = 0; j < e.InnerExceptions.Count; j++)
    {
        Console.WriteLine("\n-------------------------------------------------\n{0}", e.InnerExceptions[j].ToString());
    }
}

    Können Sie hier mehr Lesen:
    http://msdn.microsoft.com/en-us/library/dd270695.aspx

    Im wesentlichen das fangen einer AggregatedException bekommt Sie das gleiche wie der Abschluss WaitAll. Es ist eine Sammlung aller Ausnahmen kehrten von Ihren Aufgaben.

    InformationsquelleAutor der Antwort Khepri

Schreibe einen Kommentar