C# 結構體：定義、示例、最佳實踐和陷阱

C#結構體：從C/C++時代遷移過來的經典。結構體與類相似，也有大量不同之處 。結構體對做為C#開發者來說有很多價值。一般不需要用到結構體，但是有些方面結構體比類做得好。

結構體是什么？

結構體是class對象的小姐妹。初相見，他們之間區別不大。他們都包含不同類型的字段的集合，如下

public struct Flower
{
  public string name;
  protected int beautyRating;
  private bool isVascular;
}

可以試一下結構體。做為一種簡單的數據結構，可以將結構體視為一種字段包。可能你會用結構體做為數據傳輸對象，或者可能你想要在其它基於字段值的地方運行一些邏輯。

也可以用結構體封裝行為，如下：

 public struct FlowerWithBehavior
{
  string name;
  int beautyRating;
  bool isVascular;

  public void makeBeautiful()
  {
    beautyRating = 10;
  }
}

到目前為止，結構體看起來像類，只是關鍵詞不同。話雖這樣說，但是結構在一些重要方式還是有別於類。

什么使結構與眾不同？

最重要的不同之處是：結構體是值類型，類是引用類型。類和結構體相似，如下：

public struct FlowerStruct
{
    string name;
    int beautyRating;
    bool isVascular;

    public FlowerStruct(string name, int beautyRating, bool isVascular)
    {
        this.name = name;
        this.beautyRating = beautyRating;
        this.isVascular = isVascular;
    }
}

public class FlowerClass
{
    public string name;
    public int beautyRating;
    public bool isVascular;

    public FlowerClass(string name, int beautyRating, bool isVascular)
    {
        this.name = name;
        this.beautyRating = beautyRating;
        this.isVascular = isVascular;
    }
}

盡管看起來相似，但是類和結構體有不同之處：

public void Test_Struct_Vs_Class_Equality()
{
    FlowerStruct struct1 = new FlowerStruct("Daisy", 3, true);
    FlowerStruct struct2 = new FlowerStruct("Daisy", 3, true);

    FlowerClass class1 = new FlowerClass("Daisy", 3, true);
    FlowerClass class2 = new FlowerClass("Daisy", 3, true);

    Assert.Equal(struct1, struct2);
    Assert.NotEqual(class1, class2);
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using System.Windows.Forms;
using Microsoft.VisualStudio.TestTools.UITesting;

namespace Struct_And_Class
{
    class Program
    {
        static void Main(string[] args)
        {
            FlowerStruct struct1 = new FlowerStruct("Daisy",3,true);
            FlowerStruct struct2 = new FlowerStruct("Daisy", 3, true);

            FlowerClass class1 = new FlowerClass("Daisy",3,true);
            FlowerClass class2 = new FlowerClass("Daisy", 3, true);

            bool Result1 = Equals(struct1,struct2);
            bool Result2 = Equals(class1,class2);

            Console.WriteLine("結構體對比結果是{0}",Result1);
            Console.WriteLine("類的對比結果是{0}",Result2);
        }
    }

    public struct FlowerStruct
    {
        string name;
        int beautyRating;
        bool isVascular;

        public FlowerStruct(string name, int beautyRating,bool isVascular)
        {
            this.name = name;
            this.beautyRating = beautyRating;
            this.isVascular = isVascular;
        }
    }

    public class FlowerClass
    {
        string name;
        int beautyRating;
        bool isVascular;

        public FlowerClass(string name, int beautyRating, bool isVascular)
        {
            this.name = name;
            this.beautyRating = beautyRating;
            this.isVascular = isVascular;
        }
    }
}

 

 如上面完整代碼所呈現的，對於結構體來說，只要是內部是相等相同的，結果就是相等的；而類不相等，與字段沒有關系。

這或許是結構體與類之間最大的不同之處。用struct，可以實現拆箱操作，可以創建值類型對象。

同樣，結構體永遠不是null

public void Test_Struct_Not_Null(
{
    Flower flowerStruct = null; //<-- Compile error.
}

空引用錯誤是軟件中的Bug原因之一。

當然，可以欺騙一下，使它們成為可空類型（nullable）。

注意構造函數的挑戰

冷靜一下，結構體不是完美的。如果你想要結構體做為不可改變的值對象，如下面示例所示，需要一個無參數的構造函數。這意味着你的值對偶處在一種無效狀態。

public struct StrictFlower
{
    public string name;
    public int beautyRating;

    public StrictFlower(string name, int beautyRating)
    {
        this.name = name;
        if (name == "daisy")
            this.beautyRating = beautyRating;
        else
            this.beautyRating = 5;
    }
}

[Fact]
public void Struct_Always_Has_Parameterless_Constructor()
{
    StrictFlower flower = new StrictFlower();
    flower.name = "daisy";
    int notFive = 3;
    flower.beautyRating = notFive;
}

由於這樣的原因，你不能擔保類在初始化時就是有效的，如果你想要保證你的結構體一直處於一個有效狀態，你需要讓你的團隊避免使用無參構造函數。

注意繼承限制

結構體自動繼承自ValueType類，ValueType類繼承自object（CSDN:ValueType為值類型提供基類）。但是不能繼承自他們：

public struct InheritingFlower : Flower //<- Compile Error
{
}

盡管如何，可以使用接口繼承：

public struct ImplementingFlower : IComparable<ImplementingFlower>
{
    string name;
    int beautyRating;

    public int CompareTo(ImplementingFlower other)
    {
        return beautyRating.CompareTo(other.beautyRating);
    }
}

使用結構體的最佳方式

結構體做為一種簡單的數據結構很閃亮。很容易玩轉struct結構體，當需要代表數據傳輸對象，數據輸入對象、數據輸出對象，或者其它信息持有者。當我們將它們做為一種簡單的結構形式，沒必要封閉在屬性里面。

public struct PropertyFlower
{
    string name;
    int beautyRating;
    bool isVascular; 

    public string Name { get => name; set => name = value; }
    public int BeautyRating { get => beautyRating; set => beautyRating = value; }
    public bool IsVascular { get => isVascular; set => isVascular = value; }
}

做為替代，可以讓字段自由運行，如下：

public struct FieldFlower
{
    public string name;
    public int beautyRating;
    public bool isVascular;
}

一定要避免將結構體做為collecting parameter使用。如果將結構體傳遞給了方法函數，它是值傳遞，傳遞的是struct的副本，不是struct的指針。

class StructPass
{
    public void changeName(Flower flower)
    {
        flower.name = "different";
    }
}

[Fact]
public void Structs_Pass_By_Value()
{
    Flower flower = new Flower("daisy", 3, true);
    new StructPass().changeName(flower);

    Assert.NotEqual("different", flower.name);
}

結構體是類的小兄弟，他們不與其它類一起出現，他們較少用到，但是他們有他們的用處。

結構體具有內置的平等性。他們不能為null，結構體以最簡單的方式制作出簡潔的結構數據。如果謹慎使用結構體，會物超所值。