ASP.NET Core — как устранить ошибку CS0407 «BinaryExpression Expression.Or(Expression, Expression)» имеет неправильный т ⇐ C#

[Anonymous]

В веб-API ASP.NET Core-8 с Entity Framework
Я получил следующую ошибку:
Код серьезности Описание Состояние подавления строки файла проекта
Ошибка CS0407 «BinaryExpression Expression.Or(Expression, Expression)» имеет неверный тип возвращаемого значения
выделяется:
var CombinedFilter = searchConditions.Aggregate(Expression.Or);
в
Expression.Or
из:
публичная асинхронная виртуальная задача
GetPagedReponseWithSearchSortAsync(фильтр PagingFilter)
Пожалуйста, помогите решить эту проблему
PagingDto:
public class PagingDto
{
private int _pageNumber = 1;
private int _pageSize = 10;

public int PageNumber
{
get => _pageNumber;
set => _pageNumber = value _pageSize;
set => _pageSize = value 100 ? 100 : value);
}
}

Фильтр страниц:
public class PagingFilter : PagingDto
{
public string SearchQuery { get; set; }
public string SortBy { get; set; }
public bool IsSortAscending { get; set; }
public DateTime? StartDate { get; set; }
public DateTime? EndDate { get; set; }
}

Список страниц:
public class PaginatedList
{
public List Items { get; }
public int PageNumber { get; }
public int TotalPages { get; }
public int TotalCount { get; }
public int PageSize { get; }

public PaginatedList(List items, int count, int pageNumber, int pageSize)
{
Items = items;
TotalCount = count;
PageNumber = pageNumber;
PageSize = pageSize;
TotalPages = (int)Math.Ceiling(count / (double)pageSize);
}

public bool HasPreviousPage => PageNumber > 1;
public bool HasNextPage => PageNumber < TotalPages;

public static PaginatedList Create(IQueryable source, int pageNumber, int pageSize)
{
var count = source.Count();
var items = source.Skip((pageNumber - 1) * pageSize).Take(pageSize).ToList();
return new PaginatedList(items, count, pageNumber, pageSize);
}
public static async Task
> CreateAsync(IQueryable source, int pageIndex, int pageSize)
{
var count = await source.CountAsync();
var items = await source.Skip((pageIndex - 1) * pageSize).Take(pageSize).ToListAsync();
return new PaginatedList(items, count, pageIndex, pageSize);
}
}

GenericRepositoryAsync:
public class GenericRepositoryAsync : IGenericRepositoryAsync where T : BaseEntity
{
private readonly IApplicationDbContext _dbContext;
private readonly ICurrentUserService _currentUserService;
private readonly IDateTimeService _dateTimeService;
public GenericRepositoryAsync(IApplicationDbContext dbContext, ICurrentUserService currentUserService, IDateTimeService dateTimeService)
{
_dbContext = dbContext;
_currentUserService = currentUserService;
_dateTimeService = dateTimeService;
}
public virtual async Task GetByGUIDAsync(Guid id)
{
T entity = await _dbContext.Set().FirstOrDefaultAsync(e => e.Id == id && (e.IsDeleted == false || e.IsDeleted == null));
return entity!;
}
public async Task GetAllAsync()
{
return await _dbContext.Set().Where(e => e.IsDeleted == false || e.IsDeleted == null).ToListAsync();
}
public async Task GetAllAsync(Expression predicate)
{
return await _dbContext.Set().Where(predicate).Where(e => e.IsDeleted == false || e.IsDeleted == null).ToListAsync();
}

public async virtual Task GetPagedReponseWithSearchSortAsync(PagingFilter filter)
{
// Ensure valid pagination parameters
filter.PageNumber = filter.PageNumber e.IsDeleted == false || e.IsDeleted == null);

// Apply search filter if search query is provided
if (!string.IsNullOrEmpty(filter.SearchQuery))
{
var searchableProperties = typeof(T).GetProperties()
.Where(p => p.PropertyType == typeof(string));

var parameter = Expression.Parameter(typeof(T), "x");
var searchConditions = searchableProperties
.Select(prop =>
{
var propertyAccess = Expression.Property(parameter, prop);
var searchValue = Expression.Constant(filter.SearchQuery, typeof(string));
var containsMethod = typeof(string).GetMethod("Contains", new[] { typeof(string) });
return Expression.Call(propertyAccess, containsMethod, searchValue);
});

if (searchConditions.Any())
{
var combinedFilter = searchConditions.Aggregate(Expression.Or);
var lambda = Expression.Lambda(combinedFilter, parameter);
queryable = queryable.Where(lambda);
}
}

// Apply date range filter if dates are provided
if (filter.StartDate.HasValue && filter.EndDate.HasValue)
{
var createdDateProperty = typeof(T).GetProperty("CreatedAtUtc");
if (createdDateProperty != null)
{
var startDate = filter.StartDate.Value.Date;
var endDate = filter.EndDate.Value.Date.AddDays(1).AddTicks(-1);

queryable = queryable.Where(e =>
EF.Property(e, "CreatedAtUtc") >= startDate &&
EF.Property(e, "CreatedAtUtc") m.Name == orderByMethod && m.GetParameters().Length == 2)
.MakeGenericMethod(typeof(T), property.PropertyType);

queryable = (IQueryable)genericMethod
.Invoke(null, new object[] { queryable, lambda });
}
else
{
// Default sort by Id if invalid sort property
queryable = filter.IsSortAscending ?
queryable.OrderBy(e => e.Id) :
queryable.OrderByDescending(e => e.Id);
}
}
else
{
// Default sort by Id if no sort specified
queryable = queryable.OrderBy(e => e.Id);
}

// Execute the query with pagination
var totalCount = await queryable.CountAsync();
var items = await queryable
.Skip((filter.PageNumber - 1) * filter.PageSize)
.Take(filter.PageSize)
.AsNoTracking()
.ToListAsync();

return new PaginatedList(
items,
totalCount,
filter.PageNumber,
filter.PageSize);
}
}


Подробнее здесь: https://stackoverflow.com/questions/793 ... on-orexpre