Sorting a list using Lambda Linq to objects

Question

I have the name of the  sort by property  in a string  I will need to use Lambda Linq to sort the list of objects   Ex   public class Employee     public string FirstName  set  get     public string LastName  set  get     public DateTime DOB  set  get       public void Sort ref List lt Employee gt  list  string sortBy  string sortDirection        Example data      sortBy    FirstName      sortDirection    ASC  or  DESC     if  sortBy     FirstName           list   list OrderBy x   gt  x FirstName  toList                  Instead of using a bunch of ifs to check the fieldname  sortBy   is there a cleaner way of doing the sorting Is sort aware of datatype

User · Answer

Building the order by expression can be read here

Shamelessly stolen from the page in link:

// First we define the parameter that we are going to use
// in our OrderBy clause. This is the same as "(person =>"
// in the example above.
var param = Expression.Parameter(typeof(Person), "person");

// Now we'll make our lambda function that returns the
// "DateOfBirth" property by it's name.
var mySortExpression = Expression.Lambda<Func<Person, object>>(Expression.Property(param, "DateOfBirth"), param);

// Now I can sort my people list.
Person[] sortedPeople = people.OrderBy(mySortExpression).ToArray();

User · Answer

One thing you could do is change Sort so it makes better use of lambdas   public enum SortDirection   Ascending  Descending   public void Sort lt TKey gt  ref List lt Employee gt  list                         Func lt Employee  TKey gt  sorter  SortDirection direction      if  direction    SortDirection Ascending      list   list OrderBy sorter     else     list   list OrderByDescending sorter       Now you can specify the field to sort when calling the Sort method   Sort ref employees  e   gt  e DOB  SortDirection Descending

User · Answer

If you get sort column name and sort direction as string and don t want to use switch or if else syntax to determine column  then this example may be interesting for you   private readonly Dictionary lt string  Expression lt Func lt IuInternetUsers  object gt  gt  gt   sortColumns            new Dictionary lt string  Expression lt Func lt IuInternetUsers  object gt  gt  gt                    nameof ContactSearchItem Id               c   gt  c Id              nameof ContactSearchItem FirstName        c   gt  c FirstName              nameof ContactSearchItem LastName         c   gt  c LastName              nameof ContactSearchItem Organization     c   gt  c Company Company              nameof ContactSearchItem CustomerCode     c   gt  c Company Code              nameof ContactSearchItem Country          c   gt  c CountryNavigation Code              nameof ContactSearchItem City             c   gt  c City              nameof ContactSearchItem ModifiedDate     c   gt  c ModifiedDate                private IQueryable lt IuInternetUsers gt  SetUpSort IQueryable lt IuInternetUsers gt  contacts  string sort  string sortDir                if  string IsNullOrEmpty sort                         sort   nameof ContactSearchItem Id                       sortColumns TryGetValue sort  out var sortColumn           if  sortColumn    null                        sortColumn   c   gt  c Id                     if  string IsNullOrEmpty sortDir     sortDir    SortDirections AscendingSort                        contacts   contacts OrderBy sortColumn                     else                       contacts   contacts OrderByDescending sortColumn                      return contacts          Solution based on using Dictionary that connects needed for sort column via Expression  and its key string

User · Answer

Sort uses the IComparable interface  if the type implements it  And you can avoid the ifs by implementing a custom IComparer   class EmpComp   IComparer lt Employee gt        string fieldName      public EmpComp string fieldName                this fieldName   fieldName             public int Compare Employee x  Employee y                   compare x fieldName and y fieldName           and then   list Sort new EmpComp sortBy

User · Answer

The solution provided by Rashack does not work for value types  int  enums  etc   unfortunately   For it to work with any type of property  this is the solution I found   public static Expression lt Func lt T  object gt  gt  GetLambdaExpressionFor lt T gt  this string sortColumn                var type   typeof T           var parameterExpression   Expression Parameter type   x            var body   Expression PropertyOrField parameterExpression  sortColumn           var convertedBody   Expression MakeUnary ExpressionType Convert  body  typeof object             var expression   Expression Lambda lt Func lt T  object gt  gt  convertedBody  new     parameterExpression              return expression

User · Answer

This is how I solved my problem   List lt User gt  list   GetAllUsers       Private Method  if   sortAscending        list   list             OrderBy r   gt  r GetType   GetProperty sortBy  GetValue r null               ToList      else       list   list             OrderByDescending r   gt  r GetType   GetProperty sortBy  GetValue r null               ToList

User · Answer

You could use Reflection to get the value of the property   list   list OrderBy  x   gt  TypeHelper GetPropertyValue  x  sortBy                 ToList      Where TypeHelper has a static method like   public static class TypeHelper       public static object GetPropertyValue  object obj  string name                 return obj    null   null   obj GetType                                           GetProperty  name                                           GetValue  obj  null              You might also want to look at  Dynamic LINQ from the VS2008 Samples library   You could use the IEnumerable extension to cast the List as an IQueryable and then use the Dynamic link OrderBy extension    list   list AsQueryable   OrderBy  sortBy         sortDirection

User · Answer

Answer for 1    You should be able to manually build an expression tree that can be passed into OrderBy using the name as a string  Or you could use reflection as suggested in another answer  which might be less work   Edit  Here is a working example of building an expression tree manually   Sorting on X Value  when only knowing the name  Value  of the property   You could  should  build a generic method for doing it   using System  using System Linq  using System Linq Expressions   class Program       private static readonly Random rand   new Random        static void Main string   args                var randX   from n in Enumerable Range 0  100                      select new X   Value   rand Next 1000              ParameterExpression pe   Expression Parameter typeof X    value            var expression   Expression Property pe   Value            var exp   Expression Lambda lt Func lt X  int gt  gt  expression  pe  Compile             foreach  var n in randX OrderBy exp               Console WriteLine n Value              public class X               public int Value   get  set              Building an expression tree requires you to know the particpating types  however  That might or might not be a problem in your usage scenario  If you don t know what type you should be sorting on  it will propably be easier using reflection   Answer for 2    Yes  since Comparer lt T gt  Default will be used for the comparison  if you do not explicitly define the comparer

User · Answer

This can be done as  list Sort   emp1 emp2   gt emp1 FirstName CompareTo emp2 FirstName       The  NET framework is casting the lambda  emp1 emp2   gt int as a Comparer lt Employee gt    This has the advantage of being strongly typed

User · Answer

You could use reflection to access the property   public List lt Employee gt  Sort List lt Employee gt  list  String sortBy  String sortDirection       PropertyInfo property   list GetType   GetGenericArguments   0                                   GetType   GetProperty sortBy       if  sortDirection     ASC              return list OrderBy e   gt  property GetValue e  null            if  sortDirection     DESC              return list OrderByDescending e   gt  property GetValue e  null            else            throw new ArgumentOutOfRangeException             Notes   Why do you pass the list by reference  You should use a enum for the sort direction  You could get a much cleaner solution if you would pass a lambda expression  specifying the property to sort by instead of the property name as a string  In my example list    null will cause a NullReferenceException  you should catch this case

User · Answer

Adding to what  Samuel and  bluish did   This is much shorter as the Enum was unnecessary in this case   Plus as an added bonus when the Ascending is the desired result  you can pass only 2 parameters instead of 3 since true is the default answer to the third parameter   public void Sort lt TKey gt  ref List lt Person gt  list  Func lt Person  TKey gt  sorter  bool isAscending   true        list   isAscending   list OrderBy sorter    list OrderByDescending sorter

User · Answer

using System  using System Collections Generic  using System Linq  using System Reflection  using System Linq Expressions   public static class EnumerableHelper        static MethodInfo orderBy   typeof Enumerable  GetMethods BindingFlags Static   BindingFlags Public  Where x   gt  x Name     OrderBy   amp  amp  x GetParameters   Length    2  First         public static IEnumerable lt TSource gt  OrderBy lt TSource gt  this IEnumerable lt TSource gt  source  string propertyName                var pi   typeof TSource  GetProperty propertyName  BindingFlags Public   BindingFlags FlattenHierarchy   BindingFlags Instance           var selectorParam   Expression Parameter typeof TSource    keySelector            var sourceParam   Expression Parameter typeof IEnumerable lt TSource gt     source            return              Expression Lambda lt Func lt IEnumerable lt TSource gt   IOrderedEnumerable lt TSource gt  gt  gt                                Expression Call                                       orderBy MakeGenericMethod typeof TSource   pi PropertyType                        sourceParam                       Expression Lambda                                               typeof Func lt   gt   MakeGenericType typeof TSource   pi PropertyType                            Expression Property selectorParam  pi                            selectorParam                                                           sourceParam                            Compile   source              public static IEnumerable lt TSource gt  OrderBy lt TSource gt  this IEnumerable lt TSource gt  source  string propertyName  bool ascending                return ascending   source OrderBy propertyName    source OrderBy propertyName  Reverse               Another one  this time for any IQueryable   using System  using System Linq  using System Linq Expressions  using System Reflection   public static class IQueryableHelper        static MethodInfo orderBy   typeof Queryable  GetMethods BindingFlags Static   BindingFlags Public  Where x   gt  x Name     OrderBy   amp  amp  x GetParameters   Length    2  First        static MethodInfo orderByDescending   typeof Queryable  GetMethods BindingFlags Static   BindingFlags Public  Where x   gt  x Name     OrderByDescending   amp  amp  x GetParameters   Length    2  First         public static IQueryable lt TSource gt  OrderBy lt TSource gt  this IQueryable lt TSource gt  source  params string   sortDescriptors                return sortDescriptors Length  gt  0   source OrderBy sortDescriptors  0    source             static IQueryable lt TSource gt  OrderBy lt TSource gt  this IQueryable lt TSource gt  source  string   sortDescriptors  int index                if  index  lt  sortDescriptors Length - 1  source   source OrderBy sortDescriptors  index   1           string   splitted   sortDescriptors index  Split               var pi   typeof TSource  GetProperty splitted 0   BindingFlags Public   BindingFlags FlattenHierarchy   BindingFlags Instance   BindingFlags IgnoreCase           var selectorParam   Expression Parameter typeof TSource    keySelector            return source Provider CreateQuery lt TSource gt  Expression Call  splitted Length  gt  1  amp  amp  string Compare splitted 1    desc   StringComparison Ordinal     0   orderByDescending   orderBy  MakeGenericMethod typeof TSource   pi PropertyType   source Expression  Expression Lambda typeof Func lt   gt   MakeGenericType typeof TSource   pi PropertyType   Expression Property selectorParam  pi   selectorParam                You can pass multiple sort criteria  like this   var q   dc Felhasznalos OrderBy new string      Email    FelhasznaloID desc

[c#] Sorting a list using Lambda/Linq to objects

Examples related to c#

Examples related to linq

Examples related to lambda

Examples related to linq-to-objects