避免嵌套 try catch 块的模式？

Question

考虑这样一种情况，我有三种（或更多）方法来执行计算，每种方法都可能失败并出现异常。为了尝试每一项计算直到找到成功的计算，我一直在执行以下操作：

double val;

try { val = calc1(); }
catch (Calc1Exception e1)
{ 
    try { val = calc2(); }
    catch (Calc2Exception e2)
    {
        try { val = calc3(); }
        catch (Calc3Exception e3)
        {
            throw new NoCalcsWorkedException();
        }
    }
}

是否有任何可接受的模式可以以更好的方式实现这一目标？当然，我可以将每个计算包装在一个辅助方法中，该方法在失败时返回 null，然后只使用 ?? 运算符，但是有没有一种方法可以更普遍地执行此操作（即无需编写我想使用的每种方法的辅助方法）？我考虑过使用泛型编写一个静态方法，它将任何给定的方法包装在 try/catch 中，并在失败时返回 null，但我不确定如何解决这个问题。有什么想法吗？

Answer 1

尽可能不要将异常用于控制流或非异常情况。

但要直接回答你的问题（假设所有异常类型都相同）：

Func<double>[] calcs = { calc1, calc2, calc3 };

foreach(var calc in calcs)
{
   try { return calc(); }
   catch (CalcException){  }
} 

throw new NoCalcsWorkedException();

Answer 2

只是为了提供一个“开箱即用”的替代方案，递归函数怎么样...

//Calling Code
double result = DoCalc();

double DoCalc(int c = 1)
{
   try{
      switch(c){
         case 1: return Calc1();
         case 2: return Calc2();
         case 3: return Calc3();
         default: return CalcDefault();  //default should not be one of the Calcs - infinite loop
      }
   }
   catch{
      return DoCalc(++c);
   }
}

注意：我绝不是说这是完成工作的最佳方法，只是一种不同的方式

Answer 3

您可以通过将嵌套放入这样的方法中来展平嵌套：

private double calcStuff()
{
  try { return calc1(); }
  catch (Calc1Exception e1)
  {
    // Continue on to the code below
  }

  try { return calc2(); }
  catch (Calc2Exception e1)
  {
    // Continue on to the code below
  }

  try { return calc3(); }
  catch (Calc3Exception e1)
  {
    // Continue on to the code below
  }

  throw new NoCalcsWorkedException();
}

但我怀疑真正的设计问题是存在三种不同的方法，它们本质上做相同的事情（从调用者的角度来看），但抛出不同的、不相关的例外。

这是假设这三个异常不相关。如果它们都有一个共同的基类，那么最好使用带有单个 catch 块的循环，正如 Ani 建议的那样。

Answer 4

尽量不要根据异常来控制逻辑；还要注意的是，只有在特殊情况下才应该抛出异常。大多数情况下，计算不应抛出异常，除非它们访问外部资源或解析字符串或其他内容。无论如何，在最坏的情况下，请遵循 TryMethod 风格（如 TryParse()）来封装异常逻辑，并使控制流可维护且干净：

bool TryCalculate(out double paramOut)
{
  try
  {
    // do some calculations
    return true;
  }
  catch(Exception e)
  { 
     // do some handling
    return false;
  }

}

double calcOutput;
if(!TryCalc1(inputParam, out calcOutput))
  TryCalc2(inputParam, out calcOutput);

另一种变体利用 Try 模式并组合方法列表而不是嵌套 if：

internal delegate bool TryCalculation(out double output);

TryCalculation[] tryCalcs = { calc1, calc2, calc3 };

double calcOutput;
foreach (var tryCalc in tryCalcs.Where(tryCalc => tryCalc(out calcOutput)))
  break;

并且如果 foreach 是有点复杂，你可以简单地说：

        foreach (var tryCalc in tryCalcs)
        {
            if (tryCalc(out calcOutput)) break;
        }

Answer 5

创建计算函数的委托列表，然后使用 while 循环来循环它们：

List<Func<double>> calcMethods = new List<Func<double>>();

// Note: I haven't done this in a while, so I'm not sure if
// this is the correct syntax for Func delegates, but it should
// give you an idea of how to do this.
calcMethods.Add(new Func<double>(calc1));
calcMethods.Add(new Func<double>(calc2));
calcMethods.Add(new Func<double>(calc3));

double val;
for(CalcMethod calc in calcMethods)
{
    try
    {
        val = calc();
        // If you didn't catch an exception, then break out of the loop
        break;
    }
    catch(GenericCalcException e)
    {
        // Not sure what your exception would be, but catch it and continue
    }

}

return val; // are you returning the value?

这应该让您大致了解如何执行此操作（即，这不是一个精确的解决方案）。

Answer 6

这看起来像是……MONADS 的工作！具体来说，是 Maybe monad。从 Maybe monad 开始如此处所述。然后添加一些扩展方法。我专门针对您所描述的问题编写了这些扩展方法。 monad 的好处是您可以编写适合您情况所需的精确扩展方法。

public static Maybe<T> TryGet<T>(this Maybe<T> m, Func<T> getFunction)
{
    // If m has a value, just return m - we want to return the value
    // of the *first* successful TryGet.
    if (m.HasValue)
    {
        return m;
    }

    try
    {
        var value = getFunction();

        // We were able to successfully get a value. Wrap it in a Maybe
        // so that we can continue to chain.
        return value.ToMaybe();
    }
    catch
    {
        // We were unable to get a value. There's nothing else we can do.
        // Hopefully, another TryGet or ThrowIfNone will handle the None.
        return Maybe<T>.None;
    }
}

public static Maybe<T> ThrowIfNone<T>(
    this Maybe<T> m,
    Func<Exception> throwFunction)
{
    if (!m.HasValue)
    {
        // If m does not have a value by now, give up and throw.
        throw throwFunction();
    }

    // Otherwise, pass it on - someone else should unwrap the Maybe and
    // use its value.
    return m;
}

像这样使用它：

[Test]
public void ThrowIfNone_ThrowsTheSpecifiedException_GivenNoSuccessfulTryGet()
{
    Assert.That(() =>
        Maybe<double>.None
            .TryGet(() => { throw new Exception(); })
            .TryGet(() => { throw new Exception(); })
            .TryGet(() => { throw new Exception(); })
            .ThrowIfNone(() => new NoCalcsWorkedException())
            .Value,
        Throws.TypeOf<NoCalcsWorkedException>());
}

[Test]
public void Value_ReturnsTheValueOfTheFirstSuccessfulTryGet()
{
    Assert.That(
        Maybe<double>.None
            .TryGet(() => { throw new Exception(); })
            .TryGet(() => 0)
            .TryGet(() => 1)
            .ThrowIfNone(() => new NoCalcsWorkedException())
            .Value,
        Is.EqualTo(0));
}

如果您发现自己经常进行此类计算，则 Maybe monad 应该减少您必须编写的样板代码量，同时提高代码的可读性。

Answer 7

try 方法的另一个版本。这允许类型化异常，因为每个计算都有一个异常类型：

    public bool Try<T>(Func<double> func, out double d) where T : Exception
    {
      try
      {
        d = func();
        return true;
      }
      catch (T)
      {
        d = 0;
        return false;
      }
    }

    // usage:
    double d;
    if (!Try<Calc1Exception>(() = calc1(), out d) && 
        !Try<Calc2Exception>(() = calc2(), out d) && 
        !Try<Calc3Exception>(() = calc3(), out d))

      throw new NoCalcsWorkedException();
    }

Answer 8

在 Perl 中，您可以执行 foo() 或 bar()，如果 foo() 失败，它们将执行 bar()。在 C# 中，我们看不到这种“如果失败，则”构造，但我们可以使用一个运算符来实现此目的：空合并运算符 ??，仅当第一部分成功时，该运算符才会继续为空。

如果您可以更改计算的签名，并且包装它们的异常（如之前的文章所示）或重写它们以返回 null，那么您的代码链将变得越来越简短，并且仍然易于阅读：

double? val = Calc1() ?? Calc2() ?? Calc3() ?? Calc4();
if(!val.HasValue) 
    throw new NoCalcsWorkedException();

我对您的函数使用了以下替换，这导致 val 中的值 40.40。

static double? Calc1() { return null; /* failed */}
static double? Calc2() { return null; /* failed */}
static double? Calc3() { return null; /* failed */}
static double? Calc4() { return 40.40; /* success! */}

我意识到这个解决方案并不总是适用，但你提出了一个非常有趣的问题，我相信，即使线程相对较旧，当你可以做出修正时，这是一个值得考虑的模式。

Answer 9

鉴于计算方法具有相同的无参数签名，您可以将它们注册在列表中，然后迭代该列表并执行方法。也许使用 Func 会更好，意思是“返回 double 类型结果的函数”。

using System;
using System.Collections.Generic;

namespace ConsoleApplication1
{
  class CalculationException : Exception { }
  class Program
  {
    static double Calc1() { throw new CalculationException(); }
    static double Calc2() { throw new CalculationException(); }
    static double Calc3() { return 42.0; }

    static void Main(string[] args)
    {
      var methods = new List<Func<double>> {
        new Func<double>(Calc1),
        new Func<double>(Calc2),
        new Func<double>(Calc3)
    };

    double? result = null;
    foreach (var method in methods)
    {
      try {
        result = method();
        break;
      }
      catch (CalculationException ex) {
        // handle exception
      }
     }
     Console.WriteLine(result.Value);
   }
}

Answer 10

您可以使用 Task/ContinueWith，并检查异常。这是一个很好的扩展方法，可以让它变得漂亮：

    static void Main() {
        var task = Task<double>.Factory.StartNew(Calc1)
            .OrIfException(Calc2)
            .OrIfException(Calc3)
            .OrIfException(Calc4);
        Console.WriteLine(task.Result); // shows "3" (the first one that passed)
    }

    static double Calc1() {
        throw new InvalidOperationException();
    }

    static double Calc2() {
        throw new InvalidOperationException();
    }

    static double Calc3() {
        return 3;
    }

    static double Calc4() {
        return 4;
    }
}

static class A {
    public static Task<T> OrIfException<T>(this Task<T> task, Func<T> nextOption) {
        return task.ContinueWith(t => t.Exception == null ? t.Result : nextOption(), TaskContinuationOptions.ExecuteSynchronously);
    }
}

Answer 11

如果抛出的异常的实际类型并不重要，您可以使用无类型的 catch 块：

var setters = new[] { calc1, calc2, calc3 };
bool succeeded = false;
foreach(var s in setters)
{
    try
    {
            val = s();
            succeeded = true;
            break;
    }
    catch { /* continue */ }
}
if (!suceeded) throw new NoCalcsWorkedException();

Answer 12

using System;

namespace Utility
{
    /// <summary>
    /// A helper class for try-catch-related functionality
    /// </summary>
    public static class TryHelper
    {
        /// <summary>
        /// Runs each function in sequence until one throws no exceptions;
        /// if every provided function fails, the exception thrown by
        /// the final one is left unhandled
        /// </summary>
        public static void TryUntilSuccessful( params Action[] functions )
        {
            Exception exception = null;

            foreach( Action function in functions )
            {
                try
                {
                    function();
                    return;
                }
                catch( Exception e )
                {
                    exception   = e;
                }
            }

            throw exception;
        }
    }
}

并像这样使用它：

using Utility;

...

TryHelper.TryUntilSuccessful(
    () =>
    {
        /* some code */
    },
    () =>
    {
        /* more code */
    },
    calc1,
    calc2,
    calc3,
    () =>
    {
        throw NotImplementedException();
    },
    ...
);

Answer 13

看来OP的意图是找到一个好的模式来解决他的问题并解决他当时正在努力解决的当前问题。

OP：“我可以将每个计算包装在一个辅助方法中，该方法在失败时返回 null，
然后只需使用 ?? 运算符，但是有没有一种更通用的方法
（即不必为我想使用的每个方法编写一个辅助方法）？
我考虑过使用泛型编写一个静态方法来包装任何给定的
try/catch 中的方法并在失败时返回 null，
但我不知道该怎么做。有什么想法吗？”

我在此提要中看到了许多好的避免嵌套 try catch 块的模式，但没有找到所引用问题的解决方案多于。
所以，解决方案如下：

正如上面提到的，他想要创建一个包装对象在失败时返回null。
我将其称为pod（异常安全pod）。

public static void Run()
{
    // The general case
    // var safePod1 = SafePod.CreateForValueTypeResult(() => CalcX(5, "abc", obj));
    // var safePod2 = SafePod.CreateForValueTypeResult(() => CalcY("abc", obj));
    // var safePod3 = SafePod.CreateForValueTypeResult(() => CalcZ());

    // If you have parameterless functions/methods, you could simplify it to:
    var safePod1 = SafePod.CreateForValueTypeResult(Calc1);
    var safePod2 = SafePod.CreateForValueTypeResult(Calc2);
    var safePod3 = SafePod.CreateForValueTypeResult(Calc3);

    var w = safePod1() ??
            safePod2() ??
            safePod3() ??
            throw new NoCalcsWorkedException(); // I've tested it on C# 7.2

    Console.Out.WriteLine($"result = {w}"); // w = 2.000001
}

private static double Calc1() => throw new Exception("Intentionally thrown exception");
private static double Calc2() => 2.000001;
private static double Calc3() => 3.000001;

但是，如果您想为 CalcN() 函数/方法返回的引用类型结果创建一个安全 Pod，该怎么办？

public static void Run()
{
    var safePod1 = SafePod.CreateForReferenceTypeResult(Calc1);
    var safePod2 = SafePod.CreateForReferenceTypeResult(Calc2);
    var safePod3 = SafePod.CreateForReferenceTypeResult(Calc3);

    User w = safePod1() ?? safePod2() ?? safePod3();

    if (w == null) throw new NoCalcsWorkedException();

    Console.Out.WriteLine($"The user object is {{{w}}}"); // The user object is {Name: Mike}
}

private static User Calc1() => throw new Exception("Intentionally thrown exception");
private static User Calc2() => new User { Name = "Mike" };
private static User Calc3() => new User { Name = "Alex" };

class User
{
    public string Name { get; set; }
    public override string ToString() => $"{nameof(Name)}: {Name}";
}

因此，您可能会注意到，没有必要“为您想要使用的每个方法编写一个辅助方法”。。

两种类型的 pod（对于 ValueTypeResult 和 ReferenceTypeResult）已经足够了。

---

这是SafePod的代码。但它不是一个容器。相反，它为 ValueTypeResult 和 ReferenceTypeResult 创建异常安全的委托包装器。

public static class SafePod
{
    public static Func<TResult?> CreateForValueTypeResult<TResult>(Func<TResult> jobUnit) where TResult : struct
    {
        Func<TResult?> wrapperFunc = () =>
        {
            try { return jobUnit.Invoke(); } catch { return null; }
        };

        return wrapperFunc;
    }

    public static Func<TResult> CreateForReferenceTypeResult<TResult>(Func<TResult> jobUnit) where TResult : class
    {
        Func<TResult> wrapperFunc = () =>
        {
            try { return jobUnit.Invoke(); } catch { return null; }
        };

        return wrapperFunc;
    }
}

---

这就是您如何利用空合并运算符 ?? 与一等公民实体（代表）的力量相结合。

Answer 14

您对每个计算的包装是正确的，但您应该根据“告诉-不要询问”原则进行包装。

double calc3WithConvertedException(){
    try { val = calc3(); }
    catch (Calc3Exception e3)
    {
        throw new NoCalcsWorkedException();
    }
}

double calc2DefaultingToCalc3WithConvertedException(){
    try { val = calc2(); }
    catch (Calc2Exception e2)
    {
        //defaulting to simpler method
        return calc3WithConvertedException();
    }
}


double calc1DefaultingToCalc2(){
    try { val = calc2(); }
    catch (Calc1Exception e1)
    {
        //defaulting to simpler method
        return calc2defaultingToCalc3WithConvertedException();
    }
}

操作简单，可以独立改变自己的行为。他们为什么违约并不重要。
作为证明，您可以将 calc1DefaultingToCalc2 实现为：

double calc1DefaultingToCalc2(){
    try { 
        val = calc2(); 
        if(specialValue(val)){
            val = calc2DefaultingToCalc3WithConvertedException()
        }
    }
    catch (Calc1Exception e1)
    {
        //defaulting to simpler method
        return calc2defaultingToCalc3WithConvertedException();
    }
}

Answer 15

听起来您的计算有更多有效信息要返回，而不仅仅是计算本身。也许对他们来说，进行自己的异常处理并返回一个包含错误信息、值信息等的“结果”类会更有意义。就像 AsyncResult 类遵循异步模式一样思考。然后您可以评估计算的实际结果。您可以通过以下方式来合理化这一点：如果计算失败，则与计算通过一样提供信息。因此，异常是一条信息，而不是“错误”。

internal class SomeCalculationResult 
{ 
     internal double? Result { get; private set; } 
     internal Exception Exception { get; private set; }
}

...

SomeCalculationResult calcResult = Calc1();
if (!calcResult.Result.HasValue) calcResult = Calc2();
if (!calcResult.Result.HasValue) calcResult = Calc3();
if (!calcResult.Result.HasValue) throw new NoCalcsWorkedException();

// do work with calcResult.Result.Value

...

当然，我想更多地了解您用来完成这些计算的整体架构。

Answer 16

追踪你所做的动作怎么样？

double val;
string track = string.Empty;

try 
{ 
  track = "Calc1";
  val = calc1(); 

  track = "Calc2";
  val = calc2(); 

  track = "Calc3";
  val = calc3(); 
}
catch (Exception e3)
{
   throw new NoCalcsWorkedException( track );
}