.NET C#基礎（5）：結構體 - 高性能代碼的基石

来源:https://www.cnblogs.com/HiroMuraki/archive/2022/06/07/16352079.html
-Advertisement-
Play Games

0. 文章目的 本文面向有一定.NET C#基礎知識的學習者，介紹C#中結構體定義、使用以及特點。 1. 閱讀基礎 瞭解C#基本語法 瞭解.NET中的棧與托管堆 2. 值類型 2.1 .NET的兩大類型 在.NET中，所有類型都是object類型的子類，而在object繁多的子類中，又可以將它們歸結 ...


0. 文章目的

  本文面向有一定.NET C#基礎知識的學習者，介紹C#中結構體定義、使用以及特點。

 

1. 閱讀基礎

  瞭解C#基本語法

  瞭解.NET中的棧與托管堆

 

2. 值類型

2.1 .NET的兩大類型

  在.NET中，所有類型都是object類型的子類，而在object繁多的子類中，又可以將它們歸結為兩種類型：引用類型與值類型，兩者最大的區別在於值類型對象會在棧上分配，而引用類型對象則是在托管堆中分配，由於對棧上數據的操作通常遠遠快於對托管堆中數據的操作，因此對值類型訪問與操作通常會更高效。.NET中的值類型有一個最為明顯的特點，就是所有的值類型都繼承自類ValueType。

2.2 ValueType

  ValueType是一個繼承自object的特殊抽象類，它是所有值類型的基類，它的意義在於區分值類型與引用類型。然而ValueType本身的定義很簡單，只是重寫了object中的Equals、GetHashCode以及ToString方法，並隱藏了預設構造方法：

public abstract class ValueType 
{
    protected ValueType() { ... }
    public override bool Equals(object obj) { ... }
    public override int GetHashCode() { ... }
    public override string? ToString() { ... }
}

  ValueType通過重寫Equals方法，讓其子類的比較行為為比較相等性（而非object預設的用於比較同一性），這也符合“值”的特點-兩個值應該比較是否相等而非是否同一：

????? Foo { }

Foo a = new Foo();
Foo b = new Foo();
Console.WriteLine(a.Equals(b));

  上述代碼中的兩個Foo對象a和b是兩個無關的變數，因此當Foo為引用類型時，上述代碼將會輸出False（Equals預設進行同一性比較），但是如果Foo類型為值類型且沒有重寫Equals方法，則會輸出True。所有的ValueType的子類的Equals方法預設都是進行值相等性比較，其比較依據就是比較各個欄位的值是否相等，即若兩個類型相同的值對象的所有欄位的值均相同，則這兩個值對象相同。

  另外，儘管ValueType錶面上看起來只是一個普通的抽象類，但是這是用於編譯器的類，編譯器禁止程式員顯式從ValueType派生類，也就是說下麵的代碼是不允許的：

class Foo : ValueType { ... } // 不允許從ValueType派生

  不過將其用作類型聲明是允許的，儘管大多數時候這一行為沒有什麼意義：

ValueType val = 1; // val的類型是ValueType

ValueType Add(ValueType a, ValueType b) { ... } // 將ValueType用於參數類型與返回類型

  總而言之，類型是否繼承自ValueType是.NET中引用類型與值類型的分界線。

3.3 C#中的值類型

（1）基元類型中的值類型

  C#中最基礎的值類型就是其基元類型中的值類型，如下：

C#基元類型 對應的FCL類型
sbyte System.SByte
byte System.Byte
short System.Int16
ushort System.UInt16
int System.Int32
uint System.UInt32
long System.Int64
ulong System.UInt64
char System.Char
float System.Single
double System.Double
bool System.Boolean
decimal System.Decimal

  這些類型都是常用且重要的類型，CLR也對上述類型提供了直接操作IL碼，擁有相比於其他類型來說更高的操作效率。

（2）枚舉類型

  C#中的枚舉類型也是值類型，因為所有枚舉類型都繼承自Enum類型，而Enum類型則繼承自ValueType。枚舉類型相比基元類型更複雜，需要一定的篇幅講解，但考慮到本文重點，這裡不做過多介紹。

（3）自定義值類型：結構體

  C#也允許程式員通過使用struct來定義自己的值類型，這一類型被稱為結構體。定義一個結構體的定義和定義一個類在語法上沒有太大的區別，下麵是一個簡單的結構體的示例：

struct Point
{
    public float X;
    public float Y;
}

  上述代碼定義了一個名為Point的結構體，該結構體中有兩個float類型的欄位，名為X與Y。你會發現其和定義一個類的區別似乎僅在於將class關鍵字替換為了struct。甚至在使用上也幾乎與普通的類無異：

Point p = new Point();
p.X = 1;

  然而這隻是錶面上看起來，由於使用了struct來定義Point，Point現在是一個值類型而非引用類型，意味著它遵守值類型棧上分配的規則，同時還有一些更深層次的東西。

3.4 與C++的不同

   如果你寫過C++，可能使用下麵的方法來決定對象的分配方式：

Point p;              // 分配到棧
Point* p = new Point(); // 分配到堆

  但在.NET中，你會意識到對象究竟會分配到棧還是分配到堆並不在分配時決定，而是在定義類型時就決定了（當然另一方面，C++中可以通過對析構函數與new運算符的私有化來實現在定義時限定分配方式）。

 

3. C#中的結構體

3.1 定義與使用結構體

3.1.1 定義

  一個結構體的定義非常簡單，從語法上來說只需要將定義一個類使用的class關鍵字替換為struct即可，如下：

public struct Point
{
    public float X;
    public float Y;
}

  同樣和定義類一樣，你可以定義為結構體添加訪問修飾符，例如上述定義中就為其添加了public訪問修飾符。同樣的，你也可以在結構體中定義屬性，方法，甚至事件。

3.1.2 使用

  結構體的使用也非常簡單，和類的使用基本一致：

Point p = new Point(); // 實例化一個Point
p.X = 1;               // 將p的欄位X的值設為1
int x = p.X;           // 獲取p的欄位X的值

  簡而言之，從語法層面來說，結構體的定義與使用和類的定義與使用沒有太大的差別，兩者大多數的操作基本可以通用。真正讓結構體與類區分開來的是它作為的值類型特點。

3.2 結構體的特點

3.2.1 棧上分配

  在前文對值類型的簡介中已經提到過，值類型在實例化時對象會被直接分配到棧上。而引用對象的變數只有在實例化的時候才會分配實際所需的記憶體：

FooClass foo;         // 此處只是聲明瞭一個FooClass對象的引用，FooClass實例尚未創建
foo = new FooClass(); // 到這裡才實際分配了所需記憶體並實例化了一個FooClass對象

  而值類型是棧上對象，意味著當你聲明值類型的變數後就會立馬分配記憶體：

FooStruct foo;                   // 立馬在棧上分配可以容納FooStruct大小的記憶體，並將所有欄位初始化為0
FooStruct foo = new FooStruct(); // 同上，但是語義更明確

  儘管上述代碼的第一種寫法無法通過編譯，但這隻是編譯器的要求，第一行代碼和第二行代碼的作用在預設情況下完全相同（預設情況是指使用結構體的自動生成的構造方法）。你可以認為，棧上對象的記憶體分配在你寫下的一瞬間就決定好了。你可以嘗試如下代碼來體會這一區別：

????? Foo {
    public long A;
    public long B;
    public long C;
    public long D;
    public long E;
}

var foos = new Foo[100 * 100 * 100];
Console.WriteLine(GC.GetTotalAllocatedBytes());

  上述代碼運行時會輸出程式運行時分配過的記憶體大小，將開頭的‘?????’替換為class或struct，你會發現當其為struct時程式所占的記憶體明顯高於其為class時，原因在於當Foo為struct時數組中的每一項所占的記憶體就是儲存一個Foo對象所需要的所有空間，而為class時則只會儲存一個引用所占的記憶體（通常為8位元組或4位元組，取決於平臺配置）。就像下圖這樣：

  分配到棧是值類型的重要特征，理解這一點對於值類型的很多性質的理解以及正確使用值類型有巨大幫助。

3.2.2 無繼承

  結構體不支持繼承，所有的結構體都是隱式密封的，也就是說，下麵的代碼是不可行的：

struct Foo { }
struct Foo2 : Foo { } // 結構體不允許繼承

  但是結構體可以實現介面：

struct Foo : IEquatable<Foo> { ... }

  關於為何結構體不可繼承，其中一個重要的原因是由於結構體所代表的值類型需要直接分配到棧上，在入棧出棧的時候必須能夠確定其數據大小，因此結構體需要提供明確固定的大小。如果允許繼承，下麵這種情況是難以預測的：

struct Foo { }
struct Foo2 : Foo { } 

Foo foo;
foo = new Foo();
foo = new Foo2();

  foo的尺寸應該以Foo為準還是以Foo2為準？答案是Foo，然而根據“基類引用可以指向派生類引用”這一規則，foo應該也可以指向Foo2的實例。然而值類型是棧上分配，其記憶體大小在聲明的一瞬間就已經確定，顯然如果Foo2中有額外的欄位，已分配給Foo對象的棧空間中將沒有額外的儲存空間容納這些欄位，另外從事實上來說，foo甚至不是一個引用。所以結構體不允許繼承是理所當然的。

3.3.3 副本式賦值

  對一個引用類型進行賦值的時候，獲得的是對指向對象的引用：

class Foo
{
    public int Value;
}

Foo f1 = new Foo();
Foo f2 = f;
f2.Value = 10;
Console.WriteLine(f1.Value);

  上述代碼將輸出10，儘管是對f2賦值，但是實際上是將f1所指向的對象的引用賦值給了f2，此時f1與f2指向的是同一個對象，因此f2修改Value的值時等同於修改f1指向的對象的Value的值。但對於值類型來說則不如此：

struct Foo
{
    public int Value;
}

Foo f1 = new Foo();
Foo f2 = f;
f2.Value = 10;
Console.WriteLine(f1.Value);

  上述代碼將輸出0，這是上述的賦值行為實際是將f的副本賦值給了f2，也就是說，不同於Foo為類時f1與f2指向的是同一個對象，f2在此時持有的是一個和f相同的副本，兩者互不相干，因此修改f2的Value不會影響f1的值。

  結構體的賦值方式如下：

  1. 實例化一個相同類型的結構體，作為副本
  2. 將當前結構體各個欄位的值逐一賦給創建的副本中相同的欄位

  不只於賦值操作，結構體作為方法參數、方法返回值時也是按值傳遞：

????? Foo
{
    public int Value;
}

void IncreaseValue(Foo foo)
{
    foo.Value += 1;
}

Foo f1 = new Foo();
IncreaseValue(f1);
Console.WriteLine(f1.Value);

  若Foo定義為class，則上述代碼輸出的為1，若Foo為struct，上述代碼輸出為0。原因是定義為class時，將f1作為參數傳入後foo獲得的是f1對其引用對象的引用，因此foo此時指向的就是f1指向的對象；而定義為struct時，foo此時獲取的是f1的副本。這一行為有時候會帶來一些奇怪的表現，例如：

struct CatCard
{
    public int ID;
}
class Cat
{
    public CatCard Card { get; } = new CatCard();
}

Cat cat = new Cat();
cat.CatCard.ID = 10;

  上述代碼嘗試修改直接修改Cat中CatCard屬性的ID欄位，咋一看好像沒問題，但實際上上述代碼甚至無法通過編譯。不要忘記一個很重要的點：屬性的本質是方法，因此上面的賦值代碼的實質如下：

CatCard card = cat.get_Card();
card.ID = 10;

  你可能已經發現問題了：get_Card()返回了一個CatCard對象，然而根據值類型按副本賦值的特點，get_Card()返回的其實是Cat中Card屬性的副本，因此card此時並不是表示Cat中的Card，而是其副本，這意味著對card的修改將不會對Cat的Card屬性產生任何影響。為了防止潛在的編程錯誤，這一行為會被編譯器阻止。

  不過，就像C++中可以按引用傳遞棧上對象一樣，C#也支持通過引用傳值而直接修改原始數據，具體方法會在後文提到。

3.4. 特殊結構體

3.4.1 只讀結構體（readonly）

  基元類型中的值類型的實例是不可變的，例如，下麵的代碼是無法通過編譯的：

1 = 2;

（字面值1可以視為Int32的一個實例）

  這一點很容易理解，將數字2賦值給數字1從數學上來說是及其令人困惑的，因此基元類型的值類型都是不可變類型。不可變類型可以帶來諸多好處，例如更安全的編程，可以基於不可變做出許多假設而進行優化等等，因此將類型定義為不可變類型是有意義的。你可以通過在結構體中只聲明只讀欄位來保證這一點：

struct Point
{
    public readonly float X;
    public readonly float Y;
}

  這樣當Point的實例創建後就無法修改其成員值了。當然這個結構體沒有什麼意義，因為它的X和Y值將永遠是0。為此，你還需要提供構造方法來允許在實例化時指定欄位的值：

struct Point
{
    public readonly float X;
    public readonly float Y;
    
    public Point(float x, float y)
    {
        X = x;
        Y = y;
    }
}

Point p = new Point(1, 2); // 使用示例

  儘管如此，有時在編碼時依然可能出現失誤而導致忘記將某個欄位設置為只讀欄位，並且只是在對欄位聲明只讀顯然缺乏更清晰的語義，因此C#還提供了一種語法來聲明‘只讀結構體’，只讀結構體的所有的欄位必須聲明為只讀欄位，否則會出現編譯錯誤：

readonly struct Point
{
    public readonly float X;
    public readonly float Y;
    public float Z; // 編譯錯誤，欄位必須為只讀
}

  如上，在struct關鍵字前添加readonly關鍵字，即可將結構體聲明為只讀結構體。編譯器會為readonly結構體加上IsReadonlyAttribute，因此上述代碼會被翻譯為如下：

[System.Runtime.CompilerServices.IsReadOnly]
struct Point
{
    public readonly float X;
    public readonly float Y;
}

  （當然，IsReadonlyAttribute是一個internal的類，主要用於標記元數據，程式員不應該使用它）

  除了只讀欄位外，同樣還可以聲明只讀屬性：

struct Point 
{
    public float X { get; }
    public float Y { get; }
}

  和類的只讀屬性一樣，結構體的只讀屬性同樣是依賴一個只讀欄位實現。同樣的，你可以設置init訪問器來允許在‘對象初始值設定項’中初始化欄位的值，避免定義過多的構造方法：

struct Point 
{
    public float X { get; init; }
    public float Y { get; init; }
}

Point p = new Point()
{
    X = 1,
    Y = 2
};

   此外你還可以定義只讀方法：

struct Point
{
    // ... 省略其他代碼
    public readonly void Print() 
    {  
        // X = 1; // 不允許的操作
        Console.WriteLine(X + Y);
    }
}

   被readonly修飾的方法意味方法做出保證：不會修改實例狀態，也就是說readonly方法中不能對欄位進行賦值操作，只能訪問欄位。因此如果將上面Print方法的X = 1那一行取消註釋，編譯器將會報錯，因為它嘗試修改結構體的狀態。

3.4.2 僅棧分配結構體（ref）

  ‘結構體分配到棧上’這一重點被反覆強調，然而有時候可能並不是那麼簡單：

struct Point
{
    public float X;
    public float Y;
}

class Square
{
    public Point Position;
}

Square square = new Square();

  上述代碼中，Square的Position欄位並沒有分配到棧上，反而是和Square的實例一起被分配到了托管堆中。除此之外，裝箱也會導致結構體實例分配到托管堆：

Point point = new Point();
object obj = point; // 裝箱，結構體轉移到托管堆

  上述代碼從邏輯上來說是可行的，但有時候因為性能要求或者種種原因我們希望結構體只能分配到棧上，此時便可以使用僅棧分配結構體，即ref結構體：

ref struct Point
{
    public float X;
    public float Y;
}

  儘管ref這一關鍵字讓人疑惑，但是在struct關鍵字前添加ref確實是指將結構體聲明為只能在棧上分配的結構體，對於這種結構體，任何可能將其轉移到托管堆的行為都將被阻止（例如在引用類型中定義ref結構體欄位，或者進行裝箱操作）：

class Square
{
    public Point Position; // 錯誤，Position會隨著Square實例轉移到托管堆
}

Point point = new Point();
object obj = point; // 錯誤，point會被裝箱到托管堆

  ref結構體保證了結構體只能在棧上分配，但是也因此有了諸多限制，MSDN上指出了ref結構體的的使用限制：

  • 不能是數組的元素類型。
  • 不能是類或非 ref 結構的欄位的聲明類型。
  • 不能實現介面。
  • 不能被裝箱為 System.ValueType 或 System.Object。
  • 不能是類型參數。
  • 不能由 lambda 表達式或本地函數捕獲。
  • 不能在 async 方法中使用。 但是，可以在同步方法中使用 ref 結構變數，例如，在返回 Task 或 Task<TResult>的方法中使用結構變數。
  • 不能在迭代器中使用。

  需要說明的是，你可以聲明在其他ref結構體中聲明ref結構體欄位，因為ref結構體保證棧上分配：

ref struct AlsoPoint
{
    public Point Point; // 允許，因為XPoint同樣保證了棧上分配
}

  另外，你可以聲明只讀ref結構體：

readonly ref struct Point
{
    public Point Point; // 允許，因為XPoint同樣保證了棧上分配
}

（註意，readonly關鍵字必須位於ref之前）

  ref結構體可以讓程式員對結構體的分配做出預設，從而放心實現一些高性能的庫。例如Span<T>與ReadOnlySpan<T>就是對ref結構體的具體應用。

3.4.3 記錄結構體（record）

  record是一個新的概念，闡述它需要一定的篇幅，這不是本文的重點，因此這裡不多做闡述，只是簡單說明以下可以將結構體也聲明為記錄：

record struct Point 
{
    public float X;
    public float Y;
}

  從實質上來講，記錄結構體就是實現了IEquatable<>介面，重寫了ToString、GetHashCode與Equals方法，並重載了==與!=運算符的結構體，不過這些操作均由編譯器自動完成。另外，同樣可以用下麵的語法聲明聲明記錄結構體：

record struct Point3(float X, float Y);

  上述代碼的對等代碼大概如下：

查看代碼 
record struct Point 
{
    private float _x;
    private float _y;

    public float X
    {
        get => this._x;
        set => this._x = value;
    }
    public float Y
    {
        get => this._y;
        set => this._y = value;
    }

    public Point(float X, float Y)
    {
        this._x = X;
        this._y = Y;
    }

    public void Deconstruct(out float X, out float Y)
    {
        X = this.X;
        Y = this.Y;
    }
}

（註意Point的X和Y是被定義為屬性而非欄位，並且這種聲明方式還實現了Deconstruct解構方法）

  同樣的，可以聲明只讀記錄結構體。

3.4.4 不安全結構體（unsafe）

  所謂不安全結構體就是允許出現不安全成員的結構體，例如：

unsafe struct Window
{
    public void* Handle;
}

  Handle是一個void*指針，是不安全代碼，因此使用該欄位的結構體需要聲明為unsafe。unsafe結構體不是什麼新東西，只是unsafe作用於結構體範圍的體現，不安全代碼也不是本文重點，故這裡不多做闡述。

3.4.5 多特性結構體

  可以將readonly、record、ref、unsafe等修飾符組合，來創建諸如‘只讀ref結構體’、‘只讀記錄結構體’、‘只讀不安全結構體’等具有多種特性的結構體。鑒於這些結構體只是相應修飾符含義的組合，這裡不過多闡述。

 

4. 對結構體的特殊操作

4.1 按引用傳遞值類型

  來看下麵的一個例子：

struct Point
{
    public int X;
    public int Y;
}

void AddX(Point point)
{
    point.X += 1;
    point.Y += 1;
}

Point p = new Point();
AddX(p);
Console.WriteLine(point.X);

  上述代碼中將輸出0。請記住結構體預設是副本式複製，也就是說上述代碼中調用AddX方法，並將p作為參數傳入後，方法中的point只是p的副本而非p本身，因此對point的改變不會影響到p。但有時候確實需要通過方法直接修改p的值，此時可以使用按引用傳遞：

void AddX(ref Point point)
{
    point.X += 1;
    point.Y += 1;
}

Point p = new Point();
AddX(ref p);
Console.WriteLine(point.X);

  現在AddX方法的point現在是一個ref參數，傳遞參數p時，point此時直接指向p所在的數據地址，因此修改point的值等同於直接修改p。ref參數並不奇怪，你很可能已經用過了。但現在回過頭來看前文的一個例子：

struct CatCard
{
    public int ID;
}
class Cat
{
    public CatCard Card { get; } = new CatCard();
}

Cat cat = new Cat();
cat.CatCard.ID = 10; // 報錯

  上述代碼無法通過編譯，然而如果將上述代碼中Cat的Card屬性修改為欄位，則代碼可以正常運行：

class Cat
{
    public CatCard Card = new CatCard(); // 修改為欄位
}

Cat cat = new Cat();
cat.CatCard.ID = 10; // 此時可以通過編譯

  這是由於屬性的本質是方法，因此當Card為屬性時，其等效代碼類似如下：

struct CatCard
{
    public int ID;
}
class Cat
{
    private readonly CatCard _card = new CatCard();
    
    public CatCard get_Card()
    {
        return this._card;
    };
}

Cat cat = new Cat();
cat.get_Card().ID = 10; // 報錯

  請思考一下為何編譯器不允許上述代碼：get_Card是方法，返回一個CatCard類型的對象，而CatCard是一個結構體，這意味著該方法返回的將是欄位_card的副本而非_card欄位本身，因此修改get_Card的返回值不會對_card欄位本身造成任何影響，而僅僅是修改_card欄位的一個臨時副本的X，併在修改完成後就丟棄此副本。由於這一問題會導致人對代碼本身做的事產生誤解而編寫出錯誤的代碼，因此C#編譯器禁止了上述行為。但就像按參數可以引用傳遞一樣，返回值也可以按引用返回，因此，你可以寫出如下代碼：

class Cat
{
    // ...  省略其他代碼
    public ref CatCard get_Card()
    {
        return ref this._card;
    };
}

Cat cat = new Cat();
cat.get_Card().ID = 10; // 正確，get_Card()返回的是欄位_card的引用

  註意cat.get_Card().ID = 10等效代碼如下：

ref CatCard card = ref cat.get_Card(); // 而不是CatCard card = cat.get_Card()，否則card依然只是副本
card.ID = 10

  回到屬性上，你可以聲明按引用返回的值類型屬性：

class Cat
{
    private readonly CatCard _card;
    
    public ref CatCard Card
    {
        get
        {
            return ref this._card;
        }
    }
}

Cat cat = new Cat();
cat.CatCard.ID = 10; // 正確

  基於顯而易見的原因，這種屬性不能有set訪問器。

4.2 裝箱與拆箱

  既然結構體是值類型，那麼結構體也存在裝箱與拆箱，將數據在棧與托管堆之間遷移：

struct Foo { }
Foo foo = new Foo();

object obj = foo;    // 裝箱，移動到托管堆
Foo foo2 = (Foo)obj; // 拆箱，從托管堆中獲取數據並移動到棧上

  裝箱與拆箱的相關概念不是本文的重點，故此處不做過多介紹。另外，理所當然的，ref結構體（僅棧上結構體）不允許裝箱與拆箱。

4.3. 控制結構體的記憶體佈局

  既然結構體是分配到棧上的，那結構體需要的記憶體大小必然是在編譯時與運行時都可以確定的。例如下述結構體：

struct Point
{
    public int X;
    public int Y;
}

  Point結構體有兩個int類型的欄位，C#中每個int直接映射到System.Int32類型，因此每個int欄位長度為4位元組，故儲存上述結構體所需要的記憶體大小就是4+4=8位元組。可以通過sizeof來查看結構體所需的記憶體大小：

unsafe
{
    Console.WriteLine(sizeof(Point)); // 輸出8
}

  一般來說，結構體所需的記憶體大小就是各個欄位大小的總和，但有時候還需要考慮記憶體對齊的問題。例如下述結構體：

struct Point
{
    public byte X;
    public int Y;
}

  byte類型只占用一個位元組，所以你可能會認為上述代碼中Point的大小是1+4=5位元組，然而由於記憶體對齊，byte依然會需要占據4位元組大小，因此該結構體實際上依然需要8位元組來儲存。關於記憶體對齊是一個需要一定篇幅來闡述的問題，這個不是本文的重點，如有興趣可以參考C語言中結構體的記憶體對齊的相關文章進行瞭解。

  另一個重要的點是，你可以通過System.Runtime.InteropServices.StructLayoutAttribute來指定欄位佈局方案，該Attribute主要接受一個System.Runtime.InteropServices.LayoutKind枚舉來指定對齊模式，該枚舉有三個枚舉值：

（1）Sequential：順序佈局，按欄位的聲明順序佈局，是預設行為

（2）Auto：自動佈局，自動排列欄位順序以用最小的空間來儲存欄位

  例如對於下麵結構體：

struct Foo
{
    public byte A;
    public int B;
    public byte C;
}

  預設情況下由於記憶體對齊，該結構體所需的記憶體大小為4+8+4=12，但你可以按下麵的順序聲明欄位讓其只需要8個位元組：

struct Foo
{
    public byte A;
    public byte C;
    public int B;
}

  也就是說欄位的聲明順序影響結構體的記憶體占用，而通過StructLayoutAttribute，你可以讓運行時對欄位順序自動調整以求最小記憶體浪費：

[StructLayout(LayoutKind.Auto)]
struct Foo
{
    public byte A;
    public int B;
    public byte C;
}

  經過運行時的自動調整欄位儲存順序後，一個Foo對象在程式運行的時候的記憶體占用同樣是8。

（3）Explicit：顯式佈局，手動指定欄位地址的偏移

  你可以手動指定欄位的偏移值，來達到一些特殊的效果：

[StructLayout(LayoutKind.Explicit)]
struct Foo 
{
    [FieldOffset(0)]
    public short A;
    [FieldOffset(4)]
    public int B;
    [FieldOffset(2)]
    public short C;
}

  通常，按照Foo中欄位的聲明順序，Foo的記憶體佈局應該如下圖：

  但這裡將結構體的LayoutKind設置為了Explicit，並使用了FieldOffsetAttribute來顯式指定了各個欄位相對於結構體起始地址的偏移（以位元組為單位）。因此Foo的實際記憶體佈局如下圖：

  這一功能一個比較重要的用途是用於模擬C語言中的聯合體（union），例如對於下麵C中的聯合體定義：

union Foo
{
    int IntValue;
    long LongValue;
    double DoubleValue;
};

  可以使用下述的C#的結構體來模擬：

[StructLayout(LayoutKind.Explicit)]
struct Foo 
{
    [FieldOffset(0)]
    public int IntValue;
    [FieldOffset(0)]
    public long LongValue;
    [FieldOffset(0)]
    public double DoubleValue;
}

  上述結構體的記憶體佈局如下圖：

  同樣，顯式指定記憶體也受記憶體對齊的影響。

 

5. 結構體雜談

5.1. 欄位 or 屬性

  前文給出的結構體幾乎都是直接使用欄位而非屬性，但這隻是為了避開屬性的複雜性，從而更方便更直觀地說明結構體的一些性質。在實際使用中，鑒於屬性的種種好處，一般情況下即便是結構體也應該優先使用屬性。

  不過有時候確實使用欄位更好，例如定義與非托管代碼交互的結構體的成員就最好使用欄位，或者性能瓶頸確實出現在使用屬性上因此不得不直接使用欄位（大多數情況這並不可能）。

  簡而言之，除非確實真的有必要，否則對於結構體也應該優先使用屬性而非欄位。

5.2. 類 or 結構

  通常使用結構體是因為結構體的棧上分配特點而有使其具有更好的操作性能，因此結構體通常是為高性能需要服務的。然而，結構體預設使用副本式傳值，可能會導致程式運行時創建不必要的副本，例如：

struct MethodArgs { ... }

MethodArgs args = new MethodArgs();
Method(args); // 第一次副本
Method(args); // 第二次創建副本
Method(args); // ...創建副本

  上述代碼中每一次傳參都會有一次額外的創建副本的開銷，然而如果將MethodArgs定義為class，則只會傳遞對同一個實例引用，則避免了創建副本的開銷。當然，可以通過按引用傳遞參數來解決，但這仍然不是一個完美的解決方法。

  此外，結構體不允許繼承，這意味著結構體的代碼重用能力遠低於類，並且結構體不會有多態行為。

  最後，從概念上來講，結構體是值類型，應當將其認為是表現類似於int、long、double這類數值類型的類型，遵循用於“表達一個值”的用法，並根據輕量原則，結構體不應該定義的過於複雜。

  基於上述原因，《CLR via C#》一書中建議在下麵的情況下使用結構體：

  1. 類型定義十分簡單，具有類似基元類型的表現。
  2. 不需要繼承，也不需要被繼承。
  3. 記憶體的實例較小（16位元組以下）
  4. 或者記憶體實例較大（16位元組以上），但是不會作為方法的參數與返回值使用

  不過例外的是，與非托管代碼交互時，記憶體佈局明確且不受托管堆影響的的結構體有不可替代的優勢，此時使用結構體基本是唯一的選擇。

  綜上，儘管結構體由於棧上分配擁有一定的性能優勢，然而現實中更多地依然是使用的類。因為通常來說真正需要用到結構體的地方基本都是在對性能有更高要求的地方，但真正需要這種代碼的情況可能並不多見。並且雖然結構體的棧上分配使其操作起來很快並且不會影響GC與托管堆，但是副本式的賦值方式也意味著一般情況下存在複製一個完整結構體的開銷，所以結構體也基本只用在那些需要簡單把各種基元類型簡單包裝一下的場合，例如：

  • 把2個int包一下（Point）
  • 把三個float包一下（Vector3）
  • 把4個byte包一下（模擬Int類型）

  同時，結構體本身最好使用只讀屬性或者很少有狀態更改（就像基元類型那樣）；類則相反，由於往往用於表示一個對象，因此往往會用到很多欄位或者會涉及到各種各樣的狀態更改。如果確實不確定到底應該用類還是結構體，那麼優先使用類。

5.3. 實現一個更好的結構體

（1）重寫Equals與GetHashCode方法

  預設的結構體實現會使用ValueType中重寫的Equals方法，預設實現會考慮對普遍情況的可靠性，但這往往意味著它對特定實現來說是低效的，實際上ValueType對Equals的重寫方法遠比想象中的複雜。考慮到值類型往往需要在性能敏感的場合使用，因此有必要手動重寫其Equals方法，關於如何重寫Equals方法已經在另一篇文章中提出，這裡不再贅述。同樣的，也需要重寫結構體的GetHashCode方法。

（2）使用只讀結構體

  由於結構體最好具有基元類型的表現，因此最佳的做法是儘可能地將結構體定義為只讀結構體。

（3）實現IEqualable<>介面

  作為值類型，那麼結構體自然也應該可以進行相等性比較，實現IEquatable<>介面可以為結構體提供更好的比較方法，並提高結構體的泛用性。

（4）重載==與!=運算符

  理由同上，使用==與!=對值類型進行相等性比較是符合直覺的。

（5）僅包含欄位、屬性與只讀方法

  儘管可行，但是不應該在結構體中定義事件。此外，結構體中的方法應該儘可能定義為只讀方法，或者說方法不應該修改結構體的欄位狀態。

5.4. 語法糖

  C#中提供了一種名為with表達式的語法糖來獲得對結構體進行非破壞性修改的副本：

Point p1 = new Point();
Point p2 = p1 with { X = 1 };

  上述代碼實際做的事如下：

Point p1 = new Point();
Point temp = p1;
temp.X = 1;
Poitn p2 = temp;

  在一些場合，這一語法可以有效減少不必要的代碼量。

5.5. 奇技淫巧

  如果結構體不是只讀結構體，那麼下述代碼是可行的：

struct Point 
{
    public float X;
    public float Y;

    public void Reset(Point p)
    {
        this = p; // 修改this
    }
}

  這並不奇怪，結構體在聲明時就分配好了記憶體，並遵循按副本賦值。因此上述代碼中this = p實際就是將p逐欄位賦值給this表示的實例的相應欄位的值而已。不過如果沒有必要還是應該避免這種迷惑性的操作。

5.6. 其他註意事項

（1）結構體類型無法嵌套，也就是說下麵的代碼是不可行的

struct Foo
{
    public Foo Foo; // 嵌套一個位元組
}

  顯然，這會導致遞歸定義，所以是不允許的。

（2）構造方法必須保證對每個欄位都賦值

struct Foo 
{
    public int X;
    public int Y;

    public Foo(int x) 
    {
        X = x;
    }
}

  儘管可以看出上述代碼中的構造方法是想僅設置X的值，讓Y的值保持其預設值0。然而該構造方法無法通過編譯，因為構造方法中還沒有完成對欄位Y賦值，需要將其修改為如下：

struct Foo 
{
    public int X;
    public int Y;

    public Foo(int x) 
    {
        X = x;
        Y = 0;
    }
}

 


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • Python數據分析--Numpy常用函數介紹(7)--Numpy中矩陣和通用函數
    在NumPy中，矩陣是 ndarray 的子類，與數學概念中的矩陣一樣，NumPy中的矩陣也是二維的，可以使用 mat 、 matrix 以及 bmat 函數來創建矩陣。 一、創建矩陣 mat 函數創建矩陣時，若輸入已為 matrix 或 ndarray 對象，則不會為它們創建副本。 因此，調用 m ...
  • 【Java面試】new String("abc")到底創建了幾個對象？
    一個工作了6年的粉絲和我說， 最近面試感覺越來越難的，基本上都會問技術底層原理，甚至有些還會問到操作系統層面的知識。 我說，現在各個一線大廠有很多優秀的程式員畢業了，再加上市場大環境不好對程式員的需求量也在減少。 如果技術底子不好，確實找工作會很困難。 今天分享的問題是：”new String(“a ...
  • selenium實現疫情下12306買票 Edge
    #所有流程 ！！！不要修改為搶票，遵守法律法規是每一個中國公民應盡的責任，盜用並造成不良後果自負！！！ ''' #可以實現買學生票，兒童票，殘疾票，成人票和所有能選的座位類別。 2022-05-22目前為止還是完全正常運行的，之後網頁改動就不一定了哦！！！！！！12306官網模擬買票：1.輸入賬號密 ...
  • 一文說透Sentinel熔斷策略、降級規則、流量控制
    2 Sentinel 限流熔斷降級 Sentinel 可以簡單的分為 Sentinel 核心庫和 Dashboard。核心庫不依賴 Dashboard，但是結合 Dashboard 可以取得最好的效果。我們先來學習Sentinel 核心庫的使用，後面再學習Dashboard使用。 在我們項目中，用戶 ...
  • spring boot html+vue.js 形式前後分離代碼示例
    題目描述 密碼要求: 1.長度超過8位 2.包括大小寫字母.數字.其它符號,以上四種至少三種 3.不能有長度大於2的包含公共元素的子串重覆 （註：其他符號不含空格或換行） 數據範圍：輸入的字元串長度滿足 1≤n≤100 輸入描述 一組字元串 輸入描述 如果符合要求輸出：OK，否則輸出NG 代碼和解題 ...
  • 【Python - 基礎】基礎是一切升華的根本
    前言 以下僅做相關知識的簡述，更深入的瞭解和學習，請自行查閱資料或留言。 一、Python簡介 Python請查看官網自行瞭解。 Python是一種編程語言，可以讓您更快地工作，並更有效地集成您的系統。 Python is a programming language that lets you w ...
  • 【進階】Java8新特性的理解與應用
    Java 8是Java的一個重大版本，是目前企業中使用最廣泛的一個版本。 它支持函數式編程，新的Stream API 、新的日期 API等一系列新特性。 掌握Java8的新特性已經是java程式員的標配，掌握了它，就可以看懂公司里的代碼、高效率地處理大量集合數據以及消滅“嵌套地獄”等等。 ...
  • .NET C#雜談（1）：變體 - 協變、逆變與不變
    0. 文章目的： 介紹變體的概念，並介紹其對C#的意義 1. 閱讀基礎 瞭解C#進階語言功能的使用（尤其是泛型、委托、介面） 2. 從示例入手，理解變體 變體這一概念用於描述存在繼承關係的類型間的轉化，這一概念並非只適用於C#，在許多其他的OOP語言中也都有變體概念。變體一共有三種：協變、逆變與不變 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類