registro genérico de parámetros de la función de gestión de excepciones

Question

Una gran parte de mi código C# sigue este patrón:

void foo(string param1, string param2, string param3) 
{ 
    try 
    { 
     // do something... 
    } 
    catch(Exception ex) 
    { 
     LogError(String.Format("Error in foo(param1={0}, param2={1}, param3={2}), exception={3}", param1, param2, param3, ex.Message)); 
    } 
} 

¿Hay una manera de .NET para obtener una lista de clave/valor de los parámetros de una función para que ¿Puedo llamar a otra función para construir mi cadena de registro de errores? O ¿Tiene una manera más genérica/mejor de hacer esto?

Answer 1

Usted podría utilizar la reflexión y la convención que debe pasar los parámetros a la LogError con el orden correcto:

private static void MyMethod(string s, int x, int y) 
{ 
    try 
    { 
     throw new NotImplementedException(); 
    } 
    catch (Exception ex) 
    { 
     LogError(MethodBase.GetCurrentMethod(), ex, s, x, y); 
    } 
} 

private static void LogError(MethodBase method, Exception ex, params object[] values) 
{ 
    ParameterInfo[] parms = method.GetParameters(); 
    object[] namevalues = new object[2 * parms.Length]; 

    string msg = "Error in " + method.Name + "("; 
    for (int i = 0, j = 0; i < parms.Length; i++, j += 2) 
    { 
     msg += "{" + j + "}={" + (j + 1) + "}, "; 
     namevalues[j] = parms[i].Name; 
     if (i < values.Length) namevalues[j + 1] = values[i]; 
    } 
    msg += "exception=" + ex.Message + ")"; 
    Console.WriteLine(string.Format(msg, namevalues)); 
} 

Answer 2

Cuando he hecho esto, acabo de crear un diccionario genérico para el registro.

Tengo esta clase LogArgs. Y al iniciar sesión en una clase base a la que llamo cuando tengo una excepción.

public class LogArgs 
{ 

    public string MethodName { get; set; } 
    public string ClassName { get; set; } 
    public Dictionary<string, object> Paramters { get; set; } 


    public LogArgs() 
    { 
     this.Paramters = new Dictionary<string, object>(); 
    } 

} 

Luego, al comienzo de cada método que hago

LogArgs args = new LogArgs { ClassName = "ClassName", MethodName = "MethodName" }; 
args.Paramters.Add("Param1", param1); 
args.Paramters.Add("Param2", param2); 
args.Paramters.Add("Param3", param3); 

base.Logger.MethodStartLog(args); 

Cuando tengo un error de E conectarse de esta manera.

base.Logger.LogError(args, ex); 

Answer 3

No, no hay una forma de hacerlo.

La práctica habitual es no detectar excepciones a menos que pueda manejarlas.

I.e. normalmente solo detectaría excepciones y las registraría en un manejador de excepciones de nivel superior. A continuación, obtendrá un seguimiento de pila, pero por supuesto no obtendrá detalles de todos los parámetros de todas las llamadas a métodos en la pila.

Obviamente, cuando se depuran, se desean tantos detalles como sea posible. Otras formas de lograr esto son:

• Use declaraciones Debug.Assert liberalmente para probar las suposiciones que está realizando.

• Instrumente su aplicación con el registro que se puede activar selectivamente. Uso Log4Net, pero también hay otras alternativas, incluida la utilización de la clase System.Diagnostics.Trace.

En cualquier caso, si no capturar las excepciones sólo a ellos log (me gustaría hacer esto en un límite de nivel en una aplicación de n niveles, por lo que las excepciones se registran en el servidor), entonces debería siempre volver a lanzar ellos:

try 
{ 
    ... 
} 
catch(Exception ex) 
{ 
    log(ex); 
    throw; 
} 

Answer 4

Se puede usar un estilo similar de construir el mensaje, además de añadir la palabra clave params en su método LogError para manejar los argumentos. Por ejemplo:

public void LogError(string message, params object[] parameters) 
    { 
     if (parameters.Length > 0) 
      LogError(string.Format(message, parameters)); 
     else 
      LogError(message); 
    } 

Answer 5

usted podría utilizar la programación orientada a aspectos con PostSharp (echar un vistazo en http://www.postsharp.org, y el tutorial en http://www.codeproject.com/KB/cs/ps-custom-attributes-1.aspx).Básicamente se podría hacer algo como esto:

public class LogExceptionAttribute : OnExceptionAspect 
{ 
public override void OnException(MethodExecutionEventArgs eventArgs) 
{ 
    log.error("Exception occurred in method {0}", eventArgs); 
} 
} 

[LoggingOnExceptionAspect] 
public foo(int number, string word, Person customer) 
{ 
    // ... something here throws an exception 
} 

Tal vez no es lo que quieren, pero estoy seguro de que se puede adaptar para satisfacer sus necesidades.

Answer 6

hay escenarios de algunos parámetros o gran número de parámetros ...

1. pocos parámetros, sin más, mejor escribir como parte del mensaje de registro/excepción.

2. En grandes parámetros, una aplicación de varias capas estaría utilizando ENTITIES (como cliente, CustomerOrder ...) para transferir datos entre capas. Estas entidades deben aplicar ToString anulación() de la clase Object, no por,

Mensaje de registro ("método comenzó" + paramObj.ToString()) daría a la lista de los datos en el objeto .. Cualquier opiniones? :)

gracias

Answer 7

Ésta es pequeño post anticuado, pero por si acaso alguien viene a través de este como lo hice yo - yo resolvió este problema utilizando PostSharp.

Aunque no es prácticamente gratis. La licencia Express (descargable a través de NuGet en VS) le permite decorar su método con el atributo [Log] y luego elegir su mecanismo ya configurado para el registro, como log4netnLog etc. Ahora comenzará a ver entradas de nivel de depuración en su registro dando detalles del parámetro.

Con licencia expresa, solo pude decorar un máximo de 50 métodos en mi proyecto. Si se adapta a tus necesidades, ¡ya estás listo!