public virtual SortBuilder <T> OrderBy(string orderByClause)
{
if (string.IsNullOrEmpty(orderByClause))
{
throw new ArgumentNullException("orderByClause");
}
if (!orderByClause.ToUpper().Contains("ORDER BY "))
{
orderByClause = orderByClause.Insert(0, " ORDER BY ");
}
SortBuilder.OrderBy(orderByClause);
return(SortBuilder);
}
/// <summary>
/// Handles Where.
/// </summary>
/// <param name="lambdaExpression"></param>
/// <returns></returns>
protected override Expression VisitLamda(LambdaExpression lambdaExpression)
{
_sortBuilder = Where(lambdaExpression as Expression <Func <T, bool> >);
return(base.VisitLamda(lambdaExpression));
}
public virtual SortBuilder <T> ThenByDescending(Expression <Func <T, object> > sortExpression)
{
SortBuilder.OrderByDescending(sortExpression);
return(SortBuilder);
}
public virtual SortBuilder <T> ThenBy(Expression <Func <T, object> > sortExpression, SortDirection sortDirection)
{
SortBuilder.OrderBy(sortExpression, sortDirection);
return(SortBuilder);
}
public virtual SortBuilder <T> OrderBy(Expression <Func <T, object> > sortExpression)
{
SortBuilder.OrderBy(sortExpression);
return(SortBuilder);
}
/// <summary>
/// Handles OrderBy.
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
protected override System.Linq.Expressions.Expression VisitMethodCall(MethodCallExpression expression)
{
switch (expression.Method.Name)
{
case "Where":
var quote = expression.Arguments[1] as UnaryExpression;
if (quote != null)
{
var predicate = quote.Operand as Expression <Func <TEntity, bool> >;
_sortBuilder = _queryBuilder.Where(predicate);
}
break;
case "OrderBy":
case "ThenBy":
this.Visit(expression.Arguments[0]);
var keySelectorAsc = expression.Arguments[1] as UnaryExpression;
if (keySelectorAsc != null)
{
if (_sortBuilder == null)
{
_sortBuilder = _queryBuilder.AddSortExpression(keySelectorAsc.Operand, SortDirection.Asc);
}
else
{
_sortBuilder.AddSortExpression(keySelectorAsc.Operand, SortDirection.Asc);
}
}
break;
case "OrderByDescending":
case "ThenByDescending":
this.Visit(expression.Arguments[0]);
var keySelectorDesc = expression.Arguments[1] as UnaryExpression;
if (keySelectorDesc != null)
{
if (_sortBuilder == null)
{
_sortBuilder = _queryBuilder.AddSortExpression(keySelectorDesc.Operand, SortDirection.Desc);
}
else
{
_sortBuilder.AddSortExpression(keySelectorDesc.Operand, SortDirection.Desc);
}
}
break;
case "Skip":
this.Visit(expression.Arguments[0]);
int skipVal = (int)GetConstantValue(expression.Arguments[1]);
_queryBuilder.Skip(skipVal);
break;
case "Take":
this.Visit(expression.Arguments[0]);
int takeVal = (int)GetConstantValue(expression.Arguments[1]);
_queryBuilder.Take(takeVal);
break;
case "FirstOrDefault":
case "SingleOrDefault":
this.Visit(expression.Arguments[0]);
_queryBuilder.SetSingleOrFirstAllowNull(true);
break;
case "First":
case "Single":
this.Visit(expression.Arguments[0]);
_queryBuilder.SetSingleOrFirstAllowNull(false);
break;
default:
string msg = string.Format("'{0}' expressions are not currently supported in the where clause expression tree parser.", expression.Method.Name);
throw new NotSupportedException(msg);
}
return(expression);
}
