Generic Sorting with LINQ and Lambda Expressions

/// <summary>
/// The direction that we are to sort an IEnumerable collection.
/// </summary>
public enum SortDirection
{
   /// <summary>
   /// Sort ascending.
   /// </summary>
   Ascending,
   /// <summary>
   /// Sort descending.
   /// </summary>
   Descending
}

   /// <summary>
   /// Extension method to sort dynamically based on a attribute referenced by a string.
   /// </summary>
   /// <typeparam name="T">The type of the IEnumerable collection we are working with.</typeparam>
   /// <param name="source">The source collection.</param>
   /// <param name="attribute">The name of the attribute.</param>
   /// <param name="sortDirection">The direction to perform the sort.</param>
   public static IEnumerable<T> Sort<T>(this IEnumerable<T> source, string attribute, SortDirection sortDirection)
   {
      var param = Expression.Parameter(typeof(T), "item");

      var sortExpression = Expression.Lambda<Func<T, object>>
      (
         Expression.Convert
         (
            Expression.Property(param, attribute),
            typeof(object)
         ),
         param
      );

      switch (sortDirection)
      {
         case SortDirection.Ascending:
         {
            return source.AsQueryable().OrderBy<T, object>(sortExpression);
         }

         default:
         {
            return source.AsQueryable().OrderByDescending<T, object>(sortExpression);
         }
      }
   }

class MyObject
{
   public int Value { get; set; }
}

List<MyObject> list = new List<MyObject>();

list.Add(new MyObject(50));
list.Add(new MyObject(20));
list.Add(new MyObject(60));
list.Add(new MyObject(20));
list.Add(new MyObject(10));
list.Add(new MyObject(40));
list.Add(new MyObject(30));

var sorted = list.Sort("Value", SortDirection.Ascending);

/// <summary>
/// Extension method to sort dynamically based on a attribute referenced by a string.
/// </summary>
/// <typeparam name="T">The type of the IEnumerable collection we are working with.</typeparam>
/// <param name="source">The source collection.</param>
/// <param name="attributes">A dictionary containing the attributes and sort directions.</param>
/// <remarks>Suitable for small collections.</remarks>
public static IEnumerable<T> Sort<T>(this IEnumerable<T> source, Dictionary<string, SortDirection> attributes)
{
   // result (initialize with the source)
   IEnumerable<T> result = source;

   // precedence is defined by the order of the dictionary
   foreach (string attribute in attributes.Keys)
   {
      result = result.Sort(attribute, attributes[attribute]);
   }

   return result;
}

public static class Extensions
{
    private enum SortDirection
    {
        Ascending,
        Descending,
    }

    public static IOrderedQueryable<T> OrderBy<T>( this IEnumerable<T> source, string sortBy )
    {
        return source.OrderBy( sortBy, SortDirection.Ascending );
    }

    public static IOrderedQueryable<T> OrderByDecending<T>( this IEnumerable<T> source, string sortBy )
    {
        return source.OrderBy( sortBy, SortDirection.Descending );
    }

    private static IOrderedQueryable<T> OrderBy<T>( this IEnumerable<T> source, string sortBy, SortDirection sortDirection )
    {
        var sortExpression = GetExpression<T>( sortBy );

        switch( sortDirection )
        {
            case SortDirection.Ascending:
                return source.AsQueryable<T>().OrderBy<T, object>( sortExpression );

            default:
                return source.AsQueryable<T>().OrderByDescending<T, object>( sortExpression );

        }
    }

    public static IOrderedQueryable<T> ThenBy<T>( this IOrderedQueryable<T> source, string sortBy )
    {
        return source.ThenBy( sortBy, SortDirection.Ascending );
    }

    public static IOrderedQueryable<T> ThenByDescending<T>( this IOrderedQueryable<T> source, string sortBy )
    {
        return source.ThenBy( sortBy, SortDirection.Descending );
    }

    private static IOrderedQueryable<T> ThenBy<T>( this IOrderedQueryable<T> source, string sortBy, SortDirection sortDirection )
    {
        var sortExpression = GetExpression<T>( sortBy );

        switch( sortDirection )
        {
            case SortDirection.Ascending:
                return source.ThenBy<T, object>( sortExpression );

            default:
                return source.ThenByDescending<T, object>( sortExpression );

        }
    }

    private static Expression<Func<T, object>> GetExpression<T>( string sortBy )
    {
        var param = Expression.Parameter( typeof( T ), "item" );

        return Expression.Lambda<Func<T, object>>( Expression.Convert( Expression.Property( param, sortBy ), typeof( object ) ), param );
    }
}

public class MyObject
{
    public string Value
    {
        get;
        set;
    }

    public int Secondary
    {
        get;
        set;
    }
}

List<MyObject> array = new List<MyObject>
{
    new MyObject{ Value = "1", Secondary = 1 },
    new MyObject{ Value = "2", Secondary = 2 },
    new MyObject{ Value = "2", Secondary = 1 },
    new MyObject{ Value = "3", Secondary = 1 },
};

IEnumerable<MyString> sorted = array.OrderBy( "Value" ).ThenBy( "Secondary" );

foreach( var item in sorted )
{
    Console.WriteLine( item.Value + " " + item.Secondary );
}

Schmuli wrote:

var sorted = array.OrderBy( "Value" ).ThenBy( "Secondary" );

public class GenericSorter<T>
{
    public IEnumerable<T> Sort(IEnumerable<T> source, string sortBy, string sortDirection)
    {
        var param = Expression.Parameter(typeof(T), "item");

        var sortExpression = Expression.Lambda<Func<T, object>>
            (Expression.Convert(Expression.Property(param, sortBy), typeof(object)), param);

        switch (sortDirection.ToLower())
        {
            case "asc":
                return source.AsQueryable<T>().OrderBy<T, object>(sortExpression);
            default:
                return source.AsQueryable<T>().OrderByDescending<T, object>(sortExpression);

        } 
    }
}