¿Cómo obtener un valor a través de un parámetro out/ref de un método que arroja una excepción?

Question

este código produce "valor de salida".

class P 
{ 
    public static void Main() 
    { 
    string arg = null; 
    try 
    { 
     Method(out arg); 
    } 
    catch 
    { 
    } 
    Console.WriteLine(arg); 
    } 
    public static void Method(out string arg) 
    { 
    arg = "out value"; 
    throw new Exception(); 
    } 
} 

pero este no.

class P 
{ 
    public static void Main() 
    { 
    object[] args = new object[1]; 
    MethodInfo mi = typeof(P).GetMethod("Method"); 
    try 
    { 
     mi.Invoke(null, args); 
    } 
    catch 
    { 
    } 
    Console.WriteLine(args[0]); 
    } 
    public static void Method(out string arg) 
    { 
    arg = "out value"; 
    throw new Exception(); 
    } 
} 

cómo puedo obtener tanto "valor fuera" y un excepción cuando utilizando la reflexión?

Answer 1

El parámetro out no está definido si el método arroja una excepción. Puede ver esto al no inicializarlo como nulo en el primer ejemplo, luego el código no se compilará.

Por lo tanto, tiene sentido que el método Invoke no devuelva el valor indefinido si el método arroja una excepción.

Answer 2

La excepción omitió el código en MethodInfo.Invoke() que copia el valor [out] del marco de la pila de nuevo en la matriz de objetos. El valor en el marco de pila que creó Invoke() se comporta como lo hace en su primer fragmento. Pero ahí es donde terminan las similitudes.

Answer 3

La única forma es sobrecargar su método de forma que represente la posibilidad de una excepción y luego pasar uno en "por las dudas". Lo siguiente produce lo que creo que estás buscando. El problema, tal como lo entiendo, es que la reflexión no realiza una manipulación directa de las direcciones pasadas por referencia. Las direcciones no se ven afectadas hasta que se alcanza el punto final del método sin excepción. Posiblemente una protección de memoria o esquema de seguridad de memoria de MS.

class P 
    { 
     public static void Main() 
     { 
      object[] args = { "1", new Exception()}; 
      MethodInfo mi = typeof(P).GetMethod("Method"); 
      try 
      { 
       mi.Invoke(null, args); 
      } 
      catch 
      { 
      } 
      Console.WriteLine(args[0].ToString()); 
      Console.WriteLine(args[1].ToString()); 
     } 
     public static void Method(ref string arg, ref Exception ex) 
     { 
      try 
      { 
       arg = "out value"; 
       throw new Exception(); 
      } 
      catch (Exception exc) 
      { 
       ex = exc; 
      } 
     } 
} 

Answer 4

Propongo cambiar el método para devolver el objeto Result en lugar del parámetro out. El objeto de resultado puede contener una excepción y también el valor de su arg.

Answer 5

Si el problema es cómo se da cuenta de que se ha producido una excepción y está trabajando con una aplicación de Windows Forms, ¿ha intentado buscar en el evento de excepción de subprocesos y combinarlo con SetUnhandledExceptionMode()?

Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException); 
Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException); 

static void Application_ThreadException(object sender, System.Threading.ThreadExceptionEventArgs e)   
{    
    HandleException(e.Exception);   
}