一般来说，值类型存于栈，引用类型存在于堆，值类型转化为引用类型叫Box, 引用类型转为值类型在Unbox, 最近看了一本书发现值类型与引用类型的知识远不止这些。

我发现在一下几点我的理解一直是错误的：

错误1. struct是值类型，它与System.Object没有任何关系。

struct 直接基类是System.ValueType, 而它的基类就是Sysem.Object, 而且int, bool,等基本类型都是struct. 所以所有的C#类型都继承自System.Object.

错误2. 值类型转换为接口类型不会装箱

我们都知道object obj = 3 会装箱; 其实IEquatable<int> obj = 3; 和前面的一样也会装箱。

错误3. struct类型的equals 不会装箱。

不仅有装箱，而且还有两次！

错误4：装箱，拆箱的内存分布。

装箱后，会重新分配堆，除了相关的值，还有函数表指针等，内存对齐等，还有一个漏掉的是指向这个装箱后对象的引用。

正文

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! } } }

  version 1:

  public override bool Equals(object obj)