Bonsoir,

J'ai une question toute simple, elle est spécifié dans le titre :

Comment puis je savoir le nom de la classe et éventuellement de la méthode qui appelle la méthode dont je veux justement savoir qui l'appelle ?

Un exemple, la classe Toto, instancié, appelle la méthode Tata() d'une classe lambda par le biais de la méthode Titi() de la classe Toto.

En gros :

Toto toto = new Toto();
toto.Titi(); // => Titi va appeler Tata()

// Tata affiche un message : Tiens Toto, tu m'as appelé avec Titi !

Merci bien par votre aide

Bonjour,

J'avoue avoir eu du mal à comprendre la question, ainsi que l'objectif qui se cache derrière ...
Je suis quand même parvenu à obtenir le résultat escompté, je crois

using System;
using System.Diagnostics;
using System.Linq;
using System.Reflection;

namespace SdzRaphyQuestion
{
    class Toto
    {
        public void Titi()
        {
            Program.Tata();
        }

        public int Titi(string s)
        {
            Program.Tata();
            return 42;
        }

        public double Titi<T>(T t)
        {
            Program.Tata();
            return 42D;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Toto toto = new Toto();
            toto.Titi();
            toto.Titi("");
            toto.Titi(42);
        }

        internal static void Tata()
        {
            MethodBase currentMethod = MethodBase.GetCurrentMethod();

            StackFrame[] frames = new StackTrace().GetFrames();
            MethodBase caller =
                frames.SkipWhile(frame => frame.GetMethod() != currentMethod)
                .Skip(1)
                .Select(frame => frame.GetMethod())
                .FirstOrDefault();

            if (caller != null)
            {
                Console.WriteLine("Tiens {0}, tu m'as appelé avec {1} !", caller.ReflectedType.Name, caller.Name);
            }
        }
    }
}

Dans les trois appels différents, l'affichage obtenu est bien celui attendu (sans distinction de quelle surcharge a été appelée en l'état).
Attention, je garantis pas que le comportement attendu soit le bon partout, par exemple avec ceci :

class Toto
{
    public void Titi(Action action)
    {
        Program.Tata();
        action();
    }
}
// ... 
static void Main(string[] args)
{
    Toto toto = new Toto();
    toto.Titi(() => Program.Tata());
};

Ceci affiche bien ce qu'il semble falloir pour le Tata qui se trouve dans la méthode Titi, par contre pour l'expression lambda ça ne donne pas la même chose :

Citation

Tiens Program, tu m'as appelé avec <Main>b__0 !

À voir si cela convient bien donc, et peut-être qu'un éclaircissement sur l'objectif/l'intérêt ne serait pas de trop

Cordialement !

Merci pour ta réponse et désolé pour pour le retard

Je cherche le moyen de le faire sans passer les arguments pour savoir le nom de la méthode/classe qui appelle.

Mon objectif est en faite d'avoir une méthode de ce style là :

private string MyMethod(int index)
{
    return this._MyArray[(string classe_qui_appelle)][index];
}

Comme ça en fonction de la classe qui appelle, je peux retourner une valeur spécifique.
Je peux tout aussi bien avoir le nom complet de l'assembly qui appelle la méthode, mais comment ?

EDIT : Dans le cas de l'héritage j'ai trouvé "this.GetType().Name;"
S'il existe la même chose pour les classes nos hérités ça serait exactement ce que je cherche

Je pense que s'il faut bidouiller, ça sera très laborieux d'obtenir un tel résultat et surtout de la même facilité

Ne peux-tu pas simplement envisager d'exiger un premier paramètre qui représente l'objet qui appelle ta méthode ?

Par exemple:

private string MyMethod(object caller, int index)
{
    return this._MyArray[caller.GetType().FullName][index];
}

// utilisation:
foo.MyMethod(this, 42);

Je pense finalement opter pour cette solution
Merci à vous