I'm going out on a limb here and guessing you're looking for object oriented techniques for implementing instrumentation.
There are two immediate ways that come to mind, most commonly used would be the first I'm guessing:
Have a global (singleton or what have you) stack somewhere with which every method that executes immediately adds itself to. effectively maintaining a global call chain. You could but don't have to pop at the end of each method you're trying to instrument, common other instrumentation practices are to start a stopwatch at the beginning of your method and stop at the end to record the length etc.
Have a DI type framework that is a router for all method calls, which might behave more akin to message passing, and inside of this framework you would jot down in a stack every method call that occurs similar to above except it would be centralized to this one place.
I can't say I suggest #2 without maybe using some AOP framework or something but in all, maintaining your own stack trace on 100% of method calls is a bit of an extreme instrumentation in my eyes. Great for debugging type stuff and perhaps necessary if you aren't working in a reflexive language, but I would be sure I could turn anything like that off easily for production and do my best to keep it out of the way, which is why I don't really like #2 above.
Neither of these is necessary inside a reflexive language and should therefore not be implemented in C# except to illustrate crossing process boundaries. (caveat: they might be faster than reflection if done right, but the maintenance cost still makes them not worth it)