[c#基础]泛型集合的自定义类型排序

引用

最近总有种感觉，自己复习的进度总被项目中的问题给耽搁了，项目中遇到的问题，不总结又不行，只能将复习基础方面的东西放后再放后。一直没研究过太深奥的东西，过去一年一直在基础上打转，写代码，反编译，不停的重复。一直相信，在你不知道要干嘛的时候，浮躁的时候，不如回到最基础的东西上，或许换种思考方式，会有不一样的收获。

泛型集合List<T>排序

先看一个简单的例子，int类型的集合：

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 namespace Wolfy.SortDemo
 {
     class Program
     {
         static void Main(string[] args)
         {
             List<int> list = new List<int>() {  , , , -, -, , ,  };
             Console.WriteLine("排序前....");
             foreach (int item in list)
             {
                 Console.Write(item+"\t");
             }
             list.Sort();
             Console.WriteLine();
             Console.WriteLine("排序后....");
             foreach (int item in list)
             {
                 Console.Write(item+"\t");
             }
             Console.Read();
         }
     }
 }

经sort方法之后，采用了升序的方式进行排列的。

集合的Sort方法

  //
         // 摘要:
         //     使用默认比较器对整个 System.Collections.Generic.List<T> 中的元素进行排序。
         //
         // 异常:
         //   System.InvalidOperationException:
         //     默认比较器 System.Collections.Generic.Comparer<T>.Default 找不到 T 类型的 System.IComparable<T>
         //     泛型接口或 System.IComparable 接口的实现。
         public void Sort();
         //
         // 摘要:
         //     使用指定的 System.Comparison<T> 对整个 System.Collections.Generic.List<T> 中的元素进行排序。
         //
         // 参数:
         //   comparison:
         //     比较元素时要使用的 System.Comparison<T>。
         //
         // 异常:
         //   System.ArgumentNullException:
         //     comparison 为 null。
         //
         //   System.ArgumentException:
         //     在排序过程中，comparison 的实现会导致错误。 例如，将某个项与其自身进行比较时，comparison 可能不返回 0。
         public void Sort(Comparison<T> comparison);
         //
         // 摘要:
         //     使用指定的比较器对整个 System.Collections.Generic.List<T> 中的元素进行排序。
         //
         // 参数:
         //   comparer:
         //     比较元素时要使用的 System.Collections.Generic.IComparer<T> 实现，或者为 null，表示使用默认比较器 System.Collections.Generic.Comparer<T>.Default。
         //
         // 异常:
         //   System.InvalidOperationException:
         //     comparer 为 null，且默认比较器 System.Collections.Generic.Comparer<T>.Default 找不到
         //     T 类型的 System.IComparable<T> 泛型接口或 System.IComparable 接口的实现。
         //
         //   System.ArgumentException:
         //     comparer 的实现导致排序时出现错误。 例如，将某个项与其自身进行比较时，comparer 可能不返回 0。
         public void Sort(IComparer<T> comparer);
         //
         // 摘要:
         //     使用指定的比较器对 System.Collections.Generic.List<T> 中某个范围内的元素进行排序。
         //
         // 参数:
         //   index:
         //     要排序的范围的从零开始的起始索引。
         //
         //   count:
         //     要排序的范围的长度。
         //
         //   comparer:
         //     比较元素时要使用的 System.Collections.Generic.IComparer<T> 实现，或者为 null，表示使用默认比较器 System.Collections.Generic.Comparer<T>.Default。
         //
         // 异常:
         //   System.ArgumentOutOfRangeException:
         //     index 小于 0。 - 或 - count 小于 0。
         //
         //   System.ArgumentException:
         //     index 和 count 未指定 System.Collections.Generic.List<T> 中的有效范围。 - 或 - comparer
         //     的实现导致排序时出现错误。 例如，将某个项与其自身进行比较时，comparer 可能不返回 0。
         //
         //   System.InvalidOperationException:
         //     comparer 为 null，且默认比较器 System.Collections.Generic.Comparer<T>.Default 找不到
         //     T 类型的 System.IComparable<T> 泛型接口或 System.IComparable 接口的实现。
         public void Sort(int index, int count, IComparer<T> comparer);

Sort()

可见sort方法有三个重载方法。

对自定义类型排序

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;

 namespace Wolfy.SortDemo
 {
     public class Person
     {
         public string Name { set; get; }
         public int Age { set; get; }
    }
 }

对Person进行sort后输出，就会出现如下异常：

对自定义的Person类型进行排序，出现异常。那为什么int类型就没有呢？可以反编译一下，你会发现：

可见int类型是实现了IComparable这个接口的。那么如果让自定义类型Person也可以排序，那么试试实现该接口。

修改Person类

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;

 namespace Wolfy.SortDemo
 {
     public class Person : IComparable
     {
         public string Name { set; get; }
         public int Age { set; get; }

         /// <summary>
         /// 实现接口中的方法
         /// </summary>
         /// <param name="obj"></param>
         /// <returns></returns>
         public int CompareTo(object obj)
         {
             Person p = obj as Person;
             //因为int32实现了接口IComparable，那么int也有CompareTo方法，直接调用该方法就行
             return this.Age.CompareTo(p.Age);
         }
     }
 }

CompareTo方法的参数为要与之进行比较的另一个同类型对象，返回值为int类型，如果返回值大于0，表示第一个对象大于第二个对象，如果返回值小于0,表示第一个对象小于第二个对象，如果返回0,则两个对象相等。
定义好默认比较规则后，就可以通过不带参数的Sort方法对集合进行排序。

测试结果：

以上采用的sort()方法排序的结果。

实际使用中，经常需要对集合按照多种不同规则进行排序，这就需要定义其他比较规则，可以在Compare方法中定义，该方法属于IComparer<T>泛型接口，请看下面的代码：

 namespace Wolfy.SortDemo
 {
     public class PersonNameDesc:IComparer<Person>
     {
         //存放排序器实例
         public static PersonNameDesc NameDesc = new PersonNameDesc();
         public int Compare(Person x, Person y)
         {
             return System.Collections.Comparer.Default.Compare(x.Name, y.Name);
         }
     }
 }

Compare方法的参数为要进行比较的两个同类型对象，返回值为int类型，返回值处理规则与CompareTo方法相同。其中的Comparer.Default返回一个内置的Comparer对象，用于比较两个同类型对象。

下面用新定义的这个比较器对集合进行排序：

  class Program
     {
         static void Main(string[] args)
         {
             List<Person> list = new List<Person>()
             {
                 new Person(){Name="a",Age=},
                 new Person(){Name="d",Age=},
                 new Person(){Name="b",Age=},
                 new Person(){Name="c",Age=}
             };

             list.Sort(PersonNameDesc.NameDesc);
             foreach (Person p in list)
             {
                 Console.WriteLine(p.Name + "\t" + p.Age);
             }
             Console.Read();
         }
     }

测试结果：

Sort(int index, int count, IComparer<T> comparer)

同上面的类似，只是这个是取范围的。

Sort(Comparison<T> comparison)

sort方法的一个重载是Comparison<T>类型的参数，那么Comparison到底是什么东东呢？，说实话，不F12还真发现不了。

 #region 程序集 mscorlib.dll, v4.0.0.0
 // C:\Program Files\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5\mscorlib.dll
 #endregion

 namespace System
 {
     // 摘要:
     //     表示比较同一类型的两个对象的方法。
     //
     // 参数:
     //   x:
     //     要比较的第一个对象。
     //
     //   y:
     //     要比较的第二个对象。
     //
     // 类型参数:
     //   T:
     //     要比较的对象的类型。
     //
     // 返回结果:
     //     一个有符号整数，指示 x 与 y 的相对值，如下表所示。 值 含义 小于 0 x 小于 y。 0 x 等于 y。 大于 0 x 大于 y。
     public delegate int Comparison<in T>(T x, T y);
 }

看到这里就该笑了，委托啊，那么岂不是可以匿名委托，岂不是更方便啊。那么排序可以这样了。

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 namespace Wolfy.SortDemo
 {
     class Program
     {
         static void Main(string[] args)
         {
             List<Person> list = new List<Person>()
             {
                 new Person(){Name="a",Age=},
                 new Person(){Name="b",Age=},
                 new Person(){Name="c",Age=},
                 new Person(){Name="d",Age=}
             };
             //匿名委托
             list.Sort((a,b)=>a.Age-b.Age);
             foreach (Person p in list)
             {
                 Console.WriteLine(p.Name + "\t" + p.Age);
             }
             Console.Read();
         }
     }
 }

结果：

使用Linq排序

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 namespace Wolfy.SortDemo
 {
     class Program
     {
         static void Main(string[] args)
         {
             List<Person> list = new List<Person>()
             {
                 new Person(){Name="a",Age=},
                 new Person(){Name="d",Age=},
                 new Person(){Name="b",Age=},
                 new Person(){Name="c",Age=}
             };
             var l = from p in list
                     orderby p.Age descending
                     select p;
             //list.Sort(PersonNameDesc.NameDesc);
             foreach (Person p in l)
             {
                 Console.WriteLine(p.Name + "\t" + p.Age);
             }
             Console.Read();
         }
     }
 }

总结

从下班弄到现在，一直整理笔记。泛型集合的排序选一个顺手的就行。