Получить имя свойства в виде строки

Question

(см. Ниже решение, которое я создал, используя ответ, который я принял)

Я пытаюсь улучшить удобство сопровождения некоторого кода, связанного с отражением. Приложение имеет интерфейс .NET Remoting, который предоставляет (помимо прочего) метод Execute для доступа к частям приложения, не включенным в опубликованный удаленный интерфейс.

Вот как приложение определяет свойства (статические в этом примере), которые должны быть доступны через Execute:

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

Чтобы удаленный пользователь мог позвонить:

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

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

К сожалению, если кто-то переименует SomeProperty и забудет изменить третий параметр ExposeProperty (), это нарушит этот механизм.

Мне нужно эквивалент:

SomeClass.SomeProperty.GetTheNameOfThisPropertyAsAString()

для использования в качестве третьего параметра в 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. Полировка дверных ручек - опасная работа ...

Спасибо всем.

Answer 1

С C # 6.0 это теперь не проблема, как вы можете сделать:

nameof(SomeProperty)

Это выражение разрешается во время компиляции в "SomeProperty".

MSDN документация имени .

Answer 2

Используя 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);
    }
}

Answer 3

Существует известный хак для извлечения его из лямбда-выражения (это из класса 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 Foundation .

Answer 4

Хорошо, вот что я в итоге создал (основываясь на выбранном мной ответе и вопросе, на который он ссылался):

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

Answer 5

Класс PropertyInfo должен помочь вам в этом, если я правильно понимаю.

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

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

Это то, что вам нужно?

Answer 6

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

http://www.csharp -examples.net / отражение-свойство-имен /

Если вам нужен способ присвоения «Строкового имени» свойству, почему бы вам не написать атрибут, который можно использовать для получения имени строки?

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

Answer 7

Я изменил ваше решение для объединения нескольких свойств:

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"

Answer 8

Исходя из ответа, который уже есть в вопросе и по этой статье: https://handcraftsman.wordpress.com/2008/11/11/how-to-get-c-property-names-without-magic-strings/ Я представляю свое решение этой проблемы:

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: /1591797/poluchit-imya-svoistva-v-vide-stroki
    /// </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));
    }
}

Answer 9

Старый вопрос, но другой ответ на этот вопрос - создать статическую функцию в классе помощника, который использует атрибут CallerMemberNameAttribute.

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

А затем используйте его как:

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

Answer 10

это то, как я это реализовал, причина в том, что если класс, которому вы хотите получить имя от своего члена, не является статическим, тогда вам нужно создать экземпляр этого и затем получить имя члена. здесь приходит на помощь такой общий характер

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'