Question

当我从OrderBy使用时，我得到此错误DbSortClause表达式必须具有可比较的类型。参数名称：key。我不知道如何更改此代码

 var resAsc = this.Context.Set<TEntity>().AsNoTracking().Where(predicate: predicate).OrderBy(s => sortItem.SortItems.Select(w => w.SortText).ToList()).Skip(page * size).Take(page).ToList().AsQueryable();

我该如何解决？

编辑：我想将参数发送到此方法，例如

 string test = "Id";
        SortOption objsort = new SortOption();
        objsort.SortItems = new List<SortItem>();
        objsort.SortItems.Add(new SortItem { SortText = "Id" });
        objsort.SortOrderType = EnumTypes.SortOrder.Ascending;
        var res = ApplicationService.SearchPage(w => w.Id > 2, objsort, 1, 3);

现在我在这里得到这些参数

  public Paginated<TEntity> SearchPage(Expression<Func<TEntity, bool>> predicate, SortOption sortItem, int page, int size)
    {
        Paginated<TEntity> objPage = new Paginated<TEntity>();
        if (sortItem.SortOrderType == EnumTypes.SortOrder.Ascending)
        {

            var resAsc = this.Context.Set<TEntity>().AsNoTracking().Where(predicate: predicate).OrderBy(s => sortItem.SortItems.Select(w => w.SortText).ToList()).Skip(page * size).Take(page).ToList().AsQueryable();
            objPage.Data = resAsc;
            objPage.TotalCount = this.Context.Set<TEntity>().Count();
            return objPage;
        }
        var resDesc = this.Context.Set<TEntity>().AsNoTracking().Where(predicate: predicate).OrderByDescending(s => sortItem.SortItems.Select(w => w.SortText)).Skip(page * size).Take(page).ToList().AsQueryable();
        objPage.Data = resDesc;
        objPage.TotalCount = this.Context.Set<TEntity>().Count();
        return objPage;

    }

实际上，我想在这里得到这个Id var resAsc = this.Context.Set<TEntity>().AsNoTracking().Where(predicate: predicate).OrderBy(s => s.Id).Skip(page * size).Take(page).ToList().AsQueryable();

Answer 1

您可以使用以下代码或从中获取灵感。它为您提供了一个名为IEnumerable<TEntity>的扩展方法Prepare。此方法将选择与谓词匹配的项目，然后它将对实体进行排序并最终对其进行分页。

您可以根据需要提供尽可能多的ColumnOrderConfiguration个对象。它将使用OrderBy和ThenBy来创建正确的结果。

请注意，在使用数据库时，您必须使用Expression<Func<,>>而不是Func<,>和IDbSet而不是IEnumerable。

public class ColumnOrderConfiguration<TEntity>
{
    public Func<TEntity, object> ValueSelector { get; set; } = entity => null;
    public SortOrder SortOrder { get; set; } = SortOrder.Ascending;
}

public static class CollectionPreparationExtensions
{
    public static IEnumerable<TEntity> Prepare<TEntity>(this IEnumerable<TEntity> entities, Func<TEntity, bool> predicate, IEnumerable<ColumnOrderConfiguration<TEntity>> orderConfiguration, int pageIndex, int pageSize)
        => entities.Where(predicate).OrderBy(orderConfiguration).Skip(pageIndex * pageSize).Take(pageSize);

    private static IEnumerable<TEntity> OrderBy<TEntity>(this IEnumerable<TEntity> entities, IEnumerable<ColumnOrderConfiguration<TEntity>> orderConfiguration)
    {
        var configurations = orderConfiguration.ToArray();

        if (!configurations.Any())
            return entities;

        var firstOrderConfiguration = configurations.First();
        var orderedEntities = entities.OrderBy(firstOrderConfiguration.ValueSelector, firstOrderConfiguration.SortOrder);

        for (var i = 1; i < configurations.Length; i++)
        {
            orderedEntities = orderedEntities.ThenBy(configurations[i].ValueSelector, configurations[i].SortOrder);
        }
        return orderedEntities;
    }

    private static IOrderedEnumerable<TEntity> ThenBy<TEntity>(this IOrderedEnumerable<TEntity> entities, Func<TEntity, object> valueSelector, SortOrder sortOrder)
    {
        if (sortOrder == SortOrder.Descending)
            return entities.ThenByDescending(valueSelector);
        return entities.ThenBy(valueSelector);
    }
    private static IOrderedEnumerable<TEntity> OrderBy<TEntity>(this IEnumerable<TEntity> entities, Func<TEntity, object> valueSelector, SortOrder sortOrder)
    {
        if (sortOrder == SortOrder.Descending)
            return entities.OrderByDescending(valueSelector);
        return entities.OrderBy(valueSelector);
    }
}

这就是你如何使用它。

public class MyTestEntity
{
    public bool IsTrue { get; set; }
    public string OrderText { get; set; }
    public int ThenOrderBy { get; set; }
}

var entities = new List<MyTestEntity>(new []
{
    new MyTestEntity { IsTrue = true, OrderText = "1234", ThenOrderBy = 4321 },
    new MyTestEntity { IsTrue = true, OrderText = "000001", ThenOrderBy = 000001 },
    new MyTestEntity { IsTrue = false }
});
var searchPredicate = new Func<MyTestEntity, bool>(entity => entity.IsTrue);
var orderConfig = new List<ColumnOrderConfiguration<MyTestEntity>>(new []
{
    // first order by `OrderText` ascending
    new ColumnOrderConfiguration<MyTestEntity>
    {
        ValueSelector = entity => entity.OrderText,
        SortOrder = SortOrder.Ascending
    },
    // then order by `ThenOrderBy` descending
    new ColumnOrderConfiguration<MyTestEntity>
    {
        ValueSelector = entity => entity.ThenOrderBy,
        SortOrder = SortOrder.Descending
    }
});
var pageIndex = 0;
var pageSize = 20;

var result = entities.Prepare(searchPredicate, orderConfig, pageIndex, pageSize);

DbSortClause表达式必须具有可比较的类型。参数名称：key

1 个答案: