Tri par chaîne nom colonne

Question

J'ai une collection observable. Je veux utiliser linq pour le trier. J'ai le propertyname de la propriété que je veux trier (comme une chaîne) pour mon type.

Quelle est la meilleure façon de faire cela?

Différentes chaînes de propertyName seront passées dans la fonction

Answer 1

Vous pouvez trier en utilisant lambdas. Je copiais ce qui est dans la classe interne utilisée par le DataGrid:

 IEnumerable<T> sortedList = _list.ToArray<T>(); 

     foreach (SortDescription sortDescription in SortDescriptions) 
     { 
      PropertyInfo propertyInfo = typeof(T).GetProperty(sortDescription.PropertyName); 
      Func<T, object> keySelector = item => propertyInfo.GetValue(item, null); 

      switch (sortDescription.Direction) 
      { 
       case ListSortDirection.Ascending: 
        sortedList = sortedList.OrderBy(keySelector); 
        break; 
       case ListSortDirection.Descending: 
        sortedList = sortedList.OrderByDescending(keySelector); 
        break; 
       default: 
        continue; 
      } 
     } 

     T currentItem = _currentItem; 

Works tout à fait bien et mieux que d'essayer de trouver un IComparer.

Answer 2

Je n'ai jamais été en mesure de le faire à travers la réflexion.

var v = YouList.OrderBy(t => t.GetType().InvokeMember(sField, 
    System.Reflection.BindingFlags.GetProperty, 
    null, 
    t, 
    null) 
).ToList()); 

Je suppose le même code fonctionnera pour ObservableCollection ...

Answer 3

Vous devriez être en mesure de construire une expression de ce nom de la propriété et de passer à ce OrderBy:

public IEnumerable<MyData> orderByDynamic(IEnumerable<MyData> objects, string propertyName) 
{ 
    var parameterExpression = Expression.Parameter(typeof(MyData), "x"); 
    var orderByExpression = Expression.Lambda<Func<MyData, TypeOfProperty>>(
     Expression.Property(parameterExpression, propertyName), 
     parameterExpression);  
    return objects.OrderBy(orderByExpression) 
} 

Le problème est que vous devez connaître le type de la propriété au moment de la compilation pour que cela fonctionne.