Is FunctionA(Exception ex) the same as FunctionB<T>(T ex) where T : Exception?

Question

Two simple questions about generics.

Are the following two function definitions the same?

FunctionA(Exception ex);

FunctionB<T>(T ex) where T : Exception;

Are there advantages the Generic implementation (FunctionB) has over the normal implementation (FunctionA)?

Answer 1

The following are effectively the same (in outcome):

catch (Exception e)
{
    FunctionA(e);
    FunctionB(e);
}

But it's not the same if you do this:

catch (ApplicationException e)
{
    FunctionB(e);
}
catch (Exception e)
{
    FunctionA(e);
}

This is because FunctionB gets typed to ApplicationException at compile time, wheras the call to FunctionA will always downcast the parameter to Exception. Depending on your implementation of FunctionB, this may not matter, but there are cases where it can make a difference. I would say that as a rule of thumb, if you your method implementation does not need the generic implementation, then don't use it.

Here are some examples of when it would matter:

public T AddSomeContextToThisException<T>(T ex) where T : Exception
{
    ex.Data.Add("Some key", "Some context message");
    return ex;
}

public T ThisIsABadIdeaForExceptionsButMaybeAGoodIdeaForOtherTypes<T>(T ex) where T : Exception, new()
{
    // do something with ex

    return new T();
}

The following example needs some additional code for context, so see the code beneath it:

private readonly Bar bar = new Bar();

public void HandExceptionOffToSomethingThatNeedsToBeStronglyTyped<T>(T ex) where T : Exception
{
    ICollection<T> exceptions = bar.GetCollectionOfExceptions<T>();
    exceptions.Add(ex);

    // do other stuff
}

public class Bar
{
    // value is object, because .net doesn't have covariance yet
    private Dictionary<Type, object> listsOfExceptions = new Dictionary<Type, object>();

    public ICollection<T> GetCollectionOfExceptions<T>()
    {
        if (!listsOfExceptions.ContainsKey(typeof(T)))
        {
            listsOfExceptions.Add(typeof(T), new List<T>());
        }
        return listsOfExceptions[typeof(T)] as List<T>;
    }
}

Answer 2

Inside the functions, there would be no difference. The difference comes from the outside. If you use the generic function, you could return the same type of exception back to the calling code instead of the base Exception. Most cases this is a moot point though.

Answer 3

See this question:
http://stackoverflow.com/questions/595260/difference-between-generic-argument-constrained-to-an-interface-and-just-using-th

Answer 4

There isn't much of an advantage that FunctionB has over FunctionA. However, there is a distinct difference between the two.

With FunctionA, you can pass any type that derives from (or is) an Exception into the function.

With FunctionB, you can pass any type that derives from T (which must derive from or be an Exception) into the function.

This means that depending on the type of T, you will have a more specialized parameter which will restrict the types that you can pass to it, as the parameter is going to be typed as T, not as Exception.

Now if T is an Exception, then it doesn't matter, the functions are the same. However, if T is an InvalidOperationException, then only instances of InvalidOperationException (and classes that derive from it) are permitted.

This is usually what you want when you want to ensure specialization of a type without having to resort to base classes which don't provide the level of specialization you need.