Pourquoi une exception non gérée ne termine-t-elle pas un processus pendant le débogage?

Question

C'est un comportement que j'ai remarqué plusieurs fois auparavant et j'aimerais savoir pourquoi. Si vous exécutez le programme suivant sous le débogueur (Visual Studio 2008), le débogueur continuera à rompre sur l'instruction throw, quelle que soit la fréquence à laquelle vous continuez le débogage. Vous devez arrêter le débogage pour sortir. Je m'attendrais à ce que le débogueur casse une fois et puis le processus se termine comme il arrive si vous exécutez le programme sans le débogueur. Est-ce que quelqu'un est au courant d'une bonne raison de ce comportement?

using System; 

namespace ExceptionTest 
{ 
    static internal class Program 
    { 
     static internal void Main() 
     { 
     try 
     { 
      throw new Exception(); 
     } 
     catch (Exception exception) 
     { 
      Console.WriteLine(exception.Message); 

      // The debuger will never go beyond 
      // the throw statement and terminate 
      // the process. Why? 
      throw; 
     } 
     } 
    } 
} 

Answer 1

Enjambant l'exception non gérée mettrait fin le processus - c'est probablement juste pour vous empêcher de terminer accidentellement le processus lorsque vous n'aviez pas l'intention de le faire.

Si l'exception est gérée ailleurs (par exemple dans un bloc try-catch externe générique), vous pourrez alors passer l'exception et le débogueur vous conduira à l'endroit où il est géré.

Answer 2

Vous ne pouvez pas passé une exception bulle tout le chemin vers le « haut » avec en cours de traitement Essayez ceci si vous avez vraiment besoin:

static internal void Main() 
     { 
      try 
      { 
       throw new Exception(); 
      } 
      catch (Exception exception) 
      { 
       Console.WriteLine(exception.Message); 

       // The debuger will never go beyond 
       // the throw statement and terminate 
       // the process. Why? 
       Environment.FailFast("Oops"); 
       throw; 
      } 
     } 

Answer 3

Si vous voulez arrêter le processus, utilisez le bouton "Stop". Il est parfois utile d'arrêter l'application. La raison pour laquelle le débogueur n'insiste pas sur le fait de tuer l'application est qu'un programmeur peut vouloir examiner l'état du programme dans le contexte de l'exception levée et/ou "pousser" les choses de telle sorte que le programme puisse continuer. Il est intéressant de noter que l'interruption du débogueur se produit avant l'exécution des finaliseurs; Cela permet d'examiner les aspects de l'état du programme qui seraient détruits lors de la finalisation.

Notez également qu'il est possible d'avoir une exception qui déclenchera l'interruption du débogueur "exception non interceptée" et ne terminera pas le programme. Par exemple, on pourrait faire quelque chose comme:

 
Class exTest 
    Class myException 
     Inherits Exception 
     Sub New(ByVal innerException As Exception) 
      MyBase.new("Wrapped Exception", innerException) 
     End Sub 
    End Class 
    Shared Function CopyArg1ToArg2AndReturnFalse(Of T)(ByVal arg1 As T, ByRef arg2 As T) As Boolean 
     arg2 = arg1 
     Return False 
    End Function 
    Shared Sub testIt() 
     Dim theException As Exception = Nothing 
     Try 
      Try 
       Throw New ApplicationException 
      Catch ex As Exception When CopyArg1ToArg2AndReturnFalse(ex, theException) 
       Throw 
      Finally 
       If theException IsNot Nothing Then Throw New myException(theException) 
      End Try 
     Catch ex As myException 
      Debug.Print("Exception: " & ex.InnerException.ToString) 
     End Try 
    End Sub 
End Class 

Le système détermine avant tout les clauses finally se déclenchent par l'exception que personne ne va capturer ApplicationException. Comme il arrive, cependant, si une exception est levée, la clause Finally empêchera cette exception particulière de s'échapper en lançant une nouvelle exception, une nouvelle exception qui sera prise en compte par . Cette astuce peut être utile pour le débogage dans des situations où certaines exceptions seront piégées et traitées à un niveau interne (sans perturber l'expérience utilisateur) tandis que d'autres seront piégées à un niveau externe (par exemple en affichant un message d'erreur). Les exceptions qui ne seront piégées qu'au niveau externe généreront un piège de débogueur lorsqu'elles se produisent, tandis que celles qui sont piégées au niveau interne permettront au programme de continuer.