Comment puis-je trouver la méthode qui a appelé la méthode actuelle?

Lors de la connexion en C #, comment puis-je connaître le nom de la méthode qui a appelé la méthode actuelle? Je sais tout System.Reflection.MethodBase.GetCurrentMethod(), mais je veux aller plus loin dans la trace de la pile. J'ai envisagé d'analyser la trace de la pile, mais j'espère trouver un moyen plus clair et plus explicite, quelque chose comme Assembly.GetCallingAssembly()mais pour les méthodes.

Essaye ça:

using System.Diagnostics;
// Get call stack
StackTrace stackTrace = new StackTrace(); 
// Get calling method name
Console.WriteLine(stackTrace.GetFrame(1).GetMethod().Name);

bon mot:

(new System.Diagnostics.StackTrace()).GetFrame(1).GetMethod().Name

Il s'agit de la méthode Get Calling utilisant la réflexion [C #] .

En C # 5, vous pouvez obtenir ces informations en utilisant les informations de l' appelant :

//using System.Runtime.CompilerServices;
public void SendError(string Message, [CallerMemberName] string callerName = "") 
{ 
    Console.WriteLine(callerName + "called me."); 
} 

Vous pouvez également obtenir le [CallerFilePath]et [CallerLineNumber].

Vous pouvez utiliser les informations sur l'appelant et les paramètres facultatifs:

public static string WhoseThere([CallerMemberName] string memberName = "")
{
       return memberName;
}

Ce test illustre cela:

[Test]
public void Should_get_name_of_calling_method()
{
    var methodName = CachingHelpers.WhoseThere();
    Assert.That(methodName, Is.EqualTo("Should_get_name_of_calling_method"));
}

Bien que StackTrace fonctionne assez rapidement ci-dessus et ne soit pas un problème de performances dans la plupart des cas, les informations sur l'appelant sont encore beaucoup plus rapides. Dans un échantillon de 1000 itérations, je l'ai cadencé 40 fois plus vite.

Un récapitulatif rapide des 2 approches avec comparaison de vitesse étant la partie importante.

http://geekswithblogs.net/BlackRabbitCoder/archive/2013/07/25/c.net-little-wonders-getting-caller-information.aspx

Déterminer l'appelant au moment de la compilation

static void Log(object message, 
[CallerMemberName] string memberName = "",
[CallerFilePath] string fileName = "",
[CallerLineNumber] int lineNumber = 0)
{
    // we'll just use a simple Console write for now    
    Console.WriteLine("{0}({1}):{2} - {3}", fileName, lineNumber, memberName, message);
}

Déterminer l'appelant à l'aide de la pile

static void Log(object message)
{
    // frame 1, true for source info
    StackFrame frame = new StackFrame(1, true);
    var method = frame.GetMethod();
    var fileName = frame.GetFileName();
    var lineNumber = frame.GetFileLineNumber();

    // we'll just use a simple Console write for now    
    Console.WriteLine("{0}({1}):{2} - {3}", fileName, lineNumber, method.Name, message);
}

Comparaison des 2 approches

Time for 1,000,000 iterations with Attributes: 196 ms
Time for 1,000,000 iterations with StackTrace: 5096 ms

Donc, vous voyez, l'utilisation des attributs est beaucoup, beaucoup plus rapide! En fait, près de 25 fois plus rapide.

Nous pouvons améliorer un peu le code de M. Assad (la réponse actuellement acceptée) en instanciant uniquement le cadre dont nous avons réellement besoin plutôt que la pile entière:

new StackFrame(1).GetMethod().Name;

Cela pourrait fonctionner un peu mieux, mais selon toute vraisemblance, il doit encore utiliser la pile complète pour créer cette seule image. En outre, il a toujours les mêmes mises en garde qu'Alex Lyman a souligné (l'optimiseur / code natif pourrait corrompre les résultats). Enfin, vous voudrez peut-être vérifier pour être sûr que new StackFrame(1)ou .GetFrame(1)ne revenez pas null, aussi improbable que cela puisse paraître.

Voir cette question connexe: pouvez-vous utiliser la réflexion pour trouver le nom de la méthode en cours d'exécution?

En général, vous pouvez utiliser la System.Diagnostics.StackTraceclasse pour obtenir un System.Diagnostics.StackFrame, puis utiliser la GetMethod()méthode pour obtenir un System.Reflection.MethodBaseobjet. Cependant, il y a quelques mises en garde à cette approche:

1. Il représente la pile d' exécution - les optimisations pourraient aligner une méthode, et vous ne verrez pas cette méthode dans la trace de la pile.
2. Il ne montrera aucun cadre natif, donc s'il y a même une chance que votre méthode soit appelée par une méthode native, cela ne fonctionnera pas , et il n'y a en fait aucun moyen actuellement disponible pour le faire.

( REMARQUE: je développe simplement la réponse fournie par Firas Assad .)

Depuis .NET 4.5, vous pouvez utiliser les attributs d' informations sur l'appelant :

• CallerFilePath - Le fichier source qui a appelé la fonction;
• CallerLineNumber - Ligne de code qui a appelé la fonction;

• CallerMemberName - Membre qui a appelé la fonction.

  public void WriteLine(
      [CallerFilePath] string callerFilePath = "", 
      [CallerLineNumber] long callerLineNumber = 0,
      [CallerMemberName] string callerMember= "")
  {
      Debug.WriteLine(
          "Caller File Path: {0}, Caller Line Number: {1}, Caller Member: {2}", 
          callerFilePath,
          callerLineNumber,
          callerMember);
  }

Cette fonctionnalité est également présente dans ".NET Core" et ".NET Standard".

Références

1. Microsoft - Informations sur l'appelant (C #)
2. Microsoft - CallerFilePathAttributeClasse
3. Microsoft - CallerLineNumberAttributeClasse
4. Microsoft - CallerMemberNameAttributeClasse

Notez que cela ne sera pas fiable dans le code de version, en raison de l'optimisation. De plus, l'exécution de l'application en mode sandbox (partage réseau) ne vous permettra pas du tout de saisir le cadre de la pile.

Considérez la programmation orientée aspect (AOP), comme PostSharp , qui au lieu d'être appelée à partir de votre code, modifie votre code et sait ainsi où il se trouve à tout moment.

Évidemment, c'est une réponse tardive, mais j'ai une meilleure option si vous pouvez utiliser .NET 4.5 ou plus:

internal static void WriteInformation<T>(string text, [CallerMemberName]string method = "")
{
    Console.WriteLine(DateTime.Now.ToString() + " => " + typeof(T).FullName + "." + method + ": " + text);
}

Cela affichera la date et l'heure actuelles, suivies de "Namespace.ClassName.MethodName" et se terminant par ": text".
Exemple de sortie:

6/17/2016 12:41:49 PM => WpfApplication.MainWindow..ctor: MainWindow initialized

Exemple d'utilisation:

Logger.WriteInformation<MainWindow>("MainWindow initialized");

/// <summary>
/// Returns the call that occurred just before the "GetCallingMethod".
/// </summary>
public static string GetCallingMethod()
{
   return GetCallingMethod("GetCallingMethod");
}

/// <summary>
/// Returns the call that occurred just before the the method specified.
/// </summary>
/// <param name="MethodAfter">The named method to see what happened just before it was called. (case sensitive)</param>
/// <returns>The method name.</returns>
public static string GetCallingMethod(string MethodAfter)
{
   string str = "";
   try
   {
      StackTrace st = new StackTrace();
      StackFrame[] frames = st.GetFrames();
      for (int i = 0; i < st.FrameCount - 1; i++)
      {
         if (frames[i].GetMethod().Name.Equals(MethodAfter))
         {
            if (!frames[i + 1].GetMethod().Name.Equals(MethodAfter)) // ignores overloaded methods.
            {
               str = frames[i + 1].GetMethod().ReflectedType.FullName + "." + frames[i + 1].GetMethod().Name;
               break;
            }
         }
      }
   }
   catch (Exception) { ; }
   return str;
}

Peut-être que vous cherchez quelque chose comme ça:

StackFrame frame = new StackFrame(1);
frame.GetMethod().Name; //Gets the current method name

MethodBase method = frame.GetMethod();
method.DeclaringType.Name //Gets the current class name

private static MethodBase GetCallingMethod()
{
  return new StackFrame(2, false).GetMethod();
}

private static Type GetCallingType()
{
  return new StackFrame(2, false).GetMethod().DeclaringType;
}

Une classe fantastique est ici: http://www.csharp411.com/c-get-calling-method/

Une autre approche que j'ai utilisée consiste à ajouter un paramètre à la méthode en question. Par exemple, au lieu de void Foo(), utilisez void Foo(string context). Passez ensuite une chaîne unique qui indique le contexte d'appel.

Si vous n'avez besoin que de l'appelant / du contexte pour le développement, vous pouvez supprimer le paramavant l'expédition.

Pour obtenir le nom de la méthode et le nom de la classe, essayez ceci:

    public static void Call()
    {
        StackTrace stackTrace = new StackTrace();

        var methodName = stackTrace.GetFrame(1).GetMethod();
        var className = methodName.DeclaringType.Name.ToString();

        Console.WriteLine(methodName.Name + "*****" + className );
    }

StackFrame caller = (new System.Diagnostics.StackTrace()).GetFrame(1);
string methodName = caller.GetMethod().Name;

sera suffisant, je pense.

Jetez un œil au nom de la méthode de journalisation dans .NET . Méfiez-vous de l'utiliser dans le code de production. StackFrame n'est peut-être pas fiable ...

Nous pouvons également utiliser des lambda pour trouver l'appelant.

Supposons que vous ayez défini une méthode:

public void MethodA()
    {
        /*
         * Method code here
         */
    }

et vous voulez trouver son appelant.

1 . Modifiez la signature de la méthode pour avoir un paramètre de type Action (Func fonctionnera également):

public void MethodA(Action helperAction)
        {
            /*
             * Method code here
             */
        }

2 . Les noms lambda ne sont pas générés de manière aléatoire. La règle semble être:> <CallerMethodName> __X où CallerMethodName est remplacé par la fonction précédente et X est un index.

private MethodInfo GetCallingMethodInfo(string funcName)
    {
        return GetType().GetMethod(
              funcName.Substring(1,
                                funcName.IndexOf(">", 1, StringComparison.Ordinal) - 1)
              );
    }

3 . Lorsque nous appelons MethodA, le paramètre Action / Func doit être généré par la méthode de l'appelant. Exemple:

MethodA(() => {});

4 . À l'intérieur de MethodA, nous pouvons maintenant appeler la fonction d'assistance définie ci-dessus et trouver le MethodInfo de la méthode de l'appelant.

Exemple:

MethodInfo callingMethodInfo = GetCallingMethodInfo(serverCall.Method.Name);

Informations supplémentaires à la réponse de Firas Assaad.

J'ai utilisé new StackFrame(1).GetMethod().Name;dans .net core 2.1 avec injection de dépendances et je reçois la méthode d'appel en tant que 'Start'.

J'ai essayé avec [System.Runtime.CompilerServices.CallerMemberName] string callerName = "" et ça me donne la bonne méthode d'appel

var callingMethod = new StackFrame(1, true).GetMethod();
string source = callingMethod.ReflectedType.FullName + ": " + callingMethod.Name;