C＃是否有办法知道是否已捕获异常

Question

Is there a way to determine if an exception was previously caught (and rethrown)? For exemple:

public void Main()
{
    try
    {
       Child();
    } 
    catch( Exception ex)
    {
    // do something only if exception was not already in another catch block
    }
}


public void Child()
{
    try
    {
        A_ThisMayThrowException();
    }
    catch (Exception ex)
    {
       LogError();
       throw;
    }

    B_ThisMayAlsoThrowAnErrorButWillNotBeCaughtHere();


}

In the Main function, in its catch block, is there a way to determine if the exception was already caught in the Child function?

Answer 1

I would create a custom LoggedException and throw it up the stack:

catch (Exception ex)
{
     Log(ex);
     throw new LoggedException(ex);
}

Answer 2

While I'm not sure I'd recommend this, you can modify the dictionary returned by the Exception.Data property. If your LogError method were to accept the exception and modify it in a way that allowed you to check later, that should work for you.

Note that this allows the rest of the code not to care about the logging aspect, unlike InBetween's answer. For example, you may have some code that wants to catch exceptions based on type - it feels to me like the part about "marking an exception as logged" should be orthogonal to that. If you're changing the type of exception being thrown, that can change behavior of code further up in the stack in a fashion which is unrelated to logging.

Here's an example:

using System;

class Test
{
    static void Main()
    {
        TestHandling(true);
        TestHandling(false);
    }

    static void TestHandling(bool throwFirst)
    {
        try
        {
            Child(throwFirst);
        } 
        catch (Exception ex)
        {
            Console.WriteLine($"Previously caught? {ex.Data.Contains("Logged")}");
        }
    }


    static void Child(bool throwFirst)
    {
        try
        {
            if (throwFirst)
            {
                throw new Exception();
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine("Logging!");
            ex.Data["Logged"] = true;
            throw;
        }
        throw new Exception();
    }
}

Output:

Logging!
Previously caught? True
Previously caught? False

This approach would work with exception filters as well, and you could even make it only log once, as well. For example:

public bool LogAndThrow(Exception ex)
{
    if (!ex.Data.Contains("Logged"))
    {
        // Replace with real logging
        Console.WriteLine("An exception occurred!");
        ex.Data["Logged"] = true;
    }
    // Always continue up the stack: this never filters
    return false;
}

public static bool CatchIfNotLogged(this Exception ex) =>
    !ex.Data.Contains("Logged");

Then you could have:

try
{
    Foo();
}
catch (Exception ex) when (ex.CatchIfNotLogged()
{
    // We only get here if the exception hasn't been logged
}

and

try
{
    Foo();
}
catch (Exception ex) when (ex.LogAndThrow())
{
    // We never get here
}