tipos - try catch c#

La reanudación de la ejecución del código después de la excepción es lanzada y atrapada

Question

¿Cómo es posible reanudar la ejecución del código después de lanzar una excepción?

Por ejemplo, tome el siguiente código:

namespace ConsoleApplication1
{
public class Test
{
public void s()
{
throw new NotSupportedException();
string @class = "" ;
Console.WriteLine(@class);
Console.ReadLine();
}
}
public class Program
{
public static void Main(string[] args)
{
try
{
new Test().s();
}
catch (ArgumentException x)
{
}
catch (Exception ex)
{
}
}
}
}

Después de detectar la excepción al avanzar, el programa dejará de ejecutarse. ¿Cómo puedo seguir ejecutando?

EDITAR: Lo que quiero decir específicamente es la línea Console.WriteLine (@class); No parece que se haya alcanzado, porque cuando lo ejecuto cuando estoy en modo de depuración, el programa sale del modo de depuración. Quiero correr a esta línea y detenerme en ello.

Gracias

Answer 1

¡El programa deja de ejecutarse porque no hay ningún código siguiente para ejecutar en el método Main ()! Puede agregar la siguiente línea a su código para mantener el programa en ejecución hasta que haya una entrada de consola:

Console.ReadLine();

Answer 2

Bueno, no tienes ningún código después de los bloques catch , por lo que el programa dejaría de ejecutarse. No estoy seguro de lo que estás tratando de hacer.

Lo siguiente debe ser una prueba de que el programa no simplemente se "detiene" después de los bloques de catch . Ejecutará código después de los bloques de catch si hay código para ejecutar:

static void Main(string[] args)
{
try
{
new Test().s();
}
catch (ArgumentException x)
{
Console.WriteLine("ArgumentException caught!");
}
catch (Exception ex)
{
Console.WriteLine("Exception caught!");
}
Console.WriteLine("I am some code that''s running after the exception!");
}

El código imprimirá la cadena apropiada dependiendo de la excepción que se detectó. Luego, se imprimirá I am some code that''s running after the exception! al final.

ACTUALIZAR

En su edición, preguntó por qué Console.WriteLine(@class); No parece ser golpeado. La razón es que está lanzando explícitamente una excepción en la primera línea de su método s() ; Todo lo que sigue se ignora. Cuando se encuentra una excepción, la ejecución se detiene y la excepción se propaga en la pila de llamadas hasta que el manejador apropiado pueda manejarla (esto puede ser un bloque catch que corresponde al try que envuelve la declaración en cuestión dentro del mismo método, o puede sea ​​un bloque catch más arriba en la pila de llamadas. Si no se encuentra un manejador apropiado, el programa terminará con un seguimiento de pila [al menos en Java - no estoy seguro si sucede lo mismo en C #]).

Si desea golpear la línea Console.WriteLine , no debe lanzar explícitamente una excepción al principio del método.

Answer 3

Cierto código simple que reuní para capturar excepciones que se lanzan dentro de un bloque catch:

try
{
//do code here
}
catch (Exception ex)
{
try { SomeMethod1(); }
catch { }
try { SomeMethod2(); }
catch { }
try { SomeMethod3(); }
catch { }
}
finally
{
//cleanup goes here
}

Answer 4

Descargo de responsabilidad: no estoy sugiriendo que realmente haga esto.

Puede imitar el antiguo estilo de VB On Error Resume Next con el siguiente código.

public static class ControlFlow
{
public static Exception ResumeOnError(Action action)
{
try
{
action();
return null;
}
catch (Exception caught)
{
return caught;
}
}
}

Y luego podría ser utilizado como el siguiente.

public static void Main()
{
ControlFlow.ResumeOnError(() => { throw new NotSupportedException(); });
ControlFlow.ResumeOnError(() => { Console.WriteLine(); });
ControlFlow.ResumeOnError(() => { Console.ReadLine(); });
}

Answer 5

La ejecución aún continúa, pero no hay ningún código después de que se detecte la excepción. Si desea llamar repetidamente a s, considere envolver el bloque try / catch en un bucle while.

Answer 6

Para ese código, no puedes. Si divide las tareas en partes más pequeñas, puede reanudar en la siguiente parte. Pero normalmente es más fácil tener un mecanismo diferente a las excepciones para informar errores no fatales, como una función de devolución de llamada que devuelve si continuar o no.

Answer 7

Puede utilizar la función "paso a paso" en la depuración para lograr esto en una base por ejecución.

Answer 8

Si le preocupa que se lance una excepción en el método pero desea que el método continúe, agregue un controlador de errores dentro del método.

class Test
{
public void s()
{
try
{
// Code that may throw an exception
throw new NotSupportedException();
}
catch(Exception ex)
{
// Handle the exception - log?, reset some values?
}
string @class = "" ;
Console.WriteLine(@class);
Console.ReadLine();
}
} 

También puede devolver un valor bool o algún otro valor para indicar el estado.

Answer 9

Suena como si estuvieras queriendo excepciones reanudables. C # no hace excepciones reanudables, y dudo que CLR las respalde.

El propósito de lanzar una excepción es abortar una función y una operación completa (pila de llamadas) si / cuando algo en el entorno de la llamada (parámetros, estado del objeto, estado global) hace que la operación de la función sea imposible o no válida. Pasar un parámetro cero a una función que necesita dividir una cantidad por ese parámetro, por ejemplo. La división por cero no producirá un resultado significativo, y si ese es el único propósito de la función, entonces la función tampoco puede devolver un resultado significativo. Por lo tanto, lanzar una excepción. Esto hará que la ejecución salte a la captura más cercana o que finalmente se bloquee en la pila de llamadas. No hay vuelta a la función que lanzó la excepción.

Si desea ingresar a su código en el depurador para rastrear las llamadas de Console.WriteLine (), debe eliminar la nueva línea NotSupportedException () de su código y volver a compilar.

Answer 10

public static void Main()
{
for (int j = 0; j <= 100000; j++)
{
try
{
// TODO: Application logic...
}
catch
{
System.Threading.Thread.Sleep(1000);
}
}
}