Шаблон, чтобы избежать вложенных блоков try catch?

Рассмотрим ситуацию, когда у меня есть три (или более) способа выполнения вычислений, каждый из которых может завершиться ошибкой за исключением. Чтобы попытаться выполнить каждый расчет, пока мы не найдем тот, который будет успешным, я сделал следующее:

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 в случае неудачи, но я не уверен, как бы я поступил с этим. Любые идеи?

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

Но чтобы ответить на ваш вопрос напрямую (при условии, что все типы исключений одинаковы):

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

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

throw new NoCalcsWorkedException();

Чтобы предложить нестандартную альтернативу, как насчет рекурсивной функции ...

//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);
   }
}

ПРИМЕЧАНИЕ: я ни в коем случае не говорю, что это лучший способ выполнить работу, просто другой способ.

Вы можете сгладить вложение, поместив его в такой метод:

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, как предложила Ани.

Старайтесь не контролировать логику, основанную на исключениях; также обратите внимание, что исключения следует выдавать только в исключительных случаях. Вычисления в большинстве случаев не должны вызывать исключения, если они не обращаются к внешним ресурсам, не анализируют строки или что-то еще. В любом случае, в худшем случае следуйте стилю 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 и объединяющий список методов вместо вложенных, если:

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;
        }

Создайте список делегатов для ваших функций вычисления, а затем создайте цикл 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?

Это должно дать вам общее представление о том, как это сделать (т.е. это не точное решение).

Похоже, это работа для ... МОНАД! В частности, монада Maybe. Начните с монады Maybe, как описано здесь . Затем добавьте несколько методов расширения. Я написал эти методы расширения специально для той проблемы, которую вы описали. В монадах хорошо то, что вы можете написать точные методы расширения, необходимые для вашей ситуации.

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 должна уменьшить объем шаблонного кода, который вы должны написать, одновременно увеличивая читаемость вашего кода.

Другой вариант подхода с использованием пробного метода. Этот допускает типизированные исключения, поскольку для каждого вычисления существует тип исключения:

    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();
    }

В Perl вы можете это сделать foo() or bar(), и это будет выполнено в bar()случае foo()неудачи. В C # мы не видим эту конструкцию «if fail, then», но есть оператор, который мы можем использовать для этой цели: оператор объединения с нулевым значением ??, который продолжается, только если первая часть равна нулю.

Если вы можете изменить подпись своих вычислений и либо обернуть их исключения (как показано в предыдущих сообщениях), либо переписать их, чтобы они возвращались nullвместо этого, ваша цепочка кода станет все более короткой и по-прежнему легкой для чтения:

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

Я использовал следующие замены для ваших функций, что привело к значению 40.40в val.

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! */}

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

Учитывая, что методы расчета имеют одинаковую сигнатуру без параметров, вы можете зарегистрировать их в списке, выполнить итерацию по этому списку и выполнить методы. Возможно, вам было бы даже лучше использовать Func<double>значение «функция, которая возвращает результат типа 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);
   }
}

Вы можете использовать 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);
    }
}

Если фактический тип сгенерированного исключения не имеет значения, вы можете просто использовать блок 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();

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();
    },
    ...
);

Похоже, что намерением ОП было найти хороший образец для решения своей проблемы и решения текущей проблемы, с которой он боролся в тот момент.

ОП: «Я мог бы заключить каждое вычисление во вспомогательный метод, который возвращает ноль в случае ошибки, а затем просто использовать ??оператор, но есть ли способ сделать это в более общем плане (т.е. без необходимости писать вспомогательный метод для каждого метода, который я хочу use)? Я думал о написании статического метода с использованием универсальных шаблонов, которые обертывают любой заданный метод в try / catch и возвращают null в случае неудачи, но я не уверен, как бы я поступил с этим. Есть идеи? "

Я видел много хороших шаблонов, которые избегают вложенных блоков try catch , размещенных в этом фиде, но не нашел решения проблемы, о которой говорилось выше. Итак, вот решение:

Как упоминалось выше, он хотел создать объект-оболочку, который возвращается nullв случае сбоя . Я бы назвал это модулем ( безопасный модуль ).

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 ().

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}";
}

Итак, вы могли заметить, что нет необходимости «писать вспомогательный метод для каждого метода, который вы хотите использовать» .

Эти два типа стручков (для ValueTypeResults- и ReferenceTypeResultс) являются достаточно .

Вот код SafePod. Но это не контейнер. Вместо этого он создает безопасную в отношении исключений оболочку делегата для ValueTypeResults и ReferenceTypeResults.

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;
    }
}

Вот как вы можете использовать оператор ??объединения с нулевым значением в сочетании с мощью первоклассных гражданских сущностей delegate.

Вы правы, оборачивая каждое вычисление, но вы должны заключать его в соответствии с принципом «говори-не-спрашивай».

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();
    }
}

Похоже, ваши расчеты содержат более достоверную информацию, чем просто сам расчет. Возможно, для них было бы разумнее выполнить свою собственную обработку исключений и вернуть класс «результатов», содержащий информацию об ошибках, информацию о значениях и т. Д. Подумайте, как класс 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

...

Конечно, меня больше интересует общая архитектура, которую вы используете для выполнения этих вычислений.

А как насчет отслеживания ваших действий ...

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 );
}