MethodBase.getCurrentMethod () Performance?

Question

Ho scritto una classe di registro e una funzione come nel seguente codice:

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

Ogni volta che registro qualcosa, registro anche il nome della classe da MethodBase.Name e MethodBase.DeclaringType.Name.

Ho letto il seguente post Usando Get CurrentMethod E ho notato che questo metodo è lento.

Dovrei usare this.getType () anziché System.reflection.Methodbase o dovrei registrare manualmente il nome di classe/metodo nel mio registro EG ("ClassName.MethodName", "Messaggio di registro)? Qual è la migliore pratica?

Answer 1

Dipende davvero.

Se usi il this.GetType() Approccio perderai le informazioni sul metodo, ma avrai un grande guadagno delle prestazioni (apparentemente un fattore 1200, secondo il tuo link).

Se offri un'interfaccia che consente alle stringhe di alimentazione del chiamante (ad es. Log("ClassName.MethodName", "log message"), probabilmente guadagnerai prestazioni ancora migliori, ma questo rende la tua API meno amichevole (lo sviluppatore chiamante deve fornire il nome della classe e il nome del metodo).

Answer 2

So che questa è una vecchia domanda, ma ho pensato che avrei lanciato una soluzione semplice che sembra funzionare bene e mantiene i simboli

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);
        }
    }

L'esecuzione di questo codice mi dà i seguenti risultati:

Reflection Time: 1692.1692ms
    Lookup Time: 19.0019ms

Press Enter to exit

Per un milione di iterazioni, non è male affatto, soprattutto rispetto alla riflessione diretta. Il gruppo Method viene lanciato su un tipo delegato, mantieni un collegamento simbolico fino alla registrazione. Nessuna sciocca corde magiche.