Confusion Over Equals and "==" in Simple Way

Its consolidated overview of my understanding over Equals and "==" operator in Simple way.The information is asper my knowledge and will expand with time.

Consider that fact that object. Equals look for value as well as reference. However you can overload it to just check for value matching by overriding Equals method in class.

This is the application of "EQUALS" in various scenario.More to come,

//Use of Equals on Refrence type
using System;
class Product {
    public int Price {
        get;
        set;
    }
    public string Name {
        get;
        set;
    }
}
class ProductWithOverride {
    public int Price {
        get;
        set;
    }
    public string Name {
        get;
        set;
    }
    public override bool Equals(object obj) {
        if (obj == null) return false;
        if (this.GetType() != obj.GetType()) return false;
        ProductWithOverride p = (ProductWithOverride) obj;
        return (this.Price == p.Price) && (this.Name == p.Name);
    }
}
class Demo {
    static void Main() {
        Product p1 = new Product {
            Price = 10, Name = "foo"
        };
        Product p2 = new Product {
            Price = 10, Name = "foo"
        };
        bool a = p1.Equals(p2);
        Console.WriteLine(a.ToString()); //False
        //Reason- two different refrence .
        p2 = p1;
        bool b = p1.Equals(p2);
        Console.WriteLine(b.ToString()); //True
        //Reason -Same refrence.
        //using Override Equals now
        ProductWithOverride po1 = new ProductWithOverride {
            Price = 10, Name = "foo"
        };
        ProductWithOverride po2 = new ProductWithOverride {
            Price = 10, Name = "foo"
        };
        bool val = po1.Equals(po2);
        Console.WriteLine(val.ToString()); //True
        //Reason- Now we override equals so only hecks for value equality.
        po2 = po1;
        bool val1 = po1.Equals(po2);
        Console.WriteLine(val1.ToString()); //True
        //Reason- Same value and same refrence.
        //Now testing for String as string Confuses many :)
        string test1 = "testme";
        string test2 = "testme";
        bool stringval = test1.Equals(test2);
        Console.WriteLine(stringval.ToString());
        string test3 = "testmetoo";
        string test4 = "testmetoo";
        test4 = test3;
        bool stringval1 = test3.Equals(test4);
        Console.WriteLine(stringval1.ToString()); //True
        //Notice behaviour of String .
        //Reason-Because strings are immutable and the runtime may choose to put any two strings with the same content together into the same reference.
        //Also,Each string literal does not necessarily result in a new string instance. When two or more string literals that are equivalent according to the string equality operator (Section 7.9.7) appear in the same assembly, these string literals refer to the same string instance.
        //Casting into object

        Product p3 = new Product {
            Price = 10, Name = "foo"
        };
        Product p4 = new Product {
            Price = 10, Name = "foo"
        };
        Console.WriteLine("person1a and person1b: {0}", ((object) p3).Equals((object) p4)); //False
        p4 = p3;
        Console.WriteLine("person1a and person1b: {0}", ((object) p3).Equals((object) p4)); //True
        //using Override Equals now and converting to Object Type
        ProductWithOverride po3 = new ProductWithOverride {
            Price = 10, Name = "foo"
        };
        ProductWithOverride po4 = new ProductWithOverride {
            Price = 10, Name = "foo"
        };
        Console.WriteLine("person1a and person1b: {0}", ((object) po3).Equals((object) po4)); //True
        po4 = po3;
        Console.WriteLine("person1a and person1b: {0}", ((object) po3).Equals((object) po4)); //True

        //Casting string into Object type
        string test1 = "testme";
        string test2 = "testme";
        object one = test1;
        object two = test2;
        object three = null;
        object four = null;
        Console.WriteLine("one and two: {0}", (one.Equals(two))); // True Compiler have single refrence in case of String
        two = one;
        Console.WriteLine("one and two: {0}", (one.Equals(two))); // True We made single refrence
        Console.WriteLine("three and four: {0}", (three.Equals(four))); // This gives Exception as Equals checks for refrence and here the refrence is null. Checkinh "==" operator here is interesting(will bring that in coming article).


    }
}

Use of "== " on reference type:

• Note- For reference types where == has not been overloaded,
  
  
• It compares whether two references refer to the same object - which is exactly what the implementation of Equals does in System. Object.
  
  
• Also to note, Operators are overloaded, not overridden,
  
  
• For predefined value types,
  
  
• The equality operator (==) returns true if the values of its operands are equal, false otherwise.
  
  
• For reference types other than string, == returns true if its two operands refer to the same object. For the string type, == compares the values of the strings.

using System;
class Product {
    public int Price {
        get;
        set;
    }
    public string Name {
        get;
        set;
    }
}
class ProductWithOverride {
    public int Price {
        get;
        set;
    }
    public string Name {
        get;
        set;
    }


    public static bool operator == (ProductWithOverride a, ProductWithOverride b) {
        // If both are null, or both are same instance, return true.
        if (System.Object.ReferenceEquals(a, b)) {
            return true;
        }

        // If one is null, but not both, return false.
        if (((object) a == null) || ((object) b == null)) {
            return false;
        }

        // Return true if the fields match:
        return a.Name == b.Name && a.Price == b.Price;
    }
    public static bool operator != (ProductWithOverride a, ProductWithOverride b) {
        return !(a == b);
    }


}
class Demo {
    static void Main() {
        Product p1 = new Product {
            Price = 10,
            Name = "foo"
        };
        Product p2 = new Product {
            Price = 10,
            Name = "foo"
        };
        bool a = (p1 == p2);
        Console.WriteLine(a.ToString()); //False
        //Reason- two different refrence .
        p2 = p1;
        bool b = (p1 == p2);
        Console.WriteLine(b.ToString()); //True
        //Reason -Same refrence.
        //using Override == now
        ProductWithOverride po1 = new ProductWithOverride {
            Price = 10,
            Name = "foo"
        };
        ProductWithOverride po2 = new ProductWithOverride {
            Price = 10,
            Name = "foo"
        };
        bool val = (po1 == po2);
        Console.WriteLine(val.ToString()); //True
        //Reason- Now we override == so only hecks for value equality.
        po2 = po1;
        bool val1 = (po1 == po2);
        Console.WriteLine(val1.ToString()); //True
        //Reason- Same value and same refrence.

    }
}

For value type - Both operator checks for value Equality.