web-dev-qa-db-ja.com

タイプセーフなデータバインディング用のC＃に 'nameof'演算子がないための回避策

C＃にnameof演算子を含めることに対する多くの感情があります。この演算子の機能の例として、nameof(Customer.Name)は文字列"Name"を返します。

ドメインオブジェクトがあります。そして私はそれを縛らなければなりません。そして、私は文字列としてプロパティの名前が必要です。そして、私はそれらにタイプセーフであって欲しいです。

nameofの機能を提供し、ラムダ式が関係する.NET 3.5の回避策に出くわしたことを覚えています。ただし、この回避策を見つけることができませんでした。誰かがその回避策を私に提供できますか？

可能であれば、.NET 2.0でnameofの機能を実装する方法にも興味があります。

c#.netdata-binding.net-3.5.net-2.0
44
Paul Kapustin

このコードは基本的にそれを行います：

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コードです...）

77
reshefm

ReshefmとJon Skeetは式を使用してこれを行う適切な方法を示していますが、メソッド名に対してこれを行う安価な方法があることに注意する価値があります。

メソッドの周りにデリゲートをラップし、MethodInfoを取得すれば、準備は完了です。次に例を示します。

private void FuncPoo()
{
}

...

// Get the name of the function
string funcName = new Action(FuncPoo).Method.Name;

残念ながら、これはメソッドに対してのみ機能します。プロパティのgetterまたはsetterメソッドへのデリゲートを持つことができないため、プロパティに対しては機能しません。 （愚かな制限、IMOのようです。）

6
Judah Gabriel Himango

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
Ad P.

誰かが気にしない限り、nameof演算子はC＃6で登場するように見えます。これに関する設計会議のメモは次のとおりです。

https://roslyn.codeplex.com/discussions/552376

https://roslyn.codeplex.com/discussions/552377

4
Ronnie Overby

回避策は、式ツリーを使用し、その式ツリーを分解して、関連するMemberInfoを見つけることです。 このメモ には少し詳細とコメントがあります（ただし、メンバーを引き出すコードではありません-別のSO質問にあると思います）。

残念ながら、式ツリーは.NET 2.0には存在しないため、実際には同等のものはありません。

入力ミスを回避する1つの解決策は、特定のプロパティに関連するPropertyInfoをフェッチする一連のアクセサを用意し、それらを単体テストすることです。そこにひもがあった唯一の場所でしょう。これは重複を避け、リファクタリングを容易にしますが、少々厳しいです。

4
Jon Skeet

受け入れられているソリューションは、ニース、シンプル、そしてエレガントです。

ただし、式ツリーの構築にはコストがかかり、プロパティパス全体が必要です。

少し変更しました。エレガントではありませんが、シンプルでほとんどの場合にうまく機能します。

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"
2
Larry

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#GeneralPurpose/NameOf.cs

1
Sergey

これはC＃6.0の言語の一部です

https://msdn.Microsoft.com/en-us/magazine/dn802602.aspx

1
kotpal