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

Question

当我从OrderBy使用时，我得到这个错误DbSortClause表达式必须有一个类似的命令。参数名称：键。 我不知道如何改变这种代码

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。此方法将选择与谓词相匹配的项目，然后它将命令实体并对其进行分类。

您可以根据需要放置尽可能多的对象。它将使用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);