استرجاع اسم الخاصية من التعبير امدا

Question

هل هناك طريقة أفضل للحصول على اسم الخاصية عندما مرت عبر امدا التعبير ؟ هذا ما لدي حاليا.

على سبيل المثال.

GetSortingInfo<User>(u => u.UserId);

عملت قبل الصب أنها memberexpression فقط عندما كانت الملكية سلسلة.لأن ليس كل خصائص السلاسل اضطررت لاستخدام كائن ولكن بعد ذلك سيعود unaryexpression لأولئك.

public static RouteValueDictionary GetInfo<T>(this HtmlHelper html, 
    Expression<Func<T, object>> action) where T : class
{
    var expression = GetMemberInfo(action);
    string name = expression.Member.Name;

    return GetInfo(html, name);
}

private static MemberExpression GetMemberInfo(Expression method)
{
    LambdaExpression lambda = method as LambdaExpression;
    if (lambda == null)
        throw new ArgumentNullException("method");

    MemberExpression memberExpr = null;

    if (lambda.Body.NodeType == ExpressionType.Convert)
    {
        memberExpr = 
            ((UnaryExpression)lambda.Body).Operand as MemberExpression;
    }
    else if (lambda.Body.NodeType == ExpressionType.MemberAccess)
    {
        memberExpr = lambda.Body as MemberExpression;
    }

    if (memberExpr == null)
        throw new ArgumentException("method");

    return memberExpr;
}

Answer 1

ولقد وجدت طريقة أخرى يمكنك القيام به ما كان لديها مصدر والممتلكات كتبته بقوة ونستنتج بوضوح المدخلات لامدا. لست متأكدا إذا كان هذا هو المصطلح الصحيح ولكن هنا هو النتيجة.

public static RouteValueDictionary GetInfo<T,P>(this HtmlHelper html, Expression<Func<T, P>> action) where T : class
{
    var expression = (MemberExpression)action.Body;
    string name = expression.Member.Name;

    return GetInfo(html, name);
}

وبعد ذلك يطلق عليه مثل ذلك.

GetInfo((User u) => u.UserId);

ووفويلا يعمل.
بفضل جميع.

Answer 2

وأنا في الآونة الأخيرة فعلت شيئا مشابها جدا لجعل نوع طريقة OnPropertyChanged آمن.

إليك طريقة التي سوف تعود الكائن PropertyInfo للتعبير. فإنه يطرح استثناء إذا كان التعبير ليس الممتلكات.

public PropertyInfo GetPropertyInfo<TSource, TProperty>(
    TSource source,
    Expression<Func<TSource, TProperty>> propertyLambda)
{
    Type type = typeof(TSource);

    MemberExpression member = propertyLambda.Body as MemberExpression;
    if (member == null)
        throw new ArgumentException(string.Format(
            "Expression '{0}' refers to a method, not a property.",
            propertyLambda.ToString()));

    PropertyInfo propInfo = member.Member as PropertyInfo;
    if (propInfo == null)
        throw new ArgumentException(string.Format(
            "Expression '{0}' refers to a field, not a property.",
            propertyLambda.ToString()));

    if (type != propInfo.ReflectedType &&
        !type.IsSubclassOf(propInfo.ReflectedType))
        throw new ArgumentException(string.Format(
            "Expression '{0}' refers to a property that is not from type {1}.",
            propertyLambda.ToString(),
            type));

    return propInfo;
}

ويستخدم المعلمة source ذلك المجمع يمكن أن يفعله نوع الاستدلال على استدعاء الأسلوب. يمكنك أن تفعل ما يلي

var propertyInfo = GetPropertyInfo(someUserObject, u => u.UserID);

Answer 3

وكنت ألعب مع حولها الشيء نفسه، وعملت هذا الأمر. ليست اختبارها بشكل كامل ولكن يبدو أن التعامل مع هذه المسألة مع أنواع القيمة (القضية unaryexpression التي واجهت)

public static string GetName(Expression<Func<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;
}

Answer 4

public string GetName<TSource, TField>(Expression<Func<TSource, TField>> Field)
{
    return (Field.Body as MemberExpression ?? ((UnaryExpression)Field.Body).Operand as MemberExpression).Member.Name;
}

وهذا يعالج الأعضاء وتعبيرات الأحادية. والفرق بينهما أن ستحصل على UnaryExpression إذا تعبيركم يمثل نوع القيمة في حين ستحصل على MemberExpression إذا تعبيركم يمثل نوع مرجع. كل شيء يمكن أن يلقي إلى كائن، ولكن يجب أن يكون محاصر أنواع القيمة. وهذا هو السبب في وجود هذا UnaryExpression. المرجعي.

للأجلكم من القراءة (Jowen)، وهنا ما يعادل موسع:

public string GetName<TSource, TField>(Expression<Func<TSource, TField>> Field)
{
    if (object.Equals(Field, null))
    {
        throw new NullReferenceException("Field is required");
    }

    MemberExpression expr = null;

    if (Field.Body is MemberExpression)
    {
        expr = (MemberExpression)Field.Body;
    }
    else if (Field.Body is UnaryExpression)
    {
        expr = (MemberExpression)((UnaryExpression)Field.Body).Operand;
    }
    else
    {
        const string Format = "Expression '{0}' not supported.";
        string message = string.Format(Format, Field);

        throw new ArgumentException(message, "Field");
    }

    return expr.Member.Name;
}

Answer 5

والآن في C # 6 يمكنك ببساطة استخدام ناميوف مثل هذا nameof(User.UserId)

والذي له فوائد عديدة، من بينها هو أن يتم ذلك في وقت الترجمة ، وليس وقت التشغيل.

https://msdn.microsoft.com/en-us/magazine/ dn802602.aspx

Answer 6

ومع C # 7 نمط مطابقة:

public static string GetMemberName<T>(this Expression<T> expression)
{
    switch (expression.Body)
    {
        case MemberExpression m:
            return m.Member.Name;
        case UnaryExpression u when u.Operand is MemberExpression m:
            return m.Member.Name;
        default:
            throw new NotImplementedException(expression.GetType().ToString());
    }
}

مثال:

public static RouteValueDictionary GetInfo<T>(this HtmlHelper html, 
    Expression<Func<T, object>> action) where T : class
{
    var name = action.GetMemberName();
    return GetInfo(html, name);
}

Answer 7

هذا هو التنفيذ العامة للحصول على اسم سلسلة من الحقول/خصائص/والمفهرسات/أساليب/طرق الإرشاد/مندوبين من البنية/الطبقة/واجهة/مندوب/مجموعة.لقد اختبرت مع تركيبات ثابتة/سبيل المثال و غير عام/عام المتغيرات.

//involves recursion
public static string GetMemberName(this LambdaExpression memberSelector)
{
    Func<Expression, string> nameSelector = null;  //recursive func
    nameSelector = e => //or move the entire thing to a separate recursive method
    {
        switch (e.NodeType)
        {
            case ExpressionType.Parameter:
                return ((ParameterExpression)e).Name;
            case ExpressionType.MemberAccess:
                return ((MemberExpression)e).Member.Name;
            case ExpressionType.Call:
                return ((MethodCallExpression)e).Method.Name;
            case ExpressionType.Convert:
            case ExpressionType.ConvertChecked:
                return nameSelector(((UnaryExpression)e).Operand);
            case ExpressionType.Invoke:
                return nameSelector(((InvocationExpression)e).Expression);
            case ExpressionType.ArrayLength:
                return "Length";
            default:
                throw new Exception("not a proper member selector");
        }
    };

    return nameSelector(memberSelector.Body);
}

هذا الشيء يمكن أن تكون مكتوبة بطريقة بسيطة while حلقة جدا:

//iteration based
public static string GetMemberName(this LambdaExpression memberSelector)
{
    var currentExpression = memberSelector.Body;

    while (true)
    {
        switch (currentExpression.NodeType)
        {
            case ExpressionType.Parameter:
                return ((ParameterExpression)currentExpression).Name;
            case ExpressionType.MemberAccess:
                return ((MemberExpression)currentExpression).Member.Name;
            case ExpressionType.Call:
                return ((MethodCallExpression)currentExpression).Method.Name;
            case ExpressionType.Convert:
            case ExpressionType.ConvertChecked:
                currentExpression = ((UnaryExpression)currentExpression).Operand;
                break;
            case ExpressionType.Invoke:
                currentExpression = ((InvocationExpression)currentExpression).Expression;
                break;
            case ExpressionType.ArrayLength:
                return "Length";
            default:
                throw new Exception("not a proper member selector");
        }
    }
}

أنا أحب العودية النهج ، ولو ثانية واحدة قد تكون أسهل في القراءة.واحد يمكن أن يطلق عليه مثل:

someExpr = x => x.Property.ExtensionMethod()[0]; //or
someExpr = x => Static.Method().Field; //or
someExpr = x => VoidMethod(); //or
someExpr = () => localVariable; //or
someExpr = x => x; //or
someExpr = x => (Type)x; //or
someExpr = () => Array[0].Delegate(null); //etc

string name = someExpr.GetMemberName();

طباعة آخر عضو.

ملاحظة:

1. في حالة بالسلاسل عبارات مثل A.B.C, "ج" هو عاد.

2. هذا لا يعمل مع consts, مجموعة والمفهرسات أو enums (من المستحيل تغطية جميع الحالات).

Answer 8

وهناك حالة حافة عندما يتعلق الأمر Array.Length. في حين يتعرض "طول" كخاصية، لا يمكن استخدامه في أي من الحلول المقترحة سابقا.

using Contract = System.Diagnostics.Contracts.Contract;
using Exprs = System.Linq.Expressions;

static string PropertyNameFromMemberExpr(Exprs.MemberExpression expr)
{
    return expr.Member.Name;
}

static string PropertyNameFromUnaryExpr(Exprs.UnaryExpression expr)
{
    if (expr.NodeType == Exprs.ExpressionType.ArrayLength)
        return "Length";

    var mem_expr = expr.Operand as Exprs.MemberExpression;

    return PropertyNameFromMemberExpr(mem_expr);
}

static string PropertyNameFromLambdaExpr(Exprs.LambdaExpression expr)
{
         if (expr.Body is Exprs.MemberExpression)   return PropertyNameFromMemberExpr(expr.Body as Exprs.MemberExpression);
    else if (expr.Body is Exprs.UnaryExpression)    return PropertyNameFromUnaryExpr(expr.Body as Exprs.UnaryExpression);

    throw new NotSupportedException();
}

public static string PropertyNameFromExpr<TProp>(Exprs.Expression<Func<TProp>> expr)
{
    Contract.Requires<ArgumentNullException>(expr != null);
    Contract.Requires<ArgumentException>(expr.Body is Exprs.MemberExpression || expr.Body is Exprs.UnaryExpression);

    return PropertyNameFromLambdaExpr(expr);
}

public static string PropertyNameFromExpr<T, TProp>(Exprs.Expression<Func<T, TProp>> expr)
{
    Contract.Requires<ArgumentNullException>(expr != null);
    Contract.Requires<ArgumentException>(expr.Body is Exprs.MemberExpression || expr.Body is Exprs.UnaryExpression);

    return PropertyNameFromLambdaExpr(expr);
}

والآن مثلا الاستعمال:

int[] someArray = new int[1];
Console.WriteLine(PropertyNameFromExpr( () => someArray.Length ));

إذا PropertyNameFromUnaryExpr لم يتم التحقق من ArrayLength "someArray" سيتم طباعتها إلى وحدة التحكم (يبدو مترجم لتوليد الوصول المباشر إلى طول بدعم <م> الحقل ، باعتبارها الأمثل، حتى في التصحيح، وبالتالي حالة خاصة).

Answer 9

هنا تحديث الطريقة المقترحة من قبل كاميرون.المعلمة الأولى هو غير مطلوب.

public PropertyInfo GetPropertyInfo<TSource, TProperty>(
    Expression<Func<TSource, TProperty>> propertyLambda)
{
    Type type = typeof(TSource);

    MemberExpression member = propertyLambda.Body as MemberExpression;
    if (member == null)
        throw new ArgumentException(string.Format(
            "Expression '{0}' refers to a method, not a property.",
            propertyLambda.ToString()));

    PropertyInfo propInfo = member.Member as PropertyInfo;
    if (propInfo == null)
        throw new ArgumentException(string.Format(
            "Expression '{0}' refers to a field, not a property.",
            propertyLambda.ToString()));

    if (type != propInfo.ReflectedType &&
        !type.IsSubclassOf(propInfo.ReflectedType))
        throw new ArgumentException(string.Format(
            "Expresion '{0}' refers to a property that is not from type {1}.",
            propertyLambda.ToString(),
            type));

    return propInfo;
}

يمكنك القيام بما يلي:

var propertyInfo = GetPropertyInfo<SomeType>(u => u.UserID);
var propertyInfo = GetPropertyInfo((SomeType u) => u.UserID);

أساليب الإرشاد:

public static PropertyInfo GetPropertyInfo<TSource, TProperty>(this TSource source,
    Expression<Func<TSource, TProperty>> propertyLambda) where TSource : class
{
    return GetPropertyInfo(propertyLambda);
}

public static string NameOfProperty<TSource, TProperty>(this TSource source,
    Expression<Func<TSource, TProperty>> propertyLambda) where TSource : class
{
    PropertyInfo prodInfo = GetPropertyInfo(propertyLambda);
    return prodInfo.Name;
}

يمكنك:

SomeType someInstance = null;
string propName = someInstance.NameOfProperty(i => i.Length);
PropertyInfo propInfo = someInstance.GetPropertyInfo(i => i.Length);

Answer 10

لقد وجدت أن بعض الاجابات المقترحة الذي انتقل لأسفل إلى MemberExpression/UnaryExpression لا التقاط متداخلة/subproperties.

السابق) o => o.Thing1.Thing2 يعود Thing1 بدلا من Thing1.Thing2.

هذا التمييز مهم إذا كنت في محاولة للعمل مع EntityFramework DbSet.Include(...).

لقد وجدت أن مجرد تحليل Expression.ToString() يبدو أن تعمل بشكل جيد و بسرعة نسبيا.أنا مع ضد UnaryExpression الإصدار ، وحتى الحصول على ToString الخروج من Member/UnaryExpression لمعرفة ما إذا كان ذلك أسرع, ولكن الفرق لا يكاد يذكر.يرجى تصحيح لي إذا كان هذا هو فكرة سيئة.

طريقة التمديد

/// <summary>
/// Given an expression, extract the listed property name; similar to reflection but with familiar LINQ+lambdas.  Technique @via https://stackoverflow.com/a/16647343/1037948
/// </summary>
/// <remarks>Cheats and uses the tostring output -- Should consult performance differences</remarks>
/// <typeparam name="TModel">the model type to extract property names</typeparam>
/// <typeparam name="TValue">the value type of the expected property</typeparam>
/// <param name="propertySelector">expression that just selects a model property to be turned into a string</param>
/// <param name="delimiter">Expression toString delimiter to split from lambda param</param>
/// <param name="endTrim">Sometimes the Expression toString contains a method call, something like "Convert(x)", so we need to strip the closing part from the end</param>
/// <returns>indicated property name</returns>
public static string GetPropertyName<TModel, TValue>(this Expression<Func<TModel, TValue>> propertySelector, char delimiter = '.', char endTrim = ')') {

    var asString = propertySelector.ToString(); // gives you: "o => o.Whatever"
    var firstDelim = asString.IndexOf(delimiter); // make sure there is a beginning property indicator; the "." in "o.Whatever" -- this may not be necessary?

    return firstDelim < 0
        ? asString
        : asString.Substring(firstDelim+1).TrimEnd(endTrim);
}//--   fn  GetPropertyNameExtended

(فحص محدد بل قد يكون مبالغة)

Demo (LinqPad)

مظاهرة + المقارنة رمز -- https://gist.github.com/zaus/6992590

Answer 11

وأنا "م باستخدام طريقة تمديد لمرحلة ما قبل C # 6 مشاريع و ناميوف ( ) للحصول على تلك التي تستهدف C # 6.

public static class MiscExtentions
{
    public static string NameOf<TModel, TProperty>(this object @object, Expression<Func<TModel, TProperty>> propertyExpression)
    {
        var expression = propertyExpression.Body as MemberExpression;
        if (expression == null)
        {
            throw new ArgumentException("Expression is not a property.");
        }

        return expression.Member.Name;
    }
}

وأنا أسميها مثل:

public class MyClass 
{
    public int Property1 { get; set; }
    public string Property2 { get; set; }
    public int[] Property3 { get; set; }
    public Subclass Property4 { get; set; }
    public Subclass[] Property5 { get; set; }
}

public class Subclass
{
    public int PropertyA { get; set; }
    public string PropertyB { get; set; }
}

// result is Property1
this.NameOf((MyClass o) => o.Property1);
// result is Property2
this.NameOf((MyClass o) => o.Property2);
// result is Property3
this.NameOf((MyClass o) => o.Property3);
// result is Property4
this.NameOf((MyClass o) => o.Property4);
// result is PropertyB
this.NameOf((MyClass o) => o.Property4.PropertyB);
// result is Property5
this.NameOf((MyClass o) => o.Property5);

وأنه يعمل بشكل جيد مع كل الحقول والممتلكات.

Answer 12

حسنا، ليس هناك حاجة لاستدعاء .Name.ToString()، ولكن على نطاق واسع هذا هو عن ذلك، نعم. الاعتبار الوحيد قد تحتاج هو ما إذا كان x.Foo.Bar يجب أن تعود "فو"، "بار"، أو استثناء - أي هل تحتاج إلى تكرار في كل

و(إعادة تعليق) لمعرفة المزيد عن الفرز مرونة، انظر> وأ href = "http://groups.google.com/group/microsoft.public.dotnet.languages.csharp/msg/7d931ec0e2356d21" يختلط = "noreferrer" > هنا .

Answer 13

وأنا خلقت طريقة التمديد على ObjectStateEntry لتكون قادرة على خصائص العلم (الطبقات إطار الكيان POCO) بصيغتها المعدلة بطريقة آمنة نوع، لأن الأسلوب الافتراضي لا يقبل إلا سلسلة. وهنا قال لي طريقة للحصول على اسم من الملكية:

public static void SetModifiedProperty<T>(this System.Data.Objects.ObjectStateEntry state, Expression<Func<T>> action)
{
    var body = (MemberExpression)action.Body;
    string propertyName = body.Member.Name;

    state.SetModifiedProperty(propertyName);
}

Answer 14

ولقد فعلت تنفيذ INotifyPropertyChanged على غرار الأسلوب أدناه. هنا يتم تخزين الخصائص في القاموس في الفئة الأساسية هو مبين أدناه. وبطبيعة الحال لم يكن دائما المستحسن استخدام الميراث، ولكن لعرض نماذج وأعتقد أنه مقبول ويعطي إشارات الملكية نظيفة جدا في الطبقات عرض النموذج.

public class PhotoDetailsViewModel
    : PropertyChangedNotifierBase<PhotoDetailsViewModel>
{
    public bool IsLoading
    {
        get { return GetValue(x => x.IsLoading); }
        set { SetPropertyValue(x => x.IsLoading, value); }
    }

    public string PendingOperation
    {
        get { return GetValue(x => x.PendingOperation); }
        set { SetPropertyValue(x => x.PendingOperation, value); }
    }

    public PhotoViewModel Photo
    {
        get { return GetValue(x => x.Photo); }
        set { SetPropertyValue(x => x.Photo, value); }
    }
}

وهو مبين أدناه الفئة الأساسية إلى حد ما أكثر تعقيدا. وهو يتولى الترجمة من التعبير امدا إلى اسم الخاصية. لاحظ أن الخصائص هي حقا خصائص الزائفة حيث يتم استخدام أسماء فقط. ولكنها سوف تظهر شفافة لنموذج الرأي ويشير إلى الخصائص على نموذج الرأي.

public class PropertyChangedNotifierBase<T> : INotifyPropertyChanged
{
    readonly Dictionary<string, object> _properties = new Dictionary<string, object>();

    protected U GetValue<U>(Expression<Func<T, U>> property)
    {
        var propertyName = GetPropertyName(property);

        return GetValue<U>(propertyName);
    }

    private U GetValue<U>(string propertyName)
    {
        object value;

        if (!_properties.TryGetValue(propertyName, out value))
        {
            return default(U);
        }

        return (U)value;
    }

    protected void SetPropertyValue<U>(Expression<Func<T, U>> property, U value)
    {
        var propertyName = GetPropertyName(property);

        var oldValue = GetValue<U>(propertyName);

        if (Object.ReferenceEquals(oldValue, value))
        {
            return;
        }
        _properties[propertyName] = value;

        RaisePropertyChangedEvent(propertyName);
    }

    protected void RaisePropertyChangedEvent<U>(Expression<Func<T, U>> property)
    {
        var name = GetPropertyName(property);
        RaisePropertyChangedEvent(name);
    }

    protected void RaisePropertyChangedEvent(string propertyName)
    {
        if (PropertyChanged != null)
        {
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }
    }

    private static string GetPropertyName<U>(Expression<Func<T, U>> property)
    {
        if (property == null)
        {
            throw new NullReferenceException("property");
        }

        var lambda = property as LambdaExpression;

        var memberAssignment = (MemberExpression) lambda.Body;
        return memberAssignment.Member.Name;
    }

    public event PropertyChangedEventHandler PropertyChanged;
}

Answer 15

وهذا هو جواب آخر:

public static string GetPropertyName<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper,
                                                                      Expression<Func<TModel, TProperty>> expression)
    {
        var metaData = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);

        return metaData.PropertyName;
    }

Answer 16

أترك هذه الوظيفة إذا كنت ترغب في الحصول على مضاعفات المجالات:

/// <summary>
    /// Get properties separated by , (Ex: to invoke 'd => new { d.FirstName, d.LastName }')
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="exp"></param>
    /// <returns></returns>
    public static string GetFields<T>(Expression<Func<T, object>> exp)
    {
        MemberExpression body = exp.Body as MemberExpression;
        var fields = new List<string>();
        if (body == null)
        {
            NewExpression ubody = exp.Body as NewExpression;
            if (ubody != null)
                foreach (var arg in ubody.Arguments)
                {
                    fields.Add((arg as MemberExpression).Member.Name);
                }
        }

        return string.Join(",", fields);
    }

Answer 17

وهنا هو طريقة أخرى للحصول على هذه الإجابة. ويلغي الحاجة إلى مثيل كائن.

/// <summary>
/// Get metadata of property referenced by expression. Type constrained.
/// </summary>
public static PropertyInfo GetPropertyInfo<TSource, TProperty>(Expression<Func<TSource, TProperty>> propertyLambda)
{
    return GetPropertyInfo((LambdaExpression) propertyLambda);
}

/// <summary>
/// Get metadata of property referenced by expression.
/// </summary>
public static PropertyInfo GetPropertyInfo(LambdaExpression propertyLambda)
{
    // https://stackoverflow.com/questions/671968/retrieving-property-name-from-lambda-expression
    MemberExpression member = propertyLambda.Body as MemberExpression;
    if (member == null)
        throw new ArgumentException(string.Format(
            "Expression '{0}' refers to a method, not a property.",
            propertyLambda.ToString()));

    PropertyInfo propInfo = member.Member as PropertyInfo;
    if (propInfo == null)
        throw new ArgumentException(string.Format(
            "Expression '{0}' refers to a field, not a property.",
            propertyLambda.ToString()));

    if(propertyLambda.Parameters.Count() == 0)
        throw new ArgumentException(String.Format(
            "Expression '{0}' does not have any parameters. A property expression needs to have at least 1 parameter.",
            propertyLambda.ToString()));

    var type = propertyLambda.Parameters[0].Type;
    if (type != propInfo.ReflectedType &&
        !type.IsSubclassOf(propInfo.ReflectedType))
        throw new ArgumentException(String.Format(
            "Expression '{0}' refers to a property that is not from type {1}.",
            propertyLambda.ToString(),
            type));
    return propInfo;
}

ويمكن أن يسمى مثل ذلك:

var propertyInfo = GetPropertyInfo((User u) => u.UserID);

Answer 18

ولقد تحديث @ كاميرون الجواب لتشمل بعض الشيكات السلامة ضد Convert كتابة تعبيرات لامدا:

PropertyInfo GetPropertyName<TSource, TProperty>(
Expression<Func<TSource, TProperty>> propertyLambda)
{
  var body = propertyLambda.Body;
  if (!(body is MemberExpression member)
    && !(body is UnaryExpression unary
      && (member = unary.Operand as MemberExpression) != null))
    throw new ArgumentException($"Expression '{propertyLambda}' " +
      "does not refer to a property.");

  if (!(member.Member is PropertyInfo propInfo))
    throw new ArgumentException($"Expression '{propertyLambda}' " +
      "refers to a field, not a property.");

  var type = typeof(TSource);
  if (!propInfo.DeclaringType.GetTypeInfo().IsAssignableFrom(type.GetTypeInfo()))
    throw new ArgumentException($"Expresion '{propertyLambda}' " + 
      "refers to a property that is not from type '{type}'.");

  return propInfo;
}

Answer 19

وبدءا NET 4.0 يمكنك استخدام <لأ href = "https://msdn.microsoft.com/en-us/library/system.linq.expressions.expressionvisitor(v=vs.110).aspx" يختلط = "نوفولو noreferrer"> ExpressionVisitor لتجد العقار:

class ExprVisitor : ExpressionVisitor {
    public bool IsFound { get; private set; }
    public string MemberName { get; private set; }
    public Type MemberType { get; private set; }
    protected override Expression VisitMember(MemberExpression node) {
        if (!IsFound && node.Member.MemberType == MemberTypes.Property) {
            IsFound = true;
            MemberName = node.Member.Name;
            MemberType = node.Type;
        }
        return base.VisitMember(node);
    }
}

وهنا هو كيف يمكنك استخدام هذا الزائر:

var visitor = new ExprVisitor();
visitor.Visit(expr);
if (visitor.IsFound) {
    Console.WriteLine("First property in the expression tree: Name={0}, Type={1}", visitor.MemberName, visitor.MemberType.FullName);
} else {
    Console.WriteLine("No properties found.");
}