Delen via

Uitzonderingen voor Windows Workflow Foundation

Werkstromen kunnen de TryCatch-activiteit gebruiken om uitzonderingen af te handelen die worden gegenereerd tijdens de uitvoering van een werkstroom. Deze uitzonderingen kunnen worden verwerkt of ze kunnen opnieuw worden gegenereerd met behulp van de Rethrow-activiteit. Activiteiten in de sectie Finally worden uitgevoerd wanneer de sectie Try of de Catches sectie is voltooid. Werkstromen die worden gehost door een WorkflowApplication-exemplaar, kunnen ook de OnUnhandledException gebeurtenis-handler gebruiken om uitzonderingen af te handelen 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 door de werkstroom wordt gegenereerd met behulp van de Throw-activiteit.

  • Een .NET Framework 4.6.1-uitzondering die is opgetreden bij een activiteit.

  • Er is een uitzondering opgetreden bij externe code, zoals bibliotheken, onderdelen of services die in de werkstroom worden gebruikt.

Uitzonderingen verwerken

Als een uitzondering wordt gegenereerd door een activiteit en niet wordt verwerkt, is het standaardgedrag het beëindigen van het werkstroomexemplaren. Als er een aangepaste OnUnhandledException handler aanwezig is, kan dit standaardgedrag worden overschreven. Deze handler biedt de auteur van de werkstroomhost de mogelijkheid om de juiste verwerking 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 geretourneerd uit OnUnhandledException die het uiteindelijke resultaat van de werkstroom bepalen.

  • Annuleren - Een geannuleerd werkstroomexemplaren is een correct einde van de uitvoering 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 gestart. Hiermee wordt de voltooide gebeurtenis 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 Mislukt.

  • afgebroken : een afgebroken werkstroomexemplaren kunnen alleen worden hervat als deze zo is geconfigureerd dat deze permanent zijn. Zonder persistentie kan een werkstroom niet worden hervat. Op het moment dat een werkstroom wordt afgebroken, gaan alle werkzaamheden (in het geheugen) verloren sinds het laatste persistentiepunt. Voor een afgebroken werkstroom wordt de afgebroken handler aangeroepen met behulp van de uitzondering als de reden wanneer het proces wordt afgebroken. 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 te verstrekken over de uitzondering 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 {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();

Uitzonderingen verwerken met de TryCatch-activiteit

Het verwerken van uitzonderingen in een werkstroom wordt uitgevoerd met de TryCatch activiteit. De TryCatch-activiteit heeft 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 sectie Try van een TryCatch activiteit overeenkomt met de uitzondering van een Catch<TException> activiteit in de verzameling Catches, 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 in de Try sectie wordt gegenereerd door een Throw activiteit. Het bericht van de uitzondering wordt door de Catch<TException> activiteit naar de console geschreven en vervolgens wordt er een bericht naar de console geschreven in de sectie Finally.

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 sectie Finally worden uitgevoerd wanneer de sectie Try of de sectie Catches is voltooid. De Try sectie is voltooid als er geen uitzonderingen worden gegenereerd en de Catches sectie wordt voltooid als er geen uitzonderingen worden gegenereerd of opnieuw worden gegooid. 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 afgeworpen vanuit de Catches, worden de activiteiten in de Finally niet uitgevoerd tenzij een van de volgende gevallen plaatsvindt.

Afhandeling van uitzonderingen versus compensatie

Het verschil tussen de verwerking van uitzonderingen en compensatie is dat de afhandeling van uitzonderingen plaatsvindt tijdens de uitvoering van een activiteit. Compensatie treedt op nadat een activiteit is voltooid. Uitzonderingsafhandeling biedt de mogelijkheid om op te schonen nadat de activiteit de uitzondering heeft gegenereerd, terwijl compensatie een mechanisme biedt waarmee het voltooide werk van een eerder voltooide activiteit ongedaan kan worden gemaakt. Zie Compensatievoor meer informatie.

Zie ook

  • Last updated on