我怎么知道哪种方法调用我的方法？

Question

I've 3 methods A(), B() and C(), both A() and B() call C(). In method C(), how can I know it call from A() or B()?

Answer 1

You shouldn't need to. Some method should perform a specific task, which is influenced by its parameters and the object attributes, not the caller.

Answer 2

I don't recommend this approach - other posters point out better ways of handling this. But if you really, really need to know who called you, without changing C() 's parameters, you can do this:

static void A()
{
    C();
}

static void C()
{
    StackTrace st = new StackTrace();
    Console.WriteLine(st.GetFrame(1).GetMethod().Name); // prints "A"
}

Note that generating a StackTrace is somewhat costly. Not a big deal, though, unless you're doing it in code that you're calling very frequently.

Again, you almost certainly find a better way of doing whatever you're trying to do.

Answer 3

Method C() should not need to know which method called it. If this is how you are handling your flow logic, you need to think again about how you are writing your code. If we assume that there is some valid reason for needing to know which method called C(), I would create two 'wrapper' methods: C_From_A() and C_From_B(). Any logic specific to the calling methods should be moved to the new methods, while common code is left in the C() method and called from both the new methods:

public void C()
{
   // Common Code goes here
}

public void C_From_A()
{
    // Code only to be called from A() goes here.

    C();  // Common code executed
}

public void C_From_B()
{
    // Code only to be called from B() goes here.

    C();  // Common code executed
}


public void A()
{
    // Other code goes here

    C_From_A();
}

If you need to know for debugging, simple use the debugger to step through your code.

Answer 4

You should to take a look into System.Diagnostics.StackFrame class. An example here: http://www.csharp-examples.net/reflection-callstack/

Answer 5

简单（干净）的方法是向C引入一个新参数，让A和B告诉C谁调用它。

Answer 6

只需在C（）中设置断点

Answer 7

I agree in principle you shouldn't need to know in most situations.

However the one use case where this may be useful to know is when debugging where certain information came from, In the case of a bad parameter passed.

However in that case its probably better to throw an exception, log the exception and "recover" from it. Obviously this depends on how often the method is called as there is always some overhead with creating an exception. If you need to do this for some other reason than I would suggest you look at your design first.

If you need callbacks I would suggest that you make A and B both implement an interface and pass A or B as a parameter. The interface could have a method called callback and C could call A or B.

Answer 8

在你试图找出“错误参数被传递”的位置的情况下，你只需要在该方法中设置一个条件断点，或者让VS中断抛出的异常，然后你可以检查调用堆栈（ Debug Menu，Window，Call Stack）查看整个调用者链（带参数传递）给这个方法。

Answer 9

MethodBase callerMethod = new System.Diagnostics.StackFrame(1).GetMethod();

Useful if you're writing an audit / log framework, but really, YDNTN applies here. Plus it's costing a fortune at runtime.