internal static IQueryable Select(this IQueryable queryable, string propertyName)
{
if (queryable == null)
{
throw new ArgumentNullException("queryable");
}
if (string.IsNullOrEmpty(propertyName))
{
if (propertyName == null)
{
throw new ArgumentNullException("propertyName");
}
throw new ArgumentException("A property name must be provided.", "propertyName");
}
Type queryableElementType = queryable.ElementType;
ParameterExpression[] parameters = new ParameterExpression[] { Expression.Parameter(queryableElementType, "") };
MemberExpression selectMemberExpression = QueryableExtensions.GenerateMemberExpression(parameters[0], propertyName);
LambdaExpression selectLambdaExpression = Expression.Lambda(selectMemberExpression, parameters);
return(queryable.Provider.CreateQuery(
Expression.Call(typeof(Queryable), "Select",
new Type[] { queryableElementType, selectLambdaExpression.Body.Type },
queryable.Expression, Expression.Quote(selectLambdaExpression))));
}
internal static IQueryable GetSubGroupsAndCountsQueryable(this IQueryable queryable, string subGroupBy, bool sortGroupBy, ListSortDirection direction)
{
// Create GroupBy
Type queryableElementType = queryable.ElementType;
ParameterExpression[] parameters = new ParameterExpression[] { Expression.Parameter(queryableElementType, "") };
MemberExpression memberExpression = QueryableExtensions.GenerateMemberExpression(parameters[0], subGroupBy);
LambdaExpression groupByLambdaExpression = Expression.Lambda(memberExpression, parameters);
MethodCallExpression groupByMethodExpression =
Expression.Call(
typeof(Queryable), "GroupBy",
new Type[] { queryableElementType, groupByLambdaExpression.Body.Type },
new Expression[] { queryable.Expression, Expression.Quote(groupByLambdaExpression) });
IQueryable groupedResult = queryable.Provider.CreateQuery(groupByMethodExpression);
if (sortGroupBy)
{
groupedResult = groupedResult.OrderByKey(direction == ListSortDirection.Ascending);
}
ParameterExpression[] groupedParameters = new ParameterExpression[] { System.Linq.Expressions.Expression.Parameter(groupedResult.ElementType, "") };
MemberExpression keyMemberExpression = MemberExpression.Property(groupedParameters[0], "Key");
MethodCallExpression countCallExpression = MethodCallExpression.Call(typeof(Enumerable), "Count", new Type[] { queryableElementType }, groupedParameters);
QueryableGroupNameCountPairInfo queryableGroupNameCountPairInfo =
QueryableExtensions.QueryableGroupNameCountPairInfos.GetInfosForType(memberExpression.Type);
Expression[] newExpressionArguments = new Expression[2] {
keyMemberExpression, countCallExpression
};
NewExpression newExpression =
NewExpression.New(
queryableGroupNameCountPairInfo.ConstructorInfo,
newExpressionArguments,
new MemberInfo[] { queryableGroupNameCountPairInfo.KeyPropertyInfo, queryableGroupNameCountPairInfo.CountPropertyInfo });
LambdaExpression finalLambdaExpression = System.Linq.Expressions.Expression.Lambda(newExpression, groupedParameters);
MethodCallExpression finalSelectExpression =
System.Linq.Expressions.Expression.Call(
typeof(Queryable), "Select",
new Type[] { groupedResult.ElementType, finalLambdaExpression.Body.Type },
new System.Linq.Expressions.Expression[] { groupedResult.Expression, System.Linq.Expressions.Expression.Quote(finalLambdaExpression) });
return(groupedResult.Provider.CreateQuery(finalSelectExpression));
}
private static Expression FilterString(
this IQueryable queryable,
ParameterExpression sharedParameterExpression,
string propertyName,
string[] values,
StringFilterMode stringFilterMode)
{
if (queryable == null)
{
throw new ArgumentNullException("queryable");
}
if ((values == null) || (values.Length == 0))
{
throw new ArgumentNullException("values");
}
string methodName = QueryableExtensions.GetMethodNameFromStringFilterMode(stringFilterMode);
Debug.Assert(!String.IsNullOrEmpty(methodName));
MemberExpression memberExpression = QueryableExtensions.GenerateMemberExpression(sharedParameterExpression, propertyName);
Expression mergedFilterCall = null;
for (int i = 0; i < values.Length; i++)
{
ConstantExpression valueExpression = Expression.Constant(values[i]);
MethodCallExpression newFilterCall = Expression.Call(
memberExpression,
typeof(string).GetMethod(methodName, new Type[] { typeof(string) }),
Expression.Convert(valueExpression, memberExpression.Type));
if (mergedFilterCall == null)
{
mergedFilterCall = newFilterCall;
}
else
{
mergedFilterCall = MethodCallExpression.Or(mergedFilterCall, newFilterCall);
}
}
return(mergedFilterCall);
}
private static Expression CreateBinaryComparison(
this IQueryable queryable,
ParameterExpression sharedParameterExpression,
string propertyName,
object[] values,
BinaryComparisonDelegate binaryComparisonDelegate)
{
if (queryable == null)
{
throw new ArgumentNullException("queryable");
}
if ((values == null) || (values.Length == 0))
{
throw new ArgumentNullException("values");
}
if (binaryComparisonDelegate == null)
{
throw new ArgumentNullException("binaryComparisonDelegate");
}
MemberExpression memberExpression = QueryableExtensions.GenerateMemberExpression(sharedParameterExpression, propertyName);
Expression mergedFilterExpression = null;
for (int i = 0; i < values.Length; i++)
{
ConstantExpression valueExpression = Expression.Constant(values[i]);
Expression newFilterExpression = binaryComparisonDelegate(memberExpression,
Expression.Convert(valueExpression, memberExpression.Type));
if (mergedFilterExpression == null)
{
mergedFilterExpression = newFilterExpression;
}
else
{
mergedFilterExpression = Expression.Or(mergedFilterExpression, newFilterExpression);
}
}
return(mergedFilterExpression);
}
private static IQueryable OrderByKey(this IQueryable queryable, bool ascending)
{
if (queryable == null)
{
throw new ArgumentNullException("queryable");
}
Expression orderedExpression = queryable.Expression;
Type queryableElementType = queryable.ElementType;
ParameterExpression parameter = queryable.CreateParameterExpression();
MemberExpression sortMemberExpression = QueryableExtensions.GenerateMemberExpression(parameter, "Key");
string methodName = (ascending) ? "OrderBy" : "OrderByDescending";
orderedExpression = Expression.Call(typeof(Queryable),
methodName,
new Type[] { queryableElementType, sortMemberExpression.Type },
orderedExpression, Expression.Quote(Expression.Lambda(sortMemberExpression, parameter)));
return(queryable.Provider.CreateQuery(orderedExpression));
}
internal static IQueryable OrderBy(
this IQueryable queryable,
SortDescriptionCollection implicitSortDescriptions,
SortDescriptionCollection explicitSortDescriptions,
bool reverse)
{
if (queryable == null)
{
throw new ArgumentNullException("queryable");
}
if ((implicitSortDescriptions == null) && (explicitSortDescriptions == null))
{
return(queryable);
}
Expression orderedExpression = queryable.Expression;
Type queryableElementType = queryable.ElementType;
ParameterExpression[] parameters = new ParameterExpression[] { Expression.Parameter(queryableElementType, "") };
string ascendingOrderByMethodName = "OrderBy";
string descendingOrderByMethodName = "OrderByDescending";
if (explicitSortDescriptions != null)
{
foreach (SortDescription sortDescription in explicitSortDescriptions)
{
MemberExpression sortMemberExpression = QueryableExtensions.GenerateMemberExpression(parameters[0], sortDescription.PropertyName);
string methodNameToUse;
if ((sortDescription.Direction == ListSortDirection.Ascending && !reverse) || (sortDescription.Direction == ListSortDirection.Descending && reverse))
{
methodNameToUse = ascendingOrderByMethodName;
}
else
{
methodNameToUse = descendingOrderByMethodName;
}
orderedExpression = Expression.Call(typeof(Queryable),
methodNameToUse,
new Type[] { queryableElementType, sortMemberExpression.Type },
orderedExpression, Expression.Quote(Expression.Lambda(sortMemberExpression, parameters)));
ascendingOrderByMethodName = "ThenBy";
descendingOrderByMethodName = "ThenByDescending";
}
}
if (implicitSortDescriptions != null)
{
foreach (SortDescription sortDescription in implicitSortDescriptions)
{
MemberExpression sortMemberExpression = QueryableExtensions.GenerateMemberExpression(parameters[0], sortDescription.PropertyName);
string methodNameToUse;
if ((sortDescription.Direction == ListSortDirection.Ascending && !reverse) || (sortDescription.Direction == ListSortDirection.Descending && reverse))
{
methodNameToUse = ascendingOrderByMethodName;
}
else
{
methodNameToUse = descendingOrderByMethodName;
}
orderedExpression = Expression.Call(typeof(Queryable),
methodNameToUse,
new Type[] { queryableElementType, sortMemberExpression.Type },
orderedExpression, Expression.Quote(Expression.Lambda(sortMemberExpression, parameters)));
ascendingOrderByMethodName = "ThenBy";
descendingOrderByMethodName = "ThenByDescending";
}
}
return(queryable.Provider.CreateQuery(orderedExpression));
}
