C# 值类型 与引用类型

namespace ConsoleApplication1
{
    // System.ValueType -> System.Object
    struct Point2D
    {
        public int X { get; set; }

        public int Y { get; set; }

        // version 1
        public override bool Equals(object obj)
        {
            if (!(obj is Point2D)) return false;
            Point2D other = (Point2D)obj;
            return X == other.X && Y == other.Y;
        }

        // version 2
        public bool Equals(Point2D other)
        {
            return X == other.X && Y == other.Y;
        }

        // version 3
        public static bool operator ==(Point2D a, Point2D b)
        {
            return a.Equals(b);
        }
        public static bool operator !=(Point2D a, Point2D b)
        {
            return !(a == b);
        }
    }

    struct Point2D_V4 : IEquatable<Point2D_V4>
    {
        public int X { get; set; }

        public int Y { get; set; }

        // version 1
        public override bool Equals(object obj)
        {
            if (!(obj is Point2D_V4)) return false;
            Point2D_V4 other = (Point2D_V4)obj;
            return X == other.X && Y == other.Y;
        }

        // version 2
        public bool Equals(Point2D_V4 other)
        {
            return X == other.X && Y == other.Y;
        }

        // version 3
        public static bool operator ==(Point2D_V4 a, Point2D_V4 b)
        {
            return a.Equals(b);
        }
        public static bool operator !=(Point2D_V4 a, Point2D_V4 b)
        {
            return !(a == b);
        }
    }

    public class Employee
    {
        public string Name { get; set; }
        // the hashcode is base on the its cotent
        public override int GetHashCode()
        {
            return Name.GetHashCode();
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            // version 1
            Point2D a = new Point2D(), b = new Point2D();
            //object test = b; // box b from value type to reference type
            //a.Equals(b); // box a to invoke the virtual function Equals

            // if we have 10,000,000 points, we will do 20,000,000 box operation, on 32-bit system, one box will allocate 16 Bytes.

            // version 2
            // How to avoid boxing override the equals.
            //a.Equals(b); // no need box a or b this time.

            // version 3
            //bool isequal = a == b;// no boxing here.

            // it seems ok now, but there is a edge case will cause boxing at CLR generic. we need implement Iequatable
            //Point2D_V4 i = new Point2D_V4(), j = new Point2D_V4();
            //IEquatable<Point2D_V4> k = i;// box occurs here, value type to interface requires boxing.

            //i.Equals(j);// no box occurs


            // once boxing, they are not have relationship to orignal type. so the best practice is let the value type immutable, like system.datetime. 
            //Point2D_V4 point = new Point2D_V4 { X = 5, Y = 7 };
            //Point2D_V4 anotherPoint = new Point2D_V4 { X = 6, Y = 7 };
            //IEquatable<Point2D_V4> equatable = point; //boxing occurs here
            //equatable.Equals(anotherPoint); //returns false
            //point.X = 6;
            //point.Equals(anotherPoint); //returns true
            //equatable.Equals(anotherPoint); //returns false, the box was not modified!


            // then we need to talk about the hashcode, if you know about the hashkey in datastructure. the hashcode is used for identity one or more than one items.
            // here are some requirements to the hashcode function:
            //1. if two item is equal, the hashkey must be equal.
            //2. if two item is equal, the hashkey should not equal, but not must.
            //3. the GetHashCode function should fast.
            //4. the Hashcode should not change.
            HashSet<Employee> employees = new HashSet<Employee>();
            Employee kate = new Employee { Name = "Kate Jones" };
            employees.Add(kate);
            kate.Name = "Kate Jones-Smith";

            // it really shock me, I don‘t notice this before.
            bool has = employees.Contains(kate); //returns false!

        }

    }
}