C# List Sort

 .net2005中的范型List类的Sort方法有四种形式，分别是
  1，不带有任何参数的Sort方法----Sort()；
  2，带有比较器参数的Sort方法 ----Sort(IComparer<T>)
  3，带有比较代理方法参数的Sort方法----Sort(Comparison<(Of <(T>)>))
  4，带有比较起参数，可以指定排序范围的Sort方法----Sort(Int32, Int32 IComparer(T))
  首先介绍第一种方法，使用这种方法不是对List中的任何元素对象都可以进行排序，List中的元素对象必须继承IComparable接口，并且要实现IComparable接口中的CompareTo()方法，在CompareTo()方法中要自己实现对象的比较规则。详细可以参照如下代码：

1. using System;
2. using System.Collections.Generic;
3. using System.Text;
5. namespace Comparer.SortObject
6. {
7.     /// <summary>
8.     /// List<>.Sort()的测试对象，类自己实现IComparable接口，
9.     /// 当需要对List中的SortTestObj1对象进行排序时，直接调用
10.     /// Sort()方法就可以了。
11.     /// </summary>
12.     public class SortTestObj1:IComparable
13.     {
14.         #region 类字段定义
15.         private int code;
16.         private string name;
17.         #endregion
18.         public SortTestObj1()
19.         {
20.             //
21.         }
23.         #region 属性定义
24.         public int Code
25.         {
26.             set { this.code = value; }
27.             get { return this.code; }
28.         }
29.         public string Name
30.         {
31.             set { this.name = value; }
32.             get { return this.name; }
33.         }
34.         #endregion
36.         #region 实现比较接口的CompareTo方法
37.         public int CompareTo(object obj)
38.         {
39.             int res = 0;
40.             try
41.             {
42.                 SortTestObj1 sObj = (SortTestObj1)obj;
43.                 if (this.code > sObj.code)
44.                 {
45.                     res = 1;
46.                 }
47.                 else if (this.code < sObj.code)
48.                 {
49.                     res = -1;
50.                 }
51.             }
52.             catch (Exception ex)
53.             {
54.                 throw new Exception("比较异常", ex.InnerException);
55.             }
56.             return res;
57.         }
58.         #endregion
59.     }
60. }

  第二种带有比较器参数的Sort方法，List中的元素对象不需要继承IComparable接口，但需要额外创建一个对象的比较器，下面的代码中的SortTestObj2类是准备要保存到范型List中的对象，SortTestObj2Camparer 类则是SortTestObj2类的比较器，这个比较起必须继承IComparer<T>接口，并且实现接口中的Compare()方法。详细做法可参照下面的代码。
SortTestObj2类

1. using System;
2. using System.Collections.Generic;
3. using System.Text;
5. namespace Comparer.SortObject
6. {
7.     /// <summary>
8.     /// List<>.Sort(IComparer<(Of <(T>)>))的测试对象，类自己没有实现IComparable接口，
9.     /// 当需要对List中的SortTestObj2对象进行排序时，需要实例化一个SortTestObj2Camparer
10.     /// 类型的比较器,在比较器中指明排序类型(按Code排序还是按Name排序)，然后调用
11.     /// xxxLst.Sort(SortTestObj2Camparer)方法就可以了。
12.     /// </summary>
13.     public class SortTestObj2
14.     {
15.         #region 类字段定义
16.         private int code;
17.         private string name;
18.         #endregion
19.         public SortTestObj2()
20.         {
21.             //
22.         }
24.         #region 属性定义
25.         public int Code
26.         {
27.             set { this.code = value; }
28.             get { return this.code; }
29.         }
30.         public string Name
31.         {
32.             set { this.name = value; }
33.             get { return this.name; }
34.         }
35.         #endregion
36.     }
37. }

SortTestObj2Camparer类

1. using System;
2. using System.Collections.Generic;
3. using System.Text;
4. using Comparer.SortObject;
6. namespace Comparer.Camparer
7. {
8.     [Flags]
9.     //排序类型定义
10.     public enum Obj2SortKind { Code, Name }
11.     /// <summary>
12.     /// SortTestObj2类排序用的比较器，继承IComparer<>接口，
13.     /// 实现接口中的Compare()方法。
14.     /// </summary>
15.     public class SortTestObj2Camparer : IComparer<SortTestObj2>
16.     {
17.         #region 类字段定义
18.         private Obj2SortKind sortKind;
19.         #endregion
21.         #region 构造器
22.         public SortTestObj2Camparer(Obj2SortKind sk)
23.         {
24.             this.sortKind = sk;
25.         }
26.         #endregion
28.         #region IComparer接口比较方法的实现
29.         public int Compare(SortTestObj2 obj1, SortTestObj2 obj2)
30.         {
31.             int res = 0;
32.             if ((obj1 == null) && (obj2 == null))
33.             {
34.                 return 0;
35.             }
36.             else if((obj1 != null) && (obj2 == null))
37.             {
38.                 return 1;
39.             }
40.             else if ((obj1 == null) && (obj2 != null))
41.             {
42.                 return -1;
43.             }
44.             
45.             if (sortKind == Obj2SortKind.Code)
46.             {
47.                 if (obj1.Code > obj2.Code)
48.                 {
49.                     res = 1;
50.                 }
51.                 else if (obj1.Code < obj2.Code)
52.                 {
53.                     res = -1;
54.                 }
55.             }
56.             else if(sortKind == Obj2SortKind.Name)
57.             {
58.                 res = obj1.Name.CompareTo(obj2.Name);
59.             }
60.             return res;
61.         }
62.         #endregion
65.     }
66. }

   第三种方法需要编写一个对象排序比较的方法，对List中的元素对象没有特殊的要求，但在比较方法中需要实现对象比较规则，这个方法实现后，就可以把这方名字作为参数委托给List的Sort方法，Sort方法在排序时会执行这个方法对List中的对象进行比较，详细可参照下面的代码。对List中元素我们还使用上面的SortTestObj2类对象。

1.         static void Main(string[] args)
2.         {
3.             //利用代理方法进行排序
4.             DelegateSort();
5.         }
6.         
7.         //Sort(Comparison<(Of <(T>)>))方法排序,这中方法需要先编写一个对象比较的方法,然后
8.         //把这个比较方法委托给List的Sort方法。
9.         //对象比较的方法
10.         private static int SortTestObj2Compare(SortTestObj2 obj1, SortTestObj2 obj2)
11.         {
12.             int res = 0;
13.             if ((obj1 == null) && (obj2 == null))
14.             {
15.                 return 0;
16.             }
17.             else if ((obj1 != null) && (obj2 == null))
18.             {
19.                 return 1;
20.             }
21.             else if ((obj1 == null) && (obj2 != null))
22.             {
23.                 return -1;
24.             }
25.             if (obj1.Code > obj2.Code)
26.             {
27.                 res = 1;
28.             }
29.             else if (obj1.Code < obj2.Code)
30.             {
31.                 res = -1;
32.             }
33.             return res;
34.         }
35.         //List的委托排序
36.         private static void DelegateSort()
37.         {
38.             List<SortTestObj2> objLst = new List<SortTestObj2>();
39.             SortTestObj2 obj1 = new SortTestObj2();
40.             obj1.Code = 3;
41.             obj1.Name = "TestObj1";
42.             objLst.Add(obj1);
43.             SortTestObj2 obj2 = new SortTestObj2();
44.             obj2.Code = 2;
45.             obj2.Name = "TestObj2";
46.             objLst.Add(obj2);
47.             SortTestObj2 obj3 = new SortTestObj2();
48.             obj3.Code = 4;
49.             obj3.Name = "TestObj4";
50.             objLst.Add(obj3);
51.             SortTestObj2 obj4 = new SortTestObj2();
52.             obj4.Code = 1;
53.             obj4.Name = "TestObj3";
54.             objLst.Add(obj4);
55.             SortTestObj2 obj5 = new SortTestObj2();
56.             obj5.Code = 6;
57.             obj5.Name = "TestObj6";
58.             objLst.Add(obj5);
59.             objLst.Sort(SortTestObj2Compare);
60.             Console.WriteLine("委托方法排序的结果");
61.             foreach (SortTestObj2 item in objLst)
62.             {
63.                 Console.WriteLine("Code=" + item.Code + ",Name=" + item.Name);
64.             }
65.         }

   对于第四排序方法，实际是第二种比较器排序的一个扩展，在指定排序比较器的同时，指定排序范围，即List中准备排序的开始元素索引和结束元素索引，代码样式如下：

1. //按Name进行排序
2.             SortTestObj2Camparer nameCmp = new SortTestObj2Camparer(Obj2SortKind.Name);
3.             objLst.Sort(1, 3, nameCmp);

下面的代码是对上面介绍的四种方法的进行测试的代码，可以结合上面代码建立一个控制台工程体会一下。

1. using System;
2. using System.Collections.Generic;
3. using System.Text;
4. using Comparer.SortObject;
5. using Comparer.Camparer;
7. namespace Comparer
8. {
9.     class Program
10.     {
11.         static void Main(string[] args)
12.         {
13.             //List中的对象实现了IComparable接口时的排序
14.             LstSort();
15.             //利用比较器排序
16.             LstComparerSort();
17.             //利用比较器，对List中指定的区间的元素排序
18.             LstFromToSort();
19.             //利用代理方法进行排序
20.             DelegateSort();
21.         }
23.         //Sort()方法排序
24.         private static void LstSort()
25.         {
26.             List<SortTestObj1> objLst = new List<SortTestObj1>();
27.             SortTestObj1 obj1 = new SortTestObj1();
28.             obj1.Code = 3;
29.             obj1.Name = "TestObj3";
30.             objLst.Add(obj1);
31.             SortTestObj1 obj2 = new SortTestObj1();
32.             obj2.Code = 2;
33.             obj2.Name = "TestObj2";
34.             objLst.Add(obj2);
35.             SortTestObj1 obj3 = new SortTestObj1();
36.             obj3.Code = 4;
37.             obj3.Name = "TestObj4";
38.             objLst.Add(obj3);
39.             //排序
40.             objLst.Sort();
41.             foreach(SortTestObj1 item in objLst)
42.             {
43.                 Console.WriteLine("Code=" + item.Code + ",Name=" + item.Name);
44.             }
45.         }
47.         //Sort(IComparer(T))方法排序
48.         private static void LstComparerSort()
49.         {
50.             List<SortTestObj2> objLst = new List<SortTestObj2>();
51.             SortTestObj2 obj1 = new SortTestObj2();
52.             obj1.Code = 3;
53.             obj1.Name = "TestObj1";
54.             objLst.Add(obj1);
55.             SortTestObj2 obj2 = new SortTestObj2();
56.             obj2.Code = 2;
57.             obj2.Name = "TestObj2";
58.             objLst.Add(obj2);
59.             SortTestObj2 obj3 = new SortTestObj2();
60.             obj3.Code = 4;
61.             obj3.Name = "TestObj4";
62.             objLst.Add(obj3);
63.             //按Code进行排序
64.             SortTestObj2Camparer codeCmp = new SortTestObj2Camparer(Obj2SortKind.Code);
65.             //排序
66.             objLst.Sort(codeCmp);
67.             Console.WriteLine("按Code排序的结果");
68.             foreach (SortTestObj2 item in objLst)
69.             {
70.                 Console.WriteLine("Code=" + item.Code + ",Name=" + item.Name);
71.             }
72.             //按Name进行排序
73.             SortTestObj2Camparer nameCmp = new SortTestObj2Camparer(Obj2SortKind.Name);
74.             objLst.Sort(nameCmp);
75.             Console.WriteLine("按Name排序的结果");
76.             foreach (SortTestObj2 item in objLst)
77.             {
78.                 Console.WriteLine("Code=" + item.Code + ",Name=" + item.Name);
79.             }
80.         }
82.         //Sort(Int32, Int32 IComparer(T))排序,指定List中排序的开始元素和终了元素
83.         private static void LstFromToSort()
84.         {
85.             List<SortTestObj2> objLst = new List<SortTestObj2>();
86.             SortTestObj2 obj1 = new SortTestObj2();
87.             obj1.Code = 3;
88.             obj1.Name = "TestObj1";
89.             objLst.Add(obj1);
90.             SortTestObj2 obj2 = new SortTestObj2();
91.             obj2.Code = 2;
92.             obj2.Name = "TestObj2";
93.             objLst.Add(obj2);
94.             SortTestObj2 obj3 = new SortTestObj2();
95.             obj3.Code = 4;
96.             obj3.Name = "TestObj4";
97.             objLst.Add(obj3);
98.             SortTestObj2 obj4 = new SortTestObj2();
99.             obj4.Code = 1;
100.             obj4.Name = "TestObj3";
101.             objLst.Add(obj4);
102.             SortTestObj2 obj5 = new SortTestObj2();
103.             obj5.Code = 6;
104.             obj5.Name = "TestObj6";
105.             objLst.Add(obj5);
106.             //按Code进行排序
107.             SortTestObj2Camparer codeCmp = new SortTestObj2Camparer(Obj2SortKind.Code);
108.             //排序
109.             objLst.Sort(1, 3, codeCmp);
110.             Console.WriteLine("按Code排序的结果");
111.             foreach (SortTestObj2 item in objLst)
112.             {
113.                 Console.WriteLine("Code=" + item.Code + ",Name=" + item.Name);
114.             }
115.             //按Name进行排序
116.             SortTestObj2Camparer nameCmp = new SortTestObj2Camparer(Obj2SortKind.Name);
117.             objLst.Sort(1, 3, nameCmp);
118.             Console.WriteLine("按Name排序的结果");
119.             foreach (SortTestObj2 item in objLst)
120.             {
121.                 Console.WriteLine("Code=" + item.Code + ",Name=" + item.Name);
122.             }
123.         }
125.         //Sort(Comparison<(Of <(T>)>))方法排序,这中方法需要先编写一个对象比较的方法,然后
126.         //把这个比较方法委托给List的Sort方法。
127.         //对象比较的方法
128.         private static int SortTestObj2Compare(SortTestObj2 obj1, SortTestObj2 obj2)
129.         {
130.             int res = 0;
131.             if ((obj1 == null) && (obj2 == null))
132.             {
133.                 return 0;
134.             }
135.             else if ((obj1 != null) && (obj2 == null))
136.             {
137.                 return 1;
138.             }
139.             else if ((obj1 == null) && (obj2 != null))
140.             {
141.                 return -1;
142.             }
143.             if (obj1.Code > obj2.Code)
144.             {
145.                 res = 1;
146.             }
147.             else if (obj1.Code < obj2.Code)
148.             {
149.                 res = -1;
150.             }
151.             return res;
152.         }
153.         //List的委托排序
154.         private static void DelegateSort()
155.         {
156.             List<SortTestObj2> objLst = new List<SortTestObj2>();
157.             SortTestObj2 obj1 = new SortTestObj2();
158.             obj1.Code = 3;
159.             obj1.Name = "TestObj1";
160.             objLst.Add(obj1);
161.             SortTestObj2 obj2 = new SortTestObj2();
162.             obj2.Code = 2;
163.             obj2.Name = "TestObj2";
164.             objLst.Add(obj2);
165.             SortTestObj2 obj3 = new SortTestObj2();
166.             obj3.Code = 4;
167.             obj3.Name = "TestObj4";
168.             objLst.Add(obj3);
169.             SortTestObj2 obj4 = new SortTestObj2();
170.             obj4.Code = 1;
171.             obj4.Name = "TestObj3";
172.             objLst.Add(obj4);
173.             SortTestObj2 obj5 = new SortTestObj2();
174.             obj5.Code = 6;
175.             obj5.Name = "TestObj6";
176.             objLst.Add(obj5);
177.             objLst.Sort(SortTestObj2Compare);
178.             Console.WriteLine("委托方法排序的结果");
179.             foreach (SortTestObj2 item in objLst)
180.             {
181.                 Console.WriteLine("Code=" + item.Code + ",Name=" + item.Name);
182.             }
183.         }
184.     }
185. }