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

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

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

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

img_a6ff22f448eb4122b6287fe7a11f2a70.jpe

缩写的全称：

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()
                }

C# 内存分配&&垃圾回收解析

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

缩写的全称：

参考链接：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

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 中的内存管理和垃圾回收

什么是“托管代码”？

自动内存管理

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

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

综上所述：

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

string字符串内存分配

使用享元的主要原因：

垃圾回收

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

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

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

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

GC（Garbage Collector 的缩写）

1问：什么是垃圾？

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

3问：怎么回收？

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

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

非托管资源的释放

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

析构函数

Dispose

本质上是调用try finally

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

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