Ottieni il nome della proprietà come stringa

(Vedi sotto la soluzione che ho creato usando la risposta che ho accettato)

Sto cercando di migliorare la manutenibilità di alcuni codici che coinvolgono la riflessione. L'app ha un'interfaccia .NET Remoting che espone (tra le altre cose) un metodo chiamato Execute per accedere a parti dell'app non incluse nell'interfaccia remota pubblicata.

Ecco come l'app designa le proprietà (statiche in questo esempio) che devono essere accessibili tramite Execute:

RemoteMgr.ExposeProperty("SomeSecret", typeof(SomeClass), "SomeProperty");

Quindi un utente remoto può chiamare:

string response = remoteObject.Execute("SomeSecret");

e l'app userebbe la reflection per trovare SomeClass.SomeProperty e restituire il suo valore come stringa.

Sfortunatamente, se qualcuno rinomina SomeProperty e si dimentica di cambiare il terzo parametro di ExposeProperty (), si rompe questo meccanismo.

Ho bisogno dell'equivalente di:

SomeClass.SomeProperty.GetTheNameOfThisPropertyAsAString()

da utilizzare come terzo parm in ExposeProperty in modo che gli strumenti di refactoring si occupassero della ridenominazione.

C'è un modo per fare questo? Grazie in anticipo.

Ok, ecco cosa ho finito per creare (in base alla risposta che ho selezionato e alla domanda a cui faceva riferimento):

// <summary>
// Get the name of a static or instance property from a property access lambda.
// </summary>
// <typeparam name="T">Type of the property</typeparam>
// <param name="propertyLambda">lambda expression of the form: '() => Class.Property' or '() => object.Property'</param>
// <returns>The name of the property</returns>
public string GetPropertyName<T>(Expression<Func<T>> propertyLambda)
{
    var me = propertyLambda.Body as MemberExpression;

    if (me == null)
    {
        throw new ArgumentException("You must pass a lambda of the form: '() => Class.Property' or '() => object.Property'");
    }

    return me.Member.Name;
 }

Uso:

// Static Property
string name = GetPropertyName(() => SomeClass.SomeProperty);

// Instance Property
string name = GetPropertyName(() => someObject.SomeProperty);

Ora con questa fantastica funzionalità, è tempo di semplificare il metodo ExposeProperty. Lucidare le maniglie è un lavoro pericoloso ...

Grazie a tutti.

Usando GetMemberInfo da qui: Recuperando il nome della proprietà dall'espressione lambda puoi fare qualcosa del genere:

RemoteMgr.ExposeProperty(() => SomeClass.SomeProperty)

public class SomeClass
{
    public static string SomeProperty
    {
        get { return "Foo"; }
    }
}

public class RemoteMgr
{
    public static void ExposeProperty<T>(Expression<Func<T>> property)
    {
        var expression = GetMemberInfo(property);
        string path = string.Concat(expression.Member.DeclaringType.FullName,
            ".", expression.Member.Name);
        // Do ExposeProperty work here...
    }
}

public class Program
{
    public static void Main()
    {
        RemoteMgr.ExposeProperty("SomeSecret", () => SomeClass.SomeProperty);
    }
}

Con C # 6.0, questo non è un problema, come puoi fare:

nameof(SomeProperty)

Questa espressione viene risolta in fase di compilazione in "SomeProperty".

Documentazione MSDN del nome di .

C'è un noto hack per estrarlo dall'espressione lambda (questo è della classe PropertyObserver, di Josh Smith, nella sua fondazione MVVM):

    private static string GetPropertyName<TPropertySource>
        (Expression<Func<TPropertySource, object>> expression)
    {
        var lambda = expression as LambdaExpression;
        MemberExpression memberExpression;
        if (lambda.Body is UnaryExpression)
        {
            var unaryExpression = lambda.Body as UnaryExpression;
            memberExpression = unaryExpression.Operand as MemberExpression;
        }
        else
        {
            memberExpression = lambda.Body as MemberExpression;
        }

        Debug.Assert(memberExpression != null, 
           "Please provide a lambda expression like 'n => n.PropertyName'");

        if (memberExpression != null)
        {
            var propertyInfo = memberExpression.Member as PropertyInfo;

            return propertyInfo.Name;
        }

        return null;
    }

Spiacente, mancava un po 'di contesto. Questo faceva parte di una classe più ampia in cui si TPropertySourcetrova la classe che contiene la proprietà. È possibile rendere generica la funzione in TPropertySource per estrarla dalla classe. Consiglio di dare un'occhiata al codice completo della MVVM Foundation .

Ok, ecco cosa ho finito per creare (in base alla risposta che ho selezionato e alla domanda a cui faceva riferimento):

// <summary>
// Get the name of a static or instance property from a property access lambda.
// </summary>
// <typeparam name="T">Type of the property</typeparam>
// <param name="propertyLambda">lambda expression of the form: '() => Class.Property' or '() => object.Property'</param>
// <returns>The name of the property</returns>

public string GetPropertyName<T>(Expression<Func<T>> propertyLambda)
{
    var me = propertyLambda.Body as MemberExpression;

    if (me == null)
    {
        throw new ArgumentException("You must pass a lambda of the form: '() => Class.Property' or '() => object.Property'");
    }

    return me.Member.Name;
 }

Uso:

// Static Property
string name = GetPropertyName(() => SomeClass.SomeProperty);

// Instance Property
string name = GetPropertyName(() => someObject.SomeProperty);

La classe PropertyInfo dovrebbe aiutarti a raggiungere questo obiettivo, se ho capito bene.

1. Metodo Type.GetProperties ()

   PropertyInfo[] propInfos = typeof(ReflectedType).GetProperties();
   propInfos.ToList().ForEach(p => 
       Console.WriteLine(string.Format("Property name: {0}", p.Name));

è di questo che hai bisogno?

È possibile utilizzare Reflection per ottenere i nomi effettivi delle proprietà.

http://www.csharp-examples.net/reflection-property-names/

Se hai bisogno di un modo per assegnare un "Nome stringa" a una proprietà, perché non scrivi un attributo su cui riflettere per ottenere il nome della stringa?

[StringName("MyStringName")]
private string MyProperty
{
    get { ... }
}

Ho modificato la tua soluzione per concatenare più proprietà:

public static string GetPropertyName<T>(Expression<Func<T>> propertyLambda)
{
    MemberExpression me = propertyLambda.Body as MemberExpression;
    if (me == null)
    {
        throw new ArgumentException("You must pass a lambda of the form: '() => Class.Property' or '() => object.Property'");
    }

    string result = string.Empty;
    do
    {
        result = me.Member.Name + "." + result;
        me = me.Expression as MemberExpression;
    } while (me != null);

    result = result.Remove(result.Length - 1); // remove the trailing "."
    return result;
}

Uso:

string name = GetPropertyName(() => someObject.SomeProperty.SomeOtherProperty);
// returns "SomeProperty.SomeOtherProperty"

Basato sulla risposta che è già nella domanda e su questo articolo: https://handcraftsman.wordpress.com/2008/11/11/how-to-get-c-property-names-without-magic-strings/ I sto presentando la mia soluzione a questo problema:

public static class PropertyNameHelper
{
    /// <summary>
    /// A static method to get the Propertyname String of a Property
    /// It eliminates the need for "Magic Strings" and assures type safety when renaming properties.
    /// See: http://stackoverflow.com/questions/2820660/get-name-of-property-as-a-string
    /// </summary>
    /// <example>
    /// // Static Property
    /// string name = PropertyNameHelper.GetPropertyName(() => SomeClass.SomeProperty);
    /// // Instance Property
    /// string name = PropertyNameHelper.GetPropertyName(() => someObject.SomeProperty);
    /// </example>
    /// <typeparam name="T"></typeparam>
    /// <param name="propertyLambda"></param>
    /// <returns></returns>
    public static string GetPropertyName<T>(Expression<Func<T>> propertyLambda)
    {
        var me = propertyLambda.Body as MemberExpression;

        if (me == null)
        {
            throw new ArgumentException("You must pass a lambda of the form: '() => Class.Property' or '() => object.Property'");
        }

        return me.Member.Name;
    }
    /// <summary>
    /// Another way to get Instance Property names as strings.
    /// With this method you don't need to create a instance first.
    /// See the example.
    /// See: https://handcraftsman.wordpress.com/2008/11/11/how-to-get-c-property-names-without-magic-strings/
    /// </summary>
    /// <example>
    /// string name = PropertyNameHelper((Firma f) => f.Firmenumsatz_Waehrung);
    /// </example>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TReturn"></typeparam>
    /// <param name="expression"></param>
    /// <returns></returns>
    public static string GetPropertyName<T, TReturn>(Expression<Func<T, TReturn>> expression)
    {
        MemberExpression body = (MemberExpression)expression.Body;
        return body.Member.Name;
    }
}

E un test che mostra anche l'utilizzo per esempio e le proprietà statiche:

[TestClass]
public class PropertyNameHelperTest
{
    private class TestClass
    {
        public static string StaticString { get; set; }
        public string InstanceString { get; set; }
    }

    [TestMethod]
    public void TestGetPropertyName()
    {
        Assert.AreEqual("StaticString", PropertyNameHelper.GetPropertyName(() => TestClass.StaticString));

        Assert.AreEqual("InstanceString", PropertyNameHelper.GetPropertyName((TestClass t) => t.InstanceString));
    }
}

Vecchia domanda, ma un'altra risposta a questa domanda è quella di creare una funzione statica in una classe di supporto che utilizza CallerMemberNameAttribute.

public static string GetPropertyName([CallerMemberName] String propertyName = null) {
  return propertyName;
}

E poi usalo come:

public string MyProperty {
  get { Console.WriteLine("{0} was called", GetPropertyName()); return _myProperty; }
}

È possibile utilizzare la classe StackTrace per ottenere il nome della funzione corrente (o se si inserisce il codice in una funzione, si abbassa un livello e si ottiene la funzione chiamante).

Vedi http://msdn.microsoft.com/en-us/library/system.diagnostics.stacktrace(VS.71).aspx

Ho usato questa risposta con grande efficacia: ottenere la proprietà, come una stringa, da un'espressione <Func <TModel, TProperty >>

Mi rendo conto di aver già risposto a questa domanda qualche tempo fa. L'unico vantaggio della mia altra risposta è che funziona con proprietà statiche. Trovo che la sintassi in questa risposta sia molto più utile perché non è necessario creare una variabile del tipo che si desidera riflettere.

Ho avuto qualche difficoltà a utilizzare le soluzioni già suggerite per il mio caso d'uso specifico, ma alla fine l'ho capito. Non credo che il mio caso specifico sia degno di una nuova domanda, quindi sto pubblicando la mia soluzione qui come riferimento. (Questo è strettamente correlato alla domanda e fornisce una soluzione per chiunque abbia un caso simile al mio).

Il codice con cui ho finito è simile al seguente:

public class HideableControl<T>: Control where T: class
{
    private string _propertyName;
    private PropertyInfo _propertyInfo;

    public string PropertyName
    {
        get { return _propertyName; }
        set
        {
            _propertyName = value;
            _propertyInfo = typeof(T).GetProperty(value);
        }
    }

    protected override bool GetIsVisible(IRenderContext context)
    {
        if (_propertyInfo == null)
            return false;

        var model = context.Get<T>();

        if (model == null)
            return false;

        return (bool)_propertyInfo.GetValue(model, null);
    }

    protected void SetIsVisibleProperty(Expression<Func<T, bool>> propertyLambda)
    {
        var expression = propertyLambda.Body as MemberExpression;
        if (expression == null)
            throw new ArgumentException("You must pass a lambda of the form: 'vm => vm.Property'");

        PropertyName = expression.Member.Name;
    }
}

public interface ICompanyViewModel
{
    string CompanyName { get; }
    bool IsVisible { get; }
}

public class CompanyControl: HideableControl<ICompanyViewModel>
{
    public CompanyControl()
    {
        SetIsVisibleProperty(vm => vm.IsVisible);
    }
}

La parte importante per me è che nella CompanyControlclasse il compilatore mi permetterà solo di scegliere una proprietà booleana ICompanyViewModelche rende più facile per gli altri sviluppatori farlo bene.

La differenza principale tra la mia soluzione e la risposta accettata è che la mia classe è generica e voglio solo abbinare le proprietà del tipo generico che sono booleane.

è il modo in cui l'ho implementato, il motivo dietro è se la classe che si desidera ottenere il nome dal suo membro non è statica, quindi è necessario creare un istante di quello e quindi ottenere il nome del membro. così generico qui viene in aiuto

public static string GetName<TClass>(Expression<Func<TClass, object>> exp)
{
    MemberExpression body = exp.Body as MemberExpression;

    if (body == null)
    {
         UnaryExpression ubody = (UnaryExpression)exp.Body;
         body = ubody.Operand as MemberExpression;
    }

     return body.Member.Name;
}

l'uso è così

var label = ClassExtension.GetName<SomeClass>(x => x.Label); //x is refering to 'SomeClass'