让我用下面的例子来解释我的问题：
1
2
3
4
5
6
| public string ExampleFunction(string Variable) {
return something;
}
string WhatIsMyName ="Hello World"';
string Hello = ExampleFunction(WhatIsMyName); |
当我将变量"WhatIsMyName"传递给示例函数时，我希望能够获取原始变量名称的字符串。 也许是这样的：
1
| Variable.OriginalName.ToString() |
有没有办法做到这一点？
您想要的不是直接的，但您可以在C＃3.0中使用表达式：
1
2
3
4
5
| public void ExampleFunction(Expression<Func<string, string>> f) {
Console.WriteLine((f.Body as MemberExpression).Member.Name);
}
ExampleFunction(x => WhatIsMyName); |
请注意，这取决于未指定的行为，虽然它在Microsoft的当前C＃和VB编译器以及Mono的C＃编译器中都有效，但无法保证在将来的版本中不会停止工作。
这是不可能的，你想要的方式。 C＃6.0他们介绍了应该帮助改进和简化代码的运营商名称。运算符的名称解析传递给它的变量的名称。
您案例的用法如下所示：
1
2
3
4
5
6
7
| 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)); |
一个主要好处是它在编译时完成，
The nameof expression is a constant. In all cases, nameof(...) is evaluated at compile-time to produce a string. Its argument is not evaluated at runtime, and is considered unreachable code (however it does not emit an"unreachable code" warning).
更多信息可以在这里找到
旧版本的C 3.0及以上版本
建立Nawfals答案
1
2
3
4
5
6
7
8
9
10
11
| 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;
} |
1
2
3
4
5
6
7
8
9
10
11
12
| 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;
} |
更多详细信息，请参阅此博客文章。
三种方式：
1)没有反思的东西：
1
2
3
4
5
6
7
8
9
| 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)使用反射，但这比其他两个更快。
1
2
3
4
5
6
7
8
9
| 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)最慢的，不要使用。
1
2
3
4
5
6
7
8
9
| GetParameterName3(() => variable);
public static string GetParameterName3< T >(Expression<Func< T >> expr)
{
if (expr == null)
return string.Empty;
return ((MemberExpression)expr.Body).Member.Name;
} |
要获取组合参数名称和值，可以扩展这些方法。当然，如果你将参数作为另一个参数单独传递，那么它很容易获得值，但这是不优雅的。代替：
1)
1
2
3
4
5
6
7
8
9
| 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)
1
2
3
4
5
6
7
8
9
| 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)
1
2
3
4
5
6
7
8
9
| 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再次缓慢。
不，但每当你发现自己做这样极其复杂的事情时，你可能想重新考虑你的解决方案。请记住，代码应该比编写代码更容易阅读。
是!有可能的。我一直在寻找一个解决方案很长一段时间，并最终想出一个解决它的黑客(它有点讨厌)。我不建议将此作为程序的一部分使用，我只认为它在调试模式下工作。对我来说这没关系，因为我只在我的控制台类中使用它作为调试工具，所以我可以这样做：
1
2
3
4
| int testVar = 1;
bool testBoolVar = True;
myConsole.Writeline(testVar);
myConsole.Writeline(testBoolVar); |
控制台的输出是：
1
2
| testVar: 1
testBoolVar: True |
这是我用来做的功能(不包括我的控制台类的包装代码)。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| 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;
}
} |
System.Environment.StackTrace将为您提供包含当前调用堆栈的字符串。您可以解析它以获取信息，其中包括每个调用的变量名称。
那么试试这个Utility类，
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
| 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;
}
} |
和用户一样
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| /*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;
} |
做这个
1
2
3
4
| var myVariable = 123;
myVariable.Named(() => myVariable);
var name = myVariable.Name();
// use name how you like |
或手动命名代码
1
2
| var myVariable = 123.Named("my variable");
var name = myVariable.Name(); |
使用这个课程
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| 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");
}
} |
我可以想出代码测试和最优雅。
GateKiller，我的解决方法有什么问题？您可以轻松地重写您的功能以使用它(我已经冒昧地改进了功能)：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| 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();
} |
像这样称呼它：
1
2
| var errors = new List<string>() {"Hi","foo" };
var ret = sMessages(() => errors); |
您可以使用反射来获取对象的所有属性，而不是循环遍历它，并获取属性的值(属性的名称)与传入的参数匹配。
不会。对你的字符串变量的引用被传递给函数 - 它没有包含任何固有的metadeta。即使反射也不会让你走出困境 - 从单一参考类型向后工作并不能让你获得足够的信息来完成你需要做的事情。
最好回到这个画板！
RP
感谢所有的回复。我想我只需要继续我现在正在做的事情。
对于那些想知道我为什么问上述问题的人。我有以下功能：
1
2
3
4
5
6
7
8
9
10
11
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。就像是：
1
| output += sMessages(aErrors,"errors"); |
如您所见，我的变量称为aErrors，我的css类称为错误。我希望我的冷可以根据我发送的变量名来找出要使用的类。
再次感谢所有回复。
好吧有点看。当然你不能使用任何类型信息。
此外，本地变量的名称在运行时不可用
因为它们的名称没有编译到程序集的元数据中。
简短的回答是否定的......除非你真的很有动力。
唯一的方法是通过反射和堆栈行走。你必须得到一个堆栈框架，在你调用的调用函数中找出行踪，然后使用CodeDOM尝试找到树的正确部分以查看表达式是什么。
例如，如果调用是ExampleFunction("a"+"b")怎么办？
**不。**我不这么认为。
您使用的变量名称是为了方便和可读性。如果我没有弄错的话，编译器不需要它并且只是把它搞砸了。
如果它有帮助，您可以定义一个名为NamedParameter的新类，其属性为Name和Param。然后，您将此对象作为参数传递。
