在学习C#的过程中，大家一定会听说过一些CLR、JIT、LR、什么堆栈分配、内存释放的东西，谈到大家对这些元素的理解，多数都是这些是操作系统里面的东西，值类型、引用类型会和堆栈相关，但是在问到这些提到的名称具体是做什么的，或者扮演什么样的角色的时候，大家好像也能讲出点什么，但是也讲得模模糊糊，虽然这些都是一些理论知识，而且在开发的过程中可能也用不到，但还是能尽量多了解一下比较好，今天，笔者就谈一谈自己对这些元素的理解

---

有说的不准确或者不正确的地方欢迎留言指正

---

在日常生活中，如果要和其他语种的人交流，而且自己还不懂得情况下我们会怎么办？首先会想到找翻译软件，首先把自己说的话输入到翻译软件中，软件会根据输入文字的语法转到另一种歪果仁说的语言，其中主要步骤会经过检测-----校验-----输出。

其实在计算机的世界中，代码编译成0101这种形式的机器码也是大概如此，首先我们会在编译器中（例如：visual studio 2017）根据逻辑的需求编写C#代码，这个可以理解为我们说的母语，然后经过计算机的翻译编译成机器能听懂的语言（机器码），而下图中显示的 【metadata】【IL】【CLR】【JIT】就是在上面举例中提到翻译，翻译过程中【检测】----【校验】----【输出】需要这些元素的参与

缩写的全称：

• CTS是通用类型系统(Common Type System)
• CLR是公共语言运行时(Common language runtime)
• CLS是公共语言定义(Common Language Specification)

参考链接：https://blog.csdn.net/huang_xw/article/details/8578162

参考链接：https://docs.microsoft.com/zh-cn/dotnet/standard/common-type-system

代码编译后会形成DLL或者EXE文件，在这些文件中含有【metadata】与【IL】两种元素，下面我们逐一说明这两个元素的用途

---

metadata

通俗的讲：metadata就是一个档案库，一份清单，一个说明里面含有什么东西的列表。他里面详细的说明这个DLL或者EXE文件中都有什么类、函数、属性、字段、版本号等等，而且经常用到的特性（Attribute）的信息也在里面，不熟悉【特性】的小伙伴请看Unity C#基础之 特性，一个灵活的小工具。（也就是举例中需要翻译的是什么语言，多少个字，含有什么标点符号，在什么位置等等这些信息）

IL（中间语言）

IL又称：中间语言，他在翻译过程中是起到牵线搭桥的作用，类似于我能听懂（编译器），歪果仁也能听懂（计算机）的语言。如果想查看IL可以使用ILSpy反编译工具查看

---

上面提到的【metadata】【IL】仅仅是翻译前的准备工作，下面才是开始正式的【检测】----【校验】----【输出】

首先说下CLR

说道CLR他就厉害了，正是因为有了CLR这种运行环境，才能让不同语言编译的IL得以在不同的操作系统中运行，例如32位、64位的操作系统，而且不同的操作系统里面额CLR也是不一样的。

然后是JIT

基于上面提到的CLR环境，JIT根据不同的CLR将相同的IL依据清单（metadata）和dll或exe，开始正式的【检测】----【校验】----【输出】生成0101这种的机器码，JIT编译的时候会检测是否编译过机器码。如果编译过拿过来复用

上面说到的整体流程可以看一下托管执行过程

---

接下来说一下.NET 中的内存管理和垃圾回收

因为下面所提到的都是总结性结论，参考地址MSDN官方文档

• .NET 中的内存管理和垃圾回收

• 什么是“托管代码”？

• 自动内存管理

• 线程栈：栈-stack 先进后出的数据结构 随着线程而分配的 默认执行方法分配1MB内存

• 对象堆：内存，进程中独立画出来的一块儿内存，有一些对象长期使用不释放的，例如static，方便对象重用（多个对象指向一个内存地址）

我们结合代码来说一下堆栈的分配

 public struct ValuePoint// : System.ValueType 结构不能有父类，因为隐式继承了ValueType（通过反编译工具可查看） { public int x; public ValuePoint(int x) { this.x = x; } } public void Test() { //内存分配：线程栈 {//值类型分配在线程栈，变量和值都是在线程栈 ValuePoint valuePoint;//先声明变量，没有初始化 但是我可以正常赋值 跟类不同 valuePoint.x = 123; ValuePoint point = new ValuePoint(); Console.WriteLine(valuePoint.x); } } 

声明的valuePoint和他对应的x都是在栈上面的

---

 public class ReferencePoint { public int x; public ReferencePoint(int x) { this.x = x; } } public void Test() { ReferencePoint referencePoint = new ReferencePoint(123); } 

• 引用类型分布在堆上面 变量是在栈上的(保存的地址)，值是在堆上面
• new的时候去堆开辟内存，分配一个地址
• 调用构造函数(因为在构造函数里可以使用this)，才执行构造函数把引用传给变量

---

 /// <summary> /// class 引用类型 /// </summary> public class ReferenceTypeClass { private int _valueTypeField;//堆：因为对象都在堆里，对象里面的属性也在堆里 public ReferenceTypeClass() { _valueTypeField = 0; } public void Method() { int valueTypeLocalVariable = 0;//栈:全新的局部变量，线程栈来调用方法，然后分配内存 } } public void Test() { ReferenceTypeClass referenceTypeClassInstance = new ReferenceTypeClass(); referenceTypeClassInstance.Method(); } 

• _valueTypeField是在堆上面，因为对象都在堆里，对象里面的属性也在堆里
• valueTypeLocalVariable是在栈上面，因为全新的局部变量，线程栈来调用方法，然后分配内存

---

 /// <summary> /// 值类型 /// </summary> public struct ValueTypeStruct { private object _referenceTypeField;// 这个对象的变量在栈上，值在堆上 public ValueTypeStruct(int x) { _referenceTypeField = new object(); } public void Method() { object referenceTypeLocalVariable = new object();//这个对象的变量在栈上，值在堆上 } } public void Test() { ValueTypeStruct valueTypeStructInstance = new ValueTypeStruct(); valueTypeStructInstance.Method(); } 

• _referenceTypeField这个对象的变量在栈上(保存地址)，值在堆上
• referenceTypeLocalVariable这个对象的变量在栈上(保存地址)，值在堆上

综上所述：

• 方法的局部变量：根据变量自身决定，跟所在的环境没关系
• 对象是引用类型，其属性/字段，都是在堆里面
• 对象是值类型，其属性/字段，值类型就在栈里 引用类型就在堆里
• 引用类型任何时候都在堆里；值类型都在栈里， 除非值类型所在对象是在堆里（ReferencePoint这个例子就是）

---

装箱和拆箱（C# 编程指南）

 { int i = 0; object oValue = i; i = (int)oValue; } 

• 装箱拆箱(仅仅是说内存的拷贝动作):内存copy 也会浪费性能 通常都是因为object
• 装箱拆箱只能发生在父子类里面, 否则无法转换

---

string字符串内存分配

 string student = "菜鸟海澜";//开辟一块儿内存 放入“菜鸟海澜“ 返还一个引用（student变量） string student2 = student;//把student的引用copy一份儿给student2 Console.WriteLine(student);//打印结果 菜鸟海澜 Console.WriteLine(student2);//打印结果 菜鸟海澜 student2 = "菜鸟"; Console.WriteLine(student);//打印结果 ：菜鸟海澜 Console.WriteLine(student2);//打印结果：菜鸟 

• 改了student2的值 但是不是修改内存；因为string字符串的内存是不可变的
• 赋值其实是new string(APP),重新开辟内存，返回引用
• 不可变是因为享元，可能有多个变量指向同一个字符串，字符串变化了，多个变量都会受到影响。(例如多个类中的不同字符串变量都声明 "菜鸟海澜"，本质上都是指向一个地址)
• 还因为堆里面的内存是连续分配的，如果变长度，会导致大量数据的移动

 string student = "菜鸟海澜"; string student2 = "菜鸟";//共享 student2 = "菜鸟海澜"; Console.WriteLine(object.ReferenceEquals(student, student2));//打印结果为 True 

• 就是同一个 享元模式 CLR内存分配字符串的时候，会查找相同值，有就重用了

使用享元的主要原因：

• 因为在堆中每个对象的内存都是紧密连接的，使用享元且不可改变，这样可以提高内存的使用率。
• 避免导致大量数据的移动，降低内存的重新分配、摆放（有不同的线程栈，但共用一个堆）。

---

垃圾回收

参考自 垃圾回收 与 清理非托管资源

网上一位开发者的文章：https://kb.cnblogs.com/page/106720/

首先简述一下线程栈和托管堆的概念

• 值类型出现在线程栈：每次调用都有线程栈，，用完自己就结束，变量-值类型 都会释放的（不用我们维护）
• 引用类型出现在堆里：全局就一个堆，空间有限，所以才需要垃圾回收
• 操作系统里面，内存是链式分配的，可能有碎片的
• CLR的堆：连续分配(数组)，空间有限，节约空间
• 大对象策略：如果该对象占用内存大于85000字节，属于大对象，单独管理，用的是链表(碎片)，避免频繁的内存移动造成性能消耗

下面要说的垃圾回收主要是以堆中的操作为主要内容

GC（Garbage Collector 的缩写）

1问：什么是垃圾？

• 垃圾是完全访问不到的东西了。例如临时变量，或者已经赋值为null的引用类型的变量

2问：什么时候会发生GC？

• gc发生在new的时候 new一个对象时，会开辟内存，看看空间够不够，不够的话就要GC了
• gc程序退出的时候也会gc
• 手动GC。例如定时程序，很久执行一次，而且使用的时长很短，这时候就可以手动GC了

3问：怎么回收？

• new的时候发现内存不够，然后就去遍历所有堆的对象，标记有引用的对象，然后启动一个线程来清理内存
• 清除没有标记的对象，挪动其他剩余对象，然后整齐摆放，所以这个时候全部线程停止（开多线程时这个时候是停止的），不允许操作内存
• 内存不够的是指一级对象的内存，有个临界值，也不是全部的堆的大小
• 但是类中含有 析构函数【~类名称()】 ，内存的释放就需要单独的处理，把这些对象放入一个队列单独处理，具体哪一时刻调用析构函数不确定
  

注意：静态的对象是不会被回收的，且持有的引用也是不会被回收的

关于垃圾回收第几代的问题官方文档是这么说明的

在下面的例子中，声明一个静态变量staticStudent ，调用Test方法后主动调用GC，最终 变量【student】【@class】会被回收，但他们对应在堆中的内容不会被回收，因为有staticStudent 持有，变量 【i】会在弹栈之后直接被回收，变量【gCTest】以及它对应在堆中的内容都会被回收

 private static Student staticStudent = new Student()//静态的不可能被回收 静态持有的引用也不会被回收 { Id = 123, Name = "菜鸟海澜" }; public void Test() { Student student = staticStudent; Class @class = new Class() { classId = 1, classdata = "数据" }; student.tempdata = @class; int i = 0;//都会被GC GCTest gCTest = new GCTest();//都会被GC } 

在下面的示例中，很多开发者会把一个非静态变量设置成null，其实编译器会无视这句话，不是改成null这个对象没有了，其实内存还占用着，把对象赋值成null 意义不大，垃圾回收主要的原因是因为访问不到。但是静态可以把变量设置成null，促进垃圾回收，这样可以让变量不再被引用

 Student student = new Student() { Id = 1, Name = "su9257", tempdata = new Class() { classId = 1, classdata = "数据1" } }; student = null; GC.Collect(); 

非托管资源的释放

关于释放非托管资源必须要谈到的两个东西：【析构函数】和【Disposable】

析构函数

• 析构函数 主要是用来释放非托管资源（函数中调用具体释放资源的API或方法），等着GC的时候去把非托管资源释放掉 系统自动执行
• GC回收的时候，CLR一定调用的，但是可能有延迟，具体是哪个时刻不确定

Dispose

• Dispose() 也是释放非托管资源的，主动释放（或手动调用），方法本身是没有意义的，我们需要在方法里面实现对资源的释放
• GC不会调用，而是用对象时，使用者主动调用这个方法，去释放非托管资源

不过Dispose有一个自动调用的方法，就是使用【using】关键字,在using语句块运行完时自动调用Dispose方法（前提有的情况下）。且在Dispose方法中调用GC.SuppressFinalize(this);就是告诉CLR这个类我要释放的东西已经释放完了，你就不用调用析构函数了

 using (Student student = new Student()) { Console.WriteLine("菜鸟海澜"); } 

 public class People : IDisposable { public string Remark { get; set; } public virtual void Dispose() { Console.WriteLine($"执行{this.GetType().Name}Dispose"); } } public class Student : People, IDisposable { public int Id { get; set; } public string Name { get; set; } public Class tempdata { get; set; } public override void Dispose()//提供主动释放方式 { base.Dispose();//把我引用的其他东西给清理掉 if (this.tempdata != null) { this.tempdata.Dispose(); } //通知垃圾回收机制不再调用终结器（析构器） GC.SuppressFinalize(this); } 

本质上是调用try finally

 try { } finally { //调用的dispose() }