Problemumgehung für das Fehlen des 'nameof' -Operators in C # für typsichere Datenbindung?

Während reshefm und Jon Skeet zeigen, der richtige Weg, dies zu tun, verwenden Ausdrücke, sollte es erwähnenswert sein, es ist ein billiger Weg, dies zu tun für die Methoden-Namen:

Wickeln delegieren, um Ihre Methode bekommen die MethodInfo, und du bist gut zu gehen. Hier ist ein Beispiel:

private void FuncPoo()
{
}

...

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

Leider funktioniert dies nur für Methoden, es funktioniert nicht für Eigenschaften, wie Sie nicht haben Delegaten-Eigenschaft getter-oder setter-Methoden. (Scheint wie eine dumme Einschränkung, IMO.)

InformationsquelleAutor der Antwort Judah Himango

Eine Erweiterung zu dem, was reshefm hast, das vereinfacht die Nutzung der nameof () - operator und gibt die Namen der Methoden und Klassen-member und-Methoden sowie:

///<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.
    }
}

InformationsquelleAutor der Antwort Ad P.

Akzeptierte Lösung ist schön, schlicht und elegant.

Doch bauen Sie einen Ausdruck-Baum ist teuer, und ich brauche das ganze Grundstück Weg.

Damit ich es ein bisschen geändert. Es ist nicht elegant, aber es ist einfach und funktioniert gut in den meisten Fällen:

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;
}

Beispiel:

? Nameof<DataGridViewCell>.Property(c => c.Style.BackColor.A);
"Style.BackColor.A"

InformationsquelleAutor der Antwort Larry

Die Antwort von reshefm ist ziemlich gut, aber das ist ein bisschen einfacher API-IMO:

Beispiel:
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;
    }
  }
}

Vollständige code ist hier:
http://agiledesignutilities.codeplex.com/SourceControl/changeset/view/b76cefa4234a#GeneralPurpose/NameOf.cs

InformationsquelleAutor der Antwort Sergey