C#: Obsługa wyjątków w rekursywnym wywołaniu

Question

Mam rekurencyjne wywołanie metody. Kiedy zostanie zgłoszony wyjątek, chciałbym zobaczyć, gdzie w rekursywnym stosie wywołań się stało. Mam pole, które zawiera "ścieżkę", która reprezentuje stos rekursji.

Teraz chciałbym dodać informacje o ścieżce do każdego wyjątku, który mógłby zostać zgłoszony w wywołaniu rekursywnym.

void Recursive(int x) 
{ 
    // maintain the recursion path information 
    path.Push(x); 

    try 
    { 
    // do some stuff and recursively call the method 
    Recursive(x + 6); 
    } 
    catch(Exception ex) 
    { 
    if (ex is RecursionException) 
    { 
     // The exception is already wrapped 
     throw; 
    } 
    // wrap the exception, this should be done only once. 
    // save the path and original exception to the wrapper. 
    throw new RecursionException(path.ToString(), ex); 
    } 
    finally 
    { 
    // maintain the recursion path information 
    path.Pop() 
    } 
} 

To po prostu wygląda na zbyt skomplikowane. Istnieje nie tylko jedna metoda. Prawdopodobnie istnieje dwadzieścia lub nawet więcej miejsc, w których musiałem napisać ten kod.

Czy istnieje prostszy sposób wdrożenia tego?

---

Edit: Aby to podkreślić: Chciałbym mieć dużo prostszą sytuację, gdzie nie ma takich napowietrznych rekursywnie wywołać metodę, bo mam wiele takich rekurencyjnych wywołań, istnieje nie tylko jedna metoda, istnieje kilka metod rekurencyjnie wywołujących się nawzajem, które są wystarczająco złożone.

Chciałbym więc uniknąć całego bloku try-catch, ale nie widzę na to żadnego rozwiązania.

To nie jest duży problem dla wyjątków wyrzuconych w moim własnym kodzie, ponieważ może zawierać ścieżkę od początku. Ale jest to problem z każdym innym wyjątkiem.

---

Edit: Wyjątki muszą być opakowane w każdym innym kodem, a nie tylko wtedy, gdy wywołanie metody rekurencyjnej:

try 
    { 
    int a = 78/x; // DivisionByZeroExeption   

    Recursive(x + 6); 

    this.NullReference.Add(x); // NullReferenceException 
    } 

Więc owijania tylko wezwanie do Recusive nie działa.

Istnieje wiele takich metod, mających różne podpisy, robiąc różne rzeczy, jedyną popularną rzeczą jest obsługa wyjątków.

Answer 1

Myślę, że próbujesz uwzględnić ścieżkę rekurencyjną w szczegółach wyjątku, aby ułatwić debugowanie.

Co z wypróbowaniem tego.

public void Recursive(int x) 
{ 
    try 
    { 
    _Recursive(x) 
    } 
    catch 
    { 
    throw new RecursionException(path.ToString(), ex); 
    clear path, we know we are at the top at this point 
    } 
} 

private void _Recursive(int x) 
{ 
    // maintain the recursion path information 
    path.Push(x); 

    _Recursive(x + 6); 

    //maintain the recursion path information 
    //note this is not in a catch so will not be called if there is an exception 
    path.Pop() 
} 

Jeśli używasz gwintowania itp, będzie można spojrzeć na przechowywanie ścieżki w pamięć lokalna wątku.

---

Jeśli nie chcesz, aby zmusić rozmówcę do czynienia z RecursionException, można dokonać „ścieżka” społeczeństwu tak dzwoniący do niego dostęp. (Jak zwykle Eric Lippert odpowie później)

Albo możesz zalogować ścieżkę do swojego systemu rejestrowania błędów, gdy przechwycisz wyjątek, a następnie po prostu ponownie wyrzucisz wyjątek.

public void Recursive(int x) 
{ 
    try 
    { 
    _Recursive(x) 
    } 
    catch 
    { 
    //Log the path to your loggin sysem of choose 
    //Maybe log the exception if you are not logging at the top 
    // of your applicatoin   
    //Clear path, we know we are at the top at this point 
    } 
} 

Ma to tę zaletę, że osoba dzwoniąca wcale nie musi wiedzieć o "ścieżce".

Wszystko sprowadza się do tego, czego potrzebuje rozmówca, jakoś myślę, że jesteś dzwoniącym dla tego kodu, więc nie ma sensu próbować odgadnąć, co jest potrzebne na tym poziomie transakcji.

Answer 2

Wystarczy uproszczenie (nieznacznie) obchodzenia wyjątek:

void Recursive(int x) 
{ 
    // maintain the recursion path information 
    path.Push(x); 

    try 
    { 
     // do some stuff and recursively call the method 
     Recursive(x + 6); 
    } 
    catch(RecursionException) 
    { 
     throw; 
    } 
    catch(Exception) 
    { 
     throw new RecursionException(path.ToString(), ex); 
    } 
    finally 
    { 
     // maintain the recursion path information 
     path.Pop() 
    } 
} 

Otrzymasz callstack informacji w za wyjątkiem jeśli to w jakikolwiek sposób użyteczne dla was, poza tym można napisać to jako urywek następnie wystarczy włożyć że gdzie potrzeba do ponownego użycia.

Istnieje również możliwość, która będzie powolny, ale powinno działać:

void DoStuff() 
{ 
    this.Recursive(1, this.RecursiveFunction1); 
    this.Recursive(2, this.RecursiveFunction2); 
} 

bool RecursiveFunction1(int x) 
{ 
    bool continueRecursing = false; 

    // do some stuff 
    return continueRecursing; 
} 

bool RecursiveFunction2(int y) 
{ 
    bool continueRecursing = false; 

    // do some other stuff here 
    return continueRecursing; 
} 

private void Recursive(int x, Func<int, bool> actionPerformer) 
{ 
    // maintain the recursion path information 
    path.Push(x); 

    try 
    { 
     // recursively call the method 
     if(actionPerformer(x)) 
     { 
      Recursive(x + 6, actionPerformer); 
     } 
    } 
    catch(RecursionException) 
    { 
     throw; 
    } 
    catch(Exception ex) 
    { 
     throw new RecursionException(path.ToString(), ex); 
    } 
    finally 
    { 
     // maintain the recursion path information 
     path.Pop(); 
    } 
} 

Answer 3

Co wyszarpując obsługi catch z funkcji rekurencyjnej i po prostu pisać bez rekursji mniej manipulacji?

void StartRecursion(int x) 
{ 
    try 
    { 
     path.Clear(); 
     Recursive(x); 
    } 
    catch (Exception ex) 
    { 
     throw new RecursionException(path.ToString(), ex); 
    } 
} 

void Recursive(int x) 
{ 
    path.Push(x); 
    Recursive(x + 6); 
    path.Pop(); 
} 

void Main() 
{ 
    StartRecursion(100); 
} 

Answer 4

void Recursive(int x) 
{ 
    // maintain the recursion path information 
    path.Push(x); 

    try 
    { 
    // do some stuff and recursively call the method 
    Recursive(x + 6); 
    } 
    finally 
    { 
    // maintain the recursion path information 
    path.Pop() 
    } 
} 

void Recursive2(int x) 
{ 
    try 
    { 
    Recursive(x); 
    } 
    catch() 
    { 
     // Whatever 
    } 
} 

ten sposób można obsłużyć tylko jeden raz, jeśli wyjątek budzi Recursive2 uchwyty, tym rekurencji zostaje przerwana.

Answer 5

Twój problem dotyczy obsługi wyjątków. Zawijanie wyjątku we własnym wyjątku jest generalnie złym pomysłem, ponieważ obciąża ono wywołującego twój kod, aby obsługiwał twój wyjątek. Osoba dzwoniąca, która podejrzewa, że ​​może, na przykład, wywołać wyjątek "nie można odnaleźć ścieżki", wywołując kod, nie może zawijać połączenia w try-catch, który przechwytuje wyjątek IOException. Muszą złapać twój wyjątek RecursionException, a następnie napisać kilka kodu, aby go przesłuchać, aby ustalić, jaki to był wyjątek. Są chwile, kiedy ten wzór jest uzasadniony, ale nie widzę, że jest to jeden z nich.

Chodzi o to, że w ogóle tutaj nie jest konieczne używanie wyjątków. Oto niektóre pożądane aspekty rozwiązania:

• dzwoniący może złapać cokolwiek rodzaju wyjątku chcą
• w debugowania, dzwoniący może określić informacje o tym co funkcja rekurencyjna robił, gdy wyjątek.

OK, super, jeśli takie są cele projektu, a następnie wdrożyć że:

class C 
{ 
    private Stack<int> path 

#if DEBUG

= new Stack<int>(); 

#else

= null; 

#endif

public Stack<int> Path { get { return path; } } 

    [Conditional("DEBUG")] private void Push(int x) { Path.Push(x); } 
    [Conditional("DEBUG")] private void Pop() { Path.Pop(); } 
    public int Recursive(int n) 
    { 
    Push(n); 
    int result = 1; 
    if (n > 1) 
    { 
     result = n * Recursive(n-1); 
     DoSomethingDangerous(n); 
    } 
    Pop(); 
    return result; 
    } 
} 

A teraz dzwoniący może sobie z tym poradzić:

C c = new C(); 
try 
{ 
    int x = c.Recursive(10); 
} 
catch(Exception ex) 
{ 

#if DEBUG

// do something with c.Path 

Widzisz, co tu robimy? Wykorzystujemy fakt, że wyjątek zatrzymuje algorytm rekurencyjny na swoich ścieżkach.Ostatnią rzeczą, jaką chcemy zrobić, to oczyścić ścieżkę, wpadając w końcu; my chce wyskakuje do wyrzucenia na wyjątku!

Sens?