Delen via

Windows Workflow Foundation-uitzonderingen

  • Artikel

Werkstromen kunnen de TryCatch activiteit gebruiken om uitzonderingen te verwerken die worden gegenereerd tijdens het uitvoeren van een werkstroom. Deze uitzonderingen kunnen worden verwerkt of opnieuw worden gegenereerd met behulp van de Rethrow activiteit. Activiteiten in de Finally sectie worden uitgevoerd wanneer de Try sectie of de Catches sectie is voltooid. Werkstromen die worden gehost door een WorkflowApplication exemplaar kunnen ook de OnUnhandledException gebeurtenis-handler gebruiken om uitzonderingen te verwerken die niet worden verwerkt door een TryCatch activiteit.

Oorzaken van uitzonderingen

In een werkstroom kunnen uitzonderingen op de volgende manieren worden gegenereerd:

  • Een time-out van transacties in TransactionScope.

  • Een expliciete uitzondering die wordt gegenereerd door de werkstroom met behulp van de Throw activiteit.

  • Een .NET Framework 4.6.1-uitzondering veroorzaakt door een activiteit.

  • Een uitzondering die wordt veroorzaakt door externe code, zoals bibliotheken, onderdelen of services die worden gebruikt in de werkstroom.

Uitzonderingen verwerken

Als een uitzondering wordt gegenereerd door een activiteit en niet wordt afgehandeld, is het standaardgedrag om het werkstroomexemplaren te beëindigen. Als er een aangepaste OnUnhandledException handler aanwezig is, kan deze dit standaardgedrag overschrijven. Deze handler biedt de auteur van de werkstroomhost de mogelijkheid om de juiste afhandeling te bieden, zoals aangepaste logboekregistratie, het afbreken van de werkstroom, het annuleren van de werkstroom of het beëindigen van de werkstroom. Als een werkstroom een uitzondering genereert die niet wordt verwerkt, wordt de OnUnhandledException handler aangeroepen. Er zijn drie mogelijke acties die het OnUnhandledException uiteindelijke resultaat van de werkstroom bepalen.

  • Annuleren : een geannuleerde werkstroominstantie is een probleemloze afsluitbewerking van een vertakking. U kunt het annuleringsgedrag modelleren (bijvoorbeeld met behulp van een CancellationScope-activiteit). De voltooide handler wordt aangeroepen wanneer het annuleringsproces is voltooid. Een geannuleerde werkstroom heeft de status Geannuleerd.

  • Beëindigen : een beëindigd werkstroomexemplaren kunnen niet worden hervat of opnieuw worden gestart. Hiermee wordt de gebeurtenis Voltooid geactiveerd waarin u een uitzondering kunt opgeven als de reden waarom deze is beëindigd. De beëindigde handler wordt aangeroepen wanneer het beëindigingsproces is voltooid. Een beëindigde werkstroom heeft de status Fout.

  • Afbreken : een afgebroken werkstroomexemplaren kunnen alleen worden hervat als deze is geconfigureerd als permanent. Zonder persistentie kan een werkstroom niet worden hervat. Op het moment dat een werkstroom wordt afgebroken, gaan alle werkzaamheden (in het geheugen) sinds het laatste persistentiepunt verloren. Voor een afgebroken werkstroom wordt de afgebroken handler aangeroepen met behulp van de uitzondering als reden voor het voltooien van het afgebroken proces. In tegenstelling tot Geannuleerd en Beëindigd wordt de voltooide handler echter niet aangeroepen. Een afgebroken werkstroom heeft de status Afgebroken.

In het volgende voorbeeld wordt een werkstroom aangeroepen die een uitzondering genereert. De uitzondering wordt niet verwerkt door de werkstroom en de OnUnhandledException handler wordt aangeroepen. De WorkflowApplicationUnhandledExceptionEventArgs worden geïnspecteerd om informatie over de uitzondering te bieden en de werkstroom wordt beëindigd.

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 {0}\n{1}",
        e.InstanceId, e.UnhandledException.Message);

    Console.WriteLine("ExceptionSource: {0} - {1}",
        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();

Uitzonderingen verwerken met de Activiteit TryCatch

Het verwerken van uitzonderingen in een werkstroom wordt uitgevoerd met de TryCatch activiteit. De TryCatch activiteit bevat een Catches verzameling Catch activiteiten die elk zijn gekoppeld aan een specifiek Exception type. Als de uitzondering die wordt gegenereerd door een activiteit die is opgenomen in de Try sectie van een TryCatch activiteit overeenkomt met de uitzondering van een Catch<TException> activiteit in de Catches verzameling, wordt de uitzondering verwerkt. Als de uitzondering expliciet opnieuw wordt gegenereerd of als er een nieuwe uitzondering wordt gegenereerd, wordt deze uitzondering doorgegeven aan de bovenliggende activiteit. In het volgende codevoorbeeld ziet u een TryCatch activiteit die een ApplicationException verwerkt die door een Throw activiteit in de Try sectie wordt gegenereerd. Het bericht van de uitzondering wordt door de activiteit naar de Catch<TException> console geschreven en vervolgens wordt er een bericht naar de console in de Finally sectie geschreven.

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."
    }
};

De activiteiten in de Finally sectie worden uitgevoerd wanneer de Try sectie of de Catches sectie is voltooid. De Try sectie wordt voltooid als er geen uitzonderingen worden gegenereerd en de Catches sectie wordt voltooid als er geen uitzonderingen worden gegenereerd of opnieuw worden verwijderd. Als er een uitzondering wordt gegenereerd in de Try sectie van een TryCatch en niet wordt verwerkt door een Catch<TException> in de Catches sectie, of opnieuw wordt verwijderd van de Catches, worden de activiteiten in de Finally niet uitgevoerd, tenzij het volgende gebeurt.

Uitzonderingsafhandeling versus compensatie

Het verschil tussen uitzonderingsafhandeling en compensatie is dat uitzonderingsafhandeling plaatsvindt tijdens de uitvoering van een activiteit. Compensatie vindt plaats nadat een activiteit is voltooid. Uitzonderingsafhandeling biedt de mogelijkheid om op te schonen nadat de activiteit de uitzondering veroorzaakt, terwijl compensatie een mechanisme biedt waarmee het voltooide werk van een eerder voltooide activiteit ongedaan kan worden gemaakt. Zie Compensatie voor meer informatie.

Zie ook