Wie zu Warten, für Abgebrochene Aufgabe zu Beenden?

Ich natürlich nicht weiß, was ich Tue, wenn es um die parallele Programmierung mit .NET 4.0. Ich habe eine einfache Windows-Anwendung, die eine Aufgabe startet, um einige der sinnlosen Arbeit (die Ausgabe von zahlen 1-1000). Ich habe eine beträchtliche pause in der Hälfte Weg durch simulieren eines lang andauernden Prozesses. Während dieser langen pause stattfindet, wenn ich drücken Sie die Stop-Taste, wird die zugehörige event-handler ruft die Cancel-Methode des CancellationTokenSource. Ich will nicht zu tun, jede weitere Verarbeitung (in diesem Fall die Ausgabe einer Nachricht) in der Haltestellen-button-event-handler, bis der abgebrochene Aufgabe wird erledigt, mit der aktuellen iteration. Wie mache ich das? Ich habe versucht, mit Aufgabe.WaitAll, etc in der Stop-button-event-handler, aber nur wirft eine unbehandelte AggregateException. Hier ist der code, die helfen, zu erklären, mein problem, wenn ausgeführt, wie oben beschrieben:

  private Task t;
  private CancellationTokenSource cts;

  public Form1()
  {
     InitializeComponent();
  }

  private void startButton_Click(object sender, EventArgs e)
  {
     statusTextBox.Text = "Output started.";

     //Create the cancellation token source.
     cts = new CancellationTokenSource();

     //Create the cancellation token.
     CancellationToken ct = cts.Token;

     //Create & start worker task.
     t = Task.Factory.StartNew(() => DoWork(ct), ct);
  }

  private void DoWork(CancellationToken ct)
  {
     for (int i = 1; i <= 1000; i++)
     {
        ct.ThrowIfCancellationRequested();

        Thread.Sleep(10);  //Slow down for text box outout.
        outputTextBox.Invoke((Action)(() => outputTextBox.Text = i + Environment.NewLine));

        if (i == 500)
        {
           Thread.Sleep(5000);
        }
     }
  }

  private void stopButton_Click(object sender, EventArgs e)
  {
     cts.Cancel();

     Task.WaitAll(t);  //this doesn't work :-(

     statusTextBox.Text = "Output ended.";
  }

  private void exitButton_Click(object sender, EventArgs e)
  {
     this.Close();
  }

Jede Hilfe bei diesem würde sehr geschätzt werden. Vielen Dank im Voraus.

InformationsquelleAutor Mac | 2012-08-17

10

Würden Sie normalerweise benutzen Sie einfach Task.Wait (statt WaitAll), als es eine einzelne Aufgabe. und dann die Ausnahme behandelt entsprechend:
```
private void stopButton_Click(object sender, EventArgs e)
{
    cts.Cancel();
    try
    {
        t.Wait();  //This will throw
    }
    catch (AggregateException ae)
    {
       ae.Handle<OperationCanceledException>(ce => true);
    }

    statusTextBox.Text = "Output ended.";
}
```
Wenn Sie kündigen, eine Task, die OperationCanceledException erhalten-verpackt in einer AggregateException und geworfen werden, sobald Sie anrufen Wait() oder versuchen Sie, die Aufgabe Result (wenn es ein Task<T>).

Rein zu Ihrer information - Dies ist ein Ort, vor allem angesichts dessen, was du hier tust, wo C# 5 vereinfacht die Dinge. Mit dem neuen async-Unterstützung, Sie können dies schreiben als:
```
//No need for "t" variable anymore 
//private Task t;


private async void startButton_Click(object sender, EventArgs e)
{
   statusTextBox.Text = "Output started.";

   //Create the cancellation token source.
   cts = new CancellationTokenSource();

   try
   {
      //Create & start worker task.
      await Task.Run(() => DoWork(cts.Token));
      statusTextBox.Text = "Output ended.";
   }
   catch(OperationCanceledException ce) 
   {
      //Note that we get "normal" exception handling
      statusTextBox.Text = "Operation canceled.";
   }
}

private void stopButton_Click(object sender, EventArgs e)
{
   //Just cancel the source - nothing else required here
   cts.Cancel();
}
```
- Ich wollte Sie bitten, einige Referenz auf die Task, Task<T> , async und await, ich habe Ihre blog-posts und wollte mehr darüber Lesen. würde Sie jedem empfehlen Referenz?
- Mein blog ist gut für Aufgaben - für async/await, msdn.microsoft.com/en-us/vstudio/hh378091.aspx und Jon Skeet ' s blog
- Vielen Dank für die Beantwortung meiner Frage, Reed, und für die zusätzlichen Informationen, die vorwärts gehen mit C# 5. Sie erklärt alles sehr gründlich. Nochmals vielen Dank!
- Ich sehe nicht, eine generische form von AggregateException.Griff<T>. Ist dies eine Erweiterung Methode, die Sie geschrieben haben?
- true); sollte: ae.Handle(x => x is OperationCanceledException); ich denke, Reed möglicherweise eine Erweiterung Methode ermöglicht die Typ-parameter.
InformationsquelleAutor Reed Copsey
4

Sorry, nicht genug Ruf, fügen Sie einfach eine Frage als Kommentar zu dieser Antwort. Ich wollte mal Fragen, wie ein work-around als eine Antwort.

Nicht den code in die Antwort setzen auf irgendeine Art von Benutzeroberfläche optimieren, um den Benutzer vor dem starten mehr als ein hintergrund-Prozess zu einer Zeit? Das ist immer ein problem, natürlich.

Hier präsentiere ich Euch eine alternative, die die Frage beantworten, die angegeben ist. Es zeigt, wie zu warten, bis die Abmeldung zu beenden. Er tut dies in einer Weise, dass lässt immer noch den UI-Schraube Dinge, wenn es nicht gut gelungen, aber hat code, der eigentlich wartet, nach der Absage, wenn es das ist, was wirklich gebraucht wird. Dies ist ein Auszug aus einem größeren C# - Klasse:
```
AutoResetEvent m_TaskFinishedEvent = new AutoResetEvent( false );
private IAsyncAction m_Operation = null;

private Task WaitOnEventAsync( EventWaitHandle WaitForEvent )
{
    return Task.Run( () => { WaitForEvent.WaitOne(); } );
}

public async void Start()
{
if( m_Operation != null )
    {
        //Cancel existing task
        m_Operation.Cancel();
        //Wait for it to finish. This returns control to the UI.
        await WaitOnEventAsync( m_TaskFinishedEvent );
    }
    //Start the background task.
    m_Operation = ThreadPool.RunAsync( WorkerMethod );
}

private void WorkerMethod( IAsyncAction operation )
{
    while( m_Operation.Status != AsyncStatus.Canceled )
        ; //Add real work here.

    m_TaskFinishedEvent.Set();
}
```
Dieser code beruht auf ein Ereignis-Objekt, um zu signalisieren, dass die Aufgabe ist meist fertig. Die WorkerMethod() code hat sich nicht zurück-noch nicht, aber alle nützlich, die Arbeit ist getan, wenn das Ereignis signalisiert wird.

Ich nicht eine Stop () - Funktion, weil, wie ich diesen code verwenden. Der code dazu das warten würde nur gehen, dass die Stop () - Funktion, wenn das war, wie der code arbeiten muss.

Ja, Sie können nicht mit einem regelmäßigen Wait () - Funktion aufgrund der Stornierung Ausnahme. Aber die akzeptierte Antwort ist mehr ein work-around, nichts für ungut (und vielleicht bin ich falsch?).

InformationsquelleAutor David Rector

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.