How to get Type name of a CallerMember

Question

I got this class

public class fooBase
{
    public List<MethodsWithCustAttribute> MethodsList;
    public bool fooMethod([CallerMemberName]string membername =""))
    {
        //This returns a value depending of type and method 
    } 
    public void GetMethods()
    {
        // Here populate MethodsList using reflection
    }
}

And This Attribue Class

// This attribute get from a database some things, then fooMethod check this attribute members 
public class CustomAttribute
{
    public string fullMethodPath;
    public bool someThing ; 
    public bool CustomAttribute([CallerMemberName]string membername ="")
    {
        fullMethodPath = **DerivedType** + membername 
        //  I need here to get the type of membername parent. 
        //  Here I want to get CustClass, not fooBase

    }
}

Then I have this

public class CustClass : fooBase
{
     [CustomAttribute()]
     public string method1()
     {
         if (fooMethod())
         {
             ....
         }
     }
}

I need the Type name of the CallerMember, there is something like [CallerMemberName] to get the Type of class owner of the Caller ?

Answer 1

It isn't foolproof, but the convention with .NET is to have one type per file and to name the file the same as the type. Our tooling also tends to enforces this convention i.e. Resharper & Visual Studio.

Therefore it should be reasonable to infer the type name from the file path.

public class MyClass
{
  public void MyMethod([CallerFilePath]string callerFilePath = null, [CallerMemberName]string callerMemberName = null)
  {
    var callerTypeName = Path.GetFileNameWithoutExtension(callerFilePath);
    Console.WriteLine(callerTypeName);
    Console.WriteLine(callerMemberName);
  }
}

Answer 2

Caller member

Granted, getting the caller member name is not "natural" in the object model. That's why the C# engineers introduced CallerMemberName in the compiler.

The real enemy is duplication, and stack-based workarounds are inefficient.

[CallerMemberName] allows to get the information without duplication and without ill-effect.

Caller type

But getting the caller member type is natural and easy to get without duplication.

How to do it

Add a "caller" parameter to fooMethod, no special attribute needed.

    public bool fooMethod(object caller, [CallerMemberName]string membername = "")
    {
        Type callerType = caller.GetType();
        //This returns a value depending of type and method
        return true;
    }

And call it like this:

fooMethod(this);

This answer the question

You stated

// Here I want to get CustClass, not fooBase

and that's exactly what you'll get.

---

Other situations where it would not work, with solutions.

While this exactly answers your requirements, there are other, different, cases where it wouldn't work.

• Case 1: When caller is a static methods (there is no "this").
• Case 2: When one wants the type of the caller method itself, and not the type of the caller itself (which may be a subclass of the first).

In those cases, a [CallerMemberType] might make sense, but there are simpler solutions. Notice that the static caller case is simpler: there is no object so no discrepancy between it and the type of the calling method. No fooBase, only CustClass.

Case 1: When caller is a static methods (there is no "this")

If at least one caller is a static method, then don't do the GetType() inside the method but on call site, so don't pass "this" to the method but the type:

public bool fooMethodForStaticCaller(Type callerType, [CallerMemberName]string membername = "")

Static caller will do:

public class MyClassWithAStaticMethod  // can be CustClass, too
{
    public static string method1static()
    {
        fooMethodForStaticCaller(typeof(MyClassWithAStaticMethod));
    }
}

To keep compatibility with object callers, either keep the other fooMethod that takes the this pointer, or you can remove it and object callers will do:

fooMethod(this.GetType());

You can notice that the typeof(MyClassWithAStaticMethod) above repeats the class name and it's true. It would be nicer to not repeat the class name, but it's not such a big deal because this repeats only once, as a typed item (not a string) and inside the same class. It's not as serious a problem as the original problem that the [CallerMemberName] solves, which was a problem of repeating the caller name in all call sites.

Case 2: When one wants the type of the caller method, not the type of the caller

For example, in class fooBase you want to call anotherFooMethod from object context but want the type being passed to always be fooBase, not the actual type of the object (e.g. CustClass).

In this case there is a this pointer but you don't want to use it. So, just use actually the same solution:

public class fooBase
{
     [CustomAttribute()]
     public string method1()
     {
         if (anotherFooMethod(typeof(fooBase)))
         {
             ....
         }
     }
}

Just like in case 1, there is one repetition, not one per call site, unless you have an pre-existing problem of rampant code duplication, in which case the problem being addressed here is not the one you should worry about.

Conclusion

[CallerMemberType] might still make sense to avoid duplication at all, but:

• anything added to the compiler is a complexity burden with maintenance cost
• given the existing solutions I'm not surprised there are items with higher priority in the C# development team list.

Answer 3

See Edit 2 for the better solution.

The information that CompilerServices provides is too little in my opinion to get the type from the calling method. What you could do is use StackTrace (see) to find the calling method (using GetMethod()) and get the type using Reflection from there.
Consider the following:

using System.Runtime.CompilerServices;

public class Foo {
    public void Main() {
        what();
    }

    public void what() {
        Bar.GetCallersType();
    }

    public static class Bar {

        [MethodImpl(MethodImplOptions.NoInlining)]  //This will prevent inlining by the complier.
        public static void GetCallersType() {
            StackTrace stackTrace = new StackTrace(1, false); //Captures 1 frame, false for not collecting information about the file
            var type = stackTrace.GetFrame(1).GetMethod().DeclaringType;
            //this will provide you typeof(Foo);
        }
    }
}

Notice - As @Jay said in the comments, it might be pretty expensive but it does the work well.

Edit:

I found couple of arcticles comparing the performance, and it is indeed horrbily expensive comparing to Reflection which is also considered not the best.
See: [1] [2]

Edit 2:

So after a look in depth on StackTrace, it is indeed not safe to use it and even expensive.
Since every method that will be called is going to be marked with a [CustomAttribute()], it is possible to collect all methods that contains it in a static list.

public class CustomAttribute : Attribute {
    public static List<MethodInfo> MethodsList = new List<MethodInfo>();
    static CustomAttribute() {
        var methods = Assembly.GetExecutingAssembly() //Use .GetCallingAssembly() if this method is in a library, or even both
                  .GetTypes()
                  .SelectMany(t => t.GetMethods())
                  .Where(m => m.GetCustomAttributes(typeof(CustomAttribute), false).Length > 0)
                  .ToList();
        MethodsList = methods;
    }

    public string fullMethodPath;
    public bool someThing;

    public  CustomAttribute([CallerMemberName] string membername = "") {
        var method = MethodsList.FirstOrDefault(m=>m.Name == membername);
        if (method == null || method.DeclaringType == null) return; //Not suppose to happen, but safety comes first
        fullMethodPath = method.DeclaringType.Name + membername; //Work it around any way you want it
        //  I need here to get the type of membername parent. 
        //  Here I want to get CustClass, not fooBase
    }
}

Play around with this approach to fit your precise need.

Answer 4

Why not just use public void MyMethod<T>(params) { string myName = typeof(T).Name }

then call it Logger.MyMethod<Form1>(...);

You avoid the performance hit of reflection, if you just need basic info.