Establecer InnerException del objeto .NET Exception

Question

¿Cómo puedo establecer la propiedad InnerException de un objeto Exception, mientras estoy en el constructor de ese objeto? Esto se reduce a encontrar y configurar el campo de respaldo de una propiedad que no tiene setter.

por cierto: He visto esto (http://evain.net/blog/articles/2009/05/01/getting-the-field-backing-a-property-using-reflection) pero estoy buscando una solución que no esté basada en IL, si es posible.

El constructor de excepción es el lugar donde se crea el tipo de excepción, por lo que no se puede llamar utilizando la MiExcepción constructor de la clase base(): base (...), etc.

Answer 1

¿Por qué no puedes simplemente llamar al constructor que toma la InnerException como parámetro? Si por alguna razón no es posible, el campo respaldo en System.Exception es:

private Exception _innerException; 

me pareció a cabo utilizando Redgate's Reflector. Usando el reflejo, supongo que podrías establecer la excepción interna.

Edit: En la mayoría de los casos, no es una buena idea acceder a los campos privados por reflexión, pero no sé lo suficiente sobre el caso de NT para saber si es una buena o mala idea.

Answer 2

Exception exceptionWithMoreInfo = new Exception("extra info", ex); 

sería una práctica normal asumiendo que atrapó una excepción a la que le gustaría agregar más información antes de burbujear.

Answer 3

configura la excepción interna llamando a la base de Héctor:

public MyException(string message, Exception innerException) 
     : base(message, innerException) {...} 

Si necesita ejecutar algún código para obtener la excepción, utilice un método estático:

public MyException(SomeData data) : base(GetMessage(data), GetInner(data)) {...} 
static Exception GetInner(SomeData data) {...} // <===== your type creation here! 
static string GetMessage(SomeData data) {...} 

Answer 4

No es InnerException se supone que se establece cuando se utiliza el constructor Exception(string, Exception) Creo que es por diseño que no se puede cambiar esto de otra manera, pero siempre se puede aplazar al constructor apropiado en el tiempo de construcción:

class MyException : Exception { 
    public MyException() 
     : base("foo", new Exception("bar")) 
    { 
     ... 
    } 

    ... 
} 

Creo que no debería nunca romper la cadena de excepción en su código, ya que por lo general conduce a errores que nunca encontrarás de nuevo.

Answer 5

La clase Exception tiene un constructor sobrecargado aceptar la excepción interna como parámetro:

Exception exc = new Exception("message", new Exception("inner message")); 

¿Es esto lo que busca?

Answer 6

Si entiendo su pregunta que queremos hacer algo como esto:

Exception ex = new Exception("test"); 
Exception innerEx = new Exception("inner"); 
ex.GetType().GetField("_innerException", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(ex, innerEx); 

Si se encuentra en el constructor de un objeto que hereda de Exception que usaría this en lugar de la primera ex.

Pero esta puede no ser la mejor manera de manejar lo que sea que esté tratando de manejar.

Answer 7

Utilice el reflector de Redgate para encontrar el campo. Dudo que la implementación de Exception cambie alguna vez ... ¡Pero es un riesgo!

Answer 8

Sé que llego muy tarde a la fiesta, pero me parece que esto funciona.

public class MyException: Exception 
{ 
    public void SetInnerException(Exception exception) 
    { 
     typeof(Exception) 
      .GetField("_innerException", BindingFlags.NonPublic | BindingFlags.Instance) 
      .SetValue(this, exception); 
    } 
} 

El truco es conseguir el campo _innerException real Exception de tipo y, a continuación, establezca el valor de excepción interna a la instancia de la clase (MyException en este caso).

Esto también funciona para las variables.

Exception mainException = new Exception(); 
typeof(Exception) 
    .GetField("_innerException", BindingFlags.NonPublic | BindingFlags.Instance) 
    .SetValue(mainException , new Exception("Something bad happened!"));