Obtenir l'instance qui a appelé la méthode en C#

Question

Je cherche un algorithme qui permette d'obtenir l'objet qui a appelé la méthode, à l'intérieur de cette méthode.

Par exemple :

public class Class1 {

    public void Method () {
        //the question
        object a = ...;//the object that called the method (in this case object1)
        //other instructions
    }

}

public class Class2 {

    public Class2 () {
        Class1 myClass1 = new Class1();
        myClass1.Method();
    }

    public static void Main () {
        Class2 object1 = new Class2();
        //...
    }

}

Existe-t-il un moyen de le faire ?

Answer 1

Voici un exemple de la manière de procéder...

...
using System.Diagnostics;
...

public class MyClass
{
/*...*/
    //default level of two, will be 2 levels up from the GetCaller function.
    private static string GetCaller(int level = 2)
    {
        var m = new StackTrace().GetFrame(level).GetMethod();

        // .Name is the name only, .FullName includes the namespace
        var className = m.DeclaringType.FullName;

        //the method/function name you are looking for.
        var methodName = m.Name;

        //returns a composite of the namespace, class and method name.
        return className + "->" + methodName;
    }

    public void DoSomething() {
        //get the name of the class/method that called me.
        var whoCalledMe = GetCaller();
        //...
    }
/*...*/
}

Je poste ceci, car il m'a fallu un certain temps pour trouver ce que je cherchais moi-même. Je l'utilise dans quelques méthodes de logger statique...

Answer 2

Vous pouvez accéder à la trace de pile actuelle dans le code et remonter d'un cran. http://msdn.microsoft.com/en-us/library/system.diagnostics.stacktrace.aspx

Mais comme cela a été commenté plus bas, vous obtiendrez la méthode et la classe qui vous appellent, mais pas l'instance (s'il y en a une, elle peut être statique bien sûr).

Answer 3

Il serait très mauvais style depuis

a) cela romprait l'encapsulation
b) il est impossible de connaître le type de l'objet appelant au moment de la compilation, de sorte que quoi que vous fassiez avec l'objet par la suite, cela ne fonctionnera probablement pas.
c) il serait plus facile/meilleur de passer l'objet au constructeur ou à la méthode, par exemple :

Class1 c1 = new Class1(object1);

Answer 4

Ou simplement passer l'objet en tant que paramètre de la méthode.

public void Method(object callerObject)
{
..
}

et appeler la méthode :

myClass.Method(this);

Salutations, Florian

Answer 5

Je ne connais évidemment pas les détails exacts de votre situation, mais j'ai vraiment l'impression que vous devez repenser un peu votre structure.

Cela pourrait être facilement réalisé si l'on structurait correctement l'héritage.

Envisagez d'étudier une classe abstraite et les classes qui héritent de cette classe abstraite. Vous pourriez même être en mesure d'accomplir la même chose avec des interfaces.