Turėti nuosavybės vardą iš lambda išraiškos

Ar yra geresnis būdas gauti turto pavadinimą, kai jis perduodamas per lambda išraišką? Štai ką aš dabar turiu.

Pavyzdžiui.

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

Tai veikė, kai ją išreiškė nario išraiška tik tada, kai nuosavybė buvo eilutė. nes ne visos savybės yra stygos, kurias turėčiau naudoti, bet tada jis grąžino jiems neteisingą išraišką.

 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; } 
431
23 марта '09 в 4:24 2009-03-23 04:24 Schotime yra nustatytas kovo 23 d ., 09:24, 04:24 2009-03-23 ​​04:24
@ 18 atsakymų

Radau kitą būdą, kaip galėtumėte tai padaryti, buvo, kad šaltinis ir turtas būtų stipriai įvedami ir aiškiai nurodyti lambda įvestį. Nesu tikras, kad tai yra teisinga terminija, bet čia yra rezultatas.

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

Ir tada jį pavadinkite.

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

ir ji veikia.
Ačiū visiems.

161
23 марта '09 в 8:39 2009-03-23 08:39 atsakymą pateikė „ Schotime “ kovo 23 d., 08:39, 2009-03-23 ​​08:39

Neseniai sukūriau labai panašų „OnPropertyChanged“ tipo saugų metodą.

Čia yra metodas, kuris grąžina PropertyInfo objektą išraiškai. Jis išmeta išimtį, jei išraiška nėra nuosavybė.

 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 parametras naudojamas, kad kompiliatorius, atlikdamas metodą, galėtų atlikti tipo išvadą. Galite atlikti šiuos veiksmus.

 var propertyInfo = GetPropertyInfo(someUserObject, u => u.UserID); 
293
23 марта '09 в 7:14 2009-03-23 07:14 atsakė „ Cameron MacFarland “ kovo 23 d., 07:14, 2009-03-23 07:14

Aš žaidžiau su tuo pačiu dalyku ir dirbau. Ji nebuvo visiškai išbandyta, tačiau, atrodo, ji susiduria su problemos, susijusios su vertės tipais, problema (problema su neteisinga išraiška, su kuria susidūrėte)

 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; } 
131
26 мая '10 в 23:04 2010-05-26 23:04 atsakymą M Thelen pateikė gegužės 26 d. 10 d. 23:04 2010-05-26 23:04
 public string GetName<TSource, TField>(Expression<Func<TSource, TField>> Field) { return (Field.Body as MemberExpression ?? ((UnaryExpression)Field.Body).Operand as MemberExpression).Member.Name; } 

Jis tvarko nario ir vienašalius išraiškas. Skirtumas yra tas, kad gausite „ UnaryExpression jei jūsų išraiška atspindi vertės tipą, o gavote „ MemberExpression jei jūsų išraiška yra atskaitos tipas. Viskas gali būti perduodama objektui, tačiau vertės laukai turi būti patalpinti į dėžutę. Štai kodėl yra UnaryExpression. Nuoroda

Jei norite skaityti (@Jowen), čia yra išplėstas atitikmuo:

 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; } 
43
23 июня '12 в 20:27 2012-06-23 20:27 atsakymą pateikė Paulius Flemingas birželio 23 d. 12 d. 8:27 val. 2012-06-23 20:27

Kur jis ateina į „ Array . Nors ilgis rodomas kaip nuosavybė, negalite jo naudoti nė viename iš anksčiau siūlomų sprendimų.

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

Dabar naudokite pavyzdį:

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

Jei PropertyNameFromUnaryExpr ArrayLength „ArrayLength“, „someArray“ bus atspausdinta į konsolę (kompiliatorius, atrodo, sukuria tiesioginę prieigą prie „Backing Length“ lauko kaip optimizavimo, net ir „Debug“, todėl ypatingu atveju).

19
13 июня '12 в 2:11 2012-06-13 02:11 atsakymas pateikiamas kornman00 birželio 13 d. 12:11 2012-06-13 02:11

Tai yra bendras įgyvendinimas, leidžiantis laukų / savybių / indeksų / metodų / metodų / pratęsimo / struct / class / interface / delegate / array komandų pavadinimų pavadinimą. Aš išbandžiau su statinių / egzempliorių deriniais, o ne bendromis / bendromis parinktimis.

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

Šis elementas gali būti parašytas paprastu 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"); } } } 

Man patinka rekursinis požiūris, nors antrasis gali būti lengviau skaitomas. Jis gali būti vadinamas:

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

spausdinti paskutinį elementą.

Pastaba:

  • ABC tipo grandininių išraiškų atveju grąžinama „C“.

  • Tai neveikia su const s, masyvo indeksatoriais arba enum (neįmanoma apimti visų atvejų).

17
12 дек. Atsakymas pateikiamas nawfal 12 d. 2013-12-12 05:11 '13, 5:11, 2013-12-12 05:11

Čia atnaujinamas Cameron pasiūlytas metodas. Pirmasis parametras nereikalingas.

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

Galite atlikti šiuos veiksmus:

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

Plėtimo metodai:

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

Galite:

 SomeType someInstance = null; string propName = someInstance.NameOfProperty(i => i.Length); PropertyInfo propInfo = someInstance.GetPropertyInfo(i => i.Length); 
14
25 сент. atsakymą pateikė Adrianas 25 sep. 2014-09-25 06:39 '14 at 6:39 2014-09-25 06:39

dabar C # 6 galite naudoti tik pavadinimą , pvz., šį nameof(User.UserId)

kuris turi daug privalumų, tarp jų yra tai, kad tai daroma kompiliavimo metu , o ne vykdymo metu.

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

13
02 дек. Atsakymas duotas Maslow 02 Dec. 2015-12-02 20:10 '15, 8:10 pm 2015-12-02 20:10

Radau, kad kai kurie siūlomi atsakymai, kurie yra dislokuoti „ MemberExpression / UnaryExpression , nelaikomi įdėtos / sub-savybės.

ex) o => o.Thing1.Thing2 grąžina Thing1 , o ne Thing1.Thing2 .

Šis skirtumas yra svarbus, jei bandote dirbti su EntityFramework DbSet.Include(...) .

Radau, kad tiesiog analizuojant Expression.ToString() atrodo gerai ir gana greitai. Palyginau ją su UnaryExpression versija ir netgi gavęs Member/UnaryExpressionMember/UnaryExpression norėdami pamatyti, ar jis buvo greitesnis, bet skirtumas buvo nereikšmingas. Prašome ištaisyti mane, jei tai yra baisi idėja.

Pratęsimo metodas

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

(Ribotuvo patikrinimas gali būti net per didelis)

Demo („LinqPad“)

Demonstravimas + palyginimo kodas - https://gist.github.com/zaus/6992590

12
20 июня '13 в 21:09 2013-06-20 21:09 atsakymą pateikė drzaus birželio 20 d., 13 val., 21:09 val. 2013-06-20 21:09

Na, nereikia skambinti .Name.ToString() , bet plačiąja prasme tai yra apie jį, taip. Vienintelis dalykas, kurį jums reikia, yra tai, ar x.Foo.Bar grąžinti „Foo“, „Bar“ ar išimtis - tai yra, jums paprastai reikia kartoti.

(dar kartą komentuokite), jei norite gauti daugiau informacijos apie lanksčią rūšiavimą, žr.

5
23 марта '09 в 8:19 2009-03-23 08:19 atsakė Marc Gravellui kovo 23 d. 08:19, 2009-03-23 ​​08:19

Aš naudoju pratęsimo metodą, skirtą prieš C # 6 projektams, ir pavadinimą (), kad nukreiptumėte 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; } } 

Ir aš tai vadinu:

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

Jis puikiai tinka tiek laukams, tiek savybėms.

4
18 февр. atsakymas pateikiamas Kalitsov 18 vas . 2016-02-18 01:42 '16 at 1:42 2016-02-18 01:42

Tai dar vienas atsakymas:

 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; } 
3
02 янв. atsakymas pateiktas Memo 02 jan. 2015-01-02 03:44 '15 at 3:44 2015-01-02 03:44

INotifyPropertyChanged įgyvendinimą, panašų į toliau pateiktą metodą. Čia ypatybės yra saugomos pagrindinėje klasėje esančiame žodyne, kaip parodyta žemiau. Žinoma, ne visada pageidautina naudoti paveldėjimą, bet žiūrėjimo modeliams manau, kad tai priimtina, ir pateikti labai švarias nuorodas į savybes vaizdinio modelio klasėse.

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

Žemiau yra šiek tiek sudėtingesnė bazinė klasė. Jis tvarko vertimą iš lambda išraiškos į nuosavybės pavadinimą. Atkreipkite dėmesį, kad savybės yra tikrai pseudo-savybės, nes naudojami tik pavadinimai. Tačiau jis bus skaidrus peržiūros modelio ir nuosavybės nuorodų peržiūros modelyje.

 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; } 
3
11 мая '12 в 0:02 2012-05-11 00:02 atsakymas į dvasininką pateikiamas gegužės 12 d., 12 val. 0:02 2012-05-11 00:02

Aš sukūriau ObjectStateEntry objekto išplėtimo būdą, kad galėčiau pažymėti saugaus tipo modifikuotas savybes („POCO“ klasės „Entity Framework“ klasės), nes numatytasis metodas priima tik eilutę. Štai mano būdas gauti pavadinimą iš nuosavybės:

 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); } 
3
03 февр. Anderso atsakymas 03 vasaris 2011-02-03 12:34 '11 at 12:34 2011-02-03 12:34

Pradedant nuo .NET 4.0, galite naudoti „ ExpressionVisitor kad rastumėte savybes:

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

Štai kaip jūs naudojate šį lankytoją:

 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."); } 
1
20 окт. atsakymas pateikiamas dasblinkenlight 20 okt. 2017-10-20 18:47 '17 at 6:47 2017-10-20 18:47

Palieku šią funkciją, jei norite gauti laukus su keliomis reikšmėmis:

 /// <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); } 
1
25 июля '17 в 2:27 2017-07-25 02:27 atsakymą pateikė Carlos Bolivar , liepos 25 d. 17, 02:27 2017-07-25 02:27

Atnaujinau „ @Cameron“ atsakymą, kad būtų įtraukti kai kurie „ Convert įvestų lambda žodžių saugumo patikrinimai:

 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; } 
1
12 мая '17 в 10:20 2017-05-12 10:20 atsakymą pateikė Shimmy gegužės 12 d., „17, 10:20 2017-05-12 10:20

Čia yra dar vienas būdas gauti PropertyInfo pagal šį atsakymą. Tai pašalina objekto pavyzdžio poreikį.

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

Galite jį pavadinti taip:

 var propertyInfo = GetPropertyInfo((User u) => u.UserID); 
1
20 апр. Hans Vonn atsakymas, pateiktas balandžio 20 d 2017-04-20 15:00 '17 15:00 val