İç içe geçmiş deneme yakalama bloklarını önlemek için desen?

Her biri bir istisna ile başarısız olabilecek üç (veya daha fazla) hesaplama yöntemim olduğu bir durumu düşünün. Başarılı olan bir hesaplama bulana kadar her hesaplamayı denemek için aşağıdakileri yapıyorum:

double val;

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

Bunu daha güzel bir şekilde gerçekleştiren kabul edilmiş bir model var mı? Elbette, her bir hesaplamayı, başarısızlık durumunda null döndüren bir yardımcı yönteme sarabilirim ve ardından yalnızca ??operatörü kullanabilirim , ancak bunu daha genel bir şekilde yapmanın bir yolu var mı (yani, kullanmak istediğim her yöntem için bir yardımcı yöntem yazmak zorunda kalmadan) )? Herhangi bir yöntemi bir dene / yakala ile saran ve başarısızlık durumunda null döndüren jenerikleri kullanarak statik bir yöntem yazmayı düşündüm, ancak bunu nasıl yapacağımdan emin değilim. Herhangi bir fikir?

Mümkün olduğunca, kontrol akışı veya istisnai olmayan durumlar için istisnalar kullanmayın.

Ancak sorunuzu doğrudan yanıtlamak için (tüm istisna türlerinin aynı olduğunu varsayarak):

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

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

throw new NoCalcsWorkedException();

Sadece "kutunun dışında" bir alternatif sunmak için, özyinelemeli bir işleve ne dersiniz?

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

NOT: Hiçbir şekilde işi halletmenin en iyi yolu olduğunu söylemiyorum, sadece farklı bir şekilde

Yuvayı aşağıdaki gibi bir yöntemle düzleştirebilirsiniz:

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

Ancak gerçek tasarım sorununun, esasen aynı şeyi yapan (arayanın bakış açısından) ancak farklı, ilgisiz istisnalar ortaya çıkaran üç farklı yöntemin varlığından kaynaklandığından şüpheleniyorum .

Bu üç istisna üstleniyor olan ilgisiz. Eğer hepsinin ortak bir temel sınıfı varsa, Ani'nin önerdiği gibi tek bir catch bloğu olan bir döngü kullanmak daha iyi olacaktır.

İstisnalara dayalı olarak mantığı kontrol etmemeye çalışın; ayrıca istisnaların yalnızca istisnai durumlarda atılması gerektiğini unutmayın. Çoğu durumda hesaplamalar, dış kaynaklara erişmedikleri veya dizeleri ayrıştırmadıkları veya başka bir şey yapmadıkları sürece istisnalar atmamalıdır. Her neyse, en kötü durumda, istisna mantığını kapsüllemek ve kontrol akışınızı sürdürülebilir ve temiz hale getirmek için TryMethod stilini (TryParse () gibi) izleyin:

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 modelini kullanan ve iç içe yerleştirilmiş yerine yöntem listesini birleştiren başka bir varyasyon şu durumlarda:

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;

ve eğer foreach biraz karmaşıksa, bunu açıklığa kavuşturabilirsiniz:

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

Hesaplama işlevleriniz için bir temsilci listesi oluşturun ve ardından bunlar arasında geçiş yapmak için bir süre döngüsüne sahip olun:

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?

Bu size bunun nasıl yapılacağına dair genel bir fikir vermelidir (yani bu kesin bir çözüm değildir).

Bu, MONADS için bir işe benziyor! Özellikle, Belki monad. Burada anlatıldığı gibi Belki monad ile başlayın . Ardından bazı uzantı yöntemleri ekleyin. Bu uzatma yöntemlerini özellikle sizin tanımladığınız sorun için yazdım. Monad'ların güzel yanı, durumunuz için gereken tam uzatma yöntemlerini yazabilmenizdir.

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

Bunu şu şekilde kullanın:

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

Kendinizi bu tür hesaplamaları sık sık yaparken bulursanız, belki de monad, kodunuzun okunabilirliğini artırırken yazmanız gereken standart kod miktarını azaltmalıdır.

Try yöntemi yaklaşımının başka bir versiyonu . Bu, her hesaplama için bir istisna türü olduğundan, yazılan istisnalara izin verir:

    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 yapabileceğiniz foo() or bar()yürütmek, hangi bar()eğer foo()başarısız olur. C # 'da bunu "başarısız olursa, sonra" oluşturmayı görmüyoruz, ancak bu amaçla kullanabileceğimiz bir operatör var: boş birleştirme operatörü?? yalnızca ilk bölüm boş ise devam .

Hesaplamalarınızın imzasını değiştirebilirseniz ve istisnalarını (önceki yazılarda gösterildiği gibi) sararsanız veya geri dönmek için yeniden yazarsanız null, kod zinciriniz giderek daha kısa ve okunması kolay hale gelir:

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

Ben senin fonksiyonları, değer sonuçlar için aşağıdaki değiştirmeler kullanılan 40.40içinde 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! */}

Bu çözümün her zaman uygulanabilir olmayacağının farkındayım, ancak çok ilginç bir soru sormuştunuz ve inanıyorum ki, konu nispeten eski olsa da, düzeltmeyi yapabileceğiniz zaman bunun dikkate alınmaya değer bir model olduğuna inanıyorum.

Hesaplama yöntemlerinin aynı parametresiz imzaya sahip olduğu göz önüne alındığında, bunları bir listeye kaydedebilir ve bu listeyi yineleyebilir ve yöntemleri çalıştırabilirsiniz. Muhtemelen, Func<double>"türünün sonucunu döndüren bir işlev" anlamını kullanmanız sizin için daha da iyi olacaktır 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);
   }
}

Bir Task / ContinueWith kullanabilir ve istisnayı kontrol edebilirsiniz. İşte güzelleştirmeye yardımcı olacak güzel bir uzatma yöntemi:

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

Atılan istisnanın gerçek türü önemli değilse, sadece yazısız bir yakalama bloğu kullanabilirsiniz:

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

Ve böyle kullanın:

using Utility;

...

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

Görünüşe göre OP'nin amacı, sorununu çözmek ve o anda mücadele ettiği mevcut sorunu çözmek için iyi bir model bulmaktı.

OP: "Her bir hesaplamayı, başarısızlık durumunda null döndüren bir yardımcı yönteme sığdırabilirim ve ardından yalnızca ??operatörü kullanabilirim , ancak bunu daha genel bir şekilde yapmanın bir yolu var mı (yani, istediğim her yöntem için yardımcı bir yöntem yazmak zorunda kalmadan herhangi bir yöntemi bir dene / yakala ile saran ve başarısızlık durumunda boş döndüren jenerikler kullanarak statik bir yöntem yazmayı düşündüm, ancak bunu nasıl yapacağımdan emin değilim. Herhangi bir fikir? "

İç içe geçmiş deneme yakalama bloklarını engelleyen birçok iyi desen gördümBu beslemede yayınlanan, , ancak yukarıda belirtilen soruna bir çözüm bulamayan . İşte çözüm:

OP'nin yukarıda bahsettiği gibi, başarısız olduğunda geri dönennull bir sarmalayıcı nesne yapmak istedi . Ben buna bir kapsül ( İstisna-güvenli bölme ) derdim .

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;

Ancak , CalcN () işlevleri / yöntemleri tarafından döndürülen Referans Türü sonucu için güvenli bir bölme oluşturmak isterseniz ne olur?

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

Bu nedenle, "kullanmak istediğiniz her yöntem için bir yardımcı yöntem yazmaya" gerek olmadığını fark edebilirsiniz .

Bölmelerin iki tip (için ValueTypeResults ve ReferenceTypeResults) olan yeterli .

İşte kodu SafePod. Yine de bir konteyner değil. Bunun yerine, hem s hem de s için istisna korumalı bir temsilci sarmalayıcısı oluşturur .ValueTypeResultReferenceTypeResult

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

Birinci sınıf vatandaş varlıkların ??gücüyle birlikte sıfır birleştirme operatöründen bu şekilde yararlanabilirsiniz .delegate

Her bir hesaplamayı tamamlama konusunda haklısınız, ancak söyleme-sorma ilkesine göre sarmalamanız gerekir.

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

İşlemler basittir ve davranışlarını bağımsız olarak değiştirebilir. Ve neden varsayılan oldukları önemli değil. Bir kanıt olarak calc1DefaultingToCalc2'yi şu şekilde uygulayabilirsiniz:

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

Hesaplamalarınız, döndürülecek hesaplamanın kendisinden daha geçerli bilgilere sahip gibi görünüyor. Belki de kendi istisna işlemlerini yapmaları ve hata bilgileri, değer bilgileri vb. İçeren bir "sonuçlar" sınıfı döndürmeleri daha mantıklı olabilir. AsyncResult sınıfının zaman uyumsuz modeli izleyerek yaptığı gibi düşünün. Daha sonra hesaplamanın gerçek sonucunu değerlendirebilirsiniz. Bunu, bir hesaplama başarısız olursa, bu sanki başarılı gibi bilgi amaçlı olarak düşünerek mantıklı hale getirebilirsiniz. Bu nedenle, bir istisna, bir "hata" değil, bir bilgi parçasıdır.

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

...

Elbette, bu hesaplamaları yapmak için kullandığınız genel mimari hakkında daha çok merak ediyorum.

Yaptığınız eylemleri izlemeye ne dersiniz ...

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