Question

I thought this approach would be safe, in that it wouldn’t allow exceptions to propagate. A colleague of mine suggested that the exceptions may need to be observed on the main thread, and should thus be passed up to the main thread. Is that the answer? Can you see how an exception could leak through this?

    private static void InvokeProcessHandlers<T>(List<T> processHandlers, Action<T> action)
    {            
        // Loop through process handlers asynchronously, giving them each their own chance to do their thing.
        Task.Factory.StartNew(() =>
        {
            foreach (T handler in processHandlers)
            {
                try
                {
                    action.Invoke(handler);
                }
                catch (Exception ex)
                {
                    try
                    {
                        EventLog.WriteEntry(ResourceCommon.LogSource,
                                             String.Format(CultureInfo.CurrentCulture, "An error occurred in a pre- or post-process interception handler: {0}", ex.ToString()),
                                             EventLogEntryType.Error);
                    }
                    catch (Exception)
                    {
                        // Eat it. Nothing else we can do. Something is seriously broken.
                    }

                    continue;  // Don't let one handler failure stop the rest from processing.
                }
            }
        });
    }

By the way, a stack trace is indeed showing that an exception is leaking from this method.

The exception is AccessViolation, and I believe it has to do with the code that calls this method:

InvokeProcessHandlers<IInterceptionPostProcessHandler>(InterceptionPostProcessHandlers, handler => handler.Process(methodCallMessage, methodReturnMessage));

The getter for InterceptionPostProcessHandlers contains this:

_interceptionPreprocessHandlers = ReflectionUtility.GetObjectsForAnInterface<IInterceptionPreprocessHandler>(Assembly.GetExecutingAssembly());

Answer 1

Just make sure to check parameter for null references before you iterate

other than that there is nothing wrong as log writing is not something to stop the execution, but i would recommend to make it more clean and maintainable by encapsulating the logging into a mothod like:

bool Logger.TryLog(params);

and inside this method do the try with a catch that returns false and if you want to handle it in client code do it and if you dont never mind just call the logger in a clean encapsulated way