## Книга: C# 2008 Programmer

Besides overloading methods, C# also supports the overloading of operators (such as `+`, `-`, `/`, and `*`). Operator overloading allows you to provide your own operator implementation for your specific type. To see how operator overloading works, consider the following program containing the Point class representing a point in a coordinate system:

```using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace OperatorOverloading {  class Program {   static void Main(string[] args) {}  }  class Point {   public Single X { get; set; }   public Single Y { get; set; }   public Point(Single X, Single Y) {    this.X = X;    this.Y = Y;   }   public double DistanceFromOrigin() {    return (Math.Sqrt(Math.Pow(this.X, 2) + Math.Pow(this.Y, 2)));   }  } }```

The `Point` class contains two public properties (`X` and `Y`), a constructor, and a method — `DistanceFromOrigin()`.

If you constantly perform calculations where you need to add the distances of two points (from the origin), your code may look like this:

```static void Main(string[] args) {  Point ptA = new Point(4, 5);  Point ptB = new Point(2, 7);  double distanceA, distanceB;  distanceA = ptA.DistanceFromOrigin(); //---6.40312423743285---  distanceB = ptB.DistanceFromOrigin(); //---7.28010988928052---  Console.WriteLine(distanceA + distanceB); //---13.6832341267134---  Console.ReadLine(); }```

A much better implementation is to overload the `+` operator for use with the `Point` class. To overload the `+` operator, define a public static operator within the `Point` class as follows:

```class Point {  public Single X { get; set; }  public Single Y { get; set; }  public Point(Single X, Single Y) {   this.X = X;   this.Y = Y;  }  public double DistanceFromOrigin() {   return (Math.Sqrt(Math.Pow(this.X, 2) + Math.Pow(this.Y, 2)));  }  public static double operator +(Point A, Point B) {   return (A.DistanceFromOrigin() + B.DistanceFromOrigin());  } }```

The `operator` keyword overloads a built-in operator. In this example, the overloaded `+` operator allows it to "add" two `Point` objects by adding the result of their `DistanceFromOrigin()` methods:

```static void Main(string[] args) {  Point ptA = new Point(4, 5);  Point ptB = new Point(2, 7);  Console.WriteLine(ptA + ptB); //---13.6832341267134---  Console.ReadLine(); }```

You can also use the `operator` keyword to define a conversion operator, as the following example shows:

```class Point {  public Single X { get; set; }  public Single Y { get; set; }  public Point(Single X, Single Y) {   this.X = X;   this.Y = Y;  }  public double DistanceFromOrigin() {   return (Math.Sqrt(Math.Pow(this.X, 2) + Math.Pow(this.Y, 2)));  }  public static double operator +(Point A, Point B) {   return (A.DistanceFromOrigin() + B.DistanceFromOrigin());  }  public static implicit operator double(Point pt) {   return (pt.X / pt.Y);  } }```

Here, the `implicit` keyword indicates that you want to implicitly perform a conversion of the `Point` class to a `double` value (this value is defined to be the ratio of the X and Y coordinates).

Now when you assign a `Point` object to a double variable, the ratio of the `X` and `Y` coordinates is assigned automatically, as the following statements prove:

```static void Main(string[] args) {  Point ptA = new Point(4, 5);  Point ptB = new Point(2, 7);  double ratio = ptA; //---implicitly convert to a double type---  ptB = ptA; //---assign to another Point object---  Console.WriteLine(ratio); //---0.8---  Console.WriteLine((double)ptB); //---0.8---  Console.ReadLine(); }```

Оглавление книги Генерация: 1.159. Запросов К БД/Cache: 3 / 0
поделиться
Вверх Вниз