Отримайте назву властивості у вигляді рядка

(Дивіться нижче рішення, яке я створив, використовуючи відповідь, яку я прийняв)

Я намагаюся покращити ремонтопридатність якогось коду, що включає рефлексію. У додатку є інтерфейс видалення .NET, що відкриває (серед іншого) метод, який називається Execute для доступу до частин програми, які не входять до його опублікованого віддаленого інтерфейсу.

Ось як додаток позначає властивості (статичні в цьому прикладі), які повинні бути доступні через Execute:

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

Тож віддалений користувач може зателефонувати:

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

і додаток використовує відображення, щоб знайти SomeClass.SomeProperty і повернути його значення у вигляді рядка.

На жаль, якщо хтось перейменує SomeProperty і забуде змінити 3-ю парму ExposeProperty (), він порушує цей механізм.

Мені потрібно еквівалент:

SomeClass.SomeProperty.GetTheNameOfThisPropertyAsAString()

використовувати в якості 3-го парму в ExposeProperty, щоб інструменти рефакторингу дбали про перейменування.

Чи є спосіб це зробити? Заздалегідь спасибі.

Гаразд, ось що я в кінцевому підсумку створив (на основі відповіді, яку я вибрав, і питання, на який він посилався):

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

Використання:

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

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

Тепер з цією цікавою можливістю прийшов час спростити метод ExposeProperty. Полірування дверних ручок - небезпечна робота ...

Дякую всім.

Використовуючи GetMemberInfo звідси: Отримавши ім'я власності з лямбда-виразу, ви можете зробити щось подібне:

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

Що стосується C # 6.0, це вже не проблема, як це можна зробити:

nameof(SomeProperty)

Цей вираз вирішується під час компіляції до "SomeProperty".

Документація MSDN іменіof .

Існує відомий хак, щоб витягнути його з лямбда-експресії (це з класу PropertyObserver Джоша Сміта у його фонді 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;
    }

Вибачте, у цьому контексті бракує певного контексту. Це було частиною більшого класу, де TPropertySourceклас, що містить властивість. Ви можете зробити функцію загальною в TPropertySource, щоб отримати її з класу. Рекомендую переглянути повний код фонду MVVM .

Гаразд, ось що я в кінцевому підсумку створив (на основі відповіді, яку я вибрав, і питання, на який він посилався):

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

Використання:

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

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

Клас PropertyInfo повинен допомогти вам досягти цього, якщо я правильно розумію.

1. Метод Type.GetProperties ()

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

Це те, що вам потрібно?

Ви можете використовувати Reflection для отримання фактичних назв властивостей.

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

Якщо вам потрібен спосіб призначити "ім'я рядка" властивості, чому б вам не написати атрибут, який можна відобразити, щоб отримати ім'я рядка?

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

Я змінив ваше рішення для створення ланцюга на кількох властивостях:

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

Використання:

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

Виходячи з відповіді, яка вже є у питанні та на цій статті: https://handcraftsman.wordpress.com/2008/11/11/how-to-get-c-property-names-without-magic-strings/ I представляю своє рішення цієї проблеми:

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

І тест, який також показує використання, наприклад, і статичні властивості:

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

Старе запитання, але ще одна відповідь на це питання полягає у створенні статичної функції в хелперному класі, який використовує CallerMemberNameAttribute.

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

А потім використовуйте його так:

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

Ви можете скористатися класом StackTrace, щоб отримати ім'я поточної функції (або якщо ви введете код у функцію, а потім зменшіть рівень та отримайте функцію виклику).

Дивіться http://msdn.microsoft.com/en-us/library/system.diagnostics.stacktrace(VS.71).aspx

Я використовую цю відповідь з великим ефектом: Отримайте властивість у вигляді рядка з виразу <Func <TModel, TProperty >>

Я усвідомлюю, що вже відповів на це питання. Єдина моя перевага - це те, що вона працює для статичних властивостей. Я вважаю синтаксис у цій відповіді набагато кориснішим, оскільки не потрібно створювати змінну типу, який ви хочете відобразити.

У мене виникли певні труднощі з використанням рішень, запропонованих для мого конкретного випадку використання, але, зрештою, це з'ясувалося. Я не думаю, що мій конкретний випадок гідний нового питання, тому я розміщую тут своє рішення для довідки. (Це дуже тісно пов'язане з питанням і забезпечує рішення для всіх, хто має подібний випадок із моїм).

Код, у якому я закінчив, виглядає приблизно так:

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

Важлива частина для мене полягає в тому, що в CompanyControlкласі компілятор дозволить мені вибрати лише булеву властивість, ICompanyViewModelяка полегшує іншим розробникам правильне її встановлення.

Основна відмінність мого рішення від прийнятої відповіді полягає в тому, що мій клас є загальним, і я хочу лише відповідати властивостям із загального типу, що є булевими.

це те, як я його реалізував, причина в тому, що якщо клас, який ви хочете отримати ім'я від свого члена, не є статичним, то вам потрібно створити ім'я цього, а потім отримати ім'я учасника. настільки загальне тут приходить на допомогу

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

використання таке

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