C# 在C中使用Moq进行分页和排序的单元测试返回至少一个对象必须实现IComparable

我在C#和Moq中实现了分页和排序（通过多列）。现在我想为它创建一个单元测试，但我得到了一个错误：

“至少有一个对象必须实现IComparable”

我已经在日志对象中实现了IComparable，但我一直收到错误消息

我知道这个问题来自OrderBy，然后是ByDescending，等等。但是我认为在日志中实现IComparable就足以解决它了

无论如何，我只是在比较ID，但我应该能够通过sortColumns拥有的任何东西进行比较，也许每列创建一个比较器，但首先我必须知道如何使其工作

有什么建议吗

这是我的代码：

单元测试的片段。

logRepository.Setup(p => p.All()).Returns(logs.AsQueryable); 
var logService = new LogService { PrivateLoggingCatalog = catalog.Object };     
var logsReturned = logService.SearchLogs(null, null, 1, 10, new List<string>{"Message"}, new List<string>{"desc"}).Items.ToList();

logRepository.Setup（p=>p.All（））.Returns（logs.AsQueryable）；
var logService=newlogservice{PrivateLoggingCatalog=catalog.Object}；
var logsreern=logService.SearchLogs（null，null，1，10，新列表{“Message”}，新列表{“desc”}）；

日志服务

public class LogService : ILogService
{
    public PageOf<Log> SearchLogs(DateTime? from, DateTime? to, int pageNumber, int pageSize, IEnumerable<string> sortColumns, IEnumerable<string> sortDirections, string searchTerm = null)
    {
        var filteredData = PrivateLoggingCatalog.LogRepository.All()
                   .Where(x => (!from.HasValue || x.Date >= from)
                       && (!to.HasValue || x.Date < to));

        filteredData = FilterLogBySearchTerm(filteredData, searchTerm);

        return PageSortResult(filteredData, pageNumber, pageSize, sortColumns.ToList(), sortDirections.ToList());
    }

    private static IQueryable<T> FilterLogBySearchTerm<T>(IQueryable<T> filteredData, string searchTerm)
        where T : Log
    {
        if (!string.IsNullOrWhiteSpace(searchTerm))
        {
            filteredData = filteredData.Where(x => x.Level.Contains(searchTerm) ||
                                x.Message.ToUpper().Contains(searchTerm) ||
                                x.MachineName.ToUpper().Contains(searchTerm) ||
                                x.CallSite.ToUpper().Contains(searchTerm) ||
                                x.Exception.ToUpper().Contains(searchTerm) ||
                                x.Stacktrace.ToUpper().Contains(searchTerm) ||
                                x.ErrorClass.ToUpper().Contains(searchTerm) ||
                                x.ErrorMessage.ToUpper().Contains(searchTerm) ||
                                x.ErrorMethod.ToUpper().Contains(searchTerm) ||
                                x.ErrorSource.ToUpper().Contains(searchTerm) ||
                                x.InnerException.ToUpper().Contains(searchTerm));
        }
        return filteredData;
    }

    private static PageOf<T> PageSortResult<T>(IQueryable<T> filteredData, int pageNumber, int pageSize, IList<string> sortColumns, IList<string> sortDirections) where T : Log
    {
        IOrderedQueryable<T> items = null;

        items = sortDirections[0] == "asc"
                        ? filteredData.OrderBy(SortColumns<T>()[sortColumns.ElementAtOrDefault(0)])
                        : filteredData.OrderByDescending(SortColumns<T>()[sortColumns.ElementAtOrDefault(0)]);

        var i = 1;

        if (sortDirections.Count > 1)
        {
            sortDirections.RemoveAt(0);
            items = sortDirections.Aggregate(items, (current, sortDirection) => sortDirection == "asc" ? 
                current.ThenBy(SortColumns<T>()[sortColumns.ElementAtOrDefault(i++)]) : 
                current.ThenByDescending(SortColumns<T>()[sortColumns.ElementAtOrDefault(i++)]));
        }

        items = items.ThenByDescending(SortColumns<T>()["Id"]);

        var result = new PageOf<T>
        {
            TotalItems = filteredData.Count(),
            Items = items.Skip((pageNumber - 1) * pageSize).Take(pageSize)
        };

        return result;
    }

    static DictionaryWithDefault<string, Expression<Func<T, object>>> SortColumns<T>() where T : Log
    {
        return new DictionaryWithDefault<string, Expression<Func<T, object>>>(x => new { x.Id })
            {
                { "Id", x => new {x.Id} },
                { "Message", x => new {x.Message}},
                { "Level", x => new {x.Level}},
                { "Date", x => new {x.Date}},
                { "Logger", x => new {x.Logger}},
                { "MachineName", x => new {x.MachineName}},
                { "CallSite", x => new {x.CallSite}},
                { "Exception", x => new {x.Exception}},
                { "InnerException", x => new {x.InnerException}},
                { "Stacktrace", x => new {x.Stacktrace}},
                { "ErrorSource", x => new {x.ErrorSource}},
                { "ErrorClass", x => new {x.ErrorClass}},
                { "ErrorMethod", x => new {x.ErrorMethod}},
                { "ErrorMessage", x => new {x.ErrorMessage}}
            };
    }

公共类日志服务：ILogService
{
搜索日志的公共页面（DateTime？from，DateTime？to，int pageNumber，int pageSize，IEnumerable sortColumns，IEnumerable sortDirections，字符串searchTerm=null）
{
var filteredData=PrivateLoggingCatalog.LogRepository.All（）
.其中（x=>（！from.HasValue | | x.Date>=from）
&&（！to.HasValue | | x.Datex.Level.Contains（searchTerm）||
x、 Message.ToUpper（）包含（searchTerm）||
x、 MachineName.ToUpper（）包含（searchTerm）||
x、 CallSite.ToUpper（）包含（searchTerm）||
x、 Exception.ToUpper（）包含（searchTerm）||
x、 Stacktrace.ToUpper（）包含（searchTerm）||
x、 ErrorClass.ToUpper（）包含（searchTerm）||
x、 ErrorMessage.ToUpper（）包含（searchTerm）||
x、 ErrorMethod.ToUpper（）包含（searchTerm）||
x、 ErrorSource.ToUpper（）包含（searchTerm）||
x、 包含（searchTerm））；
}
返回过滤器数据；
}
PageSortResult（IQueryable filteredData、int pageNumber、int pageSize、IList sortColumns、IList sortDirections）的私有静态页面，其中T:Log
{
IOrderedQueryable项=空；
items=sortDirections[0]=“asc”
？filteredData.OrderBy（SortColumns（）[SortColumns.ElementAtOrderFault（0）]）
：filteredData.OrderByDescending（SortColumns（）[SortColumns.ElementAtOrderFault（0）]；
var i=1；
如果（sortDirections.Count>1）
{
sortDirections.RemoveAt（0）；
items=sortDirection.Aggregate（items，（当前，sortDirection）=>sortDirection==“asc”？
current.ThenBy（SortColumns（）[SortColumns.elementAtOrderFault（i++]）：
current.ThenByDescending（SortColumns（）[SortColumns.elementAtOrderFault（i++]）；
}
items=items.ThenByDescending（SortColumns（）[“Id”]）；
var结果=新页面，共页
{
TotalItems=filteredData.Count（），
Items=Items.Skip（（页码-1）*页面大小）。Take（页面大小）
};
返回结果；
}
静态字典WithDefault SortColumns（），其中T:Log
{
返回newdictionaryWithDefault（x=>new{x.Id}）
{
{“Id”，x=>new{x.Id}，
{“Message”，x=>new{x.Message}，
{“Level”，x=>new{x.Level}，
{“Date”，x=>new{x.Date}，
{“Logger”，x=>new{x.Logger}，
{“MachineName”，x=>新的{x.MachineName}，
{“CallSite”，x=>new{x.CallSite}，
{“异常”，x=>new{x.Exception}，
{“InnerException”，x=>new{x.InnerException}，
{“Stacktrace”，x=>new{x.Stacktrace}，
{“ErrorSource”，x=>new{x.ErrorSource}，
{“ErrorClass”，x=>new{x.ErrorClass}，
{“ErrorMethod”，x=>新的{x.ErrorMethod}，
{“ErrorMessage”，x=>new{x.ErrorMessage}
};
}

Log.cs的片段

public class Log : Entity, IComparable
    {
      public int CompareTo(object other)
        {
            var log = (Log)other;
            if (this.Id > log.Id)
                return 1;

            if (this.Id < log.Id)
                return -1;

            return 0;
        }
}

公共类日志：实体，IComparable
{
公共整数比较（对象其他）
{
var log=（log）其他；
if（this.Id>log.Id）
返回1；
if（this.Id