MethodBase.getCurrentMethod () rendimiento?

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 registro algo, también registro el nombre de clase de MethodBase.Name y MethodBase.DeclaringType.name.

Leí la siguiente publicación Usando 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 clase/método en mi registro, por ejemplo, log ("classname.methodname", "Mensaje de registro)? ¿Cuál es la mejor práctica?

Answer 1

Realmente depende.

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

Si ofrece una interfaz que permite que las cadenas de suministro de la persona que llamen (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 de llamadas debe proporcionar el nombre de clase y el nombre del método).

Answer 2

Sé que esta es una pregunta antigua, pero pensé que tiraría 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);
        }
    }

Ejecutar este código me da los siguientes resultados:

Reflection Time: 1692.1692ms
    Lookup Time: 19.0019ms

Press Enter to exit

Por un millón de iteraciones, eso no es malo en absoluto, especialmente en comparación con la reflexión directa. El grupo de métodos se está lanzando a un tipo delegado, mantiene un enlace simbólico hasta el registro. No hay cuerdas mágicas tontas.