ждать в блоке try-finally

Я экспериментировал с Visual Studio 14 CTP 2. Эта версия C# vNext позволяет использовать ключевое слово await внутри блока finally.

Пытаюсь понять, как это реализовано. Я знаю, что это деталь реализации, и она может быть изменена до выпуска RTM, но мне все же пришлось хорошенько подумать над этой функцией.

Чтобы попытаться понять базовый код, сгенерированный компилятором, я создал этот пример кода:

private async void button1_Click(object sender, EventArgs e)
{
    try
    {
    }
    finally
    {
        await MyFinallyTest();
    }
}

private async Task MyFinallyTest()
{
    await Task.Delay(1000);
}

Это сгенерированный компилятором класс:

[CompilerGenerated]
private sealed class <button1_Click>d__1 : IAsyncStateMachine
{
    public int <>1__state;
    public Form1 <>4__this;
    public object <>7__wrap1;
    public int <>7__wrap2;
    public AsyncVoidMethodBuilder <>t__builder;
    public TaskAwaiter <>u__$awaiter0;

    private void MoveNext()
    {
        int num = this.<>1__state;
        try
        {
            TaskAwaiter awaiter;
            switch (num)
            {
                case 1:
                    break;

                default:
                {
                    this.<>7__wrap1 = null;
                    this.<>7__wrap2 = 0;

                    try
                    {
                    }
                    catch (object obj2)
                    {
                        this.<>7__wrap1 = obj2;
                    }

                    awaiter = this.<>4__this.MyFinallyTest().GetAwaiter();
                    if (awaiter.IsCompleted)
                    {
                        goto Label_0096;
                    }

                    this.<>1__state = num = 1;
                    this.<>u__$awaiter0 = awaiter;

                    Form1.<button1_Click>d__1 stateMachine = this;
                    this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter, Form1.<button1_Click>d__1>(ref awaiter, ref stateMachine);
                    return;
                }
            }

            awaiter = this.<>u__$awaiter0;
            this.<>u__$awaiter0 = new TaskAwaiter();
            this.<>1__state = num = -1;

        Label_0096:
            awaiter.GetResult();
            awaiter = new TaskAwaiter();
            object obj3 = this.<>7__wrap1;
            if (obj3 != null)
            {
                Exception source = obj3 as Exception;
                if (source <= null)
                {
                    throw obj3;
                }
                ExceptionDispatchInfo.Capture(source).Throw();
            }

            int num1 = this.<>7__wrap2;
            this.<>7__wrap1 = null;
        }
        catch (Exception exception2)
        {
            this.<>1__state = -2;
            this.<>t__builder.SetException(exception2);
            return;
        }
        this.<>1__state = -2;
        this.<>t__builder.SetResult();
    }

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

Насколько я понимаю, компилятор берет блок кода finally и перемещает его после того, как компилятор сгенерировал блок catch. Что-то похожее на то, что нам приходилось делать, если мы хотели await что-то в catch-finally до C# 6.0.

Я вижу пару вещей, которые я не понимаю:

1. Компилятор добавляет сгенерированный блок catch (которого не было в моем методе) в форме catch (object obj2) и устанавливает его внутреннее object в исключение obj2. Я не понимаю, зачем это делается.

2. Блок finally, который я создал, больше не существует. Означает ли это, что любой код, который находится awaited внутри блока finally, не может «наслаждаться» гарантиями, которые мы получаем от фактического помещения кода внутрь такого блока?