C#比較類/接口、Dictionary 排序

作者：l625208058

鏈接：https://www.jianshu.com/p/cd1be6652570

先 F12 看下 List.Sort() 方法：

public void Sort(int index, int count, IComparer<T> comparer);  //指定范圍排序
public void Sort(Comparison<T> comparison); //Comparison<T>其實就是個委托
public void Sort(); //使用默認排序
public void Sort(IComparer<T> comparer); //使用一個自定義排序者

 

一. Comparison<T>

 public delegate int Comparison<in T>(T x, T y); 

這其實就是個委托，排序示例：

Dictionary<string, int> dic = new Dictionary<string, int>();
dic.Add("index.html", 50);
dic.Add("product.html", 13);
dic.Add("aboutus.html", 4);
dic.Add("online.aspx", 22);
dic.Add("news.aspx", 18);

public static int h1(KeyValuePair<string, int> s1, KeyValuePair<string, int> s2)
{
    return s2.Value.CompareTo(s1.Value);
}        

//第一種，使用預先定義的靜態方法
List<KeyValuePair<string, int>> list1 = new List<KeyValuePair<string, int>>(dic);
list1.Sort(h1);

//第二種，使用Dictionary<string, int> dic = new Dictionary<string, int>();
dic.Add("index.html", 50);
dic.Add("product.html", 13);
dic.Add("aboutus.html", 4);
dic.Add("online.aspx", 22);
dic.Add("news.aspx", 18);

public static int h1(KeyValuePair<string, int> s1, KeyValuePair<string, int> s2)
{
    return s2.Value.CompareTo(s1.Value);
}        

//第一種，使用預先定義的靜態方法
List<KeyValuePair<string, int>> list1 = new List<KeyValuePair<string, int>>(dic);
list1.Sort(h1);

//第二種，使用匿名方法
List<KeyValuePair<string, int>> list2 = new List<KeyValuePair<string, int>>(dic);
list1.Sort(delegate (KeyValuePair<string, int> s1, KeyValuePair<string, int> s2)
{
    return s2.Value.CompareTo(s1.Value);
});

//第三種，使用 lambda 表達式
List<KeyValuePair<string, int>> list3 = new List<KeyValuePair<string, int>>(dic);
list2.Sort((s1, s2) => { return s1.Value.CompareTo(s2.Value); });

二. Comparer<T>、IComparer<T>

　　1. 概念：為 IComparer<T> 泛型接口實現提供的基類。

public abstract class Comparer<T> : IComparer, IComparer<T>
{
    protected Comparer();
    public static Comparer<T> Default { get; }
    public static Comparer<T> Create(Comparison<T> comparison);
    public abstract int Compare(T x, T y);
}

　　2. Comparer<T>和 IComparer<T>的區別：

• • Comparer<T>是類，並提供了默認比較器，也就是說，如果需要自定義默認比較器，需要自行實現IComparer<T>接口
  • 使用Comparer<T>.Default來獲取默認比較器
  • IComparer<T> 就是提供一個統一的比較接口，而Comparer<T>就是官方為你提供的一個抽象實現類，具體還是得要你重寫實現

三. IComparable<T>

自己設計的模型類需要比較，可繼承此接口，實現后就可以直接使用排序

接口類：

public interface IComparable<in T>
{
    int CompareTo(T other);
}

 

四.Comparer<T> Class、IComparer<T>、IComparable<T>官方案例

class Test
{
    static void Main(string[] args)
    {
        List<Box> Boxes = new List<Box>();
        Boxes.Add(new Box(4, 20, 14));
        Boxes.Add(new Box(12, 12, 12));
        Boxes.Add(new Box(8, 20, 10));
        Boxes.Add(new Box(6, 10, 2));
        Boxes.Add(new Box(2, 8, 4));
        Boxes.Add(new Box(2, 6, 8));
        Boxes.Add(new Box(4, 12, 20));
        Boxes.Add(new Box(18, 10, 4));
        Boxes.Add(new Box(24, 4, 18));
        Boxes.Add(new Box(10, 4, 16));
        Boxes.Add(new Box(10, 2, 10));
        Boxes.Add(new Box(6, 18, 2));
        Boxes.Add(new Box(8, 12, 4));
        Boxes.Add(new Box(12, 10, 8));
        Boxes.Add(new Box(14, 6, 6));
        Boxes.Add(new Box(16, 6, 16));
        Boxes.Add(new Box(2, 8, 12));
        Boxes.Add(new Box(4, 24, 8));
        Boxes.Add(new Box(8, 6, 20));
        Boxes.Add(new Box(18, 18, 12));

        //使用繼承了Comparer<T>的比較器，進行排序。里面覆寫了Compare(T a,T b)方法
        Boxes.Sort(new BoxLengthFirst());  

        foreach (Box bx in Boxes)
        {
            Console.WriteLine("{0}\t{1}\t{2}",
                bx.Height.ToString(), bx.Length.ToString(),
                bx.Width.ToString());
        }

        Console.WriteLine("===============");

        //獲取默認比較器
        Comparer<Box> defComp = Comparer<Box>.Default;  

        // Calling Boxes.Sort() with no parameter
        // is the same as calling Boxs.Sort(defComp)
        // because they are both using the default comparer.
        // 等於調用Boxs.Sort(defComp);
        Boxes.Sort();

        foreach (Box bx in Boxes)
        {
            //輸出高、長、寬
            Console.WriteLine("{0}\t{1}\t{2}",
                bx.Height.ToString(), bx.Length.ToString(),
                bx.Width.ToString());
        }

        // This explicit interface implementation
        // compares first by the length.
        // Returns -1 because the length of BoxA
        // is less than the length of BoxB.
        BoxLengthFirst LengthFirst = new BoxLengthFirst();

        Comparer<Box> bc = (Comparer<Box>)LengthFirst;

        Box BoxA = new Box(2, 6, 8);
        Box BoxB = new Box(10, 12, 14);
        int x = LengthFirst.Compare(BoxA, BoxB);
        Console.WriteLine();
        Console.WriteLine(x.ToString());
 
        Console.ReadLine();
    }
}
public class BoxLengthFirst : Comparer<Box>
{
    //父類抽象方法 Compare
    // Compares by Length, Height, and Width.
    public override int Compare(Box x, Box y)
    {
        if (x.Length.CompareTo(y.Length) != 0)
        {
            return x.Length.CompareTo(y.Length);
        }
        else if (x.Height.CompareTo(y.Height) != 0)
        {
            return x.Height.CompareTo(y.Height);
        }
        else if (x.Width.CompareTo(y.Width) != 0)
        {
            return x.Width.CompareTo(y.Width);
        }
        else
        {
            return 0;
        }
    }

}


// This class is not demonstrated in the Main method
// and is provided only to show how to implement
// the interface. It is recommended to derive
// from Comparer<T> instead of implementing IComparer<T>.

//沒有在Main方法里演示，推薦使用繼承Comparer<T>的方法。
public class BoxComp : IComparer<Box>
{
    // Compares by Height, Length, and Width.
    public int Compare(Box x, Box y)
    {
        if (x.Height.CompareTo(y.Height) != 0)
        {
            return x.Height.CompareTo(y.Height);
        }
        else if (x.Length.CompareTo(y.Length) != 0)
        {
            return x.Length.CompareTo(y.Length);
        }
        else if (x.Width.CompareTo(y.Width) != 0)
        {
            return x.Width.CompareTo(y.Width);
        }
        else
        {
            return 0;
        }
    }
}

public class Box : IComparable<Box>
{
    public Box(int h, int l, int w)
    {
        this.Height = h;
        this.Length = l;
        this.Width = w;
    }
    public int Height { get; private set; }
    public int Length { get; private set; }
    public int Width { get; private set; }

    public int CompareTo(Box other)
    {
        // Compares Height, Length, and Width.
        if (this.Height.CompareTo(other.Height) != 0)
        {
            return this.Height.CompareTo(other.Height);
        }
        else if (this.Length.CompareTo(other.Length) != 0)
        {
            return this.Length.CompareTo(other.Length);
        }
        else if (this.Width.CompareTo(other.Width) != 0)
        {
            return this.Width.CompareTo(other.Width);
        }
        else
        {
            return 0;
        }
    }
}

 

五. Comparison<T>、 Comparer<T>、 System.IComparable、IComparable<T>的區別

1. Comparison<T>，繼承委托。開發人員可以在外部寫個用於比較大小的函數，然后作為 Comparison<T>類型的參數傳入，進行比較，非常方便。

2. 派生自 Comparer<T> 類和實現 System.IComparable 接口之間的差異如下：

• 若要指定默認情況下（Default獲取）應如何比較兩個對象，請在類中實現 System.IComparable 接口。 這可確保排序操作將使用您提供的默認比較代碼。

• 若要定義要使用的比較器而不是默認比較器，請從 Comparer<T> 類派生。 然后，您可以在采用比較器作為參數的排序操作中使用此比較器。

3. Default 屬性返回的對象使用 System.IComparable<T> 泛型接口來比較兩個對象。 如果類型 T 未實現 System.IComparable<T> 泛型接口，Default 屬性返回使用 System.IComparable 接口的 Comparer<T>。