Excepciones

En un flujo de trabajo, las excepciones se pueden generar de las maneras siguientes:

• Un tiempo de espera de transacciones en TransactionScope.

• Una excepción explícita iniciada por el flujo de trabajo mediante la actividad Throw.

• Una excepción .NET Framework 4.5 RC iniciada desde una actividad.

• Una excepción iniciada desde el código externo, como bibliotecas, componentes o servicios que se usan en el flujo de trabajo.

Si la actividad inicia una excepción y no está controlada, el comportamiento predeterminado es finalizar la instancia de flujo de trabajo. Si un controlador OnUnhandledException personalizado está presente, puede invalidar este comportamiento predeterminado. Este controlador da al autor de host de flujo de trabajo la oportunidad de proporcionar el control adecuado, como el registro personalizado o la anulación, cancelación o finalización del flujo de trabajo. Si un flujo de trabajo produce una excepción no administrada, se invoca el controlador OnUnhandledException. Se devuelven tres posibles acciones de OnUnhandledException que determinan el resultado final del flujo de trabajo.

• Cancel - una instancia de flujo de trabajo cancelada es una salida correcta de una ejecución de bifurcación. Puede modelar el comportamiento de cancelación (por ejemplo, con una actividad CancellationScope). Se invoca el controlador Completed cuando el proceso de cancelación se completa. Un flujo de trabajo cancelado está en estado Cancelled.

• Terminate - una instancia de flujo de trabajo finalizada no puede reanudarse o reiniciarse. Esto desencadena el evento Completed en el que puede proporcionar una excepción como razón por la que finalizó. Se invoca el controlador Terminated cuando el proceso de finalización se completa. Un flujo de trabajo finalizado está en el estado Faulted.

• Abort - las instancias de flujo de trabajo anuladas solo se pueden reanudar si se han configurado para ser persistentes. Sin persistencia, un flujo de trabajo no se puede reanudar. En el punto en que se anula un flujo de trabajo, se perderá todo el trabajo realizado (en memoria) desde el último punto de persistencia. Para un flujo de trabajo anulado, se invoca el controlador Aborted usando la excepción como motivo cuando se completa el proceso de anulación. Sin embargo, a diferencia de Cancelled y Terminated, no se invoca el controlador Completed. Un flujo de trabajo anulado está en un estado Aborted.

En el ejemplo siguiente se invoca un flujo de trabajo que produce una excepción. El flujo de trabajo no controla la excepción y se invoca el controlador de la propiedad OnUnhandledException. El objeto WorkflowApplicationUnhandledExceptionEventArgs se inspecciona para proporcionar información acerca de la excepción y se termina el flujo de trabajo.

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();

Administrar excepciones con la actividad TryCatch

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

La diferencia entre el control de excepciones y la compensación es que el primero se produce durante la ejecución de una actividad. La compensación, sin embargo, se produce después de que una actividad se haya completado correctamente. El control de excepciones proporciona una oportunidad para limpiar después de que la actividad produzca la excepción, mientras la compensación proporciona un mecanismo por el que se puede deshacer el trabajo terminado correctamente de una actividad completada previamente. Para obtener más información, veaCompensación.

Referencia