将泛型方法转换为异步

Question

我在抽象 class 中有以下通用方法，它在应用程序的许多地方都有：

protected T Execute<T>(Func<T> func)
 {
            try
            {
                return func();
            }
            catch (InvalidOperationException invalidEx)
            {
                throw new InvalidException(invalidEx.Message, invalidEx);
            }
            catch (SqlException sqlEx)
            {
                throw new DbException(sqlEx.Message, sqlEx, ConvertSQLError(sqlEx));
            }
 }

它位于基类 class 中，所有派生类都使用上面的这个基类来执行委托 Func。 调用代码看起来像这样：

public int SomeMethodInDerivedClass(.....){
    result = Execute(() =>
    {....code ommited becouse of clarity })
  }

最好的方法是什么

1. 重写此方法以能够以异步方式调用它
2. 在调用代码中有效地使用 await？

我想实现什么，实际上能够重写 SomeMethodInDerivedClass 以便它可以返回 Task 而不是 int？ 我应该从哪里开始？

先感谢您

Answer 1

我认为您可以为异步函数添加另一种方法：

protected async Task<T> ExecuteAsync<T>(Func<Task<T>> func)
{
    try
    {
        return await func();
    }
    catch (InvalidOperationException)
    {
        throw;
    }
    catch (SqlException)
    {
        throw;
    }
}

如果要重新抛出异常，请使用以前的代码而不是创建另一个异常，因为在创建新异常时会丢失原始异常上下文。

Answer 2

async await就像僵尸诅咒，它会污染整个代码库。 然而，它并没有那么糟糕。 是的，要有效地使用async await ，您需要返回Task<T> 。 所以在你的例子中是Task<int> 。 但是委托是异步操作吗？ 如果不是，你需要让它表现得像一个，所以你需要把它包装成一个任务。

很难给你确切的步骤，就像我说的那样，它应该会影响到 main，所以一切都在async await和Task上运行，代码才能真正从模式中受益。

Answer 3

所以最后我想出了以下解决方案：

 protected async Task<T> ExecuteAsync<T>(Func<T> func)
    {
        try
        {
            return await Task.Run(func);
        }

调用代码就像这样：

public async Task<int> SomeMethod(......)
    {
                    
            result += await ExecuteAsync(() =>
            {
            ....code ommited for brevity 
            }
    }