Lấy tên tài sản dưới dạng chuỗi

(Xem giải pháp bên dưới tôi đã tạo bằng câu trả lời tôi chấp nhận)

Tôi đang cố gắng cải thiện khả năng duy trì của một số mã liên quan đến sự phản chiếu. Ứng dụng này có giao diện .NET Remote (trong số những thứ khác), một phương thức gọi là Execute để truy cập các phần của ứng dụng không có trong giao diện từ xa được xuất bản của nó.

Dưới đây là cách ứng dụng chỉ định các thuộc tính (một tĩnh trong ví dụ này) có nghĩa là có thể truy cập được qua Execute:

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

Vì vậy, một người dùng từ xa có thể gọi:

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

và ứng dụng sẽ sử dụng sự phản chiếu để tìm một sốClass.SomeProperty và trả về giá trị của nó dưới dạng một chuỗi.

Thật không may, nếu ai đó đổi tên someProperty và quên thay đổi parm thứ 3 của ExposeProperty (), nó sẽ phá vỡ cơ chế này.

Tôi cần tương đương với:

SomeClass.SomeProperty.GetTheNameOfThisPropertyAsAString()

để sử dụng như là parm thứ 3 trong ExposeProperty, vì vậy các công cụ tái cấu trúc sẽ đảm nhiệm việc đổi tên.

Có cách nào để làm việc này không? Cảm ơn trước.

Được rồi, đây là những gì tôi đã tạo ra (dựa trên câu trả lời tôi đã chọn và câu hỏi mà anh ấy tham khảo):

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

Sử dụng:

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

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

Bây giờ với khả năng tuyệt vời này, đã đến lúc đơn giản hóa phương pháp ExposeProperty. Đánh bóng tay nắm cửa là công việc nguy hiểm ...

Cảm ơn mọi người.

Sử dụng GetMemberInfo từ đây: Lấy tên thuộc tính từ biểu thức lambda bạn có thể làm một cái gì đó như thế này:

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

Với C # 6.0, đây không phải là vấn đề như bạn có thể làm:

nameof(SomeProperty)

Biểu thức này được giải quyết tại thời gian biên dịch đến "SomeProperty".

Tài liệu MSDN của nameof .

Có một hack nổi tiếng để trích xuất nó từ biểu thức lambda (đây là từ lớp PropertyObserver, bởi Josh Smith, trong nền tảng MVVM của anh ấy):

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

Xin lỗi, điều này đã thiếu một số bối cảnh. Đây là một phần của lớp lớn hơn trong đó TPropertySourcelớp chứa thuộc tính. Bạn có thể tạo hàm chung trong TPropertySource để trích xuất nó từ lớp. Tôi khuyên bạn nên xem mã đầy đủ từ Quỹ MVVM .

Được rồi, đây là những gì tôi đã tạo ra (dựa trên câu trả lời tôi đã chọn và câu hỏi mà anh ấy tham khảo):

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

Sử dụng:

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

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

Lớp PropertyInfo sẽ giúp bạn đạt được điều này, nếu tôi hiểu chính xác.

1. Phương thức Type.GetProperIES ()

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

Đây có phải là những gì bạn cần?

Bạn có thể sử dụng Reflection để có được tên thực của các thuộc tính.

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

Nếu bạn cần một cách để gán "Tên chuỗi" cho một thuộc tính, tại sao bạn không viết một thuộc tính mà bạn có thể phản ánh để lấy tên chuỗi?

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

Tôi đã sửa đổi giải pháp của bạn để xâu chuỗi nhiều thuộc tính:

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

Sử dụng:

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

Dựa trên câu trả lời đã có trong câu hỏi và trên bài viết này: https://handccraftman.wordpress.com/2008/11/11/how-to-get-c-property-names-without-magic-strings/ I đang trình bày giải pháp của tôi cho vấn đề này:

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

Và một bài kiểm tra cũng cho thấy việc sử dụng các thuộc tính tĩnh và ví dụ:

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

Câu hỏi cũ, nhưng một câu trả lời khác cho câu hỏi này là tạo một hàm tĩnh trong lớp trình trợ giúp sử dụng CallerMemberNameAttribution.

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

Và sau đó sử dụng nó như:

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

Bạn có thể sử dụng lớp StackTrace để lấy tên của hàm hiện tại, (hoặc nếu bạn đặt mã trong một hàm, sau đó bước xuống một mức và nhận chức năng gọi).

Xem http://msdn.microsoft.com/en-us/l Library / system.diagnostics.stacktrace (VS.71) .aspx

Tôi đã sử dụng câu trả lời này cho hiệu quả tuyệt vời: Lấy thuộc tính, dưới dạng chuỗi, từ Biểu thức <Func <TModel, TProperty >>

Tôi nhận ra tôi đã trả lời câu hỏi này một thời gian trước. Ưu điểm duy nhất mà câu trả lời khác của tôi có là nó hoạt động cho các thuộc tính tĩnh. Tôi thấy cú pháp trong câu trả lời này hữu ích hơn nhiều vì bạn không phải tạo một biến loại bạn muốn phản ánh.

Tôi gặp một số khó khăn khi sử dụng các giải pháp đã được đề xuất cho trường hợp sử dụng cụ thể của mình, nhưng cuối cùng đã tìm ra nó. Tôi không nghĩ trường hợp cụ thể của tôi xứng đáng với một câu hỏi mới, vì vậy tôi sẽ đăng giải pháp của mình lên đây để tham khảo. (Điều này liên quan rất chặt chẽ đến câu hỏi và cung cấp giải pháp cho bất kỳ ai khác có trường hợp tương tự với tôi).

Mã tôi đã kết thúc với hình như thế này:

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

Phần quan trọng đối với tôi là trong CompanyControllớp, trình biên dịch sẽ chỉ cho phép tôi chọn một thuộc tính boolean ICompanyViewModelgiúp các nhà phát triển khác dễ dàng làm cho nó đúng hơn.

Sự khác biệt chính giữa giải pháp của tôi và câu trả lời được chấp nhận là lớp của tôi là chung chung và tôi chỉ muốn khớp các thuộc tính từ loại chung là boolean.

Đó là cách tôi triển khai nó, lý do đằng sau là nếu lớp mà bạn muốn lấy tên từ thành viên của nó không tĩnh thì bạn cần tạo một bản năng của nó và sau đó lấy tên của thành viên. rất chung chung ở đây để giúp đỡ

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

cách sử dụng là như thế này

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