Question

I have created a method like NUnit’s Throws method.
Basically, the method should return true if the action it’s acting on will cause an exception of type T or any derived exception type, which is passed as a generic argument.

 Action a = () => Throw(new DerivedException());
 if(!a.Throws<BaseException>())
      throw new Exception("catastrophic error");

I have a helper Throw method that just throws an exception of a given type.
The DerivedException class derives from the BaseException class, which in turn derives from the Exception class.

The problem is that the behavior of the Throws method varies depending on whether or not the debugger is attached. If the debugger is not attached, the method does what I would expect it to do. When the debugger is attached though, it doesn’t catch the DerivedException as a BaseException, but instead catches it as an Exception.

Here’s the code to reproduce (which can go in a console application project file.):

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Action a = () => Throw(new DerivedException());
            if (!a.Throws<BaseException>())
                throw new Exception("catastrophic error.");
            else
                Console.WriteLine("wow, you must not have been debugging.");
        }
        private static void Throw<T>(T exc) where T : Exception
        {
            throw exc;
        }
    }

    public static partial class ExtensionMethods
    {
        public static bool Throws<T>(this Action action) where T : Exception
        {
            try
            {
                action.Invoke();
            }
            catch (T)
            {
                return true;
            }
            catch (Exception e)
            {
                Console.WriteLine(e.GetType());
                return false;
            }
            return false;
        }

    }


    public class BaseException : Exception
    {
    }
    public class DerivedException : BaseException
    {
    }



}

Hit F5 (debug) and it doesn’t properly catch the DerivedException.
Hit Ctrl+F5 (no debugging) and it works fine, catching the DerivedException as a BaseException.

Can someone please explain the discrepancy? Thanks.

UPDATE
I am running VS 2008 Professional Edition, with Version 3.5 SP1 of the .NET Framework. Apparently this is not an issue for later versions. Thanks everyone who tried this.

Answer 1

I guess technically the answer here is to upgrade to a newer version of Visual Studio, i.e. 2010 or later.