on async Main, unhandled exception unregisters before capturing crash

static void Main(string[] args)
{
    using var _ = SentrySdk.Init();
    throw null;
}

This exception is captured as expected by the unhandled exception handler.

static async Task Main(string[] args)
{
    using var _ = SentrySdk.Init();
    throw null;
}

The code above doesn’t work as expected. Before calling the UnhandledException handler the SDK goes out of the using “block” and unregisters the unhandled exception integration.

[Tyrrrz]

This doesn’t look like a bug in sentry, but more like an expected behavior due to misuse of async. When you add async modifier to the method, the throw expression changes meaning. Instead of throwing an exception immediately on the stack, they are wrapped in a Task.

You can observe this behavior in the following example:

void A()
{
    throw null;
}

async Task B()
{
    throw null;
}

void C()
{
    // Will throw immediately
    A();

    // Will not throw
    var task = B();

    // Can inspect exception. Awaiting the task will also propagate the exception.
    task.Exception;
}

Here are the two methods from your original example, decompiled:

• Static void

public static class Program
{
    private static void Main(string[] args)
    {
        IDisposable disposable = SentrySdk.Init();
        try
        {
            throw null;
        }
        finally
        {
            if (disposable != null)
            {
                disposable.Dispose();
            }
        }
    }
}

• Static async Task

[CompilerGenerated]
    private sealed class <Main>d__0 : IAsyncStateMachine
    {
        public int <>1__state;

        public AsyncTaskMethodBuilder <>t__builder;

        public string[] args;

        private IDisposable <_>5__1;

        private void MoveNext()
        {
            int num = <>1__state;
            try
            {
                <_>5__1 = SentrySdk.Init();
                try
                {
                    throw null;
                }
                finally
                {
                    if (num < 0 && <_>5__1 != null)
                    {
                        <_>5__1.Dispose();
                    }
                }
            }
            catch (Exception exception)
            {
                <>1__state = -2;
                <>t__builder.SetException(exception);
            }
        }

        void IAsyncStateMachine.MoveNext()
        {
            //ILSpy generated this explicit interface implementation from .override directive in MoveNext
            this.MoveNext();
        }

        [DebuggerHidden]
        private void SetStateMachine(IAsyncStateMachine stateMachine)
        {
        }

        void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
        {
            //ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
            this.SetStateMachine(stateMachine);
        }
    }

    [AsyncStateMachine(typeof(<Main>d__0))]
    [DebuggerStepThrough]
    private static Task Main(string[] args)
    {
        <Main>d__0 stateMachine = new <Main>d__0();
        stateMachine.args = args;
        stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
        stateMachine.<>1__state = -1;
        AsyncTaskMethodBuilder <>t__builder = stateMachine.<>t__builder;
        <>t__builder.Start(ref stateMachine);
        return stateMachine.<>t__builder.Task;
    }

The latter generates a (useless) state machine and the exception actually gets caught and stored in Task.Exception. Because of that, the unhandled exception event is never triggered at all.

Note, the compiler also warns when you write code like this, which kind of implies that it’s probably a mistake.

[mattjohnsonpint]

This is fully resolved between #2103 and #2319. Async main, and top-level async main, should work fine now (after those are both released).