public static IQueryable <TSource> OrderByProperty <TSource>(this IQueryable <TSource> source, string propertyName)
{
ParameterExpression parameter = Expression.Parameter(typeof(TSource));
Expression orderByProperty = Expression.Property(parameter, propertyName);
LambdaExpression lambda = Expression.Lambda(orderByProperty, new[] { parameter });
MethodInfo genericMethod = OrderByMethod.MakeGenericMethod
(new[] { typeof(TSource), orderByProperty.Type });
object ret = genericMethod.Invoke(null, new object[] { source, lambda });
return((IQueryable <TSource>)ret);
}
private int GetSortFieldType(OrderByMethod orderByMethod)
{
if (orderByMethod.FieldType == typeof(string))
{
return(3);
}
if (AzureFieldBuilder.IsNumericField(orderByMethod.FieldType))
{
return(6);
}
return(AzureFieldBuilder.IsFloatingPointField(orderByMethod.FieldType) ? 7 : 3);
}
/// <summary>
/// Apply an orderby to a collection of elements
/// </summary>
/// <param name="Collection">A collection that implements the generic IEnumerable or IQueryable interfaces</param>
/// <param name="PropertyName">The property to use as an argument to the OrderBy</param>
/// <param name="Descending">Descensing sorting</param>
/// <returns></returns>
public static IEnumerable OrderBy(IEnumerable Collection, string PropertyName, bool Descending)
{
var EnumerableInterface =
Collection.GetType()
.GetInterfaces().Where(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IEnumerable <>)).First();
if (EnumerableInterface == null)
{
throw new ArgumentException("Collection must implement the generic interface IEnumerable");
}
var ElementType = EnumerableInterface.GetGenericArguments()[0];
//var Property = ElementType.GetProperty(PropertyName);
var QueryableInterface =
Collection.GetType()
.GetInterfaces().Where(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IQueryable <>)).FirstOrDefault();
MethodCallExpression mc;
if (QueryableInterface != null)
{
if (Descending)
{
mc = (MethodCallExpression)
(((Expression <Func <IQueryable <int> > >)
(() => (new int[0]).AsQueryable().OrderByDescending(y => y)))
.Body);
}
else
{
mc = (MethodCallExpression)
(((Expression <Func <IQueryable <int> > >)
(() => (new int[0]).AsQueryable().OrderBy(y => y)))
.Body);
}
}
else
{
if (Descending)
{
mc = (MethodCallExpression)
(((Expression <Func <IEnumerable <int> > >)
(() => (new int[0]).OrderByDescending(y => y)))
.Body);
}
else
{
mc = (MethodCallExpression)
(((Expression <Func <IEnumerable <int> > >)
(() => (new int[0]).OrderBy(y => y)))
.Body);
}
}
var param = Expression.Parameter(ElementType);
var PropNames = PropertyName.Split('.');
var PropertyType = ElementType;
Expression propertyExpression = param;
foreach (var P in PropNames)
{
PropertyType = PropertyType.GetProperty(P).PropertyType;
propertyExpression = Expression.Property(propertyExpression, P);
}
MethodInfo OrderByMethod;
OrderByMethod =
mc
.Method
.GetGenericMethodDefinition()
.MakeGenericMethod(ElementType, PropertyType);
var PropertyGetter = Expression.Lambda(propertyExpression, param);
var Ordered =
QueryableInterface != null?
OrderByMethod.Invoke(null, new object[] { Collection, PropertyGetter }) :
OrderByMethod.Invoke(null, new object[] { Collection, PropertyGetter.Compile() });
return((IEnumerable)Ordered);
}
