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

当我使用from OrderBy时，我得到这个错误DBSORT子句表达式必须具有顺序可比的类型。参数名称：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();

var resAsc=this.Context.Set（）；

我如何解决它

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

 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);

string test=“Id”；
SortOption objsort=新的SortOption（）；
objsort.SortItems=新列表（）；
Add（新的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;

    }

公共分页搜索页面（表达式谓词、排序选项、排序项、整型页面、整型大小）
{
分页对象页=新分页（）；
if（sortItem.SortOrderType==EnumTypes.SortOrder.Ascending）
{
var resAsc=this.Context.Set（）.AsNoTracking（）.Where（谓词：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（）.Count（）；
返回objPage；
}
var resDesc=this.Context.Set（）.AsNoTracking（）.Where（谓词：谓词）.OrderByDescending（s=>sortItem.SortItems.Select（w=>w.SortText））.Skip（page*size）.Take（page.ToList（）.AsQueryable（）；
objPage.Data=resDesc；
objPage.TotalCount=this.Context.Set（）.Count（）；
返回objPage；
}

实际上，我想在这里得到这个

Id

---

var resAsc=this.Context.Set（）
您可以使用以下代码或从中获得灵感。它为您提供了一个名为
Prepare
的扩展方法
IEnumerable
。此方法将选择与谓词匹配的项，然后对实体排序并最终对其分页

您可以根据需要提供任意数量的
ColumnOrderConfiguration
对象。它将使用
OrderBy
和
ThenBy
创建正确的结果

请记住，在处理数据库时，必须使用
Expression
而不是
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);
    }
}

公共类ColumnOrderConfiguration
{
public Func ValueSelector{get；set；}=entity=>null；
公共SortOrder SortOrder{get；set；}=SortOrder.升序；
}
公共静态类集合PreparationExtensions
{
公共静态IEnumerable Prepare（此IEnumerable实体、Func谓词、IEnumerable orderConfiguration、int pageIndex、int pageSize）
=>实体.Where（谓词）.OrderBy（orderConfiguration）.Skip（pageIndex*pageSize）.Take（pageSize）；
私有静态IEnumerable OrderBy（此IEnumerable实体，IEnumerable orderConfiguration）
{
var configurations=orderConfiguration.ToArray（）；
如果（！configurations.Any（））
返回实体；
var firstOrderConfiguration=configurations.First（）；
var orderedEntities=entities.OrderBy（firstOrderConfiguration.ValueSelector，firstOrderConfiguration.SortOrder）；
对于（变量i=1；i

这就是你如何使用它

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);

公共类MyTestEntity
{
公共布尔值为{get；set；}
公共字符串OrderText{get；set；}
公共int-ThenOrderBy{get；set；}
}
var实体=新列表（新[]
{
新MyTestEntity{IsTrue=true，OrderText=“1234”，然后orderby=4321}，
新MyTestEntity{IsTrue=true，OrderText=“000001”，然后OrderBy=000001}，
新MyTestEntity{IsTrue=false}
});
var searchPredicate=newfunc（entity=>entity.IsTrue）；
var orderConfig=新列表（新[]
{
//按'OrderText'升序排列的第一个顺序
新ColumnOrderConfiguration
{
ValueSelector=entity=>entity.OrderText，
SortOrder=SortOrder.升序
},
//然后按`然后按`降序排列
新ColumnOrderConfiguration
{
ValueSelector=entity=>entity.ThenOrderBy，
排序器=排序器。下降
}
});
var pageIndex=0；
var pageSize=20；
var result=entities.Prepare（searchPredicate、orderConfig、pageIndex、pageSize）；
问题是您试图对列表进行排序。由于IEnumerable未实现
IComparable
这是不可能的。你到底想点什么？@NtFreX我编辑我的问题，我只想从这个
ortItem.SortItems.Select（w=>w.SortText）