[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>() {  3, 4, 5, -2, -5, 11, 23,  };
            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方法有三個重載方法。

對自定義類型排序

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=2},
                new Person(){Name="d",Age=9},
                new Person(){Name="b",Age=3},
                new Person(){Name="c",Age=10}
            };
       
            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=2},
                new Person(){Name="b",Age=9},
                new Person(){Name="c",Age=3},
                new Person(){Name="d",Age=10}
            };
            //匿名委托
            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=2},
                new Person(){Name="d",Age=9},
                new Person(){Name="b",Age=3},
                new Person(){Name="c",Age=10}
            };
            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();
        }
    }
}

總結

 從下班弄到現在，一直整理筆記。泛型集合的排序選一個順手的就行。