c#.net的bcl提供了丰富的类型，最基础的是值类型、引用类型，而他们的共同（隐私）祖先是 system.object（万物之源），所以任何类型都可以转换为object。

01、数据类型汇总

c#.net 类型结构总结如下图，object是万物之源。最常用的就是值类型、引用类型，指针是一个特殊的值类型，泛型必须指定确定的类型参数后才是一个正式的类型。

1.1、值类型汇总⭐

• bool 虽然只需要1位空间，但仍然占用了1个字节，是因为字节是处理器的最小单位。如果有大量的bool，可用bitarray。
• 值类型大多都是“不可变的”，就意味着修改会创建新的对象，上面表格中除了自定义的结构体struct外都是不可变的。
• cts（common type system）为通用类型系统，为微软定制的通用类型规范，所有.net语言都支持（如f#、vb、c#）。不符合cts就意味着c#独有。

1.2、引用类型汇总⭐

1.3、object-万物之源

system.object是所有类型的根，任何类都是显式或隐式的继承于system.object，包括值类型，所以任何类型都可以转换为object！

下面代码为.net中的 system.object 源码：

public partial class object
{
    public object(){ }
    public virtual string? tostring()
    {
        return gettype().tostring();
    }
    protected internal unsafe object memberwiseclone();  //对象浅拷贝
    public virtual bool equals(object? obj)
    {
        return this == obj;
    }
    public static bool equals(object? obja, object? objb)
    {
        return obja == objb || (obja != null && objb != null && obja.equals(objb));
    }
    public static bool referenceequals(object? obja, object? objb)
    {
        return obja == objb;
    }
    public virtual int gethashcode()
    {
        return runtimehelpers.gethashcode(this);
    }
    ~object(){}  //终结器
}

02、值类型与引用类型

值类型和引用类型是c#中最重要、最常用的两种数据类型，两者是有很多区别的，而且常常和性能有很大关系，因此这是c#开发者必须掌握的基础知识。

2.1、值类型 vs 引用类型

• default可以表示任意类型的默认值，编译时会被赋值。struct的默认值为每个字段设置默认值。

int x = 100;
int y = x;     //值拷贝传递
string name = "sam";
int[] arr = new int[] { 1, 2, 3 };
var list = arr; //引用地址传递，实际指向同一个引用对象，分身幻象

📢 两者核心区别就是存储的方式不同，理解这一点非常重要，在变量（字段）赋值、方法参数传递上都是如此。

🔸stack 栈：（线程）栈，由操作系统管理，存放值类型、引用类型变量（就是引用对象在托管堆上的地址）。栈是基于线程的，也就是说一个线程会包含一个线程栈，线程栈中的值类型在对象作用域结束后会被清理，效率很高。

🔸托管堆（gc heap）：进程初始化后在进程地址空间上划分的内存空间，存储.net运行过程中的对象，所有的引用类型都分配在托管堆上，托管堆上分配的对象是由gc来管理和释放的。托管堆是基于进程的，当然托管堆内部还有其他更为复杂的结构。

关于更多堆栈内存信息，查看后文《c#的内存管理艺术》

📢值类型可使用out、ref关键字，像引用类型一样传递参数地址。两者对于编译器是一样的，都是取地址，唯一区别就是ref参数需要在外面初始化，out参数在方法内部初始化。

2.3、装箱和拆箱⁉️

因为值类型、引用类型的基类都是object，因此值类型、引用类型是可以相互转换的，但这个转换是有很高成本的，这个过程就是装箱、拆箱。

int x = 100;     //一个普通的值类型变量
object obj =x;   //装箱到obj
int y = (int)obj;//拆箱到y

可视化分析一下这个过程：

🔸装箱：值类型转换为引用对象，一般是转换为system.object类型，或接口类型。所以“箱子”就是object引用对象，装箱的过程：

• ❶ 在gc堆上申请内存，内存大小为值类型的大小，再加上额外固定空间（引用类型的标配：typehandle和同步索引块）；
• ❷ 将值（100）拷贝到分配的内存中；
• ❸ 返回新对象（箱子）的引用地址给变量obj。

🔸拆箱：引用类型转换为值类型，注意，这里的引用类型只能是被装箱的引用类型对象。

• ❶ 检测操作是否合法，如箱子是否为null，类型是否和待拆箱的类型一致，检测失败则抛出异常invalidcastexception。
• ❷ 把箱子中的值拷贝到栈上。

上面三行装箱、拆箱代码的il代码：装箱box、拆箱unbox是两个专门的指令。

由上可知，装箱会在gc堆上创建一个“箱子”（object对象）来装载值，这是装箱造成极大的性能损失的根本原因，拆箱则把值搬回到栈内存上。

• 只有值类型才会有装箱、拆箱，引用类型一直都在“箱子”里。
• 相对来说装箱的性能损失更大，原因不难理解，创建引用对象（箱子）的性能开销更大。

📢在日常开发中，很容易发生隐式装箱，所以要特别注意，尽量用泛型。如arraylist、hashtable 都是面向object的集合，应该用list<t>、dictionary<tkey, tvalue>代替。

arraylist arr = new arraylist();
arr.add(1);      //装箱
arr.add(true);   //装箱
hashtable ht = new hashtable();
ht.add(1,1.2f);  //装箱了两次

对比测试装箱、拆箱的性能影响：

private t add<t>(t arg1,t arg2) where t:inumber<t>
{
	return arg1+arg2;
}
private int addwithobject(object x, object y)
{
	return (int)x + (int)y;
}

测试结果比较明显，装箱的方法在执行效率、内存消耗上都要差很多。

03、nullable?可空类型

可空类型可用于值类型、引用类型，他们使用语法类似，不过他们是完全不同的两种东西。值类型的可空?是一个泛型nullable<t>类型，而引用类型的?只是一个用于编译器检查的语法。

int? n = null;
string? str = "sam";

可空值类型、引用类型都支持null操作符：

• null 条件运算符，str?.length
• null 合并赋值，n??=1。

3.1、值类型的nullable<t>

对于值类型，可空值类型表示值类型对象可以为null值，可空值类型t?的本质其实是nullable<t>，他是一个值类型（结构体）。

int x0 = default;  //默认值为0
int? x1 = default; //默认值值为null
int? x2 = null;
nullable<int> x3 = null;  //同上

if (x3.hasvalue)
{
    console.writeline(x3.value);
}
int a = x0 + (x3.hasvalue? x3.value : 10);
int b = x0 + x3 ?? 10; //效果同上

• 简化的语法为：type?，示例：int? n;，类型后跟一个问号"?"，和引用类型的可空语法一样。
• 属性hasvalue判断是否有值，value获取值，如果hasvalue为false时获取 value 值会抛出异常。
• 转换：t可隐式转换为t?，反之则需要显示转换。

下面为nullable<t>的源码，是一个简单的结构体，t被约束为结构体（值类型）。

public struct nullable<t> where t : struct
{
    //判断是否有值
	public readonly bool hasvalue { get; }
    //获取值
	public readonly t value { get; }
    public readonly t getvalueordefault()
    public readonly t getvalueordefault(t defaultvalue)
}

3.2、可空引用类型t?

引用类型本身的默认值就是null，为了避免一些场景下不必要的 nullreferenceexception，就有了可空的引用类型t?，其核心目的就是为提高代码的健壮性。可空的引用类型并不是一个“新的类型”，而是一个编译指令，告诉编译器这个引用类型变量可能是null，使用时需检查，未初始化也没检查null就使用，编译器会产生编译告警，由此来提前发现潜在bug，提高代码健壮性。如果没加?，则该表示引用对象不会为null。

要开启可空引用类型需要配置启用才行：

• 在项目配置中开启：<nullable>enable</nullable>，值disable表示不启用。
• 在代码文件中启用，在文件头部加#nullable enable，只对当前代码文件有效。

public int getlength(string? firstname, string lastname)
{
	var len = firstname.length; //编译器会警告 firstname 可能为null
	if (firstname != null)      //加上null判断就好了
		len += firstname.length;
	len = firstname!.length;    //加上!，则忽略检查
	len += lastname.length;     //lastname不会为null，没有告警
	return len;
}

对于上面的示例代码，编译器会认为firstname可能会为null，在使用前必须初始化，或者检查是否为null。而lastname不会为null，可以直接使用。

📢 消除可空引用类型的编译告警的方法是结尾加!（null 包容运算符），告诉编译器这个对象肯定不会为null，别再告警了！

在命名空间“system.diagnostics.codeanalysis”下还有一些特性，用来辅助代码的静态检查和编译器检查。

[notnull]  //标记返回值不会为null
private string? fullname => "sam";

//当方法返回false时参数value不会为null。该方法就是string.isnullorempty的源码
public static bool isnullorempty([notnullwhen(false)] string? value)
{
	if ((object)value != null)
	{
		return value.length == 0;
	}
	return true;
}

04、类型转换⭐

数据类型之间是可以相互转换的，由一个数据类型转换为另一数据类型，常见的转换方式：

📢注意：

• 几乎所有类型都可以隐式转换为 object，注意值类型转换object会装箱。
• 对于值类型，范围小的类型转换范围大的类型大都支持隐式转换，且不会损失精度，如float转double，int转浮点数。反之则需要强制转换，可能会损失精度，或溢出。
• is 语句可用于模式匹配，实现灵活的类型、数据检查，详细参考《c#中的模式匹配汇总》。

int a = (int)'a';     // 强制类型转换
console.writeline(a); // 97

float f = a;          // 隐式类型转换
console.writeline(f);

object obj = f;         //装箱，值类型隐式转换为引用类型
float f2 = (float)obj;  //拆箱
if(obj is float f3)     //is检查是否为float类型，如果是则转换值到变量f3
{
    console.writeline(f3);
}
string str = obj as string; //as 转换失败，obj是float装箱
console.writeline(str);     //null

4.1、数值转换方式汇总

05、相等、大小比较

📢 值类型比较的是值（结构体会比较其所有字段值），引用类型是比较的引用地址！

public interface icomparable<in t>
{
	int compareto(t? other);
}
public interface iequatable<t>
{
	bool equals(t? other);
}
public interface iequalitycomparer<in t>
{
	bool equals(t? x, t? y);

	int gethashcode([disallownull] t obj);
}
// system.object
public static bool equals(object? obja, object? objb)
{
	if (obja == objb)
	{
		return true;
	}
	if (obja == null || objb == null)
	{
		return false;
	}
	return obja.equals(objb);
}

• equals()方法必须自相等，即 x.equals(x) 必为true。
• 对于值类型，大多数情况下equals()方法等效于 ==，只有double.nan例外，double.nan 不等于任何对象。而引用类型则不一定了，有些引用类型重写了equals()方法，而没有重写 == 运算符。

console.writeline(double.nan == double.nan);     //false
console.writeline(double.nan.equals(double.nan));//true

console.writeline(object.equals(1,1));           //true  //装箱比较值
console.writeline(object.referenceequals(1,1));  //false //装箱比较引用

stringbuilder sb1 = new stringbuilder("sb");
stringbuilder sb2 = new stringbuilder("sb");
console.writeline(sb1 == sb2);                     //false
console.writeline(object.equals(sb1,sb2));         //false
console.writeline(object.referenceequals(sb1,sb2));//false
console.writeline(sb1.equals(sb2));				   //true  //与上面的 object.equals(sb1,sb2) 不同

上面的 stringbuilder 重新实现了 equals方法，但不是继承覆盖，而是隐式new覆写实现的，因此只能在 通过 stringbuilder 引用调用时才有效。参考：stringbuilder 源码。

5.1、自定义相等

⁉️什么时候需要自定义相等比较？

• 提高比较速度，多用于自定义结构体。
• 修改相等比较的语义，基于实际业务需要自定义相等的规则，如system.url、string.string 都是引用类型，只要字符值相同则相等（== 和 equals）。

⁉️如何自定义相等比较？

• 重写 gethashcode() 和 equals() 方法。这两个一般是一起配对重写，需注意 二者的一致性。
• （可选）重载 != 和 ==。
• （可选）实现 iequatable<t> 接口。

📢gethashcode() 是基类 object 的一个虚方法，该方法用于获取一个对象的 int32 类型的散列码。该散列码只在键值结构（hashtable、hashset、dictionary）中使用，用来表示元素的唯一“id”，用于在哈希表中快速检索数据。

gethashcode()的默认实现：

• 值类型的散列码 是由每一个字段的值来计算的，如果有多个字段则通过一定的规则组合（如异或运算）。
• 引用类型则基于对象的内存地址。

so，如果重写了equals() 方法，则一般要重写gethashcode()，让两者匹配。当然如果不遵守该规则也没问题，只是在使用哈希表时可能会出现问题（如性能严重下降）。

参考资料

• .net类型系统②常见类型
• c# 文档
• 《c#8.0 in a nutshell》
• .net面试题解析(02)-拆箱与装箱
• .net面试题解析(01)-值类型与引用类型