Get current method name from async function?

Question

Is there anyway to get the current method name from inside an async function?

I've tried:

System.Reflection.MethodInfo.GetCurrentMethod();

And I've tried using StackTrace and StrackFrame as follows:

StackTrace strackTrace = new StackTrace();

for (int i = 0; i < strackTrace.GetFrames().Length; i++)
{
    SafeNativeMethods.EtwTraceInfo("Function" + i + ":" + function);
    SafeNativeMethods.EtwTraceInfo("Type" + i + ":" + strackTrace.GetFrame(i).GetType().Name);
    SafeNativeMethods.EtwTraceInfo("Method" + i + ":" + strackTrace.GetFrame(i).GetMethod().Name);
    SafeNativeMethods.EtwTraceInfo("ToString Call" + i + ":" + strackTrace.GetFrame(i).ToString());
}

But neither of them seem to work, I'd get ".ctor", "InvokeMethod", "Invoke", "CreateInstance", "CreateKnownObject" or "CreateUnknownObject" or "MoveNext"

Any ideas on how I can do this? I want to create a generic logger function and I don't want to pass in the name of the function that called the logger function, so I tried the stacktrace method, didn't work.

I gave up on that and said, ok, I'll pass in the function name as the first parameter, but when I called the reflection method from the calling function that calls the generic logger function, I always get ".ctor"

Any ideas? Note the generic logger function I'm calling is a static method in the same class (it has to be this way for now...).

Answer 1

C# 5 added caller info attributes which may give you more what you are looking for. Note that these insert the appropriate information into the call site at compile-time rather than using run-time information. The functionality is more limited (you can't get a complete call stack, obviously), but it is much faster.

An example using CallerMemberNameAttribute:

using System.Runtime.CompilerServices;

public static void Main(string[] args)
{
    Test().Wait();            
}

private static async Task Test()
{
    await Task.Yield();
    Log();
    await Task.Yield();
}

private static void Log([CallerMemberName]string name = "")
{
    Console.WriteLine("Log: {0}", name);
}

There are also CallerFilePath and CallerLineNumber attributes which can get other pieces of info about the call site.

Answer 2

This method works from async method call as well as from normal method. (C#5)

/// <summary>
///     Returns Current method name
/// </summary>
/// <returns>callers method name</returns>
public string GetCurrentMethod([CallerMemberName] string callerName = "")
{
    return callerName;
}

Answer 3

Rather than doing manual stack frame walks, which is both expensive and risky (since Release builds might optimize some methods out), you can use the CallerMemberNameAttribute, one of the Caller Information attributes, which was added in .NET 4.5 (which you already use, if you use async/await) for this exact scenario - passing in a member name for loggers, property-changed handlers and the like.

It goes like this:

public void LogMessage(string message, [CallerMemberName] string caller = "")
{ 
    // caller should contain the name of the method that called LogMessage.
}

I don't know of any limitation this has with async methods.

Answer 4

1. using System.Runtime.CompilerServices;

2. Create a static method (GetMethodName) in a static class file (ExtensionHelper).

public static class ExtensionHelper 
{
    public static string GetMethodName([CallerMemberName] string name = "") => name;
}

3. Invoke GetMethodName() to get the async method name.

string methodName = ExtensionHelper.GetMethodName();

Answer 5

I used a mix of Nathan's and Mike's answers.

Using GetType() to query the method from stack trace did not work for me. Not guaranteed. But using CallerMemberNameAttrinute lets me get the exact method by its name.

So my code would be:

using System.Runtime.CompilerServices;

public static void Main(string[] args)
{
    Test().Wait();            
}

private static async Task Test()
{
    await Task.Yield();
    Log();
    await Task.Yield();
}

private static void Log([CallerMemberName]string methodName = "")
{
   var method = new StackTrace()
       .GetFrames()
       .Select(frame => frame.GetMethod())
       .FirstOrDefault(item => item.Name == methodName);

   Console.WriteLine("Log: {0}", method.DeclaringType + "." + method.Name);
}

This way I get method name with its full namespace path.

Answer 6

You need to capture the method name early in the async method, somewhere before the first async call. The most convenient way I've found to skip past the compiler generated state machine is to look at the declaring type of each method in the stack trace.

var method = new StackTrace()
    .GetFrames()
    .Select(frame => frame.GetMethod())
    .FirstOrDefault(item => item.DeclaringType == GetType());
await Task.Yield();
if (method != null)
{
    Console.WriteLine(method.Name);
}

Answer 7

It's a bit late to answer your question I guess but since I had the same issue and I needed to figure it out on my own due to lack of a good resolution to this on the internet, here is what I did and it works perfectly at least for me -

1. Define the following Regex somewhere that can be accessed by all callers since Regex objects need to be parsed before using them; hence, it can be expensive, and it's not a good practice to create them over and over if we can use the same one.
   public static readonly Regex ASYNC_METHOD_NAME_FORMAT = new Regex(@"^\<(?\w+)>\w+?");
2. Use the following code to get the method name
   string methodName = ASYNC_METHOD_NAME_FORMAT.Match(MethodBase.GetCurrentMethod().ReflectedType.Name).Groups["method_name"].Value

I hope this helps!

Answer 8

You can send the strackTrace.GetFrame(i).GetMethod() which is a System.Reflection.MethodBase object to a function that checks if the System.Reflection.MethodBase.DeclaringType.FullName has the <> chars and if so will get the requested method name that lays between the <...> chars.

static private string getMethodName(System.Reflection.MethodBase method)
    {
        string _methodName = method.DeclaringType.FullName;

        if (_methodName.Contains(">") || _methodName.Contains("<"))
        {
            _methodName = _methodName.Split('<', '>')[1];
        }
        else
        {
            _methodName = method.Name;
        }

        return _methodName;
    }

And the how to use example is:

var _stackTrace = new System.Diagnostics.StackTrace(exception, true);
string _methodName = getMethodName(_stackTrace.GetFrame(0).GetMethod());

Answer 9

I came across the same issue recently for my log message and the answers here helped. I am sharing my code in case it can help others with their questions.

using System.Runtime.CompilerServices;

namespace Foo.Services
{
    public interface ILogFormatter
    {
        public string FormatMessage(LogType logType, string details, [CallerMemberName] string caller = "");
    }


    public enum LogType
    {
        Debug,
        Information,
        Warning,
        Error
    }

    public class LogFormatterOptions
    {
        public string Subject { get; set; }
    }

    public class LogFormatter : ILogFormatter
    {
        public LogFormatter(LogFormatterOptions options)
        {
            Subject = options.Subject;
        }

        public string Subject { get; set; }

        public string FormatMessage(LogType logType, string details, [CallerMemberName] string caller = "")
        {
            return $"{Subject} - {logType}: caller: {caller} - {details}";
        }
    }
}

This is how this method is called and it works for both async and synchronized methods. Note that I am not passing value for the caller input & it picks up the caller method name.

 logger.LogInformation(logFormatter.FormatMessage(LogType.Information, ""));