Язык программирования C#9 и платформа .NET5

 }

В результате появляется возможность инкрементировать и декрементировать значения X и Y класса Point:

 ...
 // Применение унарных операций ++ и -- к объекту Point.
 Point ptFive = new Point(1, 1);
 Console.WriteLine("++ptFive = {0}", ++ptFive); // [2, 2]
 Console.WriteLine("--ptFive = {0}", --ptFive); // [1, 1]

// Применение тех же операций в виде постфиксного инкремента/декремента.
 Point ptSix = new Point(20, 20);
 Console.WriteLine("ptSix++ = {0}", ptSix++); // [20, 20]
 Console.WriteLine("ptSix-- = {0}", ptSix--); // [21, 21]
 Console.ReadLine;

В предыдущем примере кода специальные операции ++ и – - применяются двумя разными способами. В языке C++ допускается перегружать операции префиксного и постфиксного инкремента/декремента по отдельности. В C# это невозможно. Однако возвращаемое значение инкремента/декремента автоматически обрабатывается корректно (т.е. для перегруженной операции ++ выражение pt++ дает значение неизмененного объекта, в то время как результатом ++pt будет новое значение, устанавливаемое перед использованием в выражении).

Перегрузка операций эквивалентности

Как упоминалось в главе 6, метод System.Object.Equals может быть перегружен для выполнения сравнений на основе значений (а не ссылок) между ссылочными типами. Если вы решили переопределить Equals (часто вместе со связанным методом System.Object.GetHashCode), то легко переопределите и операции проверки эквивалентности (== и !=). Взгляните на обновленный тип Point:

 // В данной версии типа Point также перегружены операции == и !=.
 public class Point
 {
  ...
  public override bool Equals(object o)
  => o.ToString == this.ToString;

  public override int GetHashCode
  => this.ToString.GetHashCode;

  // Теперь перегрузить операции == и !=.
  public static bool operator ==(Point p1, Point p2)
  => p1.Equals(p2);

  public static bool operator !=(Point p1, Point p2)
  => !p1.Equals(p2);
 }

Обратите внимание, что для выполнения всей работы в реализациях операций == и != просто вызывается перегруженный метод Equals. Вот как теперь можно применять класс Point:

 // Использование перегруженных операций эквивалентности.
 ...
 Console.WriteLine("ptOne == ptTwo : {0}", ptOne == ptTwo);
 Console.WriteLine("ptOne != ptTwo : {0}", ptOne != ptTwo);
 Console.ReadLine;

Как видите, сравнение двух объектов с использованием хорошо знакомых операций == и != выглядит намного интуитивно понятнее, чем вызов метода Object.Equals. При перегрузке операций эквивалентности для определенного класса имейте в виду, что C# требует, чтобы в случае перегрузки операции == обязательно перегружалась также и операция != (компилятор напомнит, если вы забудете это сделать).

Перегрузка операций сравнения

В главе 8 было показано, каким образом реализовывать интерфейс IComparable для сравнения двух похожих объектов. В действительности для того же самого класса можно также перегрузить операции сравнения (<, >, <= и >=). Как и в случае операций эквивалентности, язык C# требует, чтобы при перегрузке операции < обязательно перегружалась также операция >. Если класс Point перегружает указанные операции сравнения, тогда пользователь объекта может сравнивать объекты Point:

 // Использование перегруженных операций < и >.
 ...
 Console.WriteLine("ptOne < ptTwo : {0}", ptOne < ptTwo);
 Console.WriteLine("ptOne > ptTwo : {0}", ptOne > ptTwo);
 Console.ReadLine;

Когда интерфейс IComparable (или, что еще лучше, его обобщенный эквивалент) реализован, перегрузка операций сравнения становится тривиальной. Вот модифицированное определение класса:

 // Объекты Point также можно сравнивать посредством операций сравнения.
 public class Point : IComparable<Point>
 {
  ...
  public int CompareTo(Point other)
  {
  if (this.X > other.X && this.Y > other.Y)
  {
  return 1;
  }
  if (this.X < other.X && this.Y < other.Y)
  {
  return -1;
  }
  return 0;
  }

  public static bool operator <(Point p1, Point p2)
  => p1.CompareTo(p2) < 0;

  public static bool operator >(Point p1, Point p2)
  => p1.CompareTo(p2) > 0;

  public static bool operator <=(Point p1, Point p2)
  => p1.CompareTo(p2) <= 0;

  public static bool operator >=(Point p1, Point p2)
  => p1.CompareTo(p2) >= 0;
 }

Финальные соображения относительно перегрузки операций

Как уже упоминалось, язык C# предоставляет возможность построения типов, которые могут уникальным образом реагировать на разнообразные встроенные хорошо известные операции. Перед добавлением поддержки такого поведения в классы вы должны удостовериться в том, что операции, которые планируется перегружать, имеют какой-нибудь смысл в реальности.