为什么调试器会遇到默认情况？

Question

Some colleague ran into a very strange debugging issue in which he steps through a switch, steps to some case but yet afterwards it hits the default case as well. I have no idea how that can ever happen!

It's easily reproducible and I finally have extracted the code into a small test.

If I put a breakpoint on the default case only, then the debugger will never stop there. But If I add a breakpoint at case 42, and then use step over, it will hit the default case afterwards!! Remark that the catch is never reached though. So it seems that the debugger is showing something that is not actually happening? Also, if I remove the async task and await, then it will not happen.. We also need another case that declares a variable (something fancy, not a simple integer etc..)

public class Foo
{
    public readonly string Bar = nameof(Bar);
}

public async Task DoSomething(int x)
{
    try
    {
       switch (x)
       {
            case 43:
                var foo = new Foo();
                break;     
            case 42:
                Console.WriteLine(x);
                break;
            default:
                throw new NotImplementedException("aaarghh..");
        }
    }
    catch (Exception exc)
    {
        MessageBox.Show(exc.Message);
    }
}

private async void btnSomethingTo_Click(object sender, EventArgs e)
{
    await DoSomething(42);
}

GIF created by Sinatr to illustrate the topic on hand, thanks!

Answer 1

You have used the DoSomething method not in proper way. ASYNC keyword means you have some await call somewhere within method (to get return point later after task end), but you haven't it. Your strange debugger behavior is related to implementation. Your exception is not thrown by fact. I have reproduced your case and MyException constructor is just ignored/skipped by debugger, and the code in catch (Exception exc) section is never called too. Or if I am got break within CASE 42: and I just press F5, then my breakpoint within DEFAULT section will be skipped.

public async Task DoSomething(int x)
        {
            try
            {
                switch (x)
                {
                    case 43:
                        var foo = new Foo();
                        break;
                    case 42:
                        Debug.WriteLine(x);
                        break;
                    case 44:
                        break;
                    default:
                        throw new MyException("aaarghh..");
                }
            }
            catch (Exception exc)
            {
                MessageBox.Show(exc.Message);
            }
        }

        private async void button1_Click(object sender, EventArgs e)
        {
            await DoSomething(42);
        }

        public class MyException : Exception
        {
            public MyException(string message): base(message)
            {
                if (message != null)
                    Debug.WriteLine(message);
            }

            public MyException() : base()
            {
            }

            public MyException(string message, Exception innerException) : base(message, innerException)
            {
            }
        }