如何获取 CallerMember 的类型名称

Question

我上了这门课

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
    }
}

还有这个属性类

// 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

    }
}

那我有这个

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

我需要 CallerMember 的类型名称，有类似 [CallerMemberName] 的东西来获取 Caller 的类所有者的类型吗？

Answer 1

这不是万无一失的，但.NET 的约定是每个文件有一个类型，并将文件命名为与类型相同。我们的工具也倾向于强制执行此约定，即 Resharper 和 Visual Studio。

因此从文件路径推断类型名称应该是合理的。

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

来电成员

当然，获取调用者成员名称​​在对象模型中不是“自然”的。 这就是 C# 工程师在编译器中引入 CallerMemberName 的原因。

真正的敌人是重复，基于堆栈的解决方法效率低下。

[CallerMemberName] 允许在不重复和无不良影响的情况下获取信息。

调用者类型

但是获取调用者成员type 是自然的，容易获取没有重复。

怎么做

给fooMethod添加一个“caller”参数，不需要特殊属性。

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

然后这样称呼它：

fooMethod(this);

这回答了问题

你说

//这里我要获取CustClass，而不是fooBase

这正是你会得到的。

---

其他不适用的情况，有解决办法。

虽然这完全符合您的要求，但在其他不同的情况下它不起作用。

• 案例1：调用者是静态方法时（没有“this”）。
• 案例 2：需要调用者方法本身的类型，而不是调用者本身的类型（可能是第一个的子类）。

在那些情况下，[CallerMemberType] 可能有意义，但有更简单的解决方案。 请注意，静态调用者的情况更简单：没有对象，因此它与调用方法的类型之间没有差异。没有fooBase，只有CustClass。

案例1：调用者是静态方法时（没有“this”）

如果至少有一个调用者是静态方法，则不要在方法内部而是在调用站点上执行GetType()，因此不要将“this”传递给方法而是传递类型：

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

静态调用者会做：

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

为了保持与对象调用者的兼容性，要么保留另一个使用 this 指针的 fooMethod，要么您可以删除它，对象调用者会这样做：

fooMethod(this.GetType());

您可以注意到上面的typeof(MyClassWithAStaticMethod) 重复了类名，这是真的。不重复类名会更好，但这没什么大不了的，因为它只重复一次，作为输入项（不是字符串）并且在同一个类中。没有[CallerMemberName]解决的原始问题那么严重，这是一个在所有呼叫站点中重复呼叫者姓名的问题。

情况2：当需要调用者方法的类型，而不是调用者的类型时

例如，在fooBase 类中，您想从对象上下文中调用anotherFooMethod，但希望传递给的类型始终为fooBase，而不是对象的实际类型（例如CustClass）。

在这种情况下，有一个 this 指针，但您不想使用它。所以，只需使用相同的解决方案：

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

就像案例 1 一样，有一个重复，而不是每个调用站点一个，除非您已经存在代码重复猖獗的问题，在这种情况下，这里要解决的问题不是您应该担心的问题。

结论

[CallerMemberType] 可能仍然可以完全避免重复，但是：

• 任何添加到编译器的东西都是复杂的负担和维护成本
• 鉴于现有的解决方案，C# 开发团队列表中有更高优先级的项目我并不感到惊讶。

Answer 3

请参阅编辑 2 以获得更好的解决方案。

CompilerServices 提供的信息在我看来太少，无法从调用方法中获取类型。 您可以做的是使用StackTrace (see) 找到调用方法（使用GetMethod()）并使用Reflection 从那里获取类型。
考虑以下几点：

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);
        }
    }
}

注意 - 正如@Jay 在 cmets 中所说，它可能非常昂贵，但效果很好。

编辑：

我发现有几篇文章比较了性能，与同样被认为不是最好的Reflection 相比，它确实非常昂贵。
请参阅：[1][2]

编辑 2：

所以深入了解StackTrace，确实使用起来并不安全，甚至还很贵。
由于将要调用的每个方法都将标有[CustomAttribute()]，因此可以将包含它的所有方法收集到一个静态列表中。

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
    }
}

尝试使用这种方法来满足您的确切需求。