C#值类型和引用类型用C语言理解

我刚用C#一个来月，可能理解得不对，还请大家指教。
读懂文章你需要对C语言的指针有所理解。

需要注意区别：对C\C++来说，任何类型都可以当成C#的“引用类型”，因为有指针。

【 在内存上】

void foo()
{
    int aaa = 0; //值类型，aaa在Stack上分配（SUB ESP,XX）
    int* paaa = new int[123]; //引用类型，paaa在Heap上分配，HeapAlloc(GetProcessHeap()...)
    foo2(&aaa); //【引用】值类型aaa
}->函数退出，aaa从栈上销毁，paaa依然存在在进程堆中。

void foo2(int* paaa)
{
    *paaa = 123;
}

【 Box和UnBox】
打个很简单的比方：
有函数：

void foo(int* pa)
{
    beginthread(&new_thread...,pa); //启动新线程操作指针pa
}

void new_thread(int* pa)
{
    Sleep(1000); //新线程睡眠1秒
    if (*pa == 123) //判断pa指针的内容是123
        OutputDebugStringA("OK.");    
}

还有函数：

void exec1()
{
    int pa = 123;
    foo(&pa);
}

大家可能看出问题了，当我们执行foo指向栈上的pa的时候，因为exec1函数已经退出，pa的值被系统回收，不可预料，线程体在睡眠一秒后去访问这个栈上的地址可能得到的值不是123，但是如果我们在堆上分配：

void exec2()
{
    int* pa = (int*)malloc(sizeof(int));
    *pa = 123;
    foo(pa);
}

执行exec2， 就可以确保pa不会被回收，因为没有显式free。

C#同理，Box就是把在exec1中的值类型pa进行exec2的处理，然后执行处理后 pa的值在exec1退出后依然在栈上销毁，但是执行foo给进去的pa是一个.NET通过类似malloc这种分配堆内存的方法分配的一个新的指针， 并且把原来栈上的值pa给memcpy进去了，并且把这个指针交给了foo函数，这个【指针】就是被装箱(Box)后的【引用类型】，此时foo引用了pa，并且把它又交给new_thread，new_thread操作完了pa后， 再也没人使用这个引用类型pa，GC会把pa进行free。

我们可以得出， 栈类型在函数体退出后，会被系统自动释放，而堆类型不会，还记得ATL的CComPtr么，而堆数据则要靠GC进行垃圾回收。
如果你对Windows COM和C++有理解，可以这样想象：
ATL::CComPtr = 值类型auto-free。为什么，因为CComPtr在函数体内构造(AddRef)，在函数体退出析构(Release)。
std::shared_ptr = 引用类型auto-free。类是new来的，shared_ptr进行引用计数管理，在某个函数体退出时引用计数跑0，才进行delete。

然后我们还可以得出， 值类型指向实际的数据，而引用类型指向数据指针。
这个你用后脑就可以想出来了，例子：

void foo()
{
    int aa = 123; //aa直接指向123，编译器通过ESP指针进行间接访问
    int* paa = (int*)malloc(sizeof(int)); //paa指向堆上的一块内存
    *paa = 123; //编译器使用直接指针访问
}

所以说，C#中，值类型还是栈变量，引用类型则是shared_ptr。

反之，引用到值的拆箱：

void foo()
{
    int* pa = new int[123]; //引用类型
    pa[0] = 123;

    int aa = *pa; //aa是栈上的值类型，从堆上把数据进行memcpy，UnBox
}

所以这2个过程是即浪费时间又浪费内存的。
从上面我们可以看出， 值类型装箱到引用类型，装箱后，值类型改变了，被装箱的引用类型不会改变，反之同理，比如：

void foo()
{
    int aa = 123; //值类型
    int* pa = new int[123]; //引用类型
    pa[0] = aa; //堆上的引用类型数据改了

    aa = 456; //栈上的值类型变了，但堆上的数据可不会同步变，这可不是WPF的数据绑定，哈哈
}

用C#代码：

private void Form1_Load(object sender, EventArgs e)
{
            int aaa = 123; //Value Type
            IntPtr paaa = System.Runtime.InteropServices.Marshal.AllocHGlobal(sizeof(int)); //Ref Type

            System.Runtime.InteropServices.Marshal.WriteInt32(paaa,aaa); //Box
            aaa = System.Runtime.InteropServices.Marshal.ReadInt32(paaa); //UnBox
}

【 继承关系】
C#的玩意儿都继承System.Object，栈上的值类型继承System.ValueType，这是编译器定义的隐性继承。
也就是这样：

void foo()
{
    int aaa = 123;
    System.Diagnostics.Debug.WriteLine(((aaa as ValueType) as object).ToString());
}

于是可以这样：

private bool IsValueType(object o)
{
            return o is ValueType ? true : false;
}

private void Form1_Load(object sender, EventArgs e)
{
            int aaa = 123;
            System.Diagnostics.Debug.WriteLine(IsValueType(aaa).ToString()); //True

            var bc = new Form();
            System.Diagnostics.Debug.WriteLine(IsValueType(bc).ToString()); //False
}

【 好玩的东西】
值类型的引用类型：
大家知道，值类型使用栈内存，在C++中，我们有栈上类（就是RIIA，资源分配即初始化），但是在C#中，所有类都必需使用new进行堆上申请，由GC进行统一管理。
比如在DirectShow基本类里面的自动临界区类CCritSec，就像C#里面的lock关键字一样。

栈的特征就是分配->初始化：
int aa = 123;
退出自动销毁。

这个RIIA范式在C++程序员手里那是用得爽。
C#下，因为一切引用类型都是在堆上跑，我们如果要做像RIIA这样的东西怎么办？
可能你已经想到了， using关键字和IDisposable。

这个我就不多说了，自己搜索一下就知道了。