LINQ 自定义排序

Question

我想要一个字母排序，但有一个例外。
我首先需要一个名称 =“Public”且 ID =“0”的组。
（宁愿使用 ID = 0）
之后，然后按名称对其余部分进行排序。
这不会首先公开。

public IEnumerable<GroupAuthority> GroupAuthoritysSorted 
{ 
   get 
   { 
       return GroupAuthoritys.OrderBy(x => x.Group.Name); 
   } 
}

我想要的是：

return GroupAuthoritys.Where(x => x.ID == 0)
       UNION 
       GroupAuthoritys.Where(x => x.ID > 0).OrderBy(x => x.Group.Name);

GroupAuthority 有一个公共属性 Group，Group 有公共属性 ID 和 Name。

我基本上使用了公认的答案

using System.ComponentModel;

namespace SortCustom
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            TestSort();
        }
        private void TestSort()
        {
            List<CustomSort> LCS = new List<CustomSort>();
            LCS.Add(new CustomSort(5, "sss"));
            LCS.Add(new CustomSort(6, "xxx"));
            LCS.Add(new CustomSort(4, "xxx"));
            LCS.Add(new CustomSort(3, "aaa"));
            LCS.Add(new CustomSort(7, "bbb"));
            LCS.Add(new CustomSort(0, "pub"));
            LCS.Add(new CustomSort(2, "eee"));
            LCS.Add(new CustomSort(3, "www"));
            foreach (CustomSort cs in LCS) System.Diagnostics.Debug.WriteLine(cs.Name);
            LCS.Sort();
            foreach (CustomSort cs in LCS) System.Diagnostics.Debug.WriteLine(cs.Name);
        }
    }
    public class CustomSort : Object, INotifyPropertyChanged, IComparable<CustomSort>
    {
        public event PropertyChangedEventHandler PropertyChanged;
        public void OnPropertyChanged(PropertyChangedEventArgs e)
        {
            if (PropertyChanged != null) PropertyChanged(this, e);
        }
        private Int16 id;
        private string name;
        public Int16 ID { get { return id; } }
        public String Name { get { return name; } }
        public int CompareTo(CustomSort obj)
        {
            if (this.ID == 0) return -1;
            if (obj == null) return 1;
            if (obj is CustomSort)
            {
                CustomSort comp = (CustomSort)obj;
                if (comp.ID == 0) return 1;
                return string.Compare(this.Name, comp.Name, true);
            }
            else
            {
                return 1;
            }
        }
        public override bool Equals(Object obj)
        {
            // Check for null values and compare run-time types.
            if (obj == null) return false;
            if (!(obj is CustomSort)) return false;
            CustomSort comp = (CustomSort)obj;
            return (comp.ID == this.ID); 
        }
        public override int GetHashCode()
        {
            return (Int32)ID;
        }
        public CustomSort(Int16 ID, String Name)
        {
            id = ID;
            name = Name;
        }
    }
}

Answer 1

您需要使用比较函数，它们是从您的类型的两个实例返回一个整数的函数，如果两者相等则返回 0，如果第一个小于第二个则返回负值，如果第一个返回正值大于秒。

MSDN 有一个nice table，比文字更容易理解（StackOverflow 在 2014 年仍然不支持表格）

IComparer<T>

大多数排序方法都接受IComparer<T> 类型的自定义比较器实现，您应该创建一个封装Group 的自定义规则：

class GroupComparer : IComparer<Group>
{
    public int Compare(Group a, Group b)
    {
        if (a != null && b != null && (a.Id == 0 || b.Id == 0))
        {
            if (a.Id == b.Id)
            {
                // Mandatory as some sort algorithms require Compare(a, b) and Compare(b, a) to be consitent
                return 0; 
            }
            return a.Id == 0 ? -1 : 1;
        }

        if (a == null || b == null)
        {
            if (ReferenceEquals(a, b))
            {
                return 0;
            }
            return a == null ? -1 : 1;
        }
        return Comparer<string>.Default.Compare(a.Name, b.Name);
    }
}

用法：

items.OrderBy(_ => _, new GroupAuthorityComparer());

IComparable<T>

如果这是比较 Group 实例的唯一方法，您应该让它实现 IComparable<T>，这样如果有人想对您的类进行排序，则不需要额外的代码：

class Group : IComparable<Group>
{
    ...

    public int CompareTo(Group b)
    {
        if (b != null && (Id == 0 || b.Id == 0))
        {
            if (Id == b.Id)
            {
                // Mandatory as some sort algorithms require Compare(a, b) and Compare(b, a) to be consitent
                return 0; 
            }
            return Id == 0 ? -1 : 1;
        }

        return Comparer<string>.Default.Compare(Name, b.Name);
    }   
}

用法：

items.OrderBy(_ => _.Group);

应根据使用此特定比较器的位置来选择一种方式或另一种方式：是此类项目的主要排序还是仅应在一种特定情况下使用的排序，例如仅在一些管理视图。

您甚至可以更上一层并提供IComparable<GroupAuthority> 实现（一旦集团实现IComparable<Group> 就很容易）：

class GroupAuthority : IComparable<GroupAuthority>
{
    ...

    public int CompareTo(GroupAuthority b)
    {
        return Comparer<Group>.Default.Compare(Group, b.Group);
    }
}

用法：

items.OrderBy(_ => _);

最后一个的优点是它会被自动使用，所以像GroupAuthoritys.ToList().Sort()这样的代码会开箱即用。

Answer 2

你可以试试这样的

list.Sort((x, y) =>
{
    if (x.Id == 0)
    {
        return -1;
    }
    if (y.Id == 0)
    {
        return 1;
    }

    return x.Group.Name.CompareTo(y.Group.Name);
});

列表是List<T>。

此方法利用List<T> 使用Comparison<T> 委托提供的自定义排序选项。

基本上这个方法的作用是，它只是在Id时添加特殊的比较条件，如果它是零，它会返回一个值，表明对象更小，这使得对象进入列表的顶部。如果不是，它会使用其Group.Name 属性按升序对对象进行排序。

Answer 3

    public IEnumerable<GroupAuthority> GroupAuthoritysSorted 
    { 
        get 
        { 
            return GroupAuthoritys.OrderBy(x => x.Group.ID == 0)
                                  .ThenBy(x => x.Group.Name); 
        } 
    }