值比较
考虑两个表示人的Person对象，它们都有一个Age整型属性。下面要比较它们，看看哪个人年龄较大。为此可以使用以下代码：
if(person1.Age > person2.Age)
{
...
}
这是可以的，但还有其他方法，例如，使用下面的语法：
if(person1 > person2)
{
...
}
可以使用运算符重载，如本节后面所述。这是一项强大的技术，但应谨慎使用。在上面的代码中，年龄的比较不是非常明显，该段代码还可以比较身高、体重、IQ等。
另一个方法是使用IComparable和IComparer接口，它们可以采用标准的方式定义比较对象的过程。.NET Framework中的各种集合类支持这种方式，这使得它们成为对集合中的对象进行排序的一种极佳方式。
1. 运算符重载
通过运算符重载（operator overloading），可以对我们设计的类使用标准的运算符，例如+、>等。这称为重载，因为在使用特定的参数类型时，我们为这些运算符提供了自己的实现代码，其方式与重载方法相同，也是为同名方法提供不同的参数。
运算符重载非常有用，因为我们可以在运算符重载的实现中执行需要的任何操作，这并不一定像用“+”表示“把这两个操作数相加”这么简单。稍后介绍一个进一步升级CardLib库的示例。我们将提供比较运算符的实现代码，比较两张牌，看看在一圈（扑克牌游戏中的一局）中哪张牌会赢。
因为在许多扑克牌游戏中，一圈取决于牌的花色，这并不像比较牌上的数字那样直接。如果第二张牌与第一张牌的花色不同，则无论其点数是什么，第一张牌都会赢。考虑两个操作数的顺序，就可以实现这种比较。也可以考虑“王牌”的花色，而王牌可以胜过其他花色，即使该王牌的花色与第一张牌不同，也是如此。也就是说，card1 > card2 是true（这表示如果card1是第一个出牌，则card1胜过了card2），并不意味着card2 > card1是false。如果card1和card2都不是王牌，且属于不同的花色，则这两个比较都是true。
但我们先看一下运算符重载的基本语法。要重载运算符，可给类添加运算符类型成员（它们必须是static）。一些运算符有多种用途（如 - 运算符就有一元和二元两种功能），因此我们还指定了要处理多少个操作数，以及这些操作数的类型。一般情况下，操作数的类型与定义运算符的类相同，但也可以定义处理混合类型的运算符，详见稍后的内容。
例如，考虑一个简单类型AddClass1，如下所示：
public class AddClass1
{
public int val;
}
这仅是int值的一个包装器（wrapper），但可以用于说明原理。对于这个类，下面的代码不能编译：
AddClass1 op1 = new AddClass1();
op1.val = 5;
AddClass1 op2 = new AddClass1();
op2.val = 5;
AddClass1 op3 = op1 + op2; ❌
其错误是+运算符不能应用于AddClass1类型的操作数，因为我们尚未定义要执行的操作。下面的代码则可执行，但无法得到预期的结果：
AddClass1 op1 = new AddClass1();
op1.val = 5;
AddClass1 op2 = new AddClass1();
op2.val = 5;
bool op3 = op1 == op2;
其中，使用==二元运算符来比较op1和op2，看它们是否引用同一个对象，而不是验证它们的值是否相等。在上述代码中，即使op1.val和op2.val相等，op3也是false。
要重载+运算符，可使用下述代码：
public class AddClass1
{
public int val;
public static AddClass1 operator + (AddClass1 op1, AddClass1 op2)
{
AddClass1 returnVal = new AddClass1();
returnVal.val = op1.val + op2.val;
return returnVal;
}
}
可以看出，运算符重载看起来与标准静态方法声明类似，但它们使用关键字operator和运算符本身，而不是一个方法名。现在可以成功地使用+运算符和这个类，如上面的示例所示：
AddClass1 op3 = op1 + op2;
重载所有的二元运算符都是一样的，一元运算符看起来也是类似的，但只有一个参数：
public class AddClass1
{
public int val;
public static AddClass1 operator +(AddClass1 op1, AddClass1 op2)
{
AddClass1 returnVal = new AddClass1();
returnVal.val = op1.val + op2.val;
return returnVal;
}
public static AddClass1 operator -(AddClass1 op1)
{
AddClass1 returnVal = new AddClass1();
returnVal.val = -op1.val;
return returnVal;
}
}
这两个运算符处理的操作数的类型与类相同，返回值也是该类型，但考虑下面的类定义：
public class AddClass1
{
public int val;
public static AddClass3 operator + (AddClass1 op1, AddClass2 op2)
{
AddClass3 returnVal = new AddClass3();
returnVal.val = op1.val + op2.val;
return returnVal;
}
public class AddClass2
{
public int val;
}
public class AddClass3
{
public int val;
}
}
下面的代码就可以执行：
AddClass1 op1 = new AddClass1();
op1.val = 5;
AddClass2 op2 = new AddClass2();
op2.val = 5;
AddClass3 op3 = op1 + op2;
可以酌情采用这种方式混合类型。但要注意，如果把相同的运算符添加到AddClass2中，上面的代码就会失败，因为它弄不清要使用哪个运算符。因此，应注意不要把签名相同的运算符添加到多个类中。
还要注意，如果混合了类型，操作数的顺序必须与运算符重载的参数顺序相同。如果使用了重载的运算符和顺序错误的操作数，操作就会失败。所以不能像下面这样使用运算符：
AddClass3 op3 = op2 + op1; ❌
当然，除非提供了另一个重载运算符和倒序的参数：
public static AddClass3 operator + (AddClass2 op1, AddClass1 op2)
{
AddClass3 returnVal = new AddClass3();
returnVal.val = op1.val + op2.val;
return returnVal;
}
可以重载下述运算符：
• 一元运算符：+，-，!，~，++，--，true，false
• 二元运算符：+，-，*，/，%，&，|，^，<<，>>
• 比较运算符：==，!=，<，>，<=，>=
如果重载true和false运算符，就可以在布尔表达式中使用类，例如，if(op1){}。
不能重载赋值运算符，例如+=，但这些运算符使用与它们对应的简单运算符，例如+，所以不必担心它们。重载+意味着+=如期执行。=运算符不能重载，因为它有一个基本的用途。但这个运算符与用户定义的转换运算符相关，详见下一节。
也不能重载&&和||，但它们使用对应的运算符&和|执行计算，所以重载&和|就足够了。
一些运算符（如<和>）必须成对重载。这就是说，如重载>，就不能重载<。许多情况下，可以在这些运算符中调用其他运算符，以减少需要的代码数量（和可能发生的错误），例如：
public class AddClass1
{
public int val;
public static bool operator >= (AddClass1 op1, AddClass1 op2)
{
return (op1.val >= op2.val);
}
public static bool operator < (AddClass1 op1, AddClass1 op2)
{
return !(op1 >= op2);
}
// Also need implementations for <= and > operators.
}
在较复杂的运算符定义中，这可以减少代码行数。这页意味着，如果后来决定修改这些运算符的实现，需要改动的代码将较少。
这同样适用于==和!=，但对于这些运算符，通常需要重写Object.Equals()和Object.GetHashCode()，因为这两个函数也可以用于比较对象。重写这些方法，可以确保无论类的用户使用什么技术，都能得到相同的结果。这不太重要，但应增加进来，以保证其完整性。它需要下述非静态重写方法：
public class AddClass1
{
public int val;
public static bool operator == (AddClass1 op1, AddClass1 op2)
{
return (op1.val == op2.val);
}
public static bool operator != (AddClass1 op1, AddClass1 op2)
{
return !(op1 == op2);
}
public override bool Equals(object op1)
{
return val == ((AddClass1)op1).val;
}
public override int GetHashCode()
{
return val;
}
}
GetHashCode()可根据其状态，获取对象实例的一个唯一int值。这里使用val就可以了，因为它也是一个int值。
注意，Equals()使用object类型参数。我们需要使用这个签名，否则就将重载这个方法，而不是重写它。类的用户仍可以访问默认的实现代码。这样就必须使用数据类型转换得到所需的结果。这常常需要使用本章前面讨论的is运算符检查对象类型，代码如下所示：
public override bool Equals(object op1)
{
if(op1 is AddClass1)
{
return val == ((AddClass1)op1).val;
}
else
{
throw new ArgumentException("Cannot compare AddClass1 objects with object of type" + op1.GetType().ToString());
}
}
在这段代码中，如果传送给Equals的操作数的类型有误，或者不能转换为正确类型，就会抛出一个异常。当然，这可能并不是我们希望的操作。我们要比较一个类型的对象和另一个类型的对象，此时需要更多的分支结构。另外，可能只允许对类型完全相同的两个对象进行比较，这需要对第一个if语句做如下修改：
if(op1.GetType() == typeof(AddClass1))
2. 给CardLib添加运算符重载
现在再次升级Ch11CardLib项目，给Card类添加运算符重载。在本章下载代码的Ch11CardLib文件夹中可以找到以下的类的代码。首先给Card类添加额外字段，指定某花色比其他花色大，使A有更高的级别。把这些字段指定为静态，因为设置它们后，它们就可以应用到所有Card对象上：
public class Card
{
/// <summary>
/// Flag for trump usage. If true, trumps are valued higher
/// than cards of other suits.
/// </summary>
public static bool useTrumps = false;
/// <summary>
/// Trump suit to use if useTrumps is true.
/// </summary>
public static Suit trump = Suit.Club;
/// <summary>
/// Flag that determines whether aces are higher than kings or lower
/// than deuces.
/// </summary>
public static bool isAceHigh = true;
}
这些规则应用于应用程序中每个Deck的所有Card对象上。因此，两个Deck中的Card不可能遵守不同规则。这适用于这个类库，但是确实可以做出这样的假设：如果一个应用程序要使用不同的规则，可以自行维护这些规则；例如，在切换牌时，设置Card的静态成员。
完成后，就要给Deck类再添加几个构造函数，以便用不同的特性来初始化扑克牌：
/// <summary>
/// Nondefault constructor. Allows aces to be set high.
/// </summary>
public Deck(bool isAceHigh) : this()
{
Card.isAceHigh = isAceHigh;
}
/// <summary>
/// Nondefault constructor. Allows a trump suit to be used.
/// </summary>
public Deck(bool useTrumps, Suit trump) : this()
{
Card.useTrumps = useTrumps;
Card.trump = trump;
}
/// <summary>
/// Nondefault constructor. Allows aces to be set high and a trump suit
/// to be used.
/// </summary>
public Deck(bool isAceHigh, bool useTrumps, Suit trump) : this()
{
Card.isAceHigh = isAceHigh;
Card.useTrumps = useTrumps;
Card.trump = trump;
}
每个构造函数都使用第9章介绍的：this()语法来定义，这样，无论如何，默认构造函数总会在非默认的构造函数之前调用，初始化扑克牌。
接着，给Card类添加运算符重载（和推荐的重写代码）：
public static bool operator == (Card card1, Card card2)
{
return (card1.suit == card2.suit) && (card1.rank == card2.rank);
}
public static bool operator != (Card card1, Card card2)
{
return !(card1 == card2);
}
public override bool Equals(object card)
{
return this == (Card)card;
}
public override int GetHashCode()
{
return 13 * (int)suit + (int)rank;
}
public static bool operator > (Card card1, Card card2)
{
if(card1.suit == card2.suit)
{
if(isAceHigh)
{
if(card1.rank == Rank.Ace)
{
if(card2.rank == Rank.Ace)
return false;
else
return true;
}
else
{
if(card2.rank == Rank.Ace)
return false;
else
return (card1.rank > card2.rank);
}
}
else
{
return (card1.rank > card2.rank);
}
}
else
{
if(useTrumps && (card2.suit == Card.trump))
return false;
else
return true;
}
}
public static bool operator < (Card card1, Card card2)
{
return !(card1 >= card2);
}
public static bool operator >= (Card car1, Card card2)
{
if(card1.suit == card2.suit)
{
if(isAceHigh)
{
if(card1.rank == Rank.Ace)
{
return true;
}
else
{
if(card2.rank == Rank.Ace)
return false;
else
return (card1.rank >= card2.rank);
}
}
else
{
return (card1.rank >= card2.rank);
}
}
else
{
if(useTrumps && (card2.suit == Card.trump))
return false;
else
return true;
}
}
public static boo operator <= (Card card1, Card card2)
{
return !(card1 > card2);
}
这段代码没什么需要特别关注之处，只是>和>=重载运算符的代码比较长。如果单步执行>运算符的代码，就可以看到它的执行情况，明白为什么需要这些步骤。
比较两张牌card1和card2，其中card1假定为先出的牌。如前所述，在使用王牌时，这是很重要的，因为王牌胜过其他牌，即使非王牌比较大，也是这样。当然，如果两张牌的花色相同，则王牌是否也是该花色就不重要了，所以这是我们要进行的第一个比较：
public static bool operator > (Card card1, Card card2)
{
if(card1.suit == card2.suit)
{
}
如果静态的isAceHigh标记为true，就不能直接通过Rank枚举中的值比较牌的点数了。因为A的点数在这个枚举中是1，比其他牌都小。此时就需要如下步骤：
• 如果第一张牌是A，就检查第二张牌是否也是A。如果是，则第一张牌就胜不过第二张牌。 如果第二张牌不是A，则第一张牌胜出：
if(isAceHigh)
{
if(card1.rank == Rank.Ace)
{
if(card2.rank == Rank.Ace)
return false;
else
return true;
}
• 如果第一张牌不是A，也需要检查第二张牌是不是A。如果是，则第二张牌胜出：否则，就可以比较牌的点数，因为此时已不比较A了：
else
{
if(card2.rank == Rank.Ace)
return false;
else
return (card1.rank > card2.rank);
}
}
• 另外，如果A不是最大的，就只需比较牌的点数：
else
{
return (card1.rank > card2.rank);
}
代码的其余部分主要考虑的是card1和card2花色不同的情况。其中静态useTrumps标记是非常重要的。如果这个标记是true，且card2是王牌，则可以肯定，card1不是王牌（因为这两张牌有不同的花色），王牌总是胜出，所以card2比较大：
else
{
if(useTrumps && (card2.suit == Card.trump))
return false;
如果card2不是王牌（或者useTrumps是false），则card1胜出，因为它是最先出的牌：
else
return true;
}
}
另有一个运算符（>=）使用与此类似的代码，除此之外的其他运算符都非常简单，所以不需要详细地分析它们。
下面的简单客户代码测试这些运算符。把它放在客户项目的Main()函数中进行测试，就像前面CardLib示例的客户代码那样（这段代码包含在Ch11CardClient\Program.cs文件中）：
Card.isAceHigh = true;
Console.WriteLine("Aces are high.");
Card.useTrumps = true;
Card.trump = Suit.Club;
Console.WriteLine("Clubs are trumps.");
Card card1, card2, card3, card4, card5;
card1 = new Card(Suit.Club, Rank.Five);
card2 = new Card(Suit.Club, Rank.Five);
card3 = new Card(Suit.Club, Rank.Ace);
card4 = new Card(Suit.Heart, Rank.Ten);
card5 = new Card(Suit.Diamond, Rank.Ace);
Console.WriteLine("{0} == {1} ? {2}",
card1.ToString(), card2.ToString(), card1 == card2);
Console.WriteLine("{0} == {1} ? {2}",
card1.ToString(), card3.ToString(), card1 != card3);
Console.WriteLine("{0}.Equals({1}) ? {2}",
card1.ToString(), card4.ToString(), card1.Equals(card4));
Console.WriteLine("Card.Equals({0}, {1}) ? {2}",
card3.ToString(), card4.ToString(), Card.Equals(card3, card4));
Console.WriteLine("{0} > {1} ? {2}",
card1.ToString(), card2.ToString(), card1 > card2);
Console.WriteLine("{0} <= {1} ? {2}",
card1.ToString(), card3.ToString(), card1 <= card3);
Console.WriteLine("{0} > {1} ? {2}",
card1.ToString(), card4.ToString(), card1 > card4);
Console.WriteLine("{0} > {1} ? {2}",
card1.ToString(), card4.ToString(), card1 > card4);
Console.WriteLine("{0} > {1} ? {2}",
card4.ToString(), card1.ToString(), card4 > card1);
Console.WriteLine("{0} > {1} ? {2}",
card5.ToString(), card4.ToString(), card5 > card4);
Console.WriteLine("{0} > {1} ? {2}",
card4.ToString(), card5.ToString(), card4 > card5);
Console.ReadKey();
在这两种情况下，在应用运算符时都考虑了指定的规则。这在输出结果的最后4行中尤其明显，说明王牌总是胜过其他牌。
3. IComparable 和 IComparer 接口
IComparable 和 IComparer 接口是 .NET Framework 中比较对象的标准方式。这两个接口之间的差别如下：
• IComparable 在要比较的对象的类中实现，可以比较该对象和另一个对象。
• IComparer 在一个单独的类中实现，可以比较任意两个对象。
一般使用 IComparable 提供了一个方法 CompareTo()，这个方法接受一个对象。例如，在实现该方法时，使其可以接受一个 Person 对象，以便确定这个人比当前的人更年老还是更年轻。实际上，这个方法返回一个int，所以也可以确定第二个人与当前的人的年龄差：
if(person1.CompareTo(person2) == 0)
{
Console.WriteLine("Same age");
}
else if(person1.CompareTo(person2) > 0)
{
Console.WriteLine("person 1 is Older");
}
else
{
Console.WriteLine("person 1 is Younger");
}
IComparer 也提供了一个方法 Compare()。这个方法接受两个对象，返回一个整型结果，这与 CompareTo() 相同。对于支持 IComparer 的对象，可使用下面的代码：
if(personComparer.Compare(person1, person2) == 0)
{
Console.WriteLine("Same age");
}
else if(personComparer.Compare(person1, person2) > 0)
{
Console.WriteLine("person 1 is Older");
}
else
{
Console.WriteLine("person 1 is Younger");
}
这两种情况下，提供给方法的参数是 System.Object 类型。这意味着可以比较一个对象与其他任意类型的另一个对象。所以，在返回结果之前，通常需要进行某种类型比较，如果使用了错误类型，还会抛出异常。
.NET Framework 在类 Comparer 上提供了 IComparer 接口的默认实现方式，类 Comparer 位于 System.Collections 名称空间中，可以对简单类型以及支持 IComparable 接口的任意类型进行特定文化的比较。例如，可通过下面的代码使用它：
string firstString = "First String";
string secondString = "Second String";
Console.WriteLine("Comparing '{0}' and '{1}', result : {2}",
firstString, secondString,
Comparer.Default.Compare(firstString, secondString));
int firstNumber = 35;
int secondNumber = 23;
Console.WriteLine("Comparing '{0}' and '{1}', result : {2}",
firstNumber, secondNumber,
Comparer.Default.Compare(firstNumber, secondNumber));
这里使用 Comparer.Default 静态成员获取 Comparer 类的一个实例，接着使用 Compare()方法比较前两个字符串，之后比较两个整数，结果如下：
Comparing 'First String' and 'Second String', result : -1
Comparing '35' and '23', result : 1
在字母表中，F 在 S 的前面，所以 F “小于” S，第一个比较的结果就是 -1。同样，35大于23，所以结果是1。注意这里的结果并未给出相差的幅度。
在使用 Comparer 时，必须使用可以比较的类型。例如，试图比较 firstString 和 firstNumber 就会生成一个异常。
下面列出有关这个类的一些注意事项：
• 检查传送给 Comparer.Compare()的对象，看看它们是否支持IComparable。如果支持，就使用该实现代码。
• 允许使用null值，它表示“小于”其他任意对象。
• 字符串根据当前文化来处理。要根据不同的文化（或语言）处理字符串，Comparer类必须使用其构造函数进行实例化，以便传送用于指定所使用的文化的 System.Globalization.CultureInfo 对象。
• 字符串在处理时要区分大小写。如果要以不区分大小写的方式来处理它们，就需要使用 CaseInsensitiveComparer 类，该类以相同的方式工作。
4. 对集合排序
许多集合类可以用对象的默认比较方式进行排序，或者用定制方法来排序。ArrayList 就是一个示例，它包含方法 Sort()，这个方法使用时可以不带参数，此时使用默认的比较方式，也可以给它传送 IComparer 接口，以比较对象时。
在给 ArrayList 填充了简单类型时，例如整数或字符串，就会进行默认的比较。对于自己的类，必须在类定义中实现 IComparable，或创建一个支持 IComparer 的类，来进行比较。
注意，System.Collentions 名称空间中的一些类，包括 CollectionBase，都没有提供排序方法。如果要对派生于这个类的集合排序，就必须多做一些工作，自己给内部的 List 集合排序。
下面的示例说明如何使用默认的和非默认的比较方式给列表排序。
添加一个新类 Person，修改 Person.cs 中的代码，如下所示：
namespace Ch11Ex05
{
public class Person : IComprable
{
public string Name;
public int Age;
public Person(string name, int age)
{
Name = name;
Age = age;
}
public int CompareTo(object obj)
{
if(obj is Person)
{
Person otherPerson = obj as Person;
return this.Age - otherPerson.Age;
}
else
{
throw new ArgumentException("Object to compare to is not a Person object.");
}
}
}
}
添加一个新类 PersonComparerName，修改代码，如下所示：
using System;
using System.Collections;
using System.Collentions.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Ch11Ex05
{
public class PersonComparerName : IComperer
{
public static IComparer Default = new PersonComparerName();
public int Compare(object x, object y)
{
if(x is Person && y is Person)
{
return Comparer.Default.Compare(
((Person)x).Name, ((Person)y).Name);
}
else
{
throw new ArgumentException("One or both objects to compare are not Person objects.");
}
}
}
}
修改 Program.cs 中的代码，如下所示：
using System;
using System.Collections;
using System.Collentions.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Ch11Ex05
{
class Program
{
static void Main(string[] args)
{
ArrayList list = new ArrayList();
list.Add(new Person("Jim", 30));
list.Add(new Person("Bob", 25));
list.Add(new Person("Bert", 27));
list.Add(new Person("Ernie", 22));
Console.WriteLine("Unsorted people");
for(int i = 0; i < list.Count; i++)
{
Console.WriteLine("{0} ({1})",
(list[i] as Person).Name, (list[i] as Person).Age);
}
Console.WriteLine();
Console.WriteLine(
"People sorted with default comparer (by age):");
list.Sort();
for(int i = 0; i < list.Count; i++)
{
Console.WriteLine("{0} ({1})",
(list[i] as Person).Name, (list[i] as Person).Age);
}
Console.WriteLine();
Console.WriteLine(
"People sorted with nondefault comparer (by name):");
list.Sort(PersonCompareName.Default);
for(int i = 0; i < list.Count; i++)
{
Console.WriteLine("{0} ({1})",
(list[i] as Person).Name, (list[i] as Person).Age);
}
Console.ReadKey();
}
}
}
示例的说明
在这个示例中，包含
Person对象的ArrayList用两种不同的方式排序。调用不带参数的ArrayList.Sort()方法，将使用默认的比较方式，也就是使用Person类中的CompareTo()方法（因为这个类实现了IComparable）：public int Compare(object x, object y) { if(x is Person && y is Person) { return Comparer.Default.Compare( ((Person)x).Name, ((Person)y).Name); } else { throw new ArgumentException("One or both objects to compare are not Person objects."); } }这个方式首先检查其参数能否与
Person对象比较，即该对象是否能转换为Person对象。如果遇到问题，就抛出一个异常。否则，就比较两个Person对象的Age属性。接着，使用实现了
IComparer的PersonComparerName类，执行非默认的比较排序。这个类有一个公共的静态字段，以方便使用：public static IComparer Default = new PersonComparerName();它可以用 PersonComparerNameDefault 获取一个实例，就像前面的
Comparer类一样。这个类的Compareto()方法如下：public int Compare(object x, object y) { if(x is Person && y is Person) { return Comparer.Default.Compare( ((Person)x).Name, ((Person)y).Name); } else { throw new ArgumentException("One or both objects to compare are not Person objects."); } }这里也是首先检查参数，看看它们是不是
Person对象，如果不是，就抛出一个异常；如果是，就使用默认的Comparer对象比较Person对象的两个字符串字段Name。
🔚