Operator Overloading in C#

Description

The Source code below shows how to use OperatorOverloading in C#. Operator Overloading is pretty useful concept derived from C++ by C#.For eg.

We can have class Matrix which hold 2D array of elements.C# add does not allow us to do Addition, Subtraction of matrices using the +,- operator rather We use to write Methods AddMatrix(),SubMatrix() with the use of Operator.

Overloading we make the user to code it:

M3=M1+M2 where M1 and M2 are matrix objects. 

Some Tips while using Operator overloading

1. While OverLoading a Operator always give public static access specifiers.
2. Operator Overloading should return a CLS type and not void.
3. Atleast one operand to the operator must be of type UDC [User Defined Class] because we cannot overload a operator with two int operands and perform subtraction for + operator which C# does not allow.
4. Relational Operators are overloaded in Pairs only.ie if == is overloaded then So !=.
5. Same Operator can be overloaded with different function signature for eg.

   public static Matrix operator +(Matrix m1,int[,] m2)
   {
   }

   we can also one more method like this:

   public static Matrix operator + (Matrix m1,Matrix m2)
   {
   }

   Please find to the code which uses overloading of almost all operators.

Source Code

// Source Code starts
using System;
class Square {
    private double Side;
    //public Constructor if int is passed convert to double and assign to Side
    public Square(int s) {
        Console.WriteLine(".ctor with int argument");
        Side = (double) s;
    }
    //OverLoaded constructor with double argument
    public Square(double s) {
        Console.WriteLine(".ctor with double argument");
        Side = s;
    }
    //override ToString() method of object class.
    public override string ToString() {
        Console.WriteLine("Override object class's string");
        return this.Side.ToString();
    }
    //Overloading + operator to add 2 square objects and return new square object
    public static Square operator + (Square x, Square y) {
        Console.WriteLine("Overloading + with Square,Square");
        return new Square(x.Side + y.Side);
    }
    //Overloading + operator to add square objects with double side and return new square object
    public static Square operator + (Square x, double y) {
        Console.WriteLine("Overloading + with Square,double");
        return new Square(x.Side + y);
    }
    //Overloading + operator to add square objects with int side and return new square object
    //This is not necessary since C# automatically calls +(Square,double)
    public static Square operator + (Square x, int y) {
        Console.WriteLine("Overloading + with Square,int");
        return x + (double) y;
    }
    public static implicit operator Square(double s) {
        Console.WriteLine("Overloading = for Square s5=1.5 assignment");
        return new Square(s);
    }
    public static implicit operator Square(int s) {
        Console.WriteLine("Overloading = for Square s5=10 assignment");
        return new Square((double) s);
    }
    //OverLoading == operator
    public static bool operator == (Square x, Square y) {
        Console.WriteLine("Overloading == with Square,Square");
        return x.Side == y.Side;
    }
    //OverLoading != operator
    public static bool operator != (Square x, Square y) {
        Console.WriteLine("Overloading != with Square,Square");
        return !(x == y); //This will call to operator == simple way to implement !=
    }
    //Always override GetHashCode(),Equals when overloading ==
    public override bool Equals(object o) {
        return this == (Square) o;
    }
    public override int GetHashCode() {
        return (int) Side;
    }
    //OverLoading > operator
    public static bool operator > (Square x, Square y) {
        Console.WriteLine("Overloading > with Square,Square");
        return x.Side > y.Side;
    }
    //OverLoading < operator
    public static bool operator < (Square x, Square y) {
        Console.WriteLine("Overloading < with Square,Square");
        return x.Side < y.Side;
    }
    //OverLoading <= operator
    public static bool operator <= (Square x, Square y) {
        Console.WriteLine("Overloading <= with Square,Square");
        return (x < y) || (x == y); //Calls to operator == and <
    }
    //OverLoading >= operator
    public static bool operator >= (Square x, Square y) {
        Console.WriteLine("Overloading >= with Square,Square");
        return (x > y) || (x == y); //Calls to operator == and >
    }
    //Readonly Property
    public double Area {
        get {
            return 2 * Side;
        }
    }
    public static void Main() {
        Square s1 = new Square(10);
        Square s2 = new Square(20);
        Square s3 = s1 + s2; // This will call operator + (Square,Square)
        Console.WriteLine(s3);
        Console.WriteLine(s3 + 15); // This will call operator + (Square,int) and then ToString()
        Console.WriteLine(s3 + 1.5); // This will call operator + (Square,double) and then ToString()
        s3 = 10; // This will call operator Square(int)
        Console.WriteLine(s3);
        Square s4 = 10;
        Console.WriteLine(s1 == s4); //Calls == operator
        Console.WriteLine(s1 != s4); //Calls != operator
        Console.WriteLine(s1 > s2); //Calls > operator
        Console.WriteLine(s1 <= s4); //Calls <= operator
    }
}
// Source Code End