MethodBase.GetCurrentMethod () Performances?

Question

J'ai écrit une classe de journal et une fonction comme dans le code suivant:

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

Chaque fois que j'enregistre quelque chose, je consigne également le nom de la classe à partir de methodBase.Name et methodBase.DeclaringType.Name.

J'ai lu l'article suivant Utilisation de Get CurrentMethod et j'ai remarquéque cette méthode est lente.

Dois-je utiliser this.GetType () au lieu de System.Reflection.MethodBase ou je devrais enregistrer manuellement le nom de la classe / méthode dans mon journal, par exempleLog ("ClassName.MethodName", "message du journal)? Quelle est la meilleure pratique?

Answer 1

Cela dépend vraiment.

Si vous utilisez l'approche this.GetType(), vous perdrez les informations sur la méthode, mais vous aurez un gros gain de performances (apparemment un facteur de 1200, selon votre lien).

Si vous proposez une interface qui permet à l'appelant de fournir des chaînes (par exemple, Log("ClassName.MethodName", "log message"), vous obtiendrez probablement de meilleures performances, mais cela rend votre API moins conviviale (le développeur appelant doit fournir le nom de la classe et le nom de la méthode).

Answer 2

Je sais que c'est une vieille question, mais j'ai pensé que je proposerais une solution simple qui semble bien fonctionner et qui maintient les symboles

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'exécution de ce code me donne les résultats suivants:

Reflection Time: 1692.1692ms
    Lookup Time: 19.0019ms

Press Enter to exit

Pour un million d'itérations, ce n'est pas mal du tout , surtout par rapport à la réflexion directe.Le groupe de méthodes est en cours de conversion en un type Délégué, vous maintenez un lien symbolique tout au long de la journalisation.Pas de cordes magiques loufoques.