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，结构体以最简单的方式制作出简洁的结构数据。如果谨慎使用结构体，会物超所值。