Freigeben über

Windows Workflow Foundation-Ausnahmen

Workflows können die TryCatch Aktivität verwenden, um Ausnahmen zu behandeln, die während der Ausführung eines Workflows ausgelöst werden. Diese Ausnahmen können behandelt werden, oder sie können mithilfe der Rethrow Aktivität erneut ausgelöst werden. Aktivitäten im abschnitt Finally werden ausgeführt, wenn entweder der Try Abschnitt oder der Catches Abschnitt abgeschlossen ist. Workflows, die von einer WorkflowApplication Instanz gehostet werden, können auch den OnUnhandledException-Ereignishandler verwenden, um Ausnahmen zu behandeln, die von einer TryCatch-Aktivität nicht behandelt werden.

Ursachen von Ausnahmen

In einem Workflow können Ausnahmen auf folgende Weise generiert werden:

  • Timeout von Transaktionen in TransactionScope.

  • Eine explizite Ausnahme, die vom Workflow mithilfe der Throw-Aktivität ausgelöst wird.

  • Eine .NET Framework 4.6.1-Ausnahme, die aus einer Aktivität ausgelöst wird.

  • Eine Ausnahme, die von externem Code ausgelöst wird, z. B. Bibliotheken, Komponenten oder Dienste, die im Workflow verwendet werden.

Behandeln von Ausnahmen

Wenn eine Ausnahme von einer Aktivität ausgelöst wird und nicht behandelt wird, besteht das Standardverhalten darin, die Workflowinstanz zu beenden. Wenn ein benutzerdefinierter OnUnhandledException-Handler vorhanden ist, kann er dieses Standardverhalten außer Kraft setzen. Dieser Handler bietet dem Workflowhostautor die Möglichkeit, die entsprechende Behandlung bereitzustellen, z. B. benutzerdefinierte Protokollierung, Abbrechen des Workflows, Abbrechen des Workflows oder Beenden des Workflows. Wenn ein Workflow eine Ausnahme auslöst, die nicht behandelt wird, wird der OnUnhandledException-Handler aufgerufen. Es gibt drei mögliche Aktionen, die von OnUnhandledException zurückgegeben werden, die das endgültige Ergebnis des Workflows bestimmen.

  • Cancel – Eine abgebrochene Workflowinstanz ist ein ordnungsgemäßer Exit einer Verzweigungsausführung. Sie können das Abbruchverhalten modellieren (z. B. mithilfe einer CancellationScope-Aktivität). Der abgeschlossene Handler wird aufgerufen, wenn der Abbruchvorgang abgeschlossen ist. Ein abgebrochener Workflow befindet sich im Status "Abgebrochen".

  • Beenden – Eine beendete Workflowinstanz kann nicht fortgesetzt oder neu gestartet werden. Dadurch wird das "Completed"-Ereignis ausgelöst, in dem Sie eine Ausnahme als Grund angeben können, warum es beendet wurde. Der Terminated-Handler wird aufgerufen, wenn der Beendigungsprozess abgeschlossen ist. Ein beendeter Workflow befindet sich im Fehlerhaften Zustand.

  • abgebrochene – Eine abgebrochene Workflowinstanz kann nur fortgesetzt werden, wenn sie so konfiguriert wurde, dass sie dauerhaft ist. Ohne Persistenz kann ein Workflow nicht fortgesetzt werden. An dem Punkt, an dem ein Workflow abgebrochen wird, gehen alle aufgaben (im Arbeitsspeicher) seit dem letzten Persistenzpunkt verloren. Bei einem abgebrochenen Workflow wird der abgebrochene Handler mithilfe der Ausnahme aufgerufen, da der Abbruchvorgang abgeschlossen ist. Im Gegensatz zu "Abgebrochen" und "Beendet" wird der abgeschlossene Handler jedoch nicht aufgerufen. Ein abgebrochener Workflow befindet sich in einem abgebrochenen Zustand.

Im folgenden Beispiel wird ein Workflow aufgerufen, der eine Ausnahme auslöst. Die Ausnahme wird vom Workflow nicht behandelt, und der OnUnhandledException-Handler wird aufgerufen. Die WorkflowApplicationUnhandledExceptionEventArgs werden überprüft, um Informationen zur Ausnahme bereitzustellen, und der Workflow wird beendet.

Activity wf = new Sequence
{
    Activities =
     {
         new WriteLine
         {
             Text = "Starting the workflow."
         },
         new Throw
        {
            Exception = new InArgument<Exception>((env) =>
                new ApplicationException("Something unexpected happened."))
        },
        new WriteLine
         {
             Text = "Ending the workflow."
         }
     }
};

WorkflowApplication wfApp = new WorkflowApplication(wf);

wfApp.OnUnhandledException = delegate (WorkflowApplicationUnhandledExceptionEventArgs e)
{
    // Display the unhandled exception.
    Console.WriteLine($"OnUnhandledException in Workflow {e.InstanceId}\n{e.UnhandledException.Message}");

    Console.WriteLine($"ExceptionSource: {e.ExceptionSource.DisplayName} - {e.ExceptionSourceInstanceId}");

    // Instruct the runtime to terminate the workflow.
    return UnhandledExceptionAction.Terminate;

    // Other choices are UnhandledExceptionAction.Abort and
    // UnhandledExceptionAction.Cancel
};

wfApp.Run();

Behandeln von Ausnahmen mit der TryCatch-Aktivität

Die Behandlung von Ausnahmen innerhalb eines Workflows erfolgt mit der TryCatch-Aktivität. Die TryCatch-Aktivität verfügt über eine Catches Sammlung von Catch Aktivitäten, die jeweils einem bestimmten Exception Typ zugeordnet sind. Wenn die Ausnahme, die von einer Aktivität ausgelöst wird, die im Abschnitt Try einer TryCatch Aktivität enthalten ist, mit der Ausnahme einer Catch<TException> Aktivität in der Catches-Auflistung übereinstimmt, wird die Ausnahme behandelt. Wenn die Ausnahme explizit erneut ausgelöst wird oder eine neue Ausnahme ausgelöst wird, wird diese Ausnahme an die übergeordnete Aktivität übergeben. Das folgende Codebeispiel zeigt eine TryCatch Aktivität, die eine ApplicationException behandelt, die im abschnitt Try durch eine Throw Aktivität ausgelöst wird. Die Meldung der Ausnahme wird durch die Catch<TException>-Aktivität in die Konsole geschrieben, und dann wird eine Nachricht im Abschnitt Finally in die Konsole geschrieben.

DelegateInArgument<ApplicationException> ex = new DelegateInArgument<ApplicationException>()
{
    Name = "ex"
};

Activity wf = new TryCatch
{
    Try = new Throw()
    {
        Exception = new InArgument<Exception>((env) => new ApplicationException("An ApplicationException was thrown."))
    },
    Catches =
    {
        new Catch<ApplicationException>
        {
            Action = new ActivityAction<ApplicationException>
            {
                Argument = ex,
                Handler = new WriteLine()
                {
                    Text = new InArgument<string>((env) => ex.Get(env).Message)
                }
            }
        }
    },
    Finally = new WriteLine()
    {
        Text = "Executing in Finally."
    }
};

Die Aktivitäten im abschnitt Finally werden ausgeführt, wenn entweder der Try Abschnitt oder der Catches Abschnitt erfolgreich abgeschlossen wird. Der Try Abschnitt wird erfolgreich abgeschlossen, wenn keine Ausnahmen daraus ausgelöst werden, und der Catches Abschnitt wird erfolgreich abgeschlossen, wenn keine Ausnahmen ausgelöst oder erneut ausgelöst werden. Wenn eine Ausnahme im Try Abschnitt eines TryCatch ausgelöst wird und entweder nicht von einem Catch<TException> im abschnitt Catches behandelt wird oder vom Catcheserneut gesprungen wird, werden die Aktivitäten im Finally nur ausgeführt, wenn eine der folgenden Aktionen auftritt.

Ausnahmebehandlung im Vergleich zur Kompensation

Der Unterschied zwischen Ausnahmebehandlung und Kompensation besteht darin, dass die Ausnahmebehandlung während der Ausführung einer Aktivität auftritt. Die Entschädigung tritt auf, nachdem eine Aktivität erfolgreich abgeschlossen wurde. Die Ausnahmebehandlung bietet die Möglichkeit, nach dem Auslösen der Aktivität die Ausnahme zu bereinigen, während die Entschädigung einen Mechanismus bietet, mit dem die erfolgreich abgeschlossene Arbeit einer zuvor abgeschlossenen Aktivität rückgängig gemacht werden kann. Weitere Informationen finden Sie unter Vergütung.

Siehe auch

  • Last updated on