 |
|
|
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 list = new List();
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.
|
|
|
|
|
|
|
|
|
|
What I did was a hack:
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
|
|
|
|
|
|
|
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 
Question 
Answer 
Joke 
Rant 
Admin 
