簡單來說，struct是值型別，建立一個struct型別的例項被分配在棧上。class是引用型別，建立一個class型別例項被分配在託管堆上。但struct和class的區別遠不止這麼簡單。

概括來講，struct和class的不同體現在：

● class是引用型別，struct是值型別，所有他有值型別和引用型別的區別特徵，參見《C#值型別和引用型別的區別》
● class的例項建立是在託管堆上，struct例項建立是在棧上
● class例項的賦值，賦的是引用地址，struct例項的賦值，賦的是值
● class作為引數型別傳遞，傳遞的是引用地址，struct作為引數型別傳遞，傳遞的是值

● class 的預設訪問許可權是private，而struct的的預設訪問許可權public

● 如果class中只聲明瞭一個有引數的建構函式，則用new關鍵字建立例項時不能再無引數建構函式（預設建構函式），否則會出現”XXX不包含0個引數的建構函式"的編譯錯誤，這句話的意思表明class中除非沒有一個建構函式，否則聲明瞭什麼建構函式，就只能用什麼建構函式。

而struct中由於只能宣告帶引數的建構函式，當建立例項時

● class建立例項必須用new關鍵字，而struct可以用new，也可以不用new，區別在於用new生成的struct中，struct的成員函式是有初始值的。例子如下：

struct Point
{
    float  x;
    float y;
}
Point p = new Point();p是值型別所以應該在棧上為其分配空間
float a = p.x;  //編譯通過,使用new 語句，C#結構體中的成員已經得到初始化,a的值為0
Point p;
foalt a = p.x;  //編譯不過,編譯器認為p的欄位未得到初始化，是未知的
 

● class支援繼承，struct不支援繼承，但支援介面。
● class偏向於"面向物件",用於複雜、大型資料，struct偏向於"簡單值"，比如小於16位元組，結構簡單
● class的成員變數可以在宣告的時候賦初值，而在struct宣告中，除非欄位被宣告為 const 或 static，否則無法初始化。

一、從賦值的角度體驗struct和class的不同

引用型別賦值，是把地址賦值給了變數

class Program
  {
    static void Main(string[] args)
    {
      SizeClass sizeClass = new SizeClass(){Width = 10, Length = 10};
      Console.WriteLine("賦值前：width={0},length={1}", sizeClass.Width, sizeClass.Length);
 
      var copyOfSizeClass = sizeClass;
      copyOfSizeClass.Length = 5;
      copyOfSizeClass.Width = 5;
      Console.WriteLine("賦值後：width={0},length={1}",sizeClass.Width, sizeClass.Length);
      Console.ReadKey();
    }
  }
 
  public class SizeClass
  {
    public int Width { get; set; }
    public int Length { get; set; }
  }
 
  public struct SizeStruct
  {
    public int Width { get; set; }
    public int Length { get; set; }
  }

執行結果如下圖所示：

以上，當把sizeClass賦值給copyOfSize變數的時候，是把sizeClass所指向的地址賦值給了copyOfSize變數，2個變數同時指向同一個地址。所以，當改變copyOfSizeClass變數的值，也相當於改變了sizeClass的值。

struct型別賦值，是完全拷貝，在棧上多了一個完全一樣的變數

class Program
  {
    static void Main(string[] args)
    {
      SizeStruct sizeStruct = new SizeStruct(){Length = 10, Width = 10};
      Console.WriteLine("賦值前：width={0},length={1}", sizeStruct.Width, sizeStruct.Length);
 
      var copyOfSizeStruct = sizeStruct;
      copyOfSizeStruct.Length = 5;
      copyOfSizeStruct.Width = 5;
      Console.WriteLine("賦值後：width={0},length={1}", sizeStruct.Width, sizeStruct.Length);
      Console.ReadKey();
    }
  }

程式執行結果如下圖所示：

以上，當把sizeStruct賦值給copyOfSizeStruct變數的時候，是完全拷貝，改變copyOfSizeStruct的值不會影響到sizeStruct。

二、從引數傳值角度體驗struct和class的不同

引用型別引數傳遞的是地址

class Program
  {
    static void Main(string[] args)
    {
      List<string> temp = new List<string>(){"my","god"};
      ChangeReferenceType(temp);
      temp.ForEach(t => Console.Write(t + " "));
      Console.ReadKey();
    }
 
    public static void ChangeReferenceType(List<string> list)
    {
      list = new List<string>(){"hello", "world"};
    }
  }

執行結果：my god

為什麼不是hello world？
→棧上的temp指向託管堆上的一個集合例項
→當temp放到ChangeReferenceType(temp)方法中，本質是把temp指向的地址賦值給了變數list
→在ChangeReferenceType(List<string> list)方法內部，又把變數list的指向了另外一個集合例項地址
→但temp的指向地址一直沒有改變

我們再來改變ChangeReferenceType(List<string> list)內部實現方式，其它不變。

class Program
  {
    static void Main(string[] args)
    {
      List<string> temp = new List<string>(){"my","god"};     
      ChangeReferenceType(temp);
      temp.ForEach(t => Console.Write(t + " "));
      Console.ReadKey();
    }
 
    public static void ChangeReferenceType(List<string> list)
    {
      list.Clear();
      list.Add("hello");
      list.Add("world");
    }
  }

執行結果：hello world

為什麼不是my god？ 
→棧上的temp指向託管堆上的一個集合例項
→當temp放到ChangeReferenceType(temp)方法中，本質是把temp指向的地址賦值給了變數list
→在ChangeReferenceType(List<string> list)方法內部，把temp和list共同指向的例項清空，又新增"hello"和"world"2個元素
→由於list和temp指向的例項是一樣的，所以改變list指向的例項就等同於改變temp指向的例項

以上，很好地說明了：引用型別引數傳遞的是地址。

值型別struct引數傳遞的是值

class Program
  {
    static void Main(string[] args)
    {
      Size s = new Size(){Length = 10, Width = 10};
      ChangeStructType(s);
      Console.Write("Length={0},Width={1}", s.Length,s.Width);
      Console.ReadKey();
    }
 
    public static void ChangeStructType(Size size)
    {
      size.Length = 0;
      size.Width = 0;
    }
  }
 
  public struct Size
  {
    public int Length { get; set; }
    public int Width { get; set; }
  }

執行結果如下圖所示：

為什麼Length和Width不是0呢？
→在棧上變數size
→當通過ChangeStructType(size)，把s變數賦值給ChangeStructType(Size size)中的size變數，其本質是在棧上又建立了一個變數size，size的值和s是完全一樣的
→在ChangeStructType(Size size)內部改變size的值，與變數s毫無關係

三、從struct型別的struct型別屬性和struct引用型別屬性體驗struct和class的不同

假設有一個struct，它有struct型別的屬性

以下， struct型別Room有struct型別的屬性TableSize和TvSize，我們如何通過Room例項來修改其struct型別的屬性值呢？

class Program
  {
    static void Main(string[] args)
    {
      Room r = new Room()
      {
        TableSize = new Size(){Length = 100, Width = 80},
        TvSize = new Size(){Length = 10, Width = 8}
      };
 
      r.TableSize.Length = 0;
       
      Console.WriteLine("table目前的尺寸是：length={0},width={1}", r.TableSize.Length, r.TableSize.Width);
      Console.ReadKey();
    }
  }
 
  public struct Size
  {
    public int Length { get; set; }
    public int Width { get; set; }
  }
 
  public struct Room
  {
    public Size TableSize { get; set; }
    public Size TvSize { get; set; }
  }

以上，r.TableSize.Length = 0；此處會報錯：不能修改r.TableSize的值，因為不是變數。的確，r.TableSize只是Size的一份拷貝，而且也沒有賦值給其它變數，所以r.TableSize是臨時的，會被自動回收，對其賦值也是沒有意義的。

 如果要修改r.TableSize，只需把

改成如下：

執行結果如下圖所示：

可見，改變struct型別的struct型別屬性的某個屬性是行不通的，因為像以上r.TableSize只是一份拷貝，是臨時的，會被自動回收的。要改變struct型別的struct型別屬性，就需要像上面一樣，給r.TableSize賦上一個完整的Size例項。

假設有一個struct，它有引用型別的屬性呢？

以下，struct型別的Room有引用型別屬性，TableSize和TvSize,如何通過Room例項來修改其引用型別的屬性值呢？並且，我們在類Size中定義了一個事件，當給Size的屬性賦值時就觸發事件，提示size類的屬性值發生了改變。

class Program
  {
    static void Main(string[] args)
    {
      var oneSize = new Size() {Length = 10, Width = 10};
      var twoSize = oneSize;
 
      oneSize.Changed += (s, e) => Console.Write("Size發生了改變~~");
      oneSize.Length = 0;
      Console.ReadKey();
    }
  }
 
  public class Size
  {
    private int _length;
    private int _width;
 
    public event System.EventHandler Changed;
 
    public int Length
    {
      get { return _length; }
      set
      {
        _length = value;
        OnChanged();
      }
    }
 
    public int Width
    {
      get { return _width; }
      set { _width = value; OnChanged(); }
    }
 
    private void OnChanged()
    {
      if (Changed != null)
      {
        Changed(this, new EventArgs());
      }
    }
  }
 
  public struct Room
  {
    public Size TableSize { get; set; }
    public Size TvSize { get; set; }
  }

執行，顯示：Size發生了改變~~

對oneSize.Length的修改，實際上修改的是oneSize.Length指向託管堆上的例項。

四、從建構函式體驗struct和class的不同

struct型別包含隱式的預設無參建構函式

class Program
  {
    static void Main(string[] args)
    {
      var size = new SizeStruct();
      Console.WriteLine("length={0},width={1}", size.Length, size.Width);
      Console.ReadKey();
    }
  }
 
  public struct SizeStruct
  {
    public int Length { get; set; }
    public int Width { get; set; }
  }

執行結果如下圖所示：

為什麼我們沒有給SizeStruct定義無參建構函式，而沒有報錯？
--因為，struct型別有一個隱式的無參建構函式，並且給所有的成員賦上預設值,int型別屬性成員的預設值是0。

而如果顯式宣告struct的預設建構函式，則會報錯，

public struct SizeStruct
{
    public SizeStruct() { } //編譯錯誤，提示結構不能包含顯式的無引數建構函式
    public int Length { get; set; }
    public int Width { get; set; }
}

但是可以宣告struct的帶引數的建構函式

public struct SizeStruct
{
    public SizeStruct(int a) { } 
    public int Length { get; set; }
    public int Width { get; set; }
}

一般情況下，如果類中沒有宣告任何建構函式，那麼系統會預設建立一個無參的建構函式，而當你定義了帶引數的建構函式以後，系統不會建立無參建構函式，這時候，如果你還想允許無參構造，就必須顯式的宣告一個

class Program
  {
    static void Main(string[] args)
    {
      var size = new SizeClass();
      Console.WriteLine("length={0},width={1}", size.Length, size.Width);
      Console.ReadKey();
    }
  }
 
  public class SizeClass
  {
    public int Length { get; set; }
    public int Width { get; set; }
 
    public SizeClass(int length, int width)
    {
      Length = length;
      Width = Width;
    }
  }

執行，報錯：SizeClass不包含0個引數的建構函式

五、從給型別成員賦初值體驗struct和class的不同

如果直接給欄位賦初值。

public struct SizeStruct
{
    public int _length = 10;
}

執行，報錯：結構中不能有例項欄位初始值設定項。除非定義的變數是static或者const型別的

如果通過建構函式給欄位賦初值。

public struct SizeStruct
  {
    public int _length;
 
    public SizeStruct()
    {
      _length = 10;
    }
  }

執行，報錯：結構中不能包含顯式無引數建構函式

可見，給struct型別成員賦初值是不太容易的，而給class成員賦初值,no problem。

何時使用struct，何時使用class?

在多數情況下，推薦使用class類，因為無論是類的賦值、作為引數型別傳遞，還是返回類的例項，實際拷貝的是託管堆上引用地址，也就大概4個位元組，這非常有助於效能的提升。

而作為struct型別，無論是賦值，作為引數型別傳遞，還是返回struct型別例項，是完全拷貝，會佔用棧上的空間。根據Microsoft's Value Type Recommendations，在如下情況下，推薦使用struct：

● 小於16個位元組
● 偏向於值，是簡單資料，而不是偏向於"面向物件"
● 希望值不可變