查找传递给函数的变量名

Question

让我用下面的例子来解释我的问题：

public string ExampleFunction(string Variable) {
    return something;
}

string WhatIsMyName = "Hello World";
string Hello = ExampleFunction(WhatIsMyName);

当我将变量WhatIsMyName 传递给ExampleFunction 时，我希望能够获得原始变量名称的字符串。也许是这样的：

Variable.OriginalName.ToString()

有什么办法吗？

Answer 1

您想要的无法直接实现，但您可以使用 C# 3.0 中的表达式：

public void ExampleFunction(Expression<Func<string, string>> f) {
    Console.WriteLine((f.Body as MemberExpression).Member.Name);
}

ExampleFunction(x => WhatIsMyName);

请注意，这依赖于未指定的行为，虽然它确实适用于 Microsoft 当前的 C# 和 VB 编译器，和在 Mono 的 C# 编译器中，但不能保证这在未来的版本中不会停止工作。

Answer 2

这不是完全可能的，你想要的方式。 C# 6.0 他们引入了 nameof 运算符，这将有助于改进和简化代码。运算符的名称解析传入的变量的名称。

您的案例的用法如下所示：

public string ExampleFunction(string variableName) {
    //Construct your log statement using c# 6.0 string interpolation
    return $"Error occurred in {variableName}";
}

string WhatIsMyName = "Hello World";
string Hello = ExampleFunction(nameof(WhatIsMyName));

一个主要的好处是它是在编译时完成的，

nameof 表达式是一个常量。在所有情况下，nameof(...) 在编译时被评估以产生一个字符串。它的参数在运行时不会被评估，并且被认为是不可访问的代码（但是它不会发出“不可访问代码”警告）。

更多信息可以找到here

旧版 C 3.0 及以上版本
以 Nawfals 答案为基础

GetParameterName2(new { variable });

//Hack to assure compiler warning is generated specifying this method calling conventions
[Obsolete("Note you must use a single parametered AnonymousType When Calling this method")]
public static string GetParameterName<T>(T item) where T : class
{
    if (item == null)
        return string.Empty;

    return typeof(T).GetProperties()[0].Name;
}

Answer 3

static void Main(string[] args)
{
  Console.WriteLine("Name is '{0}'", GetName(new {args}));
  Console.ReadLine();
}

static string GetName<T>(T item) where T : class
{
  var properties = typeof(T).GetProperties();
  Enforce.That(properties.Length == 1);
  return properties[0].Name;
}

更多详情在this blog post。

Answer 4

三种方式：

1) 完全没有反思的东西：

GetParameterName1(new { variable });

public static string GetParameterName1<T>(T item) where T : class
{
    if (item == null)
        return string.Empty;

    return item.ToString().TrimStart('{').TrimEnd('}').Split('=')[0].Trim();
}

2) 使用反射，但这比其他两个要快。

GetParameterName2(new { variable });

public static string GetParameterName2<T>(T item) where T : class
{
    if (item == null)
        return string.Empty;

    return typeof(T).GetProperties()[0].Name;
}

3) 最慢的，不要使用。

GetParameterName3(() => variable);

public static string GetParameterName3<T>(Expression<Func<T>> expr)
{
    if (expr == null)
        return string.Empty;

    return ((MemberExpression)expr.Body).Member.Name;
}

要获得组合参数名称和值，您可以扩展这些方法。当然，如果您将参数作为另一个参数单独传递，则很容易获得价值，但这很不雅。而是：

1)

public static string GetParameterInfo1<T>(T item) where T : class
{
    if (item == null)
        return string.Empty;

    var param = item.ToString().TrimStart('{').TrimEnd('}').Split('=');
    return "Parameter: '" + param[0].Trim() +
           "' = " + param[1].Trim();
}

2)

public static string GetParameterInfo2<T>(T item) where T : class
{
    if (item == null)
        return string.Empty;

    var param = typeof(T).GetProperties()[0];
    return "Parameter: '" + param.Name +
           "' = " + param.GetValue(item, null);
}

3)

public static string GetParameterInfo3<T>(Expression<Func<T>> expr)
{
    if (expr == null)
        return string.Empty;

    var param = (MemberExpression)expr.Body;
    return "Parameter: '" + param.Member.Name +
           "' = " + ((FieldInfo)param.Member).GetValue(((ConstantExpression)param.Expression).Value);
}

1 和 2 现在速度差不多，3 又慢了。

Answer 5

是的！这是可能的。我一直在寻找解决方案很长一段时间，终于想出了一个解决它的黑客（这有点讨厌）。我不建议将它用作程序的一部分，我认为它只在调试模式下工作。对我来说这并不重要，因为我只在控制台类中将它用作调试工具，所以我可以这样做：

int testVar = 1;
bool testBoolVar = True;
myConsole.Writeline(testVar);
myConsole.Writeline(testBoolVar);

控制台的输出是：

testVar: 1
testBoolVar: True

这是我用来执行此操作的函数（不包括我的控制台类的包装代码。

    public Dictionary<string, string> nameOfAlreadyAcessed = new Dictionary<string, string>();
    public string nameOf(object obj, int level = 1)
    {
        StackFrame stackFrame = new StackTrace(true).GetFrame(level);
        string fileName = stackFrame.GetFileName();
        int lineNumber = stackFrame.GetFileLineNumber();
        string uniqueId = fileName + lineNumber;
        if (nameOfAlreadyAcessed.ContainsKey(uniqueId))
            return nameOfAlreadyAcessed[uniqueId];
        else
        {
            System.IO.StreamReader file = new System.IO.StreamReader(fileName);
            for (int i = 0; i < lineNumber - 1; i++)
                file.ReadLine();
            string varName = file.ReadLine().Split(new char[] { '(', ')' })[1];
            nameOfAlreadyAcessed.Add(uniqueId, varName);
            return varName;
        }
    }

Answer 6

我知道这篇文章真的很老了，但既然现在 .Net 6 中有一种方法，我想我会分享给其他人知道。

您现在可以使用 CallerArgumentExpressionAttribute，如图所示

    /// <summary>
    /// Will throw argument exception if string IsNullOrEmpty returns true
    /// </summary>
    /// <param name="str"></param>
    /// <param name="str_name"></param>
    /// <exception cref="ArgumentException"></exception>
    public static void ValidateNotNullorEmpty(this string str,
        [CallerArgumentExpression("str")]string str_name=null)
    {       
        if (string.IsNullOrEmpty(str))
        {
            throw new ArgumentException($"'{str_name}' cannot be null or empty.", str_name);
        }
    }

现在调用：

param.ValidateNotNullorEmpty();

将抛出错误：“参数不能为空或为空。”

而不是“str不能为null或为空”

Answer 7

这样做非常有用，可以创建良好的异常消息，使人们能够更好地查明错误。行号有帮助，但您可能无法在 prod 中获得它们，并且当您获得它们时，如果代码中有大语句，您通常只会获得整个语句的第一行。

例如，如果您在未设置的 nullable 上调用 .Value，您将收到带有失败消息的异常，但由于缺少此功能，您将看不到哪个属性为 null。如果您在一个语句中执行此操作两次，例如为某个方法设置参数，您将无法看到未设置哪些可空值。

创建类似 Verify.NotNull(myvar, nameof(myvar)) 的代码是迄今为止我发现的最好的解决方法，但如果不需要添加额外的参数，那就太好了。

Answer 8

不，但是每当您发现自己在做这样极其复杂的事情时，您可能需要重新考虑您的解决方案。请记住，代码应该比编写更容易阅读。

Answer 9

System.Environment.StackTrace 将为您提供一个包含当前调用堆栈的字符串。您可以对其进行解析以获取信息，其中包括每个调用的变量名称。

Answer 10

试试这个实用程序类，

public static class Utility
{
    public static Tuple<string, TSource> GetNameAndValue<TSource>(Expression<Func<TSource>> sourceExpression)
    {
        Tuple<String, TSource> result = null;
        Type type = typeof (TSource);
        Func<MemberExpression, Tuple<String, TSource>> process = delegate(MemberExpression memberExpression)
                                                                    {
                                                                        ConstantExpression constantExpression = (ConstantExpression)memberExpression.Expression;
                                                                        var name = memberExpression.Member.Name;
                                                                        var value = ((FieldInfo)memberExpression.Member).GetValue(constantExpression.Value);
                                                                        return new Tuple<string, TSource>(name, (TSource) value);
                                                                    };

        Expression exception = sourceExpression.Body;
        if (exception is MemberExpression)
        {
            result = process((MemberExpression)sourceExpression.Body);
        }
        else if (exception is UnaryExpression)
        {
            UnaryExpression unaryExpression = (UnaryExpression)sourceExpression.Body;
            result = process((MemberExpression)unaryExpression.Operand);
        }
        else
        {
            throw new Exception("Expression type unknown.");
        }

        return result;
    }


}

用户喜欢

    /*ToDo : Test Result*/
    static void Main(string[] args)
    {
        /*Test : primivit types*/
        long maxNumber = 123123;
        Tuple<string, long> longVariable = Utility.GetNameAndValue(() => maxNumber);
        string longVariableName = longVariable.Item1;
        long longVariableValue = longVariable.Item2;

        /*Test : user define types*/
        Person aPerson = new Person() { Id = "123", Name = "Roy" };
        Tuple<string, Person> personVariable = Utility.GetNameAndValue(() => aPerson);
        string personVariableName = personVariable.Item1;
        Person personVariableValue = personVariable.Item2;

        /*Test : anonymous types*/
        var ann = new { Id = "123", Name = "Roy" };
        var annVariable = Utility.GetNameAndValue(() => ann);
        string annVariableName = annVariable.Item1;
        var annVariableValue = annVariable.Item2;

        /*Test : Enum tyoes*/
        Active isActive = Active.Yes;
        Tuple<string, Active> isActiveVariable = Utility.GetNameAndValue(() => isActive);
        string isActiveVariableName = isActiveVariable.Item1;
        Active isActiveVariableValue = isActiveVariable.Item2;
    }

Answer 11

这样做

var myVariable = 123;
myVariable.Named(() => myVariable);
var name = myVariable.Name();
// use name how you like

或在代码中手动命名

var myVariable = 123.Named("my variable");
var name = myVariable.Name();

使用这个类

public static class ObjectInstanceExtensions
{
    private static Dictionary<object, string> namedInstances = new Dictionary<object, string>();

    public static void Named<T>(this T instance, Expression<Func<T>> expressionContainingOnlyYourInstance)
    {
        var name = ((MemberExpression)expressionContainingOnlyYourInstance.Body).Member.Name;
        instance.Named(name);            
    }

    public static T Named<T>(this T instance, string named)
    {
        if (namedInstances.ContainsKey(instance)) namedInstances[instance] = named;
        else namedInstances.Add(instance, named);
        return instance;
    }        

    public static string Name<T>(this T instance)
    {
        if (namedInstances.ContainsKey(instance)) return namedInstances[instance];
        throw new NotImplementedException("object has not been named");
    }        
}

代码经过测试，是我能想到的最优雅的。

Answer 12

感谢所有回复。我想我只能继续我现在正在做的事情了。

对于那些想知道我为什么问上述问题的人。我有以下功能：

string sMessages(ArrayList aMessages, String sType) {
    string sReturn = String.Empty;
    if (aMessages.Count > 0) {
        sReturn += "<p class=\"" + sType + "\">";
        for (int i = 0; i < aMessages.Count; i++) {
            sReturn += aMessages[i] + "<br />";
        }
        sReturn += "</p>";
    }
    return sReturn;
}

我向它发送一组错误消息和一个 css 类，然后将其作为网页字符串返回。

每次调用这个函数，我都要定义sType。比如：

output += sMessages(aErrors, "errors");

如您所见，我的变量称为 aErrors，而我的 css 类称为错误。我希望我的感冒能根据我发送的变量名找出要使用的类。

再次感谢所有回复。

Answer 13

继续Caller* 属性系列（即CallerMemberName、CallerFilePath 和CallerLineNumber），CallerArgumentExpressionAttribute 从 C# Next 开始可用（更多信息 here）。

以下示例的灵感来自 Paul Mcilreavy 的 The CallerArgumentExpression Attribute in C# 8.0：

public static void ThrowIfNullOrWhitespace(this string self, 
             [CallerArgumentExpression("self")] string paramName = default)
{
    if (self is null)
    {
        throw new ArgumentNullException(paramName);
    }

    if (string.IsNullOrWhiteSpace(self))
    {
        throw new ArgumentOutOfRangeException(paramName, self, "Value cannot be whitespace");
    }        
}

Answer 14

感谢visual studio 2022，你可以使用这个

功能

       public void showname(dynamic obj) {
            obj.GetType().GetProperties().ToList().ForEach(state => {
                NameAndValue($"{state.Name}:{state.GetValue(obj, null).ToString()}");
            });
        }

使用

   var myname = "dddd";
   showname(new { myname });

Answer 15

简短的回答是否定的……除非你真的很有动力。

做到这一点的唯一方法是通过反射和堆栈遍历。您必须获得一个堆栈帧，在调用函数中找出您从中调用的位置，然后使用 CodeDOM 尝试找到树的正确部分以查看表达式是什么。

例如，如果调用是 ExampleFunction("a" + "b")？

Answer 16

没有。对您的字符串变量的引用被传递给函数——不包含任何关于它的固有元数据。即使是反射也不能让你走出困境——从单一引用类型向后工作并不能为你提供足够的信息来做你需要做的事情。

最好回到这个绘图板上！

rp

Answer 17

您可以使用反射来获取对象的所有属性，而不是遍历它，并获取（属性的）名称与传入参数匹配的属性的值。

Answer 18

嗯，看了一下。 当然你不能使用任何类型信息。 此外，局部变量的名称在运行时不可用 因为它们的名称没有编译到程序集的元数据中。

Answer 19

GateKiller，我的解决方法有什么问题？你可以简单地重写你的函数来使用它（我冒昧地改进了这个函数）：

static string sMessages(Expression<Func<List<string>>> aMessages) {
    var messages = aMessages.Compile()();

    if (messages.Count == 0) {
        return "";
    }

    StringBuilder ret = new StringBuilder();
    string sType = ((MemberExpression)aMessages.Body).Member.Name;

    ret.AppendFormat("<p class=\"{0}\">", sType);
    foreach (string msg in messages) {
        ret.Append(msg);
        ret.Append("<br />");
    }
    ret.Append("</p>");
    return ret.ToString();
}

这样称呼它：

var errors = new List<string>() { "Hi", "foo" };
var ret = sMessages(() => errors);

Answer 20

获取它的一种方法是读取代码文件并用逗号和括号将其分割...

var trace = new StackTrace(true).GetFrame(1);
var line = File.ReadAllLines(trace.GetFileName())[trace.GetFileLineNumber()];
var argumentNames = line.Split(new[] { ",", "(", ")", ";" }, 
                               StringSplitOptions.TrimEntries)
                        .Where(x => x.Length > 0)
                        .Skip(1).ToList();

Answer 21

如果我理解正确，您希望字符串“WhatIsMyName”出现在 Hello 字符串中。

string Hello = ExampleFunction(WhatIsMyName);

如果用例是它增加了 ExampleFunction 的可重用性并且 Hello 应包含类似“Hello, Peter (from WhatIsMyName)”的内容，那么我认为解决方案是将 ExampleFunction 扩展为接受：

字符串 Hello = ExampleFunction(WhatIsMyName,nameof(WhatIsMyName));

以便名称作为单独的字符串传递。是的，这与您所要求的不完全一样，您必须输入两次。但它是重构安全的，可读的，不使用调试接口，而且出错的可能性很小，因为它们一起出现在消费代码中。

string Hello1 = ExampleFunction(WhatIsMyName,nameof(WhatIsMyName));
string Hello2 = ExampleFunction(SomebodyElse,nameof(SomebodyElse));
string Hello3 = ExampleFunction(HerName,nameof(HerName));

Answer 22

不。我不这么认为。

您使用的变量名是为了您的方便和可读性。编译器不需要它，如果我没记错的话就把它扔掉。

如果有帮助，您可以定义一个名为NamedParameter 的新类，其属性为Name 和Param。然后将此对象作为参数传递。