MethodBase.GetCurrentMethod() Performance?

Question

He escrito una clase de registro y una función como en el siguiente código:

Log(System.Reflection.MethodBase methodBase, string message) 

Cada vez que me conecto algo también me conecto el nombre de clase de la methodBase.Name y methodBase.DeclaringType.Name.

Leí la siguiente publicación Using Get CurrentMethod y noté que este método es lento.

Debo usar this.GetType() en lugar de System.Reflection.MethodBase o debería registrar manualmente el nombre de la clase/método en mi log, p. Log ("ClassName.MethodName", "mensaje de registro)? ¿Cuál es la mejor práctica?

Answer 1

Realmente depende.

Si utiliza el enfoque this.GetType() perderá la información del método, pero tendrá un gran ganancia de rendimiento (aparentemente un factor de 1200, según su enlace)

Si ofrece una interfaz que permite al llamante suministrar cadenas (por ejemplo, Log("ClassName.MethodName", "log message")), probablemente obtendrá un rendimiento aún mejor, pero esto hace que su API sea menos amigable (el desarrollador llamante debe proporcionar el nombre de la clase y el nombre del método).

Answer 2

Sé que esto es una vieja pregunta, pero pensé que había que tirar a cabo una solución simple que parece funcionar bien y mantiene símbolos

static void Main(string[] args) 
    { 
     int loopCount = 1000000; // 1,000,000 (one million) iterations 
     var timer = new Timer(); 

     timer.Restart(); 
     for (int i = 0; i < loopCount; i++) 
      Log(MethodBase.GetCurrentMethod(), "whee"); 
     TimeSpan reflectionRunTime = timer.CalculateTime(); 

     timer.Restart(); 
     for (int i = 0; i < loopCount; i++) 
      Log((Action<string[]>)Main, "whee"); 
     TimeSpan lookupRunTime = timer.CalculateTime(); 

     Console.WriteLine("Reflection Time: {0}ms", reflectionRunTime.TotalMilliseconds); 
     Console.WriteLine(" Lookup Time: {0}ms", lookupRunTime.TotalMilliseconds); 
     Console.WriteLine(); 
     Console.WriteLine("Press Enter to exit"); 
     Console.ReadLine(); 

    } 

    public static void Log(Delegate info, string message) 
    { 
     // do stuff 
    } 

    public static void Log(MethodBase info, string message) 
    { 
     // do stuff 
    } 

    public class Timer 
    { 
     private DateTime _startTime; 

     public void Restart() 
     { 
      _startTime = DateTime.Now; 
     } 

     public TimeSpan CalculateTime() 
     { 
      return DateTime.Now.Subtract(_startTime); 
     } 
    } 

La ejecución de este código me da los siguientes resultados:

Reflection Time: 1692.1692ms 
    Lookup Time: 19.0019ms 

Press Enter to exit 

Para un millón de iteraciones, eso no es malo en total, especialmente en comparación con la reflexión directa. El grupo de métodos está siendo lanzado a un tipo Delegado, usted mantiene un enlace simbólico hasta el final en el registro. Sin cuerdas mágicas tontas.