将异常类型列表作为类型参数传递给泛型方法

Question

I'm trying to write a generic helper method that'd call methods and handle exceptions if any.

The method should be able to accept a List of acceptable Exception types, and handle them in a specific way. For other type of exceptions, it'll handle differently.

This is a very simplified version of the method

public static TResult InvokeMethod<TResult, TAllowedException>
                (Func<TResult> func) where TAllowedException : Exception
{
    try
    {
        return func();
    }
    catch (Exception ex)
    {
        if (ex is TAllowedException) //do something
            return default(TResult);
        else //do something else
            throw;
    }
}

Here I'm specifying the allowed Exception Type as TAllowedException . This works fine. But, this accepts only a single Exception_Type . How can I pass a List<Exception_Type> instead?

Answer 1

You cannot pass a list of types as type arguments to a generic method.

Why not simply pass a collection of types as a regular parameter?

public static TResult InvokeMethod<TResult>
        (Func<TResult> func, ICollection<Type> ignoredExceptions)
{
    try
    {
        return func();
    }
    catch (Exception ex)                         
        when (ignoredExceptions != null &&                    
              ignoredExceptions.Any(t => t.IsAssignableFrom(ex.GetType())))
    {
        return default(TResult);
    }
}

If someone passes a Type that is not an exception, nothing bad will happen. In my opinion there is no need to validate it. The method will still work correctly - the exceptions in the collection will be ignored.

What is the expected behavior of calling InvokeMethod(func, new Type[] { typeof(Int32) }) ? The func will be executed, and if it throws an exception that is an Int32 , the default result will be returned. func will never throw an Int32 exception, so it already works like that without validating ignoredExceptions .

BTW passing arg as a parameter is not necessary. You can use a lambda to capture arg in a closure - () => func(arg) . And this will work with any number of arguments.

Edit

If you really want to restrict the types at compile time, you'd have to create your own collection, with a bit weird generic Add method:

public class ExceptionCollection : IEnumerable<Type>
{
    private readonly List<Type> _exceptions = new List<Type>();        

    public void Add<T>() where T : Exception => _exceptions.Add(typeof(T));
    public IEnumerator<Type> GetEnumerator() => _exceptions.GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable)_exceptions).GetEnumerator();
}

The biggest disadvantage of this class is that it doesn't work with collection initializers.

There is a way to make it work with collection initializers too. The initializers require an Add method taking one parameter, but they will happily work with a generic Add<T>(T item) method.

public void Add<T>(T item) where T : Exception => _exceptions.Add(typeof(T));

Using it is a bit tricky too. We could of course pass instances of exceptions, but it's pointless to create an instance only to get its type. We can pass a strongly-typed null instead, using a cast or default(T) :

new ExceptionCollection { default(ArgumentNullException), default(ArgumentException) };

I still think that in this particular case it's not necessary to validate the collection of types. There might be other cases when a constrained collection of types is necessary - then the above solution is quite ok.