Handling process corrupted state exceptions using Async.Catch

Question

I have a need in my app to know when an underlying component that is executed dynamically threw a process corrupted state exception so I can log it, and mark the component as bad for loading again and crash my process.

The execution of this component is performed asynchronously and I am using Async.Catch to handle that exception. I tried the following code to test the behavior of Async.Catch and it seems to me that Async.Catch is hung. This is an undesirable effect for me and am suspecting that all PCSE will result in the same behavior.

Anyone know how to get out of this situation?

let a = async {
    System.Threading.Thread.CurrentThread.Abort()
}

let b = async {
    let! m = Async.Catch a
    return match m with
            | Choice1Of2 p -> "hello"
            | Choice2Of2 e -> "Caught: " + e.ToString()
}

Async.RunSynchronously b;;

EDIT 1: I found the documentation that pointing me to use either HandleProcessCorruptedStateExceptionsAttribute together with SecurityCriticalAttribute or use a config entry legacyCorruptedState­­ExceptionsPolicy=true. I don't want to use a config entry if at all possible.

EDIT 2: Based on the suggestion in the comment, I modified the let binding for 'b' as follows:

let b = async {
        try
            let! m = Async.Catch a
            return "hello"
        with
            | :? System.Threading.ThreadAbortException as e -> return "Caught: " + e.ToString()
    }

The program still hangs without returning or throwing.

Answer 1

This is a tricky problem - inside normal function, you can catch the ThreadAbortException and do something in reaction, but you cannot really handle it, because it will be automatically rethrown (and it will eventually kill the thread).

In F# async workflow, the exception is handled and F# async runtime stores it so that it can report it via a continuation, but before it gets a chance to do this, the exception is rethrown by .NET and it kills the thread (thus RunSynchronously hangs).

The problem is - to report exceptions, F# async needs to make some call. The call cannot be made on the current thread (which is being cancelled). If you're expecting the exception, you can start the work in a thread pool and handle it yourself. (F# cannot do that automatically, because it would be too much overhead).

You can use the following helper:

type Microsoft.FSharp.Control.Async with
  static member CatchAbort<'R>(f : unit -> 'R) : Async<'R> =
    async { let hndl = new AutoResetEvent(false)
            let result = ref (Choice3Of3())
            ThreadPool.QueueUserWorkItem(fun _ ->
              try 
                result := Choice1Of3 (f())
                hndl.Set() |> ignore
              with 
                | e -> 
                   // This handler runs correctly even for ThreadAbort
                   result := Choice2Of3 e 
                   hndl.Set() |> ignore) |> ignore
            let! _ = Async.AwaitWaitHandle(hndl) 
            match !result with
            | Choice1Of3(res) -> return res
            | Choice2Of3(exn) -> 
                // Wrap or rethrow the exception in some way
                return raise exn
            | Choice3Of3 _ -> return failwith "unexpected case" }

This starts the specified function (which is not asynchronous) on a thread pool thread. After the function completes or throws, it reports the result back to the original thread, which can resume the workflow.

To adapt your example, this should behave as expected:

let a = async {
    let! value = Async.CatchAbort(fun () ->
      System.Threading.Thread.CurrentThread.Abort()
      "not aborted")
    return value }

let b = async {
    try let! m = a
        printfn "ok"
    with e -> printfn "Caught: %A" e }

Answer 2

as you can read here - ThreadAbortException is one of those special exceptions in the CLR. It seems to breaks the Asycn-Pattern pretty hard, so I guess that's the problem here.

Try with another exception and see if that will work (it should).