是否有可能在某些异常上不中断执行流，但在其他异常上中断执行流?如果可以，如何中断?

我需要从外部框架调用几个方法-或者更确切地说，我正在编写一个包装器，以便其他用户以非预定顺序从该框架调用方法。现在框架的一些方法会抛出异常，即使没有"真正的"错误发生。基本上，它们应该是内部异常，只是通知要执行的操作之前已经执行过。例如:文件已经加载。它不会伤害加载文件另一个时间，所以我关心这个"错误"根本不是错误。所以我需要继续讨论这个异常，但我也需要捕捉其他的，真正的异常，比如当框架，连接到客户端和东西，不能这样做。

下面我有一些(非常简化的)示例代码。显然，这些代码无法编译，因为缺少用于自定义异常的代码。同样，在现实生活中，代码分布在三个程序集中。这意味着，我不能将异常处理程序包装在那些只抛出InternalFrameworkException()的框架方法周围。我只能把它包裹在整个SomeMethod()上。正如我所写的，这是一个极其简化的例子。

是否有任何方法来处理RealException()s，但继续InternalFrameworkException()s不使用此处提到的PostSharp ?请注意，这并不是说让InternalFrameworkException()掉下来，而是它们实际上根本不应该脱离try{}块。

namespace ExceptionTest
{
    using System;
    internal class Program
    {
        private static void Main(string[] args)
        {
            try
            {
                SomeMethod();
            }
            catch (InternalFrameworkException exception)
            {
                // Do not actually catch it - but also dont break the
                // execution of "SomeMethod()".
                // Actually I never want to end up here...
            }
            catch (RealException exception)
            {
                // Break the execution of SomeMethod() as usual.
                throw;
            }
            catch (Exception exception)
            {
                // Again, break the execution of SomeMethod() as usual.
                throw;
            }
            finally
            {
                // Clean up.
            }
        }
        #region == Method is actually contained in another assembly referencing this assembly ===
        private static void SomeMethod()
        {
            // Should break if uncommented.
            // MethodThrowingProperException();
            // Should not break.
            MethodThrowingInternalExceptionOrRatherContinuableError();
            // Should execute, even if previously an internal framework error happened.
            MethodNotThrowingException();
        }
        #endregion
        #region ===== Framework methods, they are contained in a foreign dll =====
        private static void MethodThrowingProperException()
        {
            // Something happened which should break execution of the
            // application using the framework
            throw new RealException();
        }
        private static void MethodThrowingInternalExceptionOrRatherContinuableError()
        {
            // Perform some stuff which might lead to a resumable error,
            // or rather an error which should not break the continuation
            // of the application. I.e. initializing a value which is
            // already initialized. The point is to tell the application using
            // this framework that the value is already initialized, but
            // as this wont influence the execution at all. So its rather
            // a notification.
            throw new InternalFrameworkException();
        }
        private static void MethodNotThrowingException()
        {
            // Well, just do some stuff.
        }
        #endregion
    }
}

void InternalFrameworkMethodSafe()
{
    try
    {
        InternalFrameworkMethod();
    }
    catch(InternalFrameworkException e)
    {
        Trace.Write("error in internal method" + e);
    }
}
void SomeMethod()
{
    ...
    InternalFrameworkMethodSafe();
    ...
}