Visit my system development blog and select the .NET Extensions category from now on.

View the new version here.

OrderBy returns a sorted list without affecting the original collection, while Sort affects the original collection without returning anything.

I found the original solution at http://www.singingeels.com/Articles/Self_Sorting_GridView_with_LINQ_Expression_Trees.aspx and have adjusted in and extracted the functionality to an extension class, which can then be used by using its namespace in any class where you need the functionality.

Add these two functions to the extension class:

        /// <summary>
        /// Apply an OrderBy rule that is based on a sort property.
        /// </summary>
        /// <typeparam name="T">The type of the objects that are stored in the collection.</typeparam>
        /// <param name="collection">The collection to sort.</param>
        /// <param name="sortProperty">The property to sort on.</param>
        /// <returns>A sorter collection.</returns>
        public static IEnumerable<T> OrderBy<T>(this IEnumerable<T> collection, string sortProperty)
        {
            //Get the collection type
            Type dataSourceType = collection.GetType();

            // Determine the data type of the items in the data source at runtime.
            Type dataItemType = typeof(object);
            if (dataSourceType.HasElementType)
                dataItemType = dataSourceType.GetElementType();
            else if (dataSourceType.IsGenericType)
                dataItemType = dataSourceType.GetGenericArguments()[0];

            // Create an instance of the GenericSorter class passing in the data item type.
            Type sorterType = typeof(GenericSorter<>).MakeGenericType(dataItemType);
            var sorterObject = Activator.CreateInstance(sorterType);

            // Now I can call the "Sort" method passing in my runtime types.
            return sorterType.GetMethod("Sort", new[] { dataSourceType, typeof(string) }).Invoke(sorterObject, new object[] { collection, sortProperty }) as IEnumerable<T>;
        }

        /// <summary>
        /// Sort a collection based on a sort property.
        /// </summary>
        /// <typeparam name="T">The type of the objects that are stored in the collection.</typeparam>
        /// <param name="list">The list to sort.</param>
        /// <param name="sortProperty">The property to sort on.</param>
        /// <returns>A sorter collection.</returns>
        public static void Sort<T>(this List<T> list, string sortProperty)
        {
            IEnumerable<T> sorted = list.OrderBy(sortProperty).ToList();
            list.Clear();
            list.AddRange(sorted);
        }

Then, add this class into the same class file as the extension class:

    /// <summary>
    /// This help class is used to encapsule sorting logic.
    /// </summary>
    /// <typeparam name="T">The type to sort.</typeparam>
    internal class GenericSorter<T>
    {
        public IEnumerable<T> Sort(IEnumerable<T> source, string sortBy)
        {
            var param = Expression.Parameter(typeof(T), "item");
            var sortExpression = Expression.Lambda<Func<T, object>>
                (Expression.Convert(Expression.Property(param, sortBy), typeof(object)), param);
            return source.AsQueryable().OrderBy(sortExpression);
        }
    }

Now, just include the namespace of your extension class, and you will be able to se the functions. The extension class – Extensions.SortExtensions – will be added to the next release of .NET Extensions.

Man, I really must start using a code tool, so that  I do not have to hack the code manually when writing these blogs  …has anyone got any tips?

The class – Extensions.PagingExtensions – contains extension methods for IEnumerable and IQueryable that simplifies applying paging to collections.

The class has the following extension methods:

   /// <summary>
   /// Apply paging to an IEnumerable.
   /// <typeparam name="TSource">The type that the collection contains.</typeparam>
   /// <param name="source">The data source.</param>
   /// <param name="page">The page index, starting at 0.</param>
   /// <param name="pageSize">The max number of items to return.</param>
   /// <returns>The resulting object collection.</returns>
   public static IEnumerable<TSource> Page<TSource>(this IEnumerable<TSource> source, int? page, int pageSize)
   {
      return source.Skip((page ?? 0) * pageSize).Take(pageSize);
   }

   /// <summary>
   /// Apply paging to an IQueryable.
   /// </summary>
   /// <typeparam name="TSource">The type that the collection contains.</typeparam>
   /// <param name="source">The data source.</param>
   /// <param name="page">The page index, starting at 0.</param>
   /// <param name="pageSize">The max number of items to return.</param>
   /// <returns>The resulting object collection.</returns>
   public static IQueryable<TSource> Page<TSource>(this IQueryable<TSource> source, int? page, int pageSize)
   {
      return source.Skip((page ?? 0) * pageSize).Take(pageSize);
   }

By using the NetExtensions.Extensions namespace, a class will then support functions like this one:

      List<string> strings = new List<string> { "a","b", "c","d","e","f","g","h","i","j"};
      strings.Page(2, 2);

This will return a list that contains “c” and “d”.

Man, I really must start using a code tool, so that  I do not have to hack the code manually when writing these blogs 

I have now uploaded the first version of the .NET Extensions DLL together with the source code. Feel free to take a look.

This blog will feature information regarding all changes that are made to the .NET Extensions project.

Links:

• Visit the .NET Extensions web site
• Visit the .NET Extensions project site