Compiler directive for current method name

[scalablecory]

From @genifycom on Thursday, April 23, 2020 6:11:15 PM

Issue Title

Could we please have a compiler directive for the current method?

General

Questions about how to print out the current method name date back to the beginning of dotnet core. These "solutions" usually require reflection or CompilerServices like CallerMemberName

e.g.
string method = $"{System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.FullName}.{System.Reflection.MethodBase.GetCurrentMethod().Name}";

These options are long, cumbersome and for async method often get changed by the underlying implementation (e.g. MoveNext or OnResume). Also if the compiler decides to inline or optimize, these methods may interfere with that.

Is it possible to have a compiler directive like #Method that gets replaced at compile time with a string containing the currently compiling method?

So then we can write out the method entry e.g.
Serilog.Log.Logger.Information("Starting #Method");

Compiler directives were such a huge and useful part of C++ that seem to have been forgotten in C#.

Copied from original issue: dotnet/core#4608

[theunrepentantgeek]

The example you give is certainly cumbersome, but there's a simpler way to achieve this today, with a very simple helper method:

    private static string CurrentMethodName(
        [CallerMemberName]string methodName = null) 
        => methodName;

The compiler will ensure the right name is passed, and the JIT will likely inline it, giving minimal overhead.

Compiler directives were such a huge and useful part of C++ that seem to have been forgotten in C#.

They weren't forgotten - they were such a fertile source of subtle and hard to diagnose issues that the folks behind C# 1.0 deliberately decided not to include a preprocessor. It wasn't forgotten, it was excluded.

Edited to remove code debris.

[nmarcel]

Plus, consider how to get a method name from a property setter or getter (no CallerMembeName can be passed there).

[jrmoreno1]

This is a (weaker) duplicate of #345 I would much prefer that instead of this.

[theunrepentantgeek]

consider how to get a method name from a property setter or getter (no CallerMembeName can be passed there).

@nmarcel Can you please expand on what you're saying here? The [CallerMemberName] attribute was originally introduced precisely for use in properties, to reduce errors in implementation of the INotifyPropertyChanged interface.

Instead of this:

public string FullName 
{
    get => _fullName;
    set => SetProperty(ref _fullName, value, nameof(FullName));
}

private void SetProperty<T>(
    ref T field, T value, string propertyName) { ... }

[CallerMemberName] lets us write this:

public string FullName 
{
    get => _fullName;
    set => SetProperty(ref _fullName, value);  // No need for nameof()
}

private void SetProperty<T>(
    ref T field, T value, [CallerMemberName]string propertyName = null) { ... }

[nmarcel]

@theunrepentantgeek what I mean is that you cannot know (easily, without reflection):

1. What method used a property.
   public in MyProperty { set{ Console.WriteLine($"Setting MyProperty from 'CallerName'."); _myProperty = value; } }
2. What implicit operation (getter or setter), not just the property name, was used when CallerMemberName applied within a property, like in your example.

[YairHalberstadt]

@nmarcel
The proposal here wouldn't help with those cases either.

[genifycom]

Actually compiler/pre-processor directives are so useful that they weren't excluded from C# rather they were diminished.

https://www.programiz.com/csharp-programming/preprocessor-directives

Macro directives were incredibly important to things like ATL. and MFC.

Having been a developer since 1975 I can attest to their importance :-)