dotnet-dynamic-linq/PoweredSoft.DynamicLinq/Extensions/QueryableExtensions.cs

173 lines
7.7 KiB
C#
Raw Normal View History

2018-02-11 20:55:29 -05:00
using PoweredSoft.DynamicLinq.Fluent;
using PoweredSoft.DynamicLinq.Helpers;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
2018-10-18 20:21:17 -04:00
using System.Reflection;
2018-02-11 20:55:29 -05:00
using System.Text;
using System.Threading.Tasks;
namespace PoweredSoft.DynamicLinq
2018-02-11 20:55:29 -05:00
{
public static class QueryableExtensions
{
2018-03-14 21:08:17 -04:00
public static IQueryable<T> Where<T>(this IQueryable<T> query, string path, ConditionOperators conditionOperator, object value,
QueryConvertStrategy convertStrategy = QueryConvertStrategy.ConvertConstantToComparedPropertyOrField,
2018-03-06 20:56:43 -05:00
QueryCollectionHandling collectionHandling = QueryCollectionHandling.Any, StringComparison? stringComparision = null)
2018-02-11 20:55:29 -05:00
{
2018-03-06 20:56:43 -05:00
query = query.Query(qb => qb.Compare(path, conditionOperator, value, convertStrategy: convertStrategy, collectionHandling: collectionHandling, stringComparision: stringComparision));
2018-02-11 20:55:29 -05:00
return query;
}
2018-10-17 20:40:07 -04:00
public static IQueryable Where(this IQueryable query, string path, ConditionOperators conditionOperator, object value,
QueryConvertStrategy convertStrategy = QueryConvertStrategy.ConvertConstantToComparedPropertyOrField,
QueryCollectionHandling collectionHandling = QueryCollectionHandling.Any, StringComparison? stringComparision = null)
{
query = query.Query(qb => qb.Compare(path, conditionOperator, value, convertStrategy: convertStrategy, collectionHandling: collectionHandling, stringComparision: stringComparision));
return query;
}
2018-03-14 20:25:47 -04:00
public static IQueryable<T> Where<T>(this IQueryable<T> query, Action<WhereBuilder> callback)
=> query.Query(callback);
2018-02-12 05:18:44 -05:00
2018-03-14 21:08:17 -04:00
public static IQueryable<T> Query<T>(this IQueryable<T> query, Action<WhereBuilder> callback)
2018-02-11 20:55:29 -05:00
{
2018-03-14 20:25:47 -04:00
var queryBuilder = new WhereBuilder(query);
2018-02-11 20:55:29 -05:00
callback(queryBuilder);
var ret = queryBuilder.Build();
2018-03-14 20:25:47 -04:00
return (IQueryable<T>)ret;
2018-02-11 20:55:29 -05:00
}
2018-02-12 05:18:44 -05:00
2018-10-17 20:40:07 -04:00
// non generics were missing.
public static IQueryable Where(this IQueryable query, Action<WhereBuilder> callback)
=> query.Query(callback);
public static IQueryable Query(this IQueryable query, Action<WhereBuilder> callback)
{
var queryBuilder = new WhereBuilder(query);
callback(queryBuilder);
var ret = queryBuilder.Build();
return ret;
}
// generic.
public static IQueryable<T> OrderBy<T>(this IQueryable<T> query, string path, QueryOrderByDirection direction, bool append)
2018-02-12 05:18:44 -05:00
{
IQueryable queryable = query;
query = queryable.OrderBy(path, direction, append) as IQueryable<T>;
return query;
2018-02-12 05:18:44 -05:00
}
public static IQueryable<T> OrderBy<T>(this IQueryable<T> query, string path)
=> query.OrderBy(path, QueryOrderByDirection.Ascending, false);
2018-02-12 05:18:44 -05:00
public static IQueryable<T> OrderByDescending<T>(this IQueryable<T> query, string path)
=> query.OrderBy(path, QueryOrderByDirection.Descending, false);
2018-02-12 05:18:44 -05:00
public static IQueryable<T> ThenBy<T>(this IQueryable<T> query, string path)
=> query.OrderBy(path, QueryOrderByDirection.Ascending, true);
2018-02-12 05:18:44 -05:00
public static IQueryable<T> ThenByDescending<T>(this IQueryable<T> query, string path)
=> query.OrderBy(path, QueryOrderByDirection.Descending, true);
// non generic.
public static IQueryable OrderBy(this IQueryable query, string path, QueryOrderByDirection direction, bool append)
2018-02-12 05:18:44 -05:00
{
var qb = new OrderByBuilder(query);
qb.OrderBy(path, direction, append);
2018-02-12 05:18:44 -05:00
var ret = qb.Build();
return ret;
}
2018-03-09 00:22:12 -05:00
public static IQueryable OrderBy(this IQueryable query, string path)
=> query.OrderBy(path, QueryOrderByDirection.Ascending, false);
public static IQueryable OrderByDescending(this IQueryable query, string path)
=> query.OrderBy(path, QueryOrderByDirection.Descending, false);
public static IQueryable ThenBy(this IQueryable query, string path)
=> query.OrderBy(path, QueryOrderByDirection.Ascending, true);
public static IQueryable ThenByDescending(this IQueryable query, string path)
=> query.OrderBy(path, QueryOrderByDirection.Descending, true);
// group by
2018-03-08 22:59:18 -05:00
public static IQueryable GroupBy<T>(this IQueryable<T> query, string path)
2018-03-09 00:22:12 -05:00
=> QueryableHelpers.GroupBy(query, typeof(T), path);
2018-03-08 22:59:18 -05:00
public static IQueryable GroupBy(this IQueryable query, Type type, string path)
2018-03-09 00:22:12 -05:00
=> QueryableHelpers.GroupBy(query, type, path);
public static IQueryable GroupBy<T>(this IQueryable<T> query, Action<GroupBuilder> callback)
=> query.GroupBy(typeof(T), callback);
public static IQueryable GroupBy(this IQueryable query, Type type, Action<GroupBuilder> callback)
2018-03-08 22:59:18 -05:00
{
var groupBuilder = new GroupBuilder(query);
2018-03-09 00:22:12 -05:00
callback(groupBuilder);
var ret = groupBuilder.Build();
return ret;
2018-03-08 22:59:18 -05:00
}
public static IQueryable Select(this IQueryable query, Action<SelectBuilder> callback)
{
var sb = new SelectBuilder(query);
callback(sb);
var ret = sb.Build();
return ret;
2018-03-13 22:01:21 -04:00
}
public static List<object> ToObjectList(this IQueryable query)
{
// Expression call tolist?
2018-03-13 22:01:21 -04:00
var ret = new List<object>();
foreach (var o in query)
ret.Add(o);
return ret;
}
public static List<dynamic> ToDynamicList(this IQueryable query)
{
var ret = new List<dynamic>();
foreach (var o in query)
ret.Add(o);
return ret;
}
2018-03-14 21:08:17 -04:00
public static List<DynamicClass> ToDynamicClassList(this IQueryable query)
{
if (!typeof(DynamicClass).IsAssignableFrom(query.ElementType))
throw new Exception($"{query.ElementType} does not inherit DynamicClass");
var ret = query.Cast<DynamicClass>().ToList();
return ret;
}
2018-10-18 20:21:17 -04:00
2018-10-18 20:27:24 -04:00
private static MethodInfo _internalCount = typeof(QueryableExtensions).GetMethod(nameof(QueryableExtensions.InternalCount), BindingFlags.Static | BindingFlags.NonPublic);
private static int InternalCount<T>(IQueryable<T> q) => System.Linq.Queryable.Count(q);
2018-10-18 20:21:17 -04:00
public static int Count(this IQueryable query) => (int)_internalCount.MakeGenericMethod(query.ElementType).Invoke(null, new object[] {query});
2018-10-18 20:27:24 -04:00
private static MethodInfo _internalLongCount = typeof(QueryableExtensions).GetMethod(nameof(QueryableExtensions.InternalLongCount), BindingFlags.Static | BindingFlags.NonPublic);
private static long InternalLongCount<T>(IQueryable<T> q) => System.Linq.Queryable.LongCount(q);
public static long LongCount(this IQueryable query)
{
var method =_internalLongCount.MakeGenericMethod(query.ElementType);
var result = method.Invoke(null, new object[] {query});
return (long) result;
}
2018-10-21 17:15:59 -04:00
public static IQueryable EmptyGroupBy(this IQueryable queryable, Type underlyingType)
{
var parameter = Expression.Parameter(underlyingType);
var genericMethod = Constants.GroupByMethod.MakeGenericMethod(underlyingType, typeof(bool));
var trueConstant = Expression.Constant(true);
var lambda = Expression.Lambda(trueConstant, parameter);
var groupByExpression = Expression.Call(genericMethod, queryable.Expression, lambda);
var result = queryable.Provider.CreateQuery(groupByExpression);
return result;
}
2018-02-11 20:55:29 -05:00
}
}