System.Func.Invoke(System.Linq.IQueryable)

Here are the examples of the csharp api System.Func.Invoke(System.Linq.IQueryable) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

142 Examples 7

19 Source : EfRepository.cs
with MIT License
from ansel86castro

public Task<PagedQuery<T>> GetAllPaginated(
          int page = 1,
          int pageSize = 100,
          bool includeDetails = true,
          Func<IQueryable<T>, IQueryable<T>> filterFunc = null,
          Func<IQueryable<T>, IOrderedQueryable<T>> sortFunc = null,
          ReadConsistency consistency = ReadConsistency.Default)
        {
            var query = GetAll(includeDetails, consistency);

            if (filterFunc != null)
                query = filterFunc(query);

            return query.AsPagedQuery(page, pageSize, sortFunc);
        }

19 Source : Extensions.cs
with MIT License
from ansel86castro

public static async Task<PagedQuery<T>> AsPagedQuery<T>(this IQueryable<T> query, int page, int pageSize,            
            Func<IQueryable<T>, IOrderedQueryable<T>> sort)
        {
            var count = await query.LongCountAsync();

            page = Math.Max(1, page);
            pageSize = Math.Min(pageSize, 100);
            if (pageSize <= 0) pageSize = 100;

            var skip = pageSize * (page - 1);
            var totalPages = count / pageSize + (count % pageSize == 0 ? 0 : 1);

            if (sort != null)
                query = sort(query);

            var items = query.Skip(skip).Take(pageSize);
            return new PagedQuery<T>(items, page, totalPages, count);
        }

19 Source : QueryableExtensions.cs
with MIT License
from ansel86castro

public static async Task<PagedQuery<T>> PageBy<T>(this IQueryable<T> source, Func<IQueryable<T>, IQueryable<T>> filter, int skip = 0, int take = 50)
        {
            source = filter(source);
            var count = await source.CountAsync();
            return source.PageBy(count, skip, take);

        }

19 Source : Repository.cs
with MIT License
from AntonioFalcao

public async Task<TEnreplacedy> GetByIdAsync(TId id, CancellationToken cancellationToken, Func<IQueryable<TEnreplacedy>, IIncludableQueryable<TEnreplacedy, object>> include = default, bool asTracking = default)
        {
            if (Equals(id, default(TId))) return default;

            return asTracking
                ? include is null
                    ? await _dbSet.FindAsync(new object[] {id}, cancellationToken)
                    : await include(_dbSet).AsTracking().SingleOrDefaultAsync(x => Equals(x.Id, id), cancellationToken)
                : include is null
                    ? await _dbSet.AsNoTracking().SingleOrDefaultAsync(x => Equals(x.Id, id), cancellationToken)
                    : await include(_dbSet).AsNoTracking().SingleOrDefaultAsync(x => Equals(x.Id, id), cancellationToken);
        }

19 Source : Repository.cs
with MIT License
from AntonioFalcao

public TEnreplacedy GetById(TId id, Func<IQueryable<TEnreplacedy>, IIncludableQueryable<TEnreplacedy, object>> include = default, bool asTracking = default)
        {
            if (Equals(id, default(TId))) return default;
            if (include is null && asTracking) return _dbSet.Find(id);

            return include is null
                ? _dbSet.AsNoTracking().SingleOrDefault(x => Equals(x.Id, id))
                : include(_dbSet).AsNoTracking().SingleOrDefault(x => Equals(x.Id, id));
        }

19 Source : Repository.cs
with MIT License
from AntonioFalcao

public Task<List<TEnreplacedy>> GetAllAsync(
            CancellationToken cancellationToken,
            Expression<Func<TEnreplacedy, bool>> predicate = default,
            Func<IQueryable<TEnreplacedy>, IOrderedQueryable<TEnreplacedy>> orderBy = default,
            Func<IQueryable<TEnreplacedy>, IIncludableQueryable<TEnreplacedy, object>> include = default,
            bool asTracking = default)
        {
            var query = asTracking ? _dbSet.AsTracking() : _dbSet.AsNoTrackingWithIdenreplacedyResolution();

            query = include is null ? query : include(query);
            query = predicate is null ? query : query.Where(predicate);
            query = orderBy is null ? query : orderBy(query);

            return query.ToListAsync(cancellationToken);
        }

19 Source : Repository.cs
with MIT License
from AntonioFalcao

public PagedResult<TEnreplacedy> GetAll(
            PageParams pageParams,
            Expression<Func<TEnreplacedy, bool>> predicate = default,
            Func<IQueryable<TEnreplacedy>, IOrderedQueryable<TEnreplacedy>> orderBy = default,
            Func<IQueryable<TEnreplacedy>, IIncludableQueryable<TEnreplacedy, object>> include = default,
            bool asTracking = default)
        {
            var query = asTracking ? _dbSet.AsTracking() : _dbSet.AsNoTrackingWithIdenreplacedyResolution();

            query = include is null ? query : include(query);
            query = predicate is null ? query : query.Where(predicate);
            query = orderBy is null ? query : orderBy(query);

            return PagedResult<TEnreplacedy>.Create(query, pageParams);
        }

19 Source : Repository.cs
with MIT License
from AntonioFalcao

public PagedResult<TResult> GetAllProjections<TResult>(
            PageParams pageParams,
            Expression<Func<TEnreplacedy, TResult>> selector = default,
            Expression<Func<TEnreplacedy, bool>> predicate = default,
            Func<IQueryable<TEnreplacedy>, IOrderedQueryable<TEnreplacedy>> orderBy = default,
            Func<IQueryable<TEnreplacedy>, IIncludableQueryable<TEnreplacedy, object>> include = default,
            bool asTracking = default)
            where TResult : clreplaced
        {
            var query = asTracking ? _dbSet.AsTracking() : _dbSet.AsNoTrackingWithIdenreplacedyResolution();

            query = include is null ? query : include(query);
            query = predicate is null ? query : query.Where(predicate);
            query = orderBy is null ? query : orderBy(query);

            return selector is null
                ? PagedResult<TResult>.Create(_dbSet.ProjectTo<TResult>(_configuration), pageParams)
                : PagedResult<TResult>.Create(query.Select(selector), pageParams);
        }

19 Source : Repository.cs
with MIT License
from AntonioFalcao

public Task<PagedResult<TEnreplacedy>> GetAllAsync(
            PageParams pageParams,
            CancellationToken cancellationToken,
            Expression<Func<TEnreplacedy, bool>> predicate = default,
            Func<IQueryable<TEnreplacedy>, IOrderedQueryable<TEnreplacedy>> orderBy = default,
            Func<IQueryable<TEnreplacedy>, IIncludableQueryable<TEnreplacedy, object>> include = default,
            bool asTracking = default)
        {
            var query = asTracking ? _dbSet.AsTracking() : _dbSet.AsNoTrackingWithIdenreplacedyResolution();

            query = include is null ? query : include(query);
            query = predicate is null ? query : query.Where(predicate);
            query = orderBy is null ? query : orderBy(query);

            return PagedResult<TEnreplacedy>.CreateAsync(query, pageParams, cancellationToken);
        }

19 Source : Repository.cs
with MIT License
from AntonioFalcao

public Task<PagedResult<TResult>> GetAllProjectionsAsync<TResult>(
            PageParams pageParams,
            CancellationToken cancellationToken,
            Expression<Func<TEnreplacedy, TResult>> selector = default,
            Expression<Func<TEnreplacedy, bool>> predicate = default,
            Func<IQueryable<TEnreplacedy>, IOrderedQueryable<TEnreplacedy>> orderBy = default,
            Func<IQueryable<TEnreplacedy>, IIncludableQueryable<TEnreplacedy, object>> include = default,
            bool asTracking = default)
            where TResult : clreplaced
        {
            var query = asTracking ? _dbSet.AsTracking() : _dbSet.AsNoTrackingWithIdenreplacedyResolution();

            query = include is null ? query : include(query);
            query = predicate is null ? query : query.Where(predicate);
            query = orderBy is null ? query : orderBy(query);

            return selector is null
                ? PagedResult<TResult>.CreateAsync(_dbSet.ProjectTo<TResult>(_configuration), pageParams, cancellationToken)
                : PagedResult<TResult>.CreateAsync(query.Select(selector), pageParams, cancellationToken);
        }

19 Source : Repository.cs
with MIT License
from AntonioFalcao

public async Task<TEnreplacedy> GetByIdAsync(TId id, CancellationToken cancellationToken, Func<IQueryable<TEnreplacedy>, IIncludableQueryable<TEnreplacedy, object>> include = default, bool asTracking = default)
        {
            if (Equals(id, default(TId))) return default;
            if (include is null && asTracking) return await _dbSet.FindAsync(new object[] {id}, cancellationToken);

            return include is null
                ? await _dbSet.AsNoTracking().SingleOrDefaultAsync(x => Equals(x.Id, id), cancellationToken)
                : await include(_dbSet).AsNoTracking().SingleOrDefaultAsync(x => Equals(x.Id, id), cancellationToken);
        }

19 Source : RepositoryBase.cs
with MIT License
from aspnetrun

public async Task<IReadOnlyList<T>> GetAsync(Expression<Func<T, bool>> predicate = null,
            Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null,
            string includeString = null,
            bool disableTracking = true)
        {
            var query = disableTracking ? TableNoTracking : Table;

            if (!string.IsNullOrWhiteSpace(includeString))
            {
                query = query.Include(includeString);
            }

            if (predicate != null)
            {
                query = query.Where(predicate);
            }

            if (orderBy != null)
            {
                return await orderBy(query).ToListAsync();
            }

            return await query.ToListAsync();
        }

19 Source : Repository.cs
with MIT License
from aspnetrun

public async Task<IReadOnlyList<T>> GetAsync(Expression<Func<T, bool>> predicate = null, Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null, string includeString = null, bool disableTracking = true)
        {
            IQueryable<T> query = _dbContext.Set<T>();
            if (disableTracking) query = query.AsNoTracking();

            if (!string.IsNullOrWhiteSpace(includeString)) query = query.Include(includeString);

            if (predicate != null) query = query.Where(predicate);

            if (orderBy != null)
                return await orderBy(query).ToListAsync();
            return await query.ToListAsync();
        }

19 Source : Repository.cs
with MIT License
from aspnetrun

public async Task<IReadOnlyList<T>> GetAsync(Expression<Func<T, bool>> predicate = null, Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null, List<Expression<Func<T, object>>> includes = null, bool disableTracking = true)
        {
            IQueryable<T> query = _dbContext.Set<T>();
            if (disableTracking) query = query.AsNoTracking();

            if (includes != null) query = includes.Aggregate(query, (current, include) => current.Include(include));

            if (predicate != null) query = query.Where(predicate);

            if (orderBy != null)
                return await orderBy(query).ToListAsync();
            return await query.ToListAsync();
        }

19 Source : RepositoryBase.cs
with MIT License
from aspnetrun

public async Task<IReadOnlyList<T>> GetAsync(Expression<Func<T, bool>> predicate = null,
            Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null,
            List<Expression<Func<T, object>>> includes = null,
            bool disableTracking = true)
        {
            var query = disableTracking ? TableNoTracking : Table;

            if (includes != null)
            {
                query = includes.Aggregate(query, (current, include) => current.Include(include));
            }

            if (predicate != null)
            {
                query = query.Where(predicate);
            }

            if (orderBy != null)
            {
                return await orderBy(query).ToListAsync();
            }

            return await query.ToListAsync();
        }

19 Source : AspnetRunRepository.cs
with MIT License
from aspnetrun

public async Task<IReadOnlyList<T>> GetAsync(Expression<Func<T, bool>> predicate = null, Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null, string includeString = null, bool disableTracking = true)
        {
            IQueryable<T> query = _dbContext.Set<T>();
            if (disableTracking) query = query.AsNoTracking();
            
            if (!string.IsNullOrWhiteSpace(includeString)) query = query.Include(includeString);

            if (predicate != null) query = query.Where(predicate);

            if (orderBy != null)
                return await orderBy(query).ToListAsync();
            return await query.ToListAsync();
        }

19 Source : QueryableExtensions.cs
with MIT License
from AutoMapper

private static IQueryable<TData> GetDataQuery<TModel, TData>(this IQueryable<TData> query, IMapper mapper,
            Expression<Func<TModel, bool>> filter = null,
            Expression<Func<IQueryable<TModel>, IQueryable<TModel>>> queryFunc = null,
            IEnumerable<Expression<Func<TModel, object>>> includeProperties = null)
        {
            Expression<Func<TData, bool>> f = mapper.MapExpression<Expression<Func<TData, bool>>>(filter);
            Func<IQueryable<TData>, IQueryable<TData>> mappedQueryFunc = mapper.MapExpression<Expression<Func<IQueryable<TData>, IQueryable<TData>>>>(queryFunc)?.Compile();
            ICollection<Expression<Func<TData, object>>> includes = mapper.MapIncludesList<Expression<Func<TData, object>>>(includeProperties);

            if (filter != null)
                query = query.Where(f);

            if (includes != null)
                query = includes.Aggregate(query, (q, next) => q.Include(next));

            return mappedQueryFunc != null ? mappedQueryFunc(query) : query;
        }

19 Source : XpressionMapper.Structs.Tests.cs
with MIT License
from AutoMapper

internal static ICollection<TModel> Gereplacedems<TModel, TData>(this IQueryable<TData> query, IMapper mapper,
        Expression<Func<TModel, bool>> filter = null,
        Expression<Func<IQueryable<TModel>, IQueryable<TModel>>> queryFunc = null)
        {
            //Map the expressions
            Expression<Func<TData, bool>> f = mapper.MapExpression<Expression<Func<TData, bool>>>(filter);
            Func<IQueryable<TData>, IQueryable<TData>> queryableFunc = mapper.MapExpression<Expression<Func<IQueryable<TData>, IQueryable<TData>>>>(queryFunc)?.Compile();

            if (filter != null)
                query = query.Where(f);

            //Call the store
            ICollection<TData> list = queryableFunc != null ? queryableFunc(query).ToList() : query.ToList();

            //Map and return the data
            return mapper.Map<IEnumerable<TData>, IEnumerable<TModel>>(list).ToList();
        }

19 Source : XpressionMapper.Structs.Tests.cs
with MIT License
from AutoMapper

internal static TModelResult Query<TModel, TData, TModelResult, TDataResult>(this IQueryable<TData> query, IMapper mapper,
            Expression<Func<IQueryable<TModel>, TModelResult>> queryFunc)
        {
            //Map the expressions
            Func<IQueryable<TData>, TDataResult> mappedQueryFunc = mapper.MapExpression<Expression<Func<IQueryable<TData>, TDataResult>>>(queryFunc).Compile();

            //execute the query
            return mapper.Map<TDataResult, TModelResult>(mappedQueryFunc(query));
        }

19 Source : QueryableExtensions.cs
with MIT License
from AutoMapper

private static IQueryable<TModel> GetQuery<TModel, TData>(this IQueryable<TData> query,
            IMapper mapper,
            Expression<Func<TModel, bool>> filter = null,
            Expression<Func<IQueryable<TModel>, IQueryable<TModel>>> queryFunc = null,
            IEnumerable<Expression<Func<TModel, object>>> includeProperties = null,
            ProjectionSettings projectionSettings = null)
        {
            Expression<Func<TData, bool>> f = mapper.MapExpression<Expression<Func<TData, bool>>>(filter);
            Func<IQueryable<TData>, IQueryable<TData>> mappedQueryFunc = mapper.MapExpression<Expression<Func<IQueryable<TData>, IQueryable<TData>>>>(queryFunc)?.Compile();

            if (filter != null)
                query = query.Where(f);

            return mappedQueryFunc != null
                    ? mapper.ProjectTo(mappedQueryFunc(query), projectionSettings?.Parameters, GetIncludes())
                    : mapper.ProjectTo(query, projectionSettings?.Parameters, GetIncludes());

            Expression<Func<TModel, object>>[] GetIncludes() => includeProperties?.ToArray() ?? new Expression<Func<TModel, object>>[] { };
        }

19 Source : QueryableExtensions.cs
with MIT License
from AutoMapper

[Obsolete]
        public static async Task<TReturn> QueryAsync<TModel, TData, TModelReturn, TDataReturn, TReturn>(this IQueryable<TData> query, IMapper mapper,
            Expression<Func<IQueryable<TModel>, TModelReturn>> queryFunc,
            ICollection<Expression<Func<IQueryable<TModel>, IIncludableQueryable<TModel, object>>>> includeProperties = null)
        {
            Func<IQueryable<TData>, TDataReturn> mappedQueryFunc = mapper.MapExpression<Expression<Func<IQueryable<TData>, TDataReturn>>>(queryFunc).Compile();
            ICollection<Expression<Func<IQueryable<TData>, IIncludableQueryable<TData, object>>>> includes = mapper.MapIncludesList<Expression<Func<IQueryable<TData>, IIncludableQueryable<TData, object>>>>(includeProperties);

            if (includes != null)
                query = includes.Select(i => i.Compile()).Aggregate(query, (q, next) => q = next(q));

            TDataReturn result = await Task.Run(() => mappedQueryFunc(query));

            return typeof(TReturn) == typeof(TDataReturn) ? (TReturn)(object)result : mapper.Map<TDataReturn, TReturn>(result);
        }

19 Source : QueryableExtensions.cs
with MIT License
from AutoMapper

private static IQueryable<TData> GetDataQuery<TModel, TData>(this IQueryable<TData> query, IMapper mapper,
            Expression<Func<TModel, bool>> filter = null,
            Expression<Func<IQueryable<TModel>, IQueryable<TModel>>> queryFunc = null,
            ICollection<Expression<Func<IQueryable<TModel>, IIncludableQueryable<TModel, object>>>> includeProperties = null)
        {
            Expression<Func<TData, bool>> f = mapper.MapExpression<Expression<Func<TData, bool>>>(filter);
            Func<IQueryable<TData>, IQueryable<TData>> mappedQueryFunc = mapper.MapExpression<Expression<Func<IQueryable<TData>, IQueryable<TData>>>>(queryFunc)?.Compile();
            ICollection<Expression<Func<IQueryable<TData>, IIncludableQueryable<TData, object>>>> includes = mapper.MapIncludesList<Expression<Func<IQueryable<TData>, IIncludableQueryable<TData, object>>>>(includeProperties);

            if (filter != null)
                query = query.Where(f);

            if (includes != null)
                query = includes.Select(i => i.Compile()).Aggregate(query, (q, next) => q = next(q));

            return mappedQueryFunc != null ? mappedQueryFunc(query) : query;
        }

19 Source : QueryableExtensions.cs
with MIT License
from AutoMapper

[Obsolete]
        public static async Task<IQueryable<TModel>> GetQueryAsync<TModel, TData>(this IQueryable<TData> query, IMapper mapper,
            Expression<Func<TModel, bool>> filter = null,
            Expression<Func<IQueryable<TModel>, IQueryable<TModel>>> queryFunc = null,
            IEnumerable<Expression<Func<TModel, object>>> includeProperties = null,
            ProjectionSettings projectionSettings = null)
        {
            //Map the expressions
            Expression<Func<TData, bool>> f = mapper.MapExpression<Expression<Func<TData, bool>>>(filter);
            Func<IQueryable<TData>, IQueryable<TData>> mappedQueryFunc = mapper.MapExpression<Expression<Func<IQueryable<TData>, IQueryable<TData>>>>(queryFunc)?.Compile();

            if (filter != null)
                query = query.Where(f);

            return await Task.Run
            (
                () => mappedQueryFunc != null
                    ? mapper.ProjectTo(mappedQueryFunc(query), projectionSettings?.Parameters, GetIncludes())
                    : mapper.ProjectTo(query, projectionSettings?.Parameters, GetIncludes())
            );

            Expression<Func<TModel, object>>[] GetIncludes() => includeProperties?.ToArray() ?? new Expression<Func<TModel, object>>[] { };
        }

19 Source : QueryableExtensions.cs
with MIT License
from AutoMapper

[Obsolete]
        public static async Task<TReturn> QueryAsync<TModel, TData, TModelReturn, TDataReturn, TReturn>(this IQueryable<TData> query, IMapper mapper,
            Expression<Func<IQueryable<TModel>, TModelReturn>> queryFunc,
            IEnumerable<Expression<Func<TModel, object>>> includeProperties = null)
        {
            Func<IQueryable<TData>, TDataReturn> mappedQueryFunc = mapper.MapExpression<Expression<Func<IQueryable<TData>, TDataReturn>>>(queryFunc).Compile();
            ICollection<Expression<Func<TData, object>>> includes = mapper.MapIncludesList<Expression<Func<TData, object>>>(includeProperties);

            if (includes != null)
                query = includes.Aggregate(query, (q, next) => q.Include(next));

            TDataReturn result = await Task.Run(() => mappedQueryFunc(query));

            return typeof(TReturn) == typeof(TDataReturn) ? (TReturn)(object)result : mapper.Map<TDataReturn, TReturn>(result);
        }

19 Source : EfDbQuery.cs
with MIT License
from Avanade

private TResult ExecuteQuery<TResult>(Func<IQueryable<TModel>, TResult> execute)
        {
            return _db.Invoker.Invoke(this, () =>
            {
                var dbSet = _db.DbContext.Set<TModel>();
                return execute((_query == null) ? dbSet : _query(dbSet));
            }, _db);
        }

19 Source : CosmosDbQuery.cs
with MIT License
from Avanade

internal TModel ExecuteQuery(Func<IQueryable<TModel>, TModel> execute)
        {
            return _container.CosmosDb.Invoker.Invoke(this, () =>
            {
                return execute(AsQueryable(false));
            }, _container.CosmosDb);
        }

19 Source : CosmosDbValueQuery.cs
with MIT License
from Avanade

internal CosmosDbValue<TModel> ExecuteQuery(Func<IQueryable<CosmosDbValue<TModel>>, CosmosDbValue<TModel>> execute)
        {
            return _container.CosmosDb.Invoker.Invoke(this, () =>
            {
                return execute(AsQueryable(false));
            }, _container.CosmosDb);
        }

19 Source : Repository.cs
with MIT License
from bbartels

protected virtual IQueryable<T> BuildQueryable(
            Expression<Func<T, bool>> predicate = null,
            Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null,
            string includes = null,
            int? skip = null,
            int? take = null)
        {
            includes = includes ?? string.Empty;
            IQueryable<T> query = Context.Set<T>();

            if (predicate != null) { query = query.Where(predicate); }

            query = includes.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
                            .Aggregate(query, (current, include) => current.Include(include));

            if (orderBy != null) { query = orderBy(query); }

            if (skip.HasValue) { query = query.Skip(skip.Value); }
            if (take.HasValue) { query = query.Take(take.Value); }

            return query;
        }

19 Source : IQueryableExtensions.cs
with MIT License
from bbartels

public static async Task<IPagedResult<T>> ToPagedResultAsync<T>(this IQueryable<T> source, 
            Func<IQueryable<T>, Task<int>> CountAsync,
            Func<IQueryable<T>, Task<List<T>>> ToListAsync, 
            IResourceParameter<T> param)
        {
            int count = await CountAsync(source);
            int pageNum = GetPageNum(count, param.PageSize, param.PageNumber);
            var test = source.Skip((pageNum == 0 ? 1 : pageNum - 1) * param.PageSize)
                             .Take(param.PageSize);
            var items = await ToListAsync(test);
            return new PagedResult<T>(items, pageNum, param.PageSize, count);
        }

19 Source : IQueryableExtensions.cs
with MIT License
from bbartels

public static async Task<IPagedResult<T>> ToPagedResultAsync<T>(this IQueryable<T> source, 
            Func<IQueryable<T>, Task<int>> CountAsync,
            Func<IQueryable<T>, Task<List<T>>> ToListAsync, 
            IResourceParameter<T> param)
        {
            int count = await CountAsync(source);
            int pageNum = GetPageNum(count, param.PageSize, param.PageNumber);
            var test = source.Skip((pageNum == 0 ? 1 : pageNum - 1) * param.PageSize)
                             .Take(param.PageSize);
            var items = await ToListAsync(test);
            return new PagedResult<T>(items, pageNum, param.PageSize, count);
        }

19 Source : ViewService.cs
with GNU General Public License v3.0
from Caijt

protected IQueryable<TViewEnreplacedy> buildQuery(TQueryDto queryParams)
        {
            var query = dbQuery.AsNoTracking();

            #region 加载导航属性
            query = buildInclude(query);
            if (onInclude != null)
            {
                query = onInclude(query);
            }
            #endregion

            #region 查询条件
            query = buildWhere(query, queryParams);
            if (onWhere != null)
            {
                query = onWhere(query, queryParams);
            }
            #endregion

            #region 排序
            bool orderDesc = queryParams.orderDesc.GetValueOrDefault(orderDescDefaultValue);
            if (orderDefaultProp != null)
            {
                query = orderDesc ? query.OrderByDescending(orderDefaultProp) : query.OrderBy(orderDefaultProp);
            }
            var exp = buildOrderProp(queryParams.orderProp) ??
                (orderProp != null ? orderProp(queryParams.orderProp) : null);
            if (exp != null)
            {
                query = orderDesc ? query.OrderByDescending(exp) : query.OrderBy(exp);
            }
            #endregion

            return query;
        }

19 Source : ViewService.cs
with GNU General Public License v3.0
from Caijt

protected T get<T>(Expression<Func<TViewEnreplacedy, bool>> whereExp, Expression<Func<TViewEnreplacedy, T>> selectExp)
        {
            var query = dbQuery.AsNoTracking().Where(whereExp);
            query = buildInclude(query);
            if (onInclude != null)
            {
                query = onInclude(query);
            }
            return query.Select(selectExp).FirstOrDefault();
        }

19 Source : RepositoryExtensions.cs
with MIT License
from cloudnative-netcore

public static async Task<TEnreplacedy> GetByIdAsync<TDbContext, TEnreplacedy>(
            this IQueryRepository<TEnreplacedy> repo,
            Guid id,
            Func<IQueryable<TEnreplacedy>, IIncludableQueryable<TEnreplacedy, object>> include = null,
            bool disableTracking = true)
            where TDbContext : DbContext
            where TEnreplacedy : clreplaced, IAggregateRoot
        {
            var queryable = repo.Queryable();

            if (disableTracking) queryable = queryable.AsNoTracking();

            if (include != null) queryable = include.Invoke(queryable);

            return await queryable.SingleOrDefaultAsync(e => e.Id.Equals(id));
        }

19 Source : RepositoryExtensions.cs
with MIT License
from cloudnative-netcore

public static async Task<TEnreplacedy> FindOneAsync<TDbContext, TEnreplacedy>(
            this IQueryRepository<TEnreplacedy> repo,
            Expression<Func<TEnreplacedy, bool>> filter,
            Func<IQueryable<TEnreplacedy>, IIncludableQueryable<TEnreplacedy, object>> include = null,
            bool disableTracking = true)
            where TDbContext : DbContext
            where TEnreplacedy : clreplaced, IAggregateRoot
        {
            var queryable = repo.Queryable();

            if (include != null) queryable = include.Invoke(queryable);

            if (disableTracking) queryable = queryable.AsNoTracking();

            return await queryable.FirstOrDefaultAsync(filter);
        }

19 Source : RepositoryExtensions.cs
with MIT License
from cloudnative-netcore

public static async Task<IReadOnlyList<TEnreplacedy>> ListAsync<TDbContext, TEnreplacedy>(
            this IQueryRepository<TEnreplacedy> repo,
            Func<IQueryable<TEnreplacedy>, IIncludableQueryable<TEnreplacedy, object>> include = null,
            bool disableTracking = true)
            where TDbContext : DbContext
            where TEnreplacedy : clreplaced, IAggregateRoot
        {
            var queryable = repo.Queryable();

            if (include != null) queryable = include.Invoke(queryable);

            if (disableTracking) queryable = queryable.AsNoTracking();

            return await queryable.ToListAsync();
        }

19 Source : RepositoryExtensions.cs
with MIT License
from cloudnative-netcore

private static async Task<PaginatedItem<TResponse>> GetDataAsync<TDbContext, TEnreplacedy, TResponse>(
            IQueryRepository<TEnreplacedy> repo,
            Criterion criterion,
            Expression<Func<TEnreplacedy, TResponse>> selector,
            Expression<Func<TEnreplacedy, bool>> filter = null,
            Func<IQueryable<TEnreplacedy>, IIncludableQueryable<TEnreplacedy, object>> include = null,
            bool disableTracking = true)
            where TDbContext : DbContext
            where TEnreplacedy : clreplaced, IAggregateRoot
        {
            var queryable = repo.Queryable();
            if (disableTracking) queryable = queryable.AsNoTracking();

            if (include != null) queryable = include.Invoke(queryable);

            if (filter != null) queryable = queryable.Where(filter);

            if (!string.IsNullOrWhiteSpace(criterion.SortBy))
            {
                var isDesc = string.Equals(criterion.SortOrder, "desc", StringComparison.OrdinalIgnoreCase) ? true : false;
                queryable = queryable.OrderByPropertyName(criterion.SortBy, isDesc);
            }

            var results = await queryable
                .Skip(criterion.CurrentPage * criterion.PageSize)
                .Take(criterion.PageSize)
                .Select(selector)
                .ToListAsync();

            var totalRecord = await queryable.CountAsync();
            var totalPages = (int)Math.Ceiling((double)totalRecord / criterion.PageSize);

            if (criterion.CurrentPage > totalPages)
            {
                // criterion.SetCurrentPage(totalPages);
            }

            return new PaginatedItem<TResponse>(totalRecord, totalPages, results);
        }

19 Source : RepositoryWithTypeExtensions.cs
with MIT License
from cloudnative-netcore

public static async Task<TEnreplacedy> GetByIdAsync<TDbContext, TEnreplacedy, TId>(
            this IQueryRepositoryWithId<TEnreplacedy, TId> repo,
            Guid id,
            Func<IQueryable<TEnreplacedy>, IIncludableQueryable<TEnreplacedy, object>> include = null,
            bool disableTracking = true)
            where TDbContext : DbContext
            where TEnreplacedy : clreplaced, IAggregateRootWithId<TId>
        {
            var queryable = repo.Queryable();

            if (disableTracking) queryable = queryable.AsNoTracking();

            if (include != null) queryable = include.Invoke(queryable);

            return await queryable.SingleOrDefaultAsync(e => e.Id.Equals(id));
        }

19 Source : RepositoryWithTypeExtensions.cs
with MIT License
from cloudnative-netcore

public static async Task<TEnreplacedy> FindOneAsync<TDbContext, TEnreplacedy, TId>(
            this IQueryRepositoryWithId<TEnreplacedy, TId> repo,
            Expression<Func<TEnreplacedy, bool>> filter,
            Func<IQueryable<TEnreplacedy>, IIncludableQueryable<TEnreplacedy, object>> include = null,
            bool disableTracking = true)
            where TDbContext : DbContext
            where TEnreplacedy : clreplaced, IAggregateRootWithId<TId>
        {
            var queryable = repo.Queryable();

            if (include != null) queryable = include.Invoke(queryable);

            if (disableTracking) queryable = queryable.AsNoTracking();

            return await queryable.FirstOrDefaultAsync(filter);
        }

19 Source : RepositoryWithTypeExtensions.cs
with MIT License
from cloudnative-netcore

public static async Task<IReadOnlyList<TEnreplacedy>> ListAsync<TDbContext, TEnreplacedy, TId>(
            this IQueryRepositoryWithId<TEnreplacedy, TId> repo,
            Func<IQueryable<TEnreplacedy>, IIncludableQueryable<TEnreplacedy, object>> include = null,
            bool disableTracking = true)
            where TDbContext : DbContext
            where TEnreplacedy : clreplaced, IAggregateRootWithId<TId>
        {
            var queryable = repo.Queryable();

            if (include != null) queryable = include.Invoke(queryable);

            if (disableTracking) queryable = queryable.AsNoTracking();

            return await queryable.ToListAsync();
        }

19 Source : RepositoryWithTypeExtensions.cs
with MIT License
from cloudnative-netcore

private static async Task<PaginatedItem<TResponse>> GetDataAsync<TDbContext, TEnreplacedy, TId, TResponse>(
            IQueryRepositoryWithId<TEnreplacedy, TId> repo,
            Criterion criterion,
            Expression<Func<TEnreplacedy, TResponse>> selector,
            Expression<Func<TEnreplacedy, bool>> filter = null,
            Func<IQueryable<TEnreplacedy>, IIncludableQueryable<TEnreplacedy, object>> include = null,
            bool disableTracking = true)
            where TDbContext : DbContext
            where TEnreplacedy : clreplaced, IAggregateRootWithId<TId>
        {
            var queryable = repo.Queryable();
            if (disableTracking) queryable = queryable.AsNoTracking();

            if (include != null) queryable = include.Invoke(queryable);

            if (filter != null) queryable = queryable.Where(filter);

            if (!string.IsNullOrWhiteSpace(criterion.SortBy))
            {
                var isDesc = string.Equals(criterion.SortOrder, "desc", StringComparison.OrdinalIgnoreCase)
                    ? true
                    : false;
                queryable = queryable.OrderByPropertyName<TEnreplacedy, TId>(criterion.SortBy, isDesc);
            }

            var results = await queryable
                .Skip(criterion.CurrentPage * criterion.PageSize)
                .Take(criterion.PageSize)
                .Select(selector)
                .ToListAsync();

            var totalRecord = await queryable.CountAsync();
            var totalPages = (int)Math.Ceiling((double)totalRecord / criterion.PageSize);

            if (criterion.CurrentPage > totalPages)
            {
                // criterion.SetCurrentPage(totalPages);
            }

            return new PaginatedItem<TResponse>(totalRecord, totalPages, results);
        }

19 Source : ShardingIQueryable.T.cs
with MIT License
from Coldairarrow

private List<dynamic> GetStatisData(Func<IQueryable, dynamic> access, IQueryable<T> newSource = null)
        {
            newSource = newSource ?? _source;
            var tables = ShardingConfig.Instance.GetReadTables(_absTableName);
            List<Task<dynamic>> tasks = new List<Task<dynamic>>();
            tables.ForEach(aTable =>
            {
                tasks.Add(Task.Run(() =>
                {
                    var targetTable = MapTable(_absTableType, aTable.tableName);
                    var targetIQ = DbFactory.GetRepository(aTable.conString, aTable.dbType).GetIQueryable(targetTable);
                    var newQ = newSource.ChangeSource(targetIQ);

                    return access(newQ);
                }));
            });
            Task.WaitAll(tasks.ToArray());

            return tasks.Select(x => x.Result).ToList();
        }

19 Source : ShardingIQueryable.T.cs
with Apache License 2.0
from Coldairarrow

private async Task<List<TResult>> GetStatisDataAsync<TResult>(Func<IQueryable, Task<TResult>> access, IQueryable newSource = null)
        {
            newSource = newSource ?? _source;
            var tables = _shardingConfig.GetReadTables(_source);

            List<Task<TResult>> tasks = new List<Task<TResult>>();
            SynchronizedCollection<IDbAccessor> dbs = new SynchronizedCollection<IDbAccessor>();
            tasks = tables.Select(aTable =>
            {
                IDbAccessor db;
                if (_shardingDb.OpenedTransaction)
                    db = _shardingDb.GetMapDbAccessor(aTable.conString, aTable.dbType, aTable.suffix);
                else
                    db = _dbFactory.GetDbAccessor(new DbContextParamters
                    {
                        ConnectionString = aTable.conString,
                        DbType = aTable.dbType,
                        Suffix = aTable.suffix
                    });

                dbs.Add(db);
                var targetIQ = db.GetIQueryable<T>();
                var newQ = newSource.ReplaceQueryable(targetIQ);

                return access(newQ);
            }).ToList();
            var res = (await Task.WhenAll(tasks)).ToList();

            if (!_shardingDb.OpenedTransaction)
                dbs.ForEach(x => x.Dispose());

            return res;
        }

19 Source : SubCollectionReplacer.cs
with MIT License
from connellw

public Task LoadAsync(IQueryable<replacedem> itemsQuery)
        {
            IQueryable<TNav> navQuery = _selectAllNavFunc(itemsQuery).SelectMany(n => n);
            return  _replacementProcessor.LoadAllAsync(navQuery);
        }

19 Source : SubItemReplacer.cs
with MIT License
from connellw

public Task LoadAsync(IQueryable<replacedem> itemsQuery)
        {
            IQueryable<TNav> navQuery = _selectAllNavFunc(itemsQuery);
            return  _replacementProcessor.LoadAllAsync(navQuery);
        }

19 Source : EFCoreQueryableRepository.cs
with Apache License 2.0
from crazyants

public virtual IQueryable<TEnreplacedy> QueryFilter(
            Expression<Func<TEnreplacedy, bool>> predicate = null,
            Func<IQueryable<TEnreplacedy>, IOrderedQueryable<TEnreplacedy>> orderBy = null,
            List<Expression<Func<TEnreplacedy, object>>> includes = null,
            int? page = null,
            int? pageSize = null)
        {
            IQueryable<TEnreplacedy> query = Set;

            if (includes != null)
            {
                query = includes.Aggregate(query, (current, include) => current.Include(include));
            }
            if (orderBy != null)
            {
                query = orderBy(query);
            }
            if (predicate != null)
            {
                query = query.Where(predicate);
            }
            if (page != null && pageSize != null)
            {
                query = query.Skip(page.Value * pageSize.Value).Take(pageSize.Value);
            }
            return query;
        }

19 Source : Repository.cs
with MIT License
from DevExpress

public virtual IEnumerable<TEnreplacedy> Get(
            Expression<Func<TEnreplacedy, bool>> filter = null,
            Func<IQueryable<TEnreplacedy>, IOrderedQueryable<TEnreplacedy>> orderBy = null,
            string includeProperties = "") {
            IQueryable<TEnreplacedy> query = dbSet;

            if(filter != null) {
                query = query.Where(filter);
            }

            foreach(var includeProperty in includeProperties.Split
                (new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries)) {
                query = query.Include(includeProperty);
            }

            if(orderBy != null) {
                return orderBy(query).ToList();
            } else {
                return query.ToList();
            }
        }

19 Source : ObjectSpaceExtensions.cs
with Apache License 2.0
from eXpandFramework

public static IObservable<(T theObject, IObjectSpace objectSpace)> ExistingObject<T>(this IObjectSpace objectSpace,Func<IQueryable<T>,IQueryable<T>> query=null){
            var objectsQuery = objectSpace.GetObjectsQuery<T>();
            if (query != null){
                objectsQuery = objectsQuery.Concat(query(objectsQuery));
            }
            return objectsQuery.ToObservable().Pair(objectSpace).TraceRX();
        }

19 Source : EFRepository{TKey}.cs
with MIT License
from eyazici90

internal IQueryable<TEnreplacedy> Select(
            Expression<Func<TEnreplacedy, bool>> filter = null,
            Func<IQueryable<TEnreplacedy>, IOrderedQueryable<TEnreplacedy>> orderBy = null,
            List<Expression<Func<TEnreplacedy, object>>> includes = null,
            int? page = null,
            int? pageSize = null)
        {
            IQueryable<TEnreplacedy> query = DbSet;

            if (includes != null)
            {
                query = includes.Aggregate(query, (current, include) => current.Include(include));
            }
            if (orderBy != null)
            {
                query = orderBy(query);
            }
            if (filter != null)
            {
                query = query.Where(filter);
            }
            if (page != null && pageSize != null)
            {
                query = query.Skip((page.Value - 1) * pageSize.Value).Take(pageSize.Value);
            }
            return query;
        }

19 Source : FunctionIncludesProvider.cs
with MIT License
from firebend

public IQueryable<TEnreplacedy> AddIncludes(IQueryable<TEnreplacedy> queryable) => Func(queryable);

19 Source : GenericRepository.cs
with MIT License
from folkehelseinstituttet

public virtual async Task<IEnumerable<T>> GetAsync(
           Expression<Func<T, bool>> filter = null,
           Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null,
           string includeProperties = "")
        {
            IQueryable<T> query = _dbSet;

            if (filter != null)
                query = query.Where(filter);

            query = includeProperties.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
                .Aggregate(query, (current, includeProperty) => current.Include(includeProperty));

            return await (orderBy != null ? orderBy(query).ToListAsync() : query.ToListAsync());
        }

See More Examples