如何合并两个排序函数

本文关键字：两个 排序 函数 合并 何合并 | 更新日期: 2023-09-27 18:04:35

我使用以下类按type成员排序列表:

public class CameraSortByType : IComparer<Camera>
{
    private bool asc;
    public CameraSortByType(bool a)
    {
        this.asc = a;
    }
    public int Compare(Camera x, Camera y)
    {
        if (x.type > y.type)
            return asc? -1 : 1;
        if (x.type < y.type)
            return asc? 1 : -1;
        else
            return 0;
    }
}

我也通过name排序相同的列表:

myList.Sort((s1, s2) => s2.name.CompareTo(s1.name));

如何将按名称排序合并到按类型排序类中?所以当我按类型排序时它也按名字排序?

Update: Linq version

var primarySortResult = primarySort ? CameraStorage.CameraList.OrderBy(x => x.type) : CameraStorage.CameraList.OrderByDescending(x => x.type);
var secondarySortResult = secondarySort ? primarySortResult.ThenBy(x => x.name) : primarySortResult.ThenByDescending(x => x.name);
CameraStorage.CameraList = secondarySortResult.ToList();

如何合并两个排序函数

如果LINQ是一个选项，您可以使用以下操作符来创建有序序列:

  • OrderBy -按升序对序列中的元素进行排序
  • orderby降序排序
  • ThenBy -按升序对序列中的元素进行后续排序
  • thenby降序-后续降序排序
示例:

var orderedList = myList.OrderBy(x => x.type)
                        .ThenByDescending(x => x.name)
                        .ToList();

如果您需要根据某些条件订购:

var result = ascendingByType ? myList.OrderBy(x => x.type) :
                               myList.OrderByDescending(x => x.type);
if (orderByNameRequired)
{
    result = ascendingByName ? result.ThenBy(x => x.name) :
                               result.ThenByDescending(x => x.name);
}
orderedList = result.ToList();

也考虑使用Dynamic Linq

这里还有对两个属性进行排序的比较实现(这里也考虑null处理):

public class CameraComparer : IComparer<Camera>
{
    private SortDirection typeSortDirection;
    private SortDirection nameSortDirection;
    public CameraComparer(SortDirection typeSortDirection, 
                          SortDirection nameSortDirection)
    {
        this.typeSortDirection = typeSortDirection;
        this.nameSortDirection = nameSortDirection;
    }
    public int Compare(Camera x, Camera y)
    {
        if (x.Type == y.Type)
            return x.Name.CompareTo(y.Name) * 
           (nameSortDirection == SortDirection.Ascending ? 1 : -1);
        return x.Type.CompareTo(y.Type) * 
           (typeSortDirection == SortDirection.Ascending ? 1 : -1);
    }
}
public enum SortDirection
{
    Ascending,
    Descending
}

用法:

myList.Sort(new CameraComparer(SortDirection.Ascending, SortDirection.Descending));

我使用Tuple s的情况如下:

public int Compare(Camera x, Camera y) {
    var xx = Tuple.Create(x.name, x.type);
    var yy = Tuple.Create(y.name, y.type);
    return xx.CompareTo(yy);
}

也就是说，假设您希望以相同的顺序比较所有属性。如果没有，我认为您可以通过执行以下操作来颠倒属性(例如name)的顺序:

var xx = Tuple.Create(y.name, x.type);
var yy = Tuple.Create(x.name, y.type);

也就是说，把它放在"错误的"元组中。但是我还没有测试过这部分

public int Compare(Camera x, Camera y)
{
    if (x.type > y.type)
        return asc ? -1 : 1;
    if (x.type < y.type)
        return asc ? 1 : -1;
    if (x.name.CompareTo(y.name) > 0)
        return asc ? -1 : 1;
    if (x.name.CompareTo(y.name) < 0)
        return asc ? 1 : -1;
    return 0;
}
相关文章：