C# Compare Exceptions

Question

I have a piece of code that sometimes throws an exception and sometimes doesn't. Depending on IO and network, different kinds of exception might be thrown. I have a wrapper for that code that shall retry the failing statement, say 10 times until it succeeds. If the exception does not go away after the 10th time, I rethrow it. Until now, I know what to do. Currently, I have something like this:

private void ExecuteStatement(Action statementToExecute)
{
    while (true)
    {
        int exceptionCount = 0;
        try
        {
            statementToExecute.Invoke();
            // statement finished successfully
            break;
        }
        catch (Exception e)
        {
            if (!IsFrameworkException(e))
                throw; // rethrow as it isn't a framework exception

            // we know now that it's a framework exception
            exceptionCount++;
            if (exceptionCount >= MaxRetriesOnFrameworkException)
                throw;
        }
    }
}

The issue is the following: I want to reset the counter in case the exception changes (i. e. different type, different stacktrace, different message). I know how to compare them individually, but I want to know if there's a standard C# way of accomplishing this.

Edit: Here's the code of IsFrameworkException:

private bool IsFrameworkException(Exception e)
{
    Exception rootCause = e.GetBaseException();
    return rootCause.GetType() == typeof(WebException);
}

Answer 1

This is not specifically related to exception handling, but a simple way to keep counters by a specific key is to use a Tuple as the key (it implements equality by value out of the box).

Note that this doesn't reset the counter on key change, it justs keeps separate counters for each key:

readonly Dictionary<Tuple<Type, string, string>, int> _counters = 
     new Dictionary<Tuple<Type, string, string>, int>();

bool IsCountExceeded(Exception ex)
{
    // create your key with whatever properties you consider to 
    // be "unique"
    var key = Tuple.Create(ex.GetType(), ex.StackTrace, ex.Message);

    // increase counter 
    int counter;
    if (!_counters.TryGetValue(key, out counter))
    {
        counter = 1;
    }
    else
    {
        counter++;
    }
    _counters[key] = counter;

    return counter > Max;
}

You can of course always make it more readable by creating your own class, which will implement Equals/GetHashCode properly.

I am also not sure that the stack trace can be considered as a unique property, and of course, catching and ignoring exceptions is usually a bad idea.