在C＃中包含nameof运算符的情绪很多。作为此运算符如何工作的示例，nameof(Customer.Name)将返回字符串"Name"。
我有一个域对象。我必须绑定它。然后我需要属性的名称作为字符串。我希望它们是类型安全的。
我记得在.NET 3.5中遇到过一种解决方法，它提供了nameof的功能并涉及lambda表达式。但是，我无法找到此解决方法。任何人都可以向我提供这种解决方法吗？
如果可能的话，我也有兴趣在.NET 2.0中实现nameof的功能。
答案 0 :(得分：77)
这段代码基本上是这样的：
class Program
{
static void Main()
{
var propName = Nameof<SampleClass>.Property(e => e.Name);
Console.WriteLine(propName);
}
}
public class Nameof<T>
{
public static string Property<TProp>(Expression<Func<T, TProp>> expression)
{
var body = expression.Body as MemberExpression;
if(body == null)
throw new ArgumentException("'expression' should be a member expression");
return body.Member.Name;
}
}
（当然是3.5代码......）
答案 1 :(得分：6)
虽然reshefm和Jon Skeet使用表达式显示了正确的方法，但值得注意的是，为方法名称执行此操作的方法更便宜：
围绕你的方法包装一个委托，得到MethodInfo，你就可以了。这是一个例子：
private void FuncPoo()
{
}
...
// Get the name of the function
string funcName = new Action(FuncPoo).Method.Name;
不幸的是，这仅适用于方法;它不适用于属性，因为您不能拥有属性getter或setter方法的委托。 （看起来像一个愚蠢的限制，IMO。）
答案 2 :(得分：4)
解决方法是使用表达式树，并将该表达式树分开以查找相关的MemberInfo。在this note中有更多的细节和评论（虽然不是提取成员的代码 - 我相信在某个地方的另一个SO问题）。
不幸的是，因为.NET 2.0中不存在表达式树，所以实际上没有等价物。
避免拼写错误的一个解决方案是使用一组访问器来获取特定属性的相关PropertyInfo，并对它们进行单元测试。那将是唯一一个有字符串的地方。这样可以避免重复并使重构更容易，但它有点严苛。
答案 3 :(得分：4)
reshefm的扩展，简化了nameof（）运算符的使用，并提供了方法和类成员及方法的名称：
/// <summary>
/// Provides the <see cref="nameof"/> extension method that works as a workarounds for a nameof() operator,
/// which should be added to C# sometime in the future.
/// </summary>
public static class NameOfHelper
{
/// <summary>
/// Returns a string represantaion of a property name (or a method name), which is given using a lambda expression.
/// </summary>
/// <typeparam name="T">The type of the <paramref name="obj"/> parameter.</typeparam>
/// <typeparam name="TProp">The type of the property (or the method's return type), which is used in the <paramref name="expression"/> parameter.</typeparam>
/// <param name="obj">An object, that has the property (or method), which its name is returned.</param>
/// <param name="expression">A Lambda expression of this pattern: x => x.Property <BR/>
/// Where the x is the <paramref name="obj"/> and the Property is the property symbol of x.<BR/>
/// (For a method, use: x => x.Method()</param>
/// <returns>A string that has the name of the given property (or method).</returns>
public static string nameof<T, TProp>(this T obj, Expression<Func<T, TProp>> expression)
{
MemberExpression memberExp = expression.Body as MemberExpression;
if (memberExp != null)
return memberExp.Member.Name;
MethodCallExpression methodExp = expression.Body as MethodCallExpression;
if (methodExp != null)
return methodExp.Method.Name;
throw new ArgumentException("'expression' should be a member expression or a method call expression.", "expression");
}
/// <summary>
/// Returns a string represantaion of a property name (or a method name), which is given using a lambda expression.
/// </summary>
/// <typeparam name="TProp">The type of the property (or the method's return type), which is used in the <paramref name="expression"/> parameter.</typeparam>
/// <param name="expression">A Lambda expression of this pattern: () => x.Property <BR/>
/// Where Property is the property symbol of x.<BR/>
/// (For a method, use: () => x.Method()</param>
/// <returns>A string that has the name of the given property (or method).</returns>
public static string nameof<TProp>(Expression<Func<TProp>> expression)
{
MemberExpression memberExp = expression.Body as MemberExpression;
if (memberExp != null)
return memberExp.Member.Name;
MethodCallExpression methodExp = expression.Body as MethodCallExpression;
if (methodExp != null)
return methodExp.Method.Name;
throw new ArgumentException("'expression' should be a member expression or a method call expression.", "expression");
}
}
使用它：
static class Program
{
static void Main()
{
string strObj = null;
Console.WriteLine(strObj.nameof(x => x.Length)); //gets the name of an object's property.
Console.WriteLine(strObj.nameof(x => x.GetType())); //gets the name of an object's method.
Console.WriteLine(NameOfHelper.nameof(() => string.Empty)); //gets the name of a class' property.
Console.WriteLine(NameOfHelper.nameof(() => string.Copy(""))); //gets the name of a class' method.
}
}
答案 4 :(得分：4)
除非有人改变主意，否则nameof运算符看起来就像C＃6中的内容。以下是有关它的设计会议说明：
答案 5 :(得分：2)
公认的解决方案很好，简单而优雅。
但是，构建表达式树很昂贵，我需要整个属性路径。
所以我改了一下。它根本不优雅，但它很简单，在大多数情况下效果很好：
public static string Property<TProp>(Expression<Func<T, TProp>> expression)
{
var s = expression.Body.ToString();
var p = s.Remove(0, s.IndexOf('.') + 1);
return p;
}
示例：
? Nameof<DataGridViewCell>.Property(c => c.Style.BackColor.A);
"Style.BackColor.A"
答案 6 :(得分：1)
reshefm的答案相当不错，但这是一个有点简单的API IMO：
用法示例：
NameOf.Property(() => new Order().Status)
using System;
using System.Diagnostics.Contracts;
using System.Linq.Expressions;
namespace AgileDesign.Utilities
{
public static class NameOf
{
///<summary>
/// Returns name of any method expression with any number of parameters either void or with a return value
///</summary>
///<param name = "expression">
/// Any method expression with any number of parameters either void or with a return value
///</param>
///<returns>
/// Name of any method with any number of parameters either void or with a return value
///</returns>
[Pure]
public static string Method(Expression<Action> expression)
{
Contract.Requires<ArgumentNullException>(expression != null);
return ( (MethodCallExpression)expression.Body ).Method.Name;
}
///<summary>
/// Returns name of property, field or parameter expression (of anything but method)
///</summary>
///<param name = "expression">
/// Property, field or parameter expression
///</param>
///<returns>
/// Name of property, field, parameter
///</returns>
[Pure]
public static string Member(Expression<Func<object>> expression)
{
Contract.Requires<ArgumentNullException>(expression != null);
if(expression.Body is UnaryExpression)
{
return ((MemberExpression)((UnaryExpression)expression.Body).Operand).Member.Name;
}
return ((MemberExpression)expression.Body).Member.Name;
}
}
}
答案 7 :(得分：1)
这是C＃6.0
中语言的一部分