Обходной путь из-за отсутствия оператора nameof в C# для привязки данных по типу?
Было много настроений, чтобы включить nameof оператор в C#. В качестве примера того, как этот оператор будет работать, nameof(Customer.Name) вернет строку "Name",
У меня есть объект домена. И я должен связать это. И тогда мне нужны имена свойств в виде строк. И я хочу, чтобы они были безопасны от типов.
Я помню, как наткнулся на обходной путь в.NET 3.5, который обеспечивал функциональность nameof и вовлеченные лямбда-выражения. Однако я не смог найти этот обходной путь. Может ли кто-нибудь предоставить мне этот обходной путь?
Я также заинтересован в способе реализации функциональности nameof в.NET 2.0, если это возможно.
8 ответов
Этот код в основном делает это:
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 кода...)
Хотя reshefm и Jon Skeet показывают правильный способ сделать это с помощью выражений, стоит отметить, что есть более дешевый способ сделать это для имен методов:
Оберните делегата вокруг вашего метода, получите MethodInfo, и все готово. Вот пример:
private void FuncPoo()
{
}
...
// Get the name of the function
string funcName = new Action(FuncPoo).Method.Name;
К сожалению, это работает только для методов; он не работает для свойств, так как вы не можете иметь делегатов для методов получения или установки свойств. (Похоже, глупое ограничение, ИМО.)
Обходной путь - использовать дерево выражений и разделить это дерево выражений, чтобы найти соответствующие MemberInfo, В этой заметке есть немного больше деталей и комментариев (хотя не код для извлечения члена - я думаю, что это где-то в другом вопросе).
К сожалению, поскольку деревья выражений не существуют в.NET 2.0, на самом деле нет эквивалента.
Одним из решений, позволяющих избежать опечаток, является наличие набора методов доступа, которые выбирают соответствующие PropertyInfo для конкретного свойства, и их модульное тестирование. Это будет единственное место, где есть строка. Это позволит избежать дублирования и упростить рефакторинг, но это немного драконовски.
Расширение того, что сделал 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.
}
}
Если кто-то не передумает, nameof Оператор выглядит так, как будто это происходит в C# 6. Вот примечания к совещанию по дизайну:
Это часть языка в C# 6.0
Принятое решение красиво, просто и элегантно.
Однако создание дерева выражений стоит дорого, и мне нужен полный путь свойства.
Так что я немного изменил это. Это совсем не элегантно, но просто и хорошо работает в большинстве случаев:
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"
Ответ от 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;
}
}
}
Полный код здесь: http://agiledesignutilities.codeplex.com/SourceControl/changeset/view/b76cefa4234a