Question

假设我有以下方法，以及调用它的代码：

public async Task<MyResult> PerformAction(string parameter)
{
   if(parameter == "fail")
      throw new Exception("You wanted me to fail.");
   return await MyResult.Create(parameter);
}

var resultOne = await PerformAction("fail");
var resultTwo = await PerformAction("success");

这可以正常工作-但会引发异常，从而导致异常的性能损失。

是否可以向调用方指示任务失败，没有抛出异常？

Answer 1

您可以这样做：

public Task<MyResult> PerformAction(string parameter)
{
   if(parameter == "fail")
   {
      return Task.FromException<MyResult>(new Exception("You wanted me to fail."));
   }
   return MyResult.Create(parameter);
}

不确定性能会提高多少。

Answer 2

在可能的情况下，避免异常产生和传播的常见解决方案是将结果包装在外部对象中

public class Response<T> {
   public IEnumerable<string> Errors {get;set;}
   public bool HasErrors => Errors?.Any() ?? false;
   public bool IsSuccess {get;set;}
   public T Data {get;set;}
}

public async Task<Response<MyResult>> PerformAction(string parameter)
{
   if(parameter == "fail")
      return new Reponse<MyResult>() {
          IsSuccess = false,
          Errors = new string[] {"Failed"}
      };
   return new Response<MyResult>(){
             Result = await MyResult.Create(parameter).ConfigureAwait(false),
             IsSuccess = true
           };
}

var resultOne = await PerformAction("fail");
if (resultOne.HasErrors) { ... }
var resultTwo = await PerformAction("success");
if (resultTwo.HasErrors) { ... }

在不引发异常的情况下使异步方法失败

2 个答案: