System.Diagnostics.StackTrace s =
         new System.Diagnostics.StackTrace(0);
Console.WriteLine(s.GetFrame(0).GetMethod().Name);

System.Diagnostics.StackTrace s =
            new System.Diagnostics.StackTrace(0);
for (int i=0; i< s.FrameCount; i++)
{
  Console.WriteLine(s.GetFrame(i).GetMethod().Name);
}

MethodBase.GetCurrentMethod();

        static void TraceToConsole(string reportText)
        {
            StackTrace st = new StackTrace(0);
            string prevFuncName = st.GetFrame(st.FrameCount - 1).GetMethod().Name;
            Console.WriteLine("{0}(): {1}", prevFuncName, reportText);
        }

Log(MethodBase.GetCurrentMethod().ToString(), "Log event");

А>Для полноты картины хотелось бы отметить, что MethodBase.GetCurrentMethod также использует StackTrace, но поскольку это выполняется в native коде, возможно это будет быстрей (ну и в любом случае правильней — помним об инлайнинге.

[MethodImpl(MethodImplOptions.NoInlining)]
public static MethodBase GetCurrentMethod()
{
    StackCrawlMark lookForMyCaller = StackCrawlMark.LookForMyCaller;
    return RuntimeMethodInfo.InternalGetCurrentMethod(ref lookForMyCaller);
}

L>[MethodImpl(MethodImplOptions.NoInlining)]
L>public static MethodBase GetCurrentMethod()
L>{
L>    StackCrawlMark lookForMyCaller = StackCrawlMark.LookForMyCaller;
L>    return RuntimeMethodInfo.InternalGetCurrentMethod(ref lookForMyCaller);
L>}
L>

L>Как видите, никакого упоминания StackTrace-а и в помине нет.

        internal static MethodBase InternalGetCurrentMethod(ref StackCrawlMark stackMark)
        {
            RuntimeMethodHandle method = RuntimeMethodHandle.GetCurrentMethod(ref stackMark);

            if (method.IsNullHandle()) 
                return null;

            // If C<Foo>.m<Bar> was called, GetCurrentMethod returns C<object>.m<object>. We cannot
            // get know that the instantiation used Foo or Bar at that point. So the next best thing
            // is to return C<T>.m<P> and that's what GetTypicalMethodDefinition will do for us. 
            method = method.GetTypicalMethodDefinition();
            
            return RuntimeType.GetMethodBase(method);
        }

// Return the MethodInfo that represents the current method (two above this one)
FCIMPL1(MethodDesc*, RuntimeMethodHandle::GetCurrentMethod, StackCrawlMark* stackMark) {
    CONTRACTL {
        THROWS;
        DISABLED(GC_TRIGGERS);
        MODE_COOPERATIVE;
        SO_TOLERANT;
    }
    CONTRACTL_END;
    
    SkipStruct skip;
    skip.pStackMark = stackMark;
    skip.pMeth = 0;
    HELPER_METHOD_FRAME_BEGIN_RET_0();
    StackWalkFunctions(GetThread(), SkipMethods, &skip);
    HELPER_METHOD_FRAME_END();
   
    return skip.pMeth;
}

....

StackWalkAction StackWalkFunctions(Thread * thread,
                                   PSTACKWALKFRAMESCALLBACK pCallback,
                                   VOID * pData)
{
    // Note: there are cases (i.e., exception handling) where we may never return from this function. This means
    // that any C++ destructors pushed in this function will never execute, and it means that this function can
    // never have a dynamic contract.
    STATIC_CONTRACT_WRAPPER;

    return thread->StackWalkFrames(pCallback, pData, FUNCTIONSONLY);
}
....

А>>Для полноты картины хотелось бы отметить, что MethodBase.GetCurrentMethod также использует StackTrace, но поскольку это выполняется в native коде, возможно это будет быстрей (ну и в любом случае правильней — помним об инлайнинге.

L>[MethodImpl(MethodImplOptions.NoInlining)]
L>public static MethodBase GetCurrentMethod()
L>{
L>    StackCrawlMark lookForMyCaller = StackCrawlMark.LookForMyCaller;
L>    return RuntimeMethodInfo.InternalGetCurrentMethod(ref lookForMyCaller);
L>}

L>Как видите, никакого упоминания StackTrace-а и в помине нет.

[MethodImpl(MethodImplOptions.InternalCall)]
private static extern unsafe void* _GetCurrentMethod(ref StackCrawlMark stackMark);

FCFuncElement("_GetCurrentMethod", RuntimeMethodHandle::GetCurrentMethod)

// Return the MethodInfo that represents the current method (two above this one)
FCIMPL1(MethodDesc*, RuntimeMethodHandle::GetCurrentMethod, StackCrawlMark* stackMark) {
    CONTRACTL {
        THROWS;
        DISABLED(GC_TRIGGERS);
        MODE_COOPERATIVE;
        SO_TOLERANT;
    }
    CONTRACTL_END;
    
    SkipStruct skip;
    skip.pStackMark = stackMark;
    skip.pMeth = 0;
    HELPER_METHOD_FRAME_BEGIN_RET_0();
    StackWalkFunctions(GetThread(), SkipMethods, &skip);
    HELPER_METHOD_FRAME_END();
   
    return skip.pMeth;
}
FCIMPLEND

StackWalkAction StackWalkFunctions(Thread * thread,
                                   PSTACKWALKFRAMESCALLBACK pCallback,
                                   VOID * pData)
{
    // Note: there are cases (i.e., exception handling) where we may never return from this function. This means
    // that any C++ destructors pushed in this function will never execute, and it means that this function can
    // never have a dynamic contract.
    STATIC_CONTRACT_WRAPPER;

    return thread->StackWalkFrames(pCallback, pData, FUNCTIONSONLY);
}