|
Hi,
Your solution helps me a lot for ordering my lists, I have converted it to a List Extension method for better use.
I am sharing my method here, hope useful to others...
public static class GenericSorterExtension
{
public static List<T> Sort<T>(this List<T> list, string sortBy_sortDirection)
{
string[] sortProperties = sortBy_sortDirection.Split(' ');
var param = Expression.Parameter(typeof(T), "item");
var sortExpression = Expression.Lambda<Func<T, object>>
(Expression.Convert(Expression.Property(param, sortProperties[0]), typeof(object)), param);
switch (sortProperties[1].ToLower())
{
case "asc":
list = list.AsQueryable<T>().OrderBy<T, object>(sortExpression).ToList();
break;
default:
list = list.AsQueryable<T>().OrderByDescending<T, object>(sortExpression).ToList();
break;
}
return list;
}
}
I can call this extension method as below...
List<student> students = new List<student>();
student s1 = new student();
s1.studentId = 1;
s1.studentName = "ABC";
s1.studentRank = 2.5F;
s1.studentClass = "First";
students.Add(s1);
student s2 = new student();
s2.studentId = 2;
s2.studentName = "XYZ";
s2.studentRank = 1.5F;
s2.studentClass = "Second";
students.Add(s2);
string sqlTypeSortExpression = "studentName DESC";
students = students.Sort(sqlTypeSortExpression);
sqlTypeSortExpression = "studentName ASC";
students = students.Sort(sqlTypeSortExpression);
sqlTypeSortExpression = "studentRank DESC";
students = students.Sort(sqlTypeSortExpression);
|
|
|
|
|
Hi,
I'm keeping getting exception at the line where I make the query result "toList()" with messgage of "Additional information: Unable to cast the type 'System.Int64' to type 'System.Object'. LINQ to Entities only supports casting EDM primitive or enumeration types."
And type 'System.Int64' may be type 'System.String' when I change to sort by other column, could you please give me some hlep?
|
|
|
|
|
Dear Adam
Could you please help me to solve my problem that I have a screen which allow user choose a list of sort fields and for each field user also choose it descending or increasing
To do that feature, I try to code a function like this:
public IEmumerable<t> Sort (IEnumerable<t> unsortCollection, string[] sortField, int[] direction)
{
.....
}
But I don't know how to do it
Could you please so me the way to do
Many thanks
|
|
|
|
|
a collection can be sorted multiple times. Just call the sort method for each field the user selects in the UI.
|
|
|
|
|
Have you done any performance testing? How would it compare to other sorting techniques?
|
|
|
|
|
I am using the code in production and am not currently having any issues with performance. However, I am making use of reflection to get the type of the object which can have some performance implications. I know that I can use it to sort in the neighborhood of 500 large objects faster than I can blink, so I haven’t been at all concerned as the app I am using it in will never have that many objects to display in a GridView. If you however have more than that you may want to consider performance testing before implementing this technique.
-Adam N. Thompson
|
|
|
|
|
According to VS2008 SP1, type inference is not implied by the usage of:
return source.AsQueryable().OrderBy(sortExpression);
Any thoughts?
|
|
|
|
|
I created the C# example with a code converter as the project I developed this in was in VB.NET. I will run sime test and update the article. But I think it might should be something like this in C#.
return source.AsQueryable<T>().OrderBy<T, object>(sortExpression);
-Adam N. Thompson
|
|
|
|
|
Adam,
Your little demonstration is something I've been looking to do properly with Linq for some time now. Thank you for explaining about the C# converter part, as I thought you may be using C# 4.0 instead. I converted the process to an extension method so that no class is required to be instantiated for its use (you are welcome to incorporate it in your article):
public enum SortDirection
{
Ascending,
Descending
}
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);
}
}
}
The usage of the extension method is simple:
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);
Now, I need to figure out how to adapt your method to be able to sort on multiple attributes in a given class. Then it would be absolutely perfect.
Thank you, again.
|
|
|
|
|
"Now, I need to figure out how to adapt your method to be able to sort on multiple attributes in a given class. Then it would be absolutely perfect."
Let me know if you get that to work.
-Adam N. Thompson
|
|
|
|
|
Until I can figure out what how to define the Linq expression, this extension method (that uses my extension method) should do the trick.
public static IEnumerable<T> Sort<T>(this IEnumerable<T> source, Dictionary<string, SortDirection> attributes)
{
IEnumerable<T> result = source;
foreach (string attribute in attributes.Keys)
{
result = result.Sort(attribute, attributes[attribute]);
}
return result;
}
Or maybe it just sorts, and unsorts...? Have to research it more in depth.
|
|
|
|
|
|
I return an IOrderedQueryable<T> from the first sort, and then overloaded the sort method to receive an IOrderedQueryable<T>. In such a case I perform a ThenBy<T, TResult> instead of the OrderBy<T, TResult>.
I guess once I do that I should call the sort method 'OrderBy' and the second sort 'ThenBy' so the intention is clear. Then after looking at the code, I realized that what I had was very similar to what exists in the framework, at least method names.
So I did the following:
These are the Extension methods:
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 );
}
}
This is an example object with two properties:
public class MyObject
{
public string Value
{
get;
set;
}
public int Secondary
{
get;
set;
}
}
This is a usage example:
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 );
}
modified on Tuesday, June 30, 2009 6:20 AM
|
|
|
|
|
I know I'm replying to my own message, but if someone reads that one, perhaps they will read this one too.
Schmuli wrote: var sorted = array.OrderBy( "Value" ).ThenBy( "Secondary" );
After having written my implementation and posted it here, I started to look over what I had. I basically had what was available to start with in System.Linq.Enumerable/Queryable, however, instead of using type-safety, by way of a delegate, to get the property to sort on, I was instead using strings, requiring also Reflection.
So I thought to myself, why would anyone want to implement sorting in this manner, and slowly it dawned on me that this is required when working with a GridView/DataGridView (as mentioned by the article's author). However, when using a GridView/DataGridView, although the sort expression is a string, the sort direction is also a string, so this means that having two methods for asc and desc will not work.
Furthermore, if I'm not mistaken, when sorting with a GridView/DataGridView, you only ever receive one sort expression to sort on. This means you need to keep some state in order to know which method to call, OrderBy or ThenBy.
All in all, although my code may come in handy for someone, it doesn't really answer the needs of the article's author.
Please let me know if I'm right in my assumptions, or does this still help with the original issue?
|
|
|
|
|
It is true that I came up with this sorting method with the Gridview sorting in mind. Sometimes clients will impart business rules on you last minute though rules like, column x will always be the secondary sort.
I think your example is helpful in the exploration of this technique.
-Adam N. Thompson
|
|
|
|
|
Hi Adam,
I really like the technique you've shared and am using it in one of my projects. I came upon another instance where I wanted to reuse the same extension method and found a limitation I wasn't sure how to overcome. I have 2 classes defined as follows:
public class Person
{
public string FirstName { get; set; }
public string LastName { get; set; }
public int Age { get; set; }
public Address Address { get; set; }
}
public class Address
{
public string Street { get; set; }
public string City { get; set; }
public string State { get; set; }
public string Zip { get; set; }
}
I have an IList<person> that I bind the Gridview to, however when I try to sort on any of the properties of the Address class it fails. Any ideas on how to sort on a complex property?
public static IEnumerable<T> Sort<T>(this IEnumerable<T> source, string sortExpression)
{
string[] sortParts = sortExpression.Split(' ');
var param = Expression.Parameter(typeof(T), string.Empty);
try
{
var property = Expression.Property(param, sortParts[0]); //This is where it fails when I try to sort on address
var sortLambda = Expression.Lambda<Func<T, object>>(Expression.Convert(property, typeof(object)), param);
if (sortParts.Length > 1 && sortParts[1].Equals(SortDirection.Descending.ToString(), StringComparison.OrdinalIgnoreCase))
{
return source.AsQueryable<T>().OrderByDescending<T, object>(sortLambda);
}
return source.AsQueryable<T>().OrderBy<T, object>(sortLambda);
}
catch (ArgumentException)
{
return source;
}
}
|
|
|
|
|
Well... I'm not sure if this will work or not, but, the implementation uses reflection so...
Have you tried passing the property name into the sort extention method like "Person.Address.Street"?
Again, I haven't tried this, but give it a shot and let me know how it works out. If It dosen't work, maybe I will revisit the article to devise a solution.
Thanks,
-Adam N. Thompson
|
|
|
|
|
I ran into the same issue as the previous poster regarding the sorting property that is actually another class. I tried fully qualifying the property such as below.
public class UserProject{
public int ProjectId {get;set;}
public Priorities Priority {get;set;}
}
public class Priority{
public int PriorityRank {get;set;}
}
I get a javascript error message when I try to sort on UserProject.Priority.PriorityRank that says "Instance property 'UserProject.Priority.PriorityRank' is not defined for type Objects.ListResults.UserProject". Were you ever able to figure out a way around this? Thanks!
|
|
|
|
|
Sorry. I alwayse forget that my angle brackets are stript out. Here is what the class should look like in C#. Thanks for letting me know, I have sent in an update for the article.
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);
}
}
}
Let me know how this works.
-Adam N. Thompson
|
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
