寻找一种优雅的方式来解决“不能在 finally 子句的主体中等待”

Question

我有以下功能：

private async Task DoSomething(NamespaceConnectionInfo nci)
{
    var session = await m_sessionProvider.GetSessionAsync(nci);
    SomeLegacySynchronousCode(session);
    await m_sessionProvider.EndSessionAsync(session);
}

EndSessionAsync 记录并吞下任何异常（就像一个好的析构函数）。

问题是SomeLegacySynchronousCode 可能会抛出异常，然后会话泄漏。

我很清楚为什么以下代码是非法的：

private async Task DoSomething(NamespaceConnectionInfo nci)
{
    var session = await m_sessionProvider.GetSessionAsync(nci);
    try
    {
        SomeLegacySynchronousCode(session);
    }
    finally
    {
        await m_sessionProvider.EndSessionAsync(session);
    }
}

所以，我正在寻找一种既正确又优雅的替代方案。

变体 I

private async Task DoSomething(NamespaceConnectionInfo nci)
{
    var session = await m_sessionProvider.GetSessionAsync(nci);
    Exception exc = null;
    try
    {
        SomeLegacySynchronousCode(session);
    }
    catch (Exception e)
    {
        exc = e;
    }
    await m_sessionProvider.EndSessionAsync(session);
    if (exc != null)
    {
        // Wrap to preserve the original stack trace.
        throw new AggregateException(exc);
    }
}

变体 II

private Task DoSomething(NamespaceConnectionInfo nci)
{
    return m_sessionProvider.GetSessionAsync(nci).ContinueWith(t =>
    {
        Task result = null;
        try
        {
            SomeLegacySynchronousCode(t.Result);
        }
        finally
        {
            if (t.Exception == null)
            {
                result = m_sessionProvider.EndSessionAsync(t.Result);
            }
        }
        return result;
    }).Unwrap();
}

两者都不如前面提到的非法 async/await 版本那样优雅。

我希望改进我提出的两个变体，因为坦率地说，两者都很丑。

有什么想法吗？

Answer 1

commonly-accepted answer 似乎与您的变体 1 相似：

您可以将逻辑移到 catch 块之外并重新抛出 之后的异常，如果需要，使用 ExceptionDispatchInfo。

static async Task f()
{
    ExceptionDispatchInfo capturedException = null;
    try
    {
        await TaskThatFails();
    }
    catch (MyException ex)
    {
        capturedException = ExceptionDispatchInfo.Capture(ex);
    }

    if (capturedException != null)
    {
        await ExceptionHandler();

        capturedException.Throw();
    }
}

这样，当调用者检查异常的 StackTrace 属性，它仍然会记录它在 TaskThatFails 中被抛出的位置。