【转】堆栈和托管堆 c#
原文地址：http://blog.csdn.net/baoxuetianxia/archive/2008/11/04/3218913.aspx
首先堆棧和堆（托管堆）都在進程的虛擬內存中。（在32位處理器上每個進程的虛擬內存為4GB）
堆棧stack
堆棧中存儲值類型。
堆棧實際上是向下填充，即由高內存地址指向低內存地址填充。
堆棧的工作方式是先分配內存的變量后釋放（先進后出原則）。
堆棧中的變量是從下向上釋放，這樣就保證了堆棧中先進后出的規則不與變量的生命周期起沖突！
堆棧的性能非常高，但是對于所有的變量來說還不太靈活，而且變量的生命周期必須嵌套。
通常我們希望使用一種方法分配內存來存儲數據，并且方法退出后很長一段時間內數據仍然可以使用。此時就要用到堆（托管堆）！
?
堆（托管堆）heap
堆（托管堆）存儲引用類型。
此堆非彼堆，.NET中的堆由垃圾收集器自動管理。
與堆棧不同，堆是從下往上分配，所以自由的空間都在已用空間的上面。
比如創建一個對象：
Customer cus;
cus = new Customer();
申明一個Customer的引用cus，在堆棧上給這個引用分配存儲空間。這僅僅只是一個引用，不是實際的Customer對象！
cus占4個字節的空間，包含了存儲Customer的引用地址。
接著分配堆上的內存以存儲Customer對象的實例，假定Customer對象的實例是32字節，為了在堆上找到一個存儲Customer對象的存儲位置。
.NET運行庫在堆中搜索第一個從未使用的，32字節的連續塊存儲Customer對象的實例！
然后把分配給Customer對象實例的地址賦給cus變量！
?
從這個例子中可以看出，建立對象引用的過程比建立值變量的過程復雜，且不能避免性能的降低！
實際上就是.NET運行庫保存對的狀態信息，在堆中添加新數據時，堆棧中的引用變量也要更新。性能上損失很多！
有種機制在分配變量內存的時候，不會受到堆棧的限制：把一個引用變量的值賦給一個相同類型的變量，那么這兩個變量就引用同一個堆中的對象。
當一個應用變量出作用域時，它會從堆棧中刪除。但引用對象的數據仍然保留在堆中，一直到程序結束 或者 該數據不被任何變量應用時，垃圾收集器會刪除它。
裝箱轉化
using System;
class Boxing
{
public static void Main()
{ int i=110;
object obj=i;
i=220;
Console.WriteLine("i={0},obj={1}",i,obj);
obj=330;
Console.WriteLine("i={0},obj={1}",i,obj);
?
}
}
定義整數類型變量I的時候，這個變量占用的內存是內存棧中分配的，第二句是裝箱操作將變量 110存放到了內存堆中，而定義object對象類型的變量obj則在內存棧中，并指向int類型的數值110，而該數值是付給變量i的數值副本。
所以運行結果是
i=220,obj=110
i=220,obj=330
內存格局通常分為四個區
全局數據區：存放全局變量，靜態數據，常量
代碼區：存放所有的程序代碼
棧區：存放為運行而分配的局部變量，參數，返回數據，返回地址等，
堆區：即自由存儲區
值類型變量與引用類型變量的內存分配模型也不一樣。為了理解清楚這個問題，讀者首
先必須區分兩種不同類型的內存區域：線程堆棧（Thread Stack）和托管堆（Managed Heap）。
每個正在運行的程序都對應著一個進程（process），在一個進程內部，可以有一個或多
個線程（thread），每個線程都擁有一塊“自留地”，稱為“線程堆棧”，大小為1M，用于保
存自身的一些數據，比如函數中定義的局部變量、函數調用時傳送的參數值等，這部分內存
區域的分配與回收不需要程序員干涉。
所有值類型的變量都是在線程堆棧中分配的。
另一塊內存區域稱為“堆（heap）”，在.NET 這種托管環境下，堆由CLR 進行管理，所
以又稱為“托管堆（managed heap）”。
用new 關鍵字創建的類的對象時，分配給對象的內存單元就位于托管堆中。
在程序中我們可以隨意地使用new 關鍵字創建多個對象，因此，托管堆中的內存資源
是可以動態申請并使用的，當然用完了必須歸還。
打個比方更易理解：托管堆相當于一個旅館，其中的房間相當于托管堆中所擁有的內存
單元。當程序員用new 方法創建對象時，相當于游客向旅館預訂房間，旅館管理員會先看
一下有沒有合適的空房間，有的話，就可以將此房間提供給游客住宿。當游客旅途結束，要
辦理退房手續，房間又可以為其他旅客提供服務了。
從表 1 可以看到，引用類型共有四種：類類型、接口類型、數組類型和委托類型。
所有引用類型變量所引用的對象，其內存都是在托管堆中分配的。
嚴格地說，我們常說的“對象變量”其實是類類型的引用變量。但在實際中人們經常將
引用類型的變量簡稱為“對象變量”，用它來指代所有四種類型的引用變量。在不致于引起
混淆的情況下，本書也采用了這種慣例。
在了解了對象內存模型之后，對象變量之間的相互賦值的含義也就清楚了。請看以下代
碼（示例項目ReferenceVariableForCS）：
class A
02 {
03 public int i;
04 }
05 class Program
06 {
07 static void Main(string[] args)
08 {
09 A a ;
10 a= new A();
11 a.i = 100;
12 A b＝null;
13 b = a; //對象變量的相互賦值
14 Console.WriteLine("b.i=" + b.i); //b.i=?
15 }
16 }
注意第12 和13 句。
程序的運行結果是：
b.i=100;
請讀者思索一下：兩個對象變量的相互賦值意味著什么？
事實上，兩個對象變量的相互賦值意味著賦值后兩個對象變量所占用的內存單元其內容
是相同的。
講得詳細一些：
第10 句創建對象以后，其首地址（假設為“1234 5678”）被放入到變量a 自身的4 個
字節的內存單元中。
第12 句又定義了一個對象變量b，其值最初為null（即對應的4 個字節內存單元中為
“0000 0000”）。
第13 句執行以后，a 變量的值被復制到b 的內存單元中，現在，b 內存單元中的值也為
“1234 5678”。
根據前面介紹的對象內存模型，我們知道現在變量a 和b 都指向同一個實例對象。
如果通過b.i 修改字段i 的值，a.i 也會同步變化，因為a.i 與b.i 其實代表同一對象的同
一字段。
整個過程可以用圖 9 來說明：
?
圖
圖 9 對象變量的相互賦值
由此得到一個重要結論：
對象變量的相互賦值不會導致對象自身被復制，其結果是兩個對象變量指向同一對象。
另外，由于對象變量本身是一個局部變量，因此，對象變量本身是位于線程堆棧中的。
嚴格區分對象變量與對象變量所引用的對象，是面向對象編程的關鍵之一。
由于對象變量類似于一個對象指針，這就產生了“判斷兩個對象變量是否引用同一對象”
的問題。
C#使用“＝＝”運算符比對兩個對象變量是否引用同一對象，“!=”比對兩個對象變量
22
是否引用不同的對象。參看以下代碼：
//a1與a2引用不同的對象
A a1= new A();
A a2= new A();
Console.WriteLine(a1 == a2);//輸出：false
a2 = a1;//a1與a2引用相同的對象
Console.WriteLine(a1 == a2);//輸出：true
需要注意的是，如果“＝＝”被用在值類型的變量之間，則比對的是變量的內容：
int i = 0;
int j = 100;
if (i == j)
{
Console.WriteLine("i與j的值相等");
}
理解值類型與引用類型的區別在面向對象編程中非常關鍵。
?
?
?
1、類型，對象，堆棧和托管堆
C#的類型和對象在應用計算機內存時，大體用到兩種內存，一個
叫堆棧，另一個叫托管堆，下面我們用直角長方形來代表堆棧，
用圓角長方形來代表托管堆。
首先討論一下方法內部變量的存放。
先舉個例子，有如下兩個方法，Method_1 和Add，分別如下：
public void Method_1()
{
int value1=10; //1
int value2=20; //2
int value3=Add(value,value); //3
}
public int Add(int n1,int n2)//4
{
rnt sum=n1+n2;//5
return sum;//6
}
這段代碼的執行，用圖表示為：
?
?
?
?
上述的每個圖片，基本對應程序中的每個步驟。在開始執行Met
hod_1的時候，先把value1 壓入堆棧頂，然后是value2，接
下來的是調用方法Add，因為方法有兩個參數是n1 和n2，所以
把n1 和n2 分別壓入堆棧，因為此處是調用了一個方法，并且方
法有返回值，所以這里需要保存Add的返回地址，然后進入Ad
d方法內部，在Add內部，首先是給sum 賦值，所以把sum 壓
入棧項，然后用return 返回，此時，先前的返回地址就起到了
作用，return 會根據地址返回去的，在返回的過程中，把sum
推出棧頂，找到了返回地址，但在Method_1 方法中，我們希望
把Add的返回值賦給value3，此時的返回地址也被推出堆棧，
把value3 壓入堆棧。雖這個例子的結果在這里沒有多大用途，
但這個例子很好的說明了在方法被執行時，變量與進出堆棧的情
況。這里也能看出為什么方法內部的局變量用過后，不能在其他
方法中訪問的原因。
其次來討論一下類和對象在托管堆和堆棧中的情況。
先看一下代碼：
class Car
{
public void Run()
{
Console.WriteLine("一切正常");
}
public virtual double GetPrice()
{
return 0;
}
public static void Purpose()
{
Console.WriteLine("載人");
}
PDF 文件使用 "pdfFactory Pro" 試用版本創建 fw w w . f i n e p rint.cn
}
class BMW : Car
{
public override double GetPrice()
{
return 800000;
}
}
上面是兩個類，一個Father一個Son，Son 繼承了Father，
因為你類中有一個virtual的BuyHouse 方法，所以Son類可以重
寫這個方法。
下面接著看調用代碼。
public void Method_A()
{
double CarPrice;//1
Car car = new BMW();//2
CarPrice = car.GetPrice();//調用虛方法（其實調用的是重寫后
的方法）
car.Run();//調用實例化方法
Car.Purpose();//調用靜態方法
}
這個方法也比較簡單，就是定義一個變量用來獲得價格，同時
定義了一個父類的變量，用子類來實例化它。
接下來，我們分步來說明。
看一下運行時堆棧和托管堆的情部我
?
?
這里需要說明的是，類是位于托管堆中的，每個類又分為四個
類部，類指針，用來關聯對象；同步索引，用來完成同步(比如線
程的同步)需建立的；靜態成員是屬于類的，所以在類中出現，還
有一個方法列表（這里的方法列表項與具體的方法對應）。
當Method_A方法的第一步執行時：
?
這時的CarPrice 是沒有值的
當Method_A方法執行到第二步，其實第二步又可以分成
Car car;
car = new BMW();
先看Car car;
?
car在這里是一個方法內部的變量，所以被壓到堆棧中。
再看 car = new BMW();
這是一個實例化過程，car變成了一個對象
?
這里是用子類來實例化父類型。對象其實是子類的類型的，但
變量的類型是父類的。
接下來，在Method_A中的調用的中調用car.GetPrice()，
對于Car來說，這個方法是虛方法（并且子類重寫了它），虛方
法在調用是不會執行類型上的方法，即不會執行Car類中的虛方
法，而是執行對象對應類上的方法，即BMW中的GtPrice。
如果Method_A中執行方法Run()，因為Run是普通實例方
法，所以會執行Car類中的Run 方法。
如果調用了Method_A的Purpose 方法，即不用變量car調
用，也不用對象調用，而是用類名Car調用，因為靜態方法會在
類中分配內存的。如果用Car生成多個實例，靜態成員只有一份，
就是在類中，而不是在對象中。
33333333333333333333333333333333
在32位的Windows操作系統中，每個進程都可以使用4GB的內存，這得益于虛擬尋址技術，在這4GB的內存中存儲著可執行代碼、代碼加載的DLL和程序運行的所有變量，在C#中，虛擬內存中有個兩個存儲變量的區域，一個稱為堆棧，一個稱為托管堆，托管堆的出現是.net不同于其他語言的地方，堆棧存儲值類型數據，而托管堆存儲引用類型如類、對象，并受垃圾收集器的控制和管理。在堆棧中，一旦變量超出使用范圍，其使用的內存空間會被其他變量重新使用，這時其空間中存儲的值將被其他變量覆蓋而不復存在，但有時候我們希望這些值仍然存在，這就需要托管堆來實現。我們用幾段代碼來說明其工作原理，假設已經定義了一個類class1:
class1 object1;
object1=new class1();
第一句定義了一個class1的引用，實質上只是在堆棧中分配了一個4個字節的空間，它將用來存府后來實例化對象在托管堆中的地址，在windows中這需要4個字節來表示內存地址。第二句實例化object1對象，實際上是在托管堆中開僻了一個內存空間來存儲類class1的一個具體對象，假設這個對象需要36個字節，那么object1指向的實際上是在托管堆一個大小為36個字節的連續內存空間開始的地址。由此也可以看出在C#編譯器中為什么不允許使用未實例化的對象，因為這個對象在托管堆中還不存在。當對象不再使用時，這個被存儲在堆棧中的引用變量將被刪除，但是從上述機制可以看出，在托管堆中這個引用指向的對象仍然存在，其空間何時被釋放取決垃圾收集器而不是引用變量失去作用域時。
在使用電腦的過程中大家可能都有過這種經驗：電腦用久了以后程序運行會變得越來越慢，其中一個重要原因就是系統中存在大量內存碎片，就是因為程序反復在堆棧中創建和釋入變量，久而久之可用變量在內存中將不再是連續的內存空間，為了尋址這些變量也會增加系統開銷。在.net中這種情形將得到很大改善，這是因為有了垃圾收集器的工作，垃圾收集器將會壓縮托管堆的內存空間，保證可用變量在一個連續的內存空間內，同時將堆棧中引用變量中的地址改為新的地址，這將會帶來額外的系統開銷，但是，其帶來的好處將會抵消這種影響，而另外一個好處是，程序員將不再花上大量的心思在內在泄露問題上。
當然，以C#程序中不僅僅只有引用類型的變量，仍然也存在值類型和其他托管堆不能管理的對象，如果文件名柄、網絡連接和數據庫連接，這些變量的釋放仍需要程序員通過析構函數或IDispose接口來做。
另一方面，在某些時候C#程序也需要追求速度，比如對一個含用大量成員的數組的操作，如果仍使用傳統的類來操作，將不會得到很好的性能，因為數組在C#中實際是System.Array的實例，會存儲在托管堆中，這將會對運算造成大量的額外的操作，因為除了垃圾收集器除了會壓縮托管堆、更新引用地址、還會維護托管堆的信息列表。所幸的是C#中同樣能夠通過不安全代碼使用C++程序員通常喜歡的方式來編碼，在標記為unsafe的代碼塊使用指針，這和在C++中使用指針沒有什么不同，變量也是存府在堆棧中，在這種情況下聲明一個數組可以使用stackalloc語法，比如聲明一個存儲有50個double類型的數組：
double* pDouble=stackalloc double[50]
stackalloc會給pDouble數組在堆棧中分配50個double類型大小的內存空間，可以使用pDouble[0]、*(pDouble+1)這種方式操作數組，與在C++中一樣，使用指針時必須知道自己在做什么，確保訪問的正確的內存空間，否則將會出現無法預料的錯誤。
掌握托管堆、堆棧、垃圾收集器和不安全代碼的工作原理和方式，將有助于你成為真正的優秀C#程序員。
進程中每個線程都有自己的堆棧，這是一段線程創建時保留下的地址區域。我們的“棧內存”即在此。至于“堆”內存，我個人認為在未用new定義時，堆應該就是未“保留”未“提交”的自由空間，new的功能是在這些自由空間中保留（并提交？）出一個地址范圍
棧(Stack)是操作系統在建立某個進程時或者線程（在支持多線程的操作系統中是線程）為這個線程建立的存儲區域，該區域具有FIFO的特性，在編譯的時候可以指定需要的Stack的大小。在編程中，例如C/C++中，所有的局部變量都是從棧中分配內存空間，實際上也不是什么分配，只是從棧頂向上用就行，在退出函數的時候，只是修改棧指針就可以把棧中的內容銷毀，所以速度最快。
堆（Heap)是應用程序在運行的時候請求操作系統分配給自己內存，一般是申請/給予的過程，C/C++分別用malloc/New請求分配Heap，用free/delete銷毀內存。由于從操作系統管理的內存分配所以在分配和銷毀時都要占用時間，所以用堆的效率低的多！但是堆的好處是可以做的很大，C/C++對分配的Heap是不初始化的。
在Java中除了簡單類型（int,char等）都是在堆中分配內存，這也是程序慢的一個主要原因。但是跟C/C++不同，Java中分配Heap內存是自動初始化的。在Java中所有的對象（包括int的wrapper Integer）都是在堆中分配的，但是這個對象的引用卻是在Stack中分配。也就是說在建立一個對象時從兩個地方都分配內存，在Heap中分配的內存實際建立這個對象，而在Stack中分配的內存只是一個指向這個堆對象的指針（引用）而已。
在.NET的所有技術中，最具爭議的恐怕是垃圾收集(Garbage Collection，GC)了。作為.NET框架中一個重要的部分，托管堆和垃圾收集機制對我們中的大部分人來說是陌生的概念。在這篇文章中將要討論托管堆，和你將從中得到怎樣的好處。
為什么要托管堆？
.NET框架包含一個托管堆，所有的.NET語言在分配引用類型對象時都要使用它。像值類型這樣的輕量級對象始終分配在棧中，但是所有的類實例和數組都被生成在一個內存池中，這個內存池就是托管堆。
垃圾收集器的基本算法很簡單：
● 將所有的托管內存標記為垃圾
● 尋找正被使用的內存塊，并將他們標記為有效
● 釋放所有沒有被使用的內存塊
● 整理堆以減少碎片
托管堆優化
看上去似乎很簡單，但是垃圾收集器實際采用的步驟和堆管理系統的其他部分并非微不足道，其中常常涉及為提高性能而作的優化設計。舉例來說，垃圾收集遍歷整個內存池具有很高的開銷。然而，研究表明大部分在托管堆上分配的對象只有很短的生存期，因此堆被分成三個段，稱作generations。新分配的對象被放在generation 0中。這個generation是最先被回收的——在這個generation中最有可能找到不再使用的內存，由于它的尺寸很小（小到足以放進處理器的L2 cache中），因此在它里面的回收將是最快和最高效的。
托管堆的另外一種優化操作與locality of reference規則有關。該規則表明，一起分配的對象經常被一起使用。如果對象們在堆中位置很緊湊的話，高速緩存的性能將會得到提高。由于托管堆的天性，對象們總是被分配在連續的地址上，托管堆總是保持緊湊，結果使得對象們始終彼此靠近，永遠不會分得很遠。這一點與標準堆提供的非托管代碼形成了鮮明的對比，在標準堆中，堆很容易變成碎片，而且一起分配的對象經常分得很遠。
還有一種優化是與大對象有關的。通常，大對象具有很長的生存期。當一個大對象在.NET托管堆中產生時，它被分配在堆的一個特殊部分中，這部分堆永遠不會被整理。因為移動大對象所帶來的開銷超過了整理這部分堆所能提高的性能。
關于外部資源（External Resources）的問題
垃圾收集器能夠有效地管理從托管堆中釋放的資源，但是資源回收操作只有在內存緊張而觸發一個回收動作時才執行。那么，類是怎樣來管理像數據庫連接或者窗口句柄這樣有限的資源的呢？等待，直到垃圾回收被觸發之后再清理數據庫連接或者文件句柄并不是一個好方法，這會嚴重降低系統的性能。
所有擁有外部資源的類，在這些資源已經不再用到的時候，都應當執行Close或者Dispose方法。從Beta2（譯注：本文中所有的Beta2均是指.NET Framework Beta2，不再特別注明）開始，Dispose模式通過IDisposable接口來實現。這將在本文的后續部分討論。
需要清理外部資源的類還應當實現一個終止操作（finalizer）。在C#中，創建終止操作的首選方式是在析構函數中實現，而在Framework層，終止操作的實現則是通過重載System.Object.Finalize 方法。以下兩種實現終止操作的方法是等效的：
~OverdueBookLocator()
{
Dispose(false);
}
和：
public void Finalize()
{
base.Finalize();
Dispose(false);
}
在C#中，同時在Finalize方法和析構函數實現終止操作將會導致錯誤的產生。
除非你有足夠的理由，否則你不應該創建析構函數或者Finalize方法。終止操作會降低系統的性能，并且增加執行期的內存開銷。同時，由于終止操作被執行的方式，你并不能保證何時一個終止操作會被執行。
內存分配和垃圾回收的細節
對GC有了一個總體印象之后，讓我們來討論關于托管堆中的分配與回收工作的細節。托管堆看起來與我們已經熟悉的C++編程中的傳統的堆一點都不像。在傳統的堆中，數據結構習慣于使用大塊的空閑內存。在其中查找特定大小的內存塊是一件很耗時的工作，尤其是當內存中充滿碎片的時候。與此不同，在托管堆中，內存被組制成連續的數組，指針總是巡著已經被使用的內存和未被使用的內存之間的邊界移動。當內存被分配的時候，指針只是簡單地遞增——由此而來的一個好處是，分配操作的效率得到了很大的提升。
當對象被分配的時候，它們一開始被放在generation 0中。當generation 0的大小快要達到它的上限的時候，一個只在generation 0中執行的回收操作被觸發。由于generation 0的大小很小，因此這將是一個非常快的GC過程。這個GC過程的結果是將generation 0徹底的刷新了一遍。不再使用的對象被釋放，確實正被使用的對象被整理并移入generation 1中。
當generation 1的大小隨著從generation 0中移入的對象數量的增加而接近它的上限的時候，一個回收動作被觸發來在generation 0和generation 1中執行GC過程。如同在generation 0中一樣，不再使用的對象被釋放，正在被使用的對象被整理并移入下一個generation中。大部分GC過程的主要目標是generation 0，因為在generation 0中最有可能存在大量的已不再使用的臨時對象。對generation 2的回收過程具有很高的開銷，并且此過程只有在generation 0和generation 1的GC過程不能釋放足夠的內存時才會被觸發。如果對generation 2的GC過程仍然不能釋放足夠的內存，那么系統就會拋出OutOfMemoryException異常
帶有終止操作的對象的垃圾收集過程要稍微復雜一些。當一個帶有終止操作的對象被標記為垃圾時，它并不會被立即釋放。相反，它會被放置在一個終止隊列（finalization queue）中，此隊列為這個對象建立一個引用，來避免這個對象被回收。后臺線程為隊列中的每個對象執行它們各自的終止操作，并且將已經執行過終止操作的對象從終止隊列中刪除。只有那些已經執行過終止操作的對象才會在下一次垃圾回收過程中被從內存中刪除。這樣做的一個后果是，等待被終止的對象有可能在它被清除之前，被移入更高一級的generation中，從而增加它被清除的延遲時間。
需要執行終止操作的對象應當實現IDisposable接口，以便客戶程序通過此接口快速執行終止動作。IDisposable接口包含一個方法——Dispose。這個被Beta2引入的接口，采用一種在Beta2之前就已經被廣泛使用的模式實現。從本質上講，一個需要終止操作的對象暴露出Dispose方法。這個方法被用來釋放外部資源并抑制終止操作，就象下面這個程序片斷所演示的那樣：
public class OverdueBookLocator: IDisposable
{
~OverdueBookLocator()
{
InternalDispose(false);
}
public void Dispose()
{
InternalDispose(true);
}
protected void InternalDispose(bool disposing)
{
if(disposing)
{
GC.SuppressFinalize(this);
// Dispose of managed objects if disposing.
}
// free external resources here
}
}
這些都是.NET中CLR的概念，和C#沒多大關系。
使用基于CLR的語言編譯器開發的代碼稱為托管代碼。
托管堆是CLR中自動內存管理的基礎。初始化新進程時，運行時會為進程保留一個連續的地址空間區域。這個保留的地址空間被稱為托管堆。托管堆維護著一個指針，用它指向將在堆中分配的下一個對象的地址。最初，該指針設置為指向托管堆的基址。
認真看MSDN Library，就會搞清楚這些概念。
以下代碼說明的很形象：
//引用類型('class' 類類型)
class SomeRef { public int32 x;}
//值類型('struct')
struct SomeVal(pulic Int32 x;}
static void ValueTypeDemo()
{
SomeRef r1=new SomeRef();//分配在托管堆
SomeVal v1=new SomeVal();//堆棧上
r1.x=5;//解析指針
v1.x=5;//在堆棧上修改
SomeRef r2=r1;//僅拷貝引用(指針)
SomeVal v2=v1;//先在堆棧上分配,然后拷貝成員
r1.x=8;//改變了r1,r2的值
v1.x=9;//改變了v1,沒有改變v2
}
4444444444444444444444444444444444444444444444444444444
棧是內存中完全用于存儲局部變量或成員字段（值類型數據）的高效的區域，但其大小有限制。
托管堆所占內存比棧大得多，當訪問速度較慢。托管堆只用于分配內存，一般由CLR（Common Language Runtime）來處理內存釋放問題。
當創建值類型數據時，在棧上分配內存；
當創建引用型數據時，在托管堆上分配內存并返回對象的引用。注意這個對象的引用，像其他局部變量一樣也是保存在棧中的。該引用指向的值則位于托管堆中。
如果創建了一個包含值類型的引用類型，比如數組，其元素的值也是存放在托管堆中而非棧中的。當從數組中檢索數據時，獲得本地使用的元素值的副本，而該副本這時候就是存放在棧中的了。所以，不能籠統的說“值類型保存在棧中，引用類型保存在托管堆中”。
值類型和引用類型的區別：引用類型存儲在托管堆的唯一位置中，其存在于托管堆中某個地方，由使用該實體的變量引用；而值類型存儲在使用它們的地方，有幾處在使用，就有幾個副本存在。
對于引用類型，如果在聲明變量的時候沒有使用new運算符，運行時就不會給它分配托管堆上的內存空間，而是在棧上給它分配一個包含null值的引用。對于值類型，運行時會給它分配棧上的空間，并調用默認的構造函數，來初始化對象的狀態。
55555555555555555555555555555555555555555555555555
一、棧和托管堆
通用類型系統(CTS)區分兩種基本類型：值類型和引用類型。它們之間的根本區別在于它們在內存中的存儲方式。.NET使用兩種不同的物理內存塊來存儲數據—棧和托管堆。如下圖所示：
?
?
二 類型層次結構
CTS定義了一種類型層次結構，該結構不僅僅描述了不同的預定義類型，還指出了用戶定義類型在層次結構種的
?
轉載于:https://www.cnblogs.com/ayi30/archive/2012/08/23/2652957.html
總結
以上是生活随笔為你收集整理的【转】堆栈和托管堆 c#的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 萌新三连是谁画的呢？
- 下一篇： Linux Mount Windows域