Click here to Skip to main content
Click here to Skip to main content

Handle GridView.OnSorting() and create sorting expression dynamically using LINQ

, 18 Jul 2014 CPOL
Rate this:
Please Sign up or sign in to vote.
How to create a sorting expression from GridViewSortEventArgs using LINQ Expression Tree.

Introduction

The GridView control from ASP.NET 2.0 such as this one is great and widely used:

<asp:GridView runat="server" ID="gridPersons" 
         AutoGenerateColumns="false" AllowSorting="true" 
         OnSorting="gridPersons_Sorting">
    <Columns>
        <asp:BoundField HeaderText="First name" 
           DataField="FirstName" SortExpression="FirstName" />
        <asp:BoundField HeaderText="Last name" 
           DataField="LastName" SortExpression="LastName" />
    </Columns>
</asp:GridView>
protected void gridPersons_Sorting(object sender, GridViewSortEventArgs e)
{
    string sortExpression = e.SortExpression;
}

But has one significant limitation: sorting event argument GridViewSortEventArg is based on string values from markup. So it can't be directly used in programmatic sorting using LINQ,

This article describes how to convert a string argument into the sorting expression.

Background

Let's assume we have a sequence of strongly typed class, say Person, and we want to bind it to a GridView and then sort it by clicking on the appropriate column:

class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

IEnumerable<Person> persons = GetPersons();
gridPersons.DataSource =  persons.ToArray();
gridPersons.DataBind();

Generally speaking, we could hard-code both the sorting expression (i.e., property to sort by) and the direction (ascending, descending):

protected void gridPersons_Sorting(object sender, GridViewSortEventArgs e)
{
    Func<Person, object> prop = null;
    switch (e.SortExpression)
    {
        case "FirstName":
        {
            prop = p => p.FirstName;
            break;
        }
        case "LastName":
        {
            prop = p => p.LastName;
            break;
        }
    }

    Func<IEnumerable<Person>, Func<Person, object>, IEnumerable<Person>> func = null;

    switch (e.SortDirection)
    {
        case SortDirection.Ascending:
        {
            func = (c, p) => c.OrderBy(p);
            break;
        }
        case SortDirection.Descending:
        {
            func = (c, p) => c.OrderByDescending(p);
            break;
        }
    }

    IEnumerable<Person> persons = GetPersons();
    persons = func(persons, prop);

    gridPersons.DataSource = persons.ToArray();
    gridPersons.DataBind();
}

But such approach contains a number of disadvantages: all the object's properties are hard-coded, as well as the sorting directions. Much better would be to create all these dynamically.

Solution

Let's encapsulate the logic into a number of dedicated classes.

The first one converts SortDirection to Func<IEnumerable<T>, Func<T, object>, IEnumerable<T>> which is a function accepting a sequence and another function accepting object and returning one of its properties; and returning that sequence sorted by that object's property.

public static class SortExpressionConverter<T>
{
    private static IDictionary<SortDirection, ISortExpression> expressions = 
        new Dictionary<SortDirection, ISortExpression>
    {
        { SortDirection.Ascending, new OrderByAscendingSortExpression() },
        { SortDirection.Descending, new OrderByDescendingSortExpression() }
    };

    interface ISortExpression
    {
        Func<IEnumerable<T>, Func<T, object>, IEnumerable<T>> GetExpression();
    }

    class OrderByAscendingSortExpression : ISortExpression
    {
        public Func<IEnumerable<T>, Func<T, object>, IEnumerable<T>> GetExpression()
        {
            return (c, f) => c.OrderBy(f);
        }
    }

    class OrderByDescendingSortExpression : ISortExpression
    {
        public Func<IEnumerable<T>, Func<T, object>, IEnumerable<T>> GetExpression()
        {
            return (c, f) => c.OrderByDescending(f);
        }
    }

    public static Func<IEnumerable<T>, Func<T, object>, IEnumerable<T>>
        Convert(SortDirection direction)
    {
        ISortExpression sortExpression = expressions[direction];
        return sortExpression.GetExpression();
    }
}

The second one builds a lambda expression Expression<Func<T, object>> and returns underlying lambda Func<T, object>:

public static class SortLambdaBuilder<T>
{
    public static Func<T, object> Build(string columnName, SortDirection direction)
    {
        // x
        ParameterExpression param = Expression.Parameter(typeof(T), "x");

        // x.ColumnName1.ColumnName2
        Expression property = columnName.Split('.')
                                        .Aggregate<string, Expression>
                                        (param, (c, m) => Expression.Property(c, m));

        // x => x.ColumnName1.ColumnName2
        Expression<Func<T, object>> lambda = Expression.Lambda<Func<T, object>>(
            Expression.Convert(property, typeof(object)),
            param);
        
        Func<T, object> func = lambda.Compile();
        return func;
    }
}

Wrap how these classes are used into an extension method:

public static class CollectionExtensions
{
    public static IEnumerable<T> OrderBy<T>(this IEnumerable<T> collection, 
           string columnName, SortDirection direction)
    {
        Func<IEnumerable<T>, Func<T, object>, IEnumerable<T>> expression =
            SortExpressionConverter<T>.Convert(direction);

        Func<T, object> lambda =
            SortLambdaBuilder<T>.Build(columnName, direction);

        IEnumerable<T> sorted = expression(collection, lambda);
        return sorted;
    }
}

So now we have a flexible, fully dynamic and generic solution:

protected void gridPersons_Sorting(object sender, GridViewSortEventArgs e)
{
    IEnumerable<Person> persons = GetPersons();
    persons = persons.OrderBy(e.SortExpression, e.SortDirection);

    gridPersons.DataSource = persons.ToArray();
    gridPersons.DataBind();
}

Points of Interest 

Here are some discussions on StackOverflow related to the subject:

History of Changes

  • 27/08/2011 - Initial publication
  • 22/03/2012 - OrderBy<T>() extension method expanded to make it easier to read and understand
  • 17/07/2014 - SortLambdaBuilder<T> supports nested properties

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Alexander Batishchev
Software Developer
United States United States
.NET developer and architect
Follow on   Twitter   LinkedIn

Comments and Discussions

 
QuestionNot supporting custom properties -- complex objects PinmemberMember 1079109110-Jun-14 7:53 
AnswerRe: Not supporting custom properties -- complex objects PinmemberAlexander Batishchev12-Jun-14 13:10 
GeneralRe: Not supporting custom properties -- complex objects PinmemberMember 1079109116-Jul-14 9:08 
GeneralRe: Not supporting custom properties -- complex objects PinmemberAlexander Batishchev17-Jul-14 9:25 
GeneralRe: Not supporting custom properties -- complex objects PinmemberMember 1079109117-Jul-14 9:33 
AnswerRe: Not supporting custom properties -- complex objects PinmemberAlexander Batishchev17-Jul-14 12:31 
GeneralRe: Not supporting custom properties -- complex objects PinmemberAlexander Batishchev21-Jul-14 11:07 
GeneralRe: Not supporting custom properties -- complex objects PinmemberMember 1079109121-Jul-14 12:05 
GeneralMy vote of 5 PinmemberJuhi Paunikar18-Apr-13 4:13 
GeneralRe: My vote of 5 PinmemberAlexander M. Batishchev18-Apr-13 20:07 
SuggestionEnabling sub-property sorting PinmemberiJazz Pizz31-Jan-13 6:37 
GeneralRe: Enabling sub-property sorting PinmemberAlexander M. Batishchev18-Apr-13 20:17 
GeneralRe: Enabling sub-property sorting Pinmembersashidhar18-Sep-13 22:43 
QuestionDynamic.cs Pinmembertmbgfan22-Mar-12 7:32 
AnswerRe: Dynamic.cs PinmemberAlexander M. Batishchev22-Mar-12 8:11 
GeneralRe: Dynamic.cs Pinmembertmbgfan22-Mar-12 9:16 
QuestionExplaination PinmemberKnvnBhat21-Mar-12 20:52 
AnswerRe: Explaination PinmemberAlexander M. Batishchev21-Mar-12 22:53 
QuestionIt does not work properly... Pinmemberjulgon200220-Mar-12 9:23 
QuestionRe: It does not work properly... PinmemberAlexander M. Batishchev21-Mar-12 6:22 
SuggestionNeeded changes PinmemberLeoric229-Aug-11 3:27 
GeneralRe: Needed changes PinmemberAlexander M. Batishchev21-Mar-12 22:55 
QuestionGood code but no explanation :( PinmemberDavid Zenou28-Aug-11 9:02 
AnswerRe: Good code but no explanation :( PinmemberAlexander M. Batishchev28-Aug-11 9:11 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Terms of Use | Mobile
Web04 | 2.8.1411023.1 | Last Updated 18 Jul 2014
Article Copyright 2011 by Alexander Batishchev
Everything else Copyright © CodeProject, 1999-2014
Layout: fixed | fluid