c# - usuario - La excepción capturada es nula en sí misma!

todas las excepciones en c#

Question

Tengo una aplicación ASP.NET. Todo estaba bien, pero recientemente obtuve excepciones que son nulas:

try
{
    // do something
}
catch (Exception ex)
{
    Logger.Log("Error while tried to do something. Error: " + ex.Message);
}

¡A veces el ex es null sí mismo!

¿Alguna idea?

Answer 1

Acabo de encontrar un problema en el que alguien pasaba ex.InnerException a un método, donde ex era la raíz. Dado que el parámetro también se denominó ex , provocó cierta confusión en el depurador cuando observé la excepción capturada originalmente. Este fue probablemente el resultado de una refactorización descuidada.

p.ej:

public void MyMethod(string input)
{
    try {
        Process(input);
    } catch (Exception ex) { // <- (2) Attempting to view ex here would show null
        _logger.log(ex);
        LogInner(ex.InnerException);
    }
}

private void LogInner(Exception ex)
{
    _logger.log(ex); // <- (1) NullReferenceExeption thrown here
    if(ex.InnerException != null)
        LogInner(ex.InnerException);
}

Esto fue refactorizado como tal:

public void MyMethod(string input)
{
    try {
        Process(input);
    } catch (Exception ex) {
        LogExceptionTree(ex);
    }
}

private void LogExceptionTree(Exception exception)
{
    _logger.log(exception);
    if(exception.InnerException != null)
        LogExceptionTree(exception.InnerException);
}

Answer 2

En mi caso, la causa fue una Exception. Tales excepciones normalmente no alcanzan el bloque catch en absoluto, pero esta vez, por alguna razón no entiendo, llegó al bloque catch, pero la excepción fue nula.

Answer 3

Eso no puede pasar.

Si throw null , obtendrás una NullReferenceException del throw ; la excepción en el bloque catch nunca puede ser null .

Tienes algo más que es null .

Answer 4

Me encontré con el mismo problema, y ​​la razón es: la excepción es una NullReferenceException, por lo que no puede usar ex.Message, y debe probar el flujo:

try
 {     // do something } 

catch (NullReferenceException)
{
  Logger.Log("Error while tried to do something. Error: Null reference");
}

catch (Exception ex) 
{     
  Logger.Log("Error while tried to do something. Error: " + ex.Message); 
} 

Answer 5

Para cualquiera que termine aquí, he encontrado una instancia en la que esto es posible (aunque solo sea detectable en el depurador). VS2013 Actualización 4.

Roto:

try
{
    // do something
}
catch (WebException ex) // <- both variables are named ''ex''
{
    Logger.Log("Error while tried to do something. Error: " + ex.Message);
}
catch (Exception ex) // <- this ''ex'' is null
{
    Logger.Log("Error while tried to do something. Error: " + ex.Message);
}

La solución es nombrar sus variables de excepción de manera diferente.

Fijo:

try
{
    // do something
}
catch (WebException webEx) // <- all good in the hood
{
    Logger.Log("Error while tried to do something. Error: " + webEx.Message); // <-
}
catch (Exception ex) // <- this ''ex'' correctly contains the exception
{
    Logger.Log("Error while tried to do something. Error: " + ex.Message);
}