/// <summary>
/// The GetHackerNewsItemExpressionSort.
/// </summary>
/// <param name="expressionBuilder">The expressionBuilder<see cref="LambdaExpressionBuilder{HackerNewsItem}"/>.</param>
/// <param name="orderByField">The orderByField<see cref="HackerNewsFieldEnum"/>.</param>
/// <param name="orderByFieldDesc">The orderByFieldDesc<see cref="bool"/>.</param>
/// <returns>The <see cref="Expression{Func{HackerNewsItem, object}}"/>.</returns>
private Expression <Func <HackerNewsItem, object> > GetHackerNewsItemExpressionSort(LambdaExpressionBuilder <HackerNewsItem> expressionBuilder, HackerNewsFieldEnum orderByField, bool orderByFieldDesc)
{
QuerySort querySort = new QuerySort
{
PropertyPath = orderByField.GetDescription(),
Desc = orderByFieldDesc
};
return(expressionBuilder.BuildQuerySortingExpression(querySort));
}
protected MethodInfo GetOrderMethod(bool isFirst, QuerySort querySort, Type type, Type[] parameterDefinitions, Type[] chainedOrderParameterDefinitions, Type[] typeArguments)
{
if (isFirst)
{
return(querySort.Direction == SortDirection.Ascending ?
MethodProvider.MakeGenericMethod(type, "OrderBy", parameterDefinitions, typeArguments) :
MethodProvider.MakeGenericMethod(type, "OrderByDescending", parameterDefinitions, typeArguments));
}
return(querySort.Direction == SortDirection.Ascending ?
MethodProvider.MakeGenericMethod(type, "ThenBy", chainedOrderParameterDefinitions, typeArguments) :
MethodProvider.MakeGenericMethod(type, "ThenByDescending", chainedOrderParameterDefinitions, typeArguments));
}
/// <summary>
/// Get sort expression from <seealso cref="PageParameters.SortBy"/>.
/// </summary>
/// <param name="querySort">The querySort<see cref="QuerySort"/>.</param>
/// <returns>.</returns>
public Expression <Func <TEntity, object> > BuildQuerySortingExpression(QuerySort querySort)
{
if (querySort == null)
{
return(null);
}
string propertyPath = GetPropertyPath(typeof(TEntity), querySort.PropertyPath.Split('.'), string.Empty);
ParameterExpression param = Expression.Parameter(typeof(TEntity), "lambdaParameter");
Expression body = propertyPath.Split('.').Aggregate((Expression)param, Expression.PropertyOrField);
Expression <Func <TEntity, object> > expression = Expression.Lambda <Func <TEntity, object> >(Expression.Convert(body, typeof(object)), param);
return(expression);
}
private QuerySort GetSort(QueryTerm queryTerm)
{
QuerySort result = new QuerySort();
if (queryTerm.Order == 0)
{
result.SortDefault = true;
}
else if (queryTerm.Order == (int)SortProperty.Price)
{
if (queryTerm.Descending == (int)SortDirection.Descending)
{
result.SortPriceDesc = true;
}
else
{
result.SortPriceAsc = true;
}
}
return(result);
}
/// <summary>
/// Builds dynamic sort string based on parameters
/// </summary>
/// <param name="sort"></param>
/// <returns></returns>
//============================================================
//Revision History
//Date Author Description
//06/28/2017 TB Created
//============================================================
public static string BuildSortString(QuerySort sort)
{
string sortOrder = sort.desc ? "desc" : "";
return(string.Format("{0} {1}", sort.selector, sortOrder));
}
private static void Main(string[] args)
{
LambdaExpressionBuilder <Subject> expressionBuilder = new LambdaExpressionBuilder <Subject>();
IEnumerable <Subject> foodList = new Seed().GetSubjectList();
IList <QueryFilter> queryFilterList = new List <QueryFilter>
{
new QueryFilter {
PropertyPath = "Id",
Operator = OperatorEnum.EqualTo,
PropertyValue = "0"
}
};
QuerySort querySort = new QuerySort
{
PropertyPath = "Id",
Desc = false
};
Expression <Func <Subject, bool> > filteringQuery = expressionBuilder.BuildQueryFilteringExpression(queryFilterList);
Expression <Func <Subject, object> > sortingQuery = expressionBuilder.BuildQuerySortingExpression(querySort);
List <Subject> result = foodList.Where(filteringQuery.Compile())
.AsQueryable()
.OrderBy(sortingQuery)
.ToList();
Console.WriteLine("------------------");
Console.WriteLine("---- QUERY -----");
Console.WriteLine("------------------");
Console.WriteLine(expressionBuilder.ToString(filteringQuery));
Console.WriteLine("------------------");
Console.WriteLine("---- SORT ------");
Console.WriteLine("------------------");
Console.WriteLine(expressionBuilder.ToString(sortingQuery));
Console.WriteLine("------------------");
Console.WriteLine("---- RESULT ----");
Console.WriteLine("------------------");
for (int i = 0; i < result.Count; i++)
{
Console.WriteLine(result[i].ToString());
}
queryFilterList = new List <QueryFilter>
{
new QueryFilter {
PropertyPath = "Teacher.Name", Operator = OperatorEnum.Contains, PropertyValue = "a"
},
};
querySort = new QuerySort
{
PropertyPath = "teacher.name",
Desc = false
};
filteringQuery = expressionBuilder.BuildQueryFilteringExpression(queryFilterList);
sortingQuery = expressionBuilder.BuildQuerySortingExpression(querySort);
result = foodList.Where(filteringQuery.Compile())
.AsQueryable()
.OrderBy(sortingQuery)
.ToList();
Console.WriteLine("------------------");
Console.WriteLine("---- QUERY -----");
Console.WriteLine("------------------");
Console.WriteLine(expressionBuilder.ToString(filteringQuery));
Console.WriteLine("------------------");
Console.WriteLine("---- SORT ------");
Console.WriteLine("------------------");
Console.WriteLine(expressionBuilder.ToString(sortingQuery));
Console.WriteLine("------------------");
Console.WriteLine("---- RESULT ----");
Console.WriteLine("------------------");
for (int i = 0; i < result.Count; i++)
{
Console.WriteLine(result[i].ToString());
}
Console.ReadLine();
}
