接口定义了所有类继承接口时应遵循的语法合同。接口定义了语法合同 “是什么” 部分，派生类定义了语法合同 “怎么做” 部分。

接口定义了属性、方法和事件，这些都是接口的成员。接口只包含了成员的声明。成员的定义是派生类的责任。接口提供了派生类应遵循的标准结构。接口使得实现接口的类或结构在形式上保持一致。

抽象类在某种程度上与接口类似，但是，它们大多只是用在当只有少数方法由基类声明由派生类实现时。

接口本身并不实现任何功能，它只是和声明实现该接口的对象订立一个必须实现哪些行为的契约。

抽象类不能直接实例化，但允许派生出具体的，具有实际功能的类。

定义接口: MyInterface.cs

接口使用 interface 关键字声明，它与类的声明类似。接口声明默认是 public 的。下面是一个接口声明的实例：

interface IMyInterface
{
    void MethodToImplement();
}

以上代码定义了接口 IMyInterface。通常接口命名以 I 字母开头，这个接口只有一个方法 MethodToImplement()，没有参数和返回值，当然我们可以按照需求设置参数和返回值。值得注意的是，该方法并没有具体的实现。

接口继承: InterfaceInheritance.cs

以下实例定义了两个接口 IMyInterface 和 IParentInterface。

如果一个接口继承其他接口，那么实现类或结构就需要实现所有接口的成员。

以下实例 IMyInterface 继承了 IParentInterface 接口，因此接口实现类必须实现 MethodToImplement() 和 ParentInterfaceMethod() 方法：

using System;

interface IParentInterface
{
    void ParentInterfaceMethod();
}

interface IMyInterface : IParentInterface
{
    void MethodToImplement();
}

class InterfaceImplementer : IMyInterface
{
    static void Main()
    {
        InterfaceImplementer iImp = new InterfaceImplementer();
        iImp.MethodToImplement();
        iImp.ParentInterfaceMethod();
    }

    public void MethodToImplement()
    {
        Console.WriteLine("MethodToImplement() called.");
    }

    public void ParentInterfaceMethod()
    {
        Console.WriteLine("ParentInterfaceMethod() called.");
    }
}

实例输出结果为：

MethodToImplement() called.
ParentInterfaceMethod() called.

您可以重定义或重载 C# 中内置的运算符。因此，程序员也可以使用用户自定义类型的运算符。重载运算符是具有特殊名称的函数，是通过关键字 operator 后跟运算符的符号来定义的。与其他函数一样，重载运算符有返回类型和参数列表。

例如，请看下面的函数：

public static Box operator+ (Box b, Box c) {
  Box box = new Box();
  box.length = b.length + c.length;
  box.breadth = b.breadth + c.breadth;
  box.height = b.height + c.height;
  return box;
}

上面的函数为用户自定义的类 Box 实现了加法运算符（+）。它把两个 Box 对象的属性相加，并返回相加后的 Box 对象。

运算符重载的实现

下面的程序演示了完整的实现：

using System;

namespace OperatorOvlApplication {
  class Box {
    private double length;    // 长度
    private double breadth;   // 宽度
    private double height;    // 高度

    public double getVolume() {
      return length * breadth * height;
    }
    public void setLength(double len) {
      length = len;
    }
    public void setBreadth(double bre) {
      breadth = bre;
    }
    public void setHeight(double hei) {
      height = hei;
    }
    // 重载 + 运算符来把两个 Box 对象相加
    public static Box operator+ (Box b, Box c) {
      Box box = new Box();
      box.length = b.length + c.length;
      box.breadth = b.breadth + c.breadth;
      box.height = b.height + c.height;
      return box;
    }
  }

  class Tester {
    static void Main(string[] args) {
      Box Box1 = new Box(); // 声明 Box1，类型为 Box
      Box Box2 = new Box(); // 声明 Box2，类型为 Box
      Box Box3 = new Box(); // 声明 Box3，类型为 Box
      double volume = 0.0;  // 体积

      // Box1 详述
      Box1.setLength(6.0);
      Box1.setBreadth(7.0);
      Box1.setHeight(5.0);

      // Box2 详述
      Box2.setLength(12.0);
      Box2.setBreadth(13.0);
      Box2.setHeight(10.0);

      // Box1 的体积
      volume = Box1.getVolume();
      Console.WriteLine("Box1 的体积： {0}", volume);

      // Box2 的体积
      volume = Box2.getVolume();
      Console.WriteLine("Box2 的体积： {0}", volume);

      // 把两个对象相加
      Box3 = Box1 + Box2;

      // Box3 的体积
      volume = Box3.getVolume();
      Console.WriteLine("Box3 的体积： {0}", volume);
      Console.ReadKey();
    }
  }
}

当上面的代码被编译和执行时，它会产生下列结果：

Box1 的体积： 210
Box2 的体积： 1560
Box3 的体积： 5400

可重载和不可重载运算符

下表描述了 C# 中运算符重载的能力：

实例

针对上述讨论，让我们扩展上面的实例，重载更多的运算符：

using System;

namespace OperatorOvlApplication {
  class Box {
    private double length;    // 长度
    private double breadth;   // 宽度
    private double height;    // 高度

    public double getVolume() {
      return length * breadth * height;
    }
    public void setLength(double len) {
      length = len;
    }
    public void setBreadth(double bre) {
      breadth = bre;
    }
    public void setHeight(double hei) {
      height = hei;
    }
    // 重载 + 运算符来把两个 Box 对象相加
    public static Box operator+ (Box b, Box c) {
      Box box = new Box();
      box.length = b.length + c.length;
      box.breadth = b.breadth + c.breadth;
      box.height = b.height + c.height;
      return box;
    }

    public static bool operator == (Box lhs, Box rhs) {
      bool status = false;
      if(lhs.length == rhs.length && lhs.height == rhs.height && lhs.breadth == rhs.breadth) {
        status = true;
      }
      return status;
    }
    public static bool operator != (Box lhs, Box rhs) {
      bool status = false;
      if(lhs.length != rhs.length || lhs.height != rhs.height || lhs.breadth != rhs.breadth) {
        status = true;
      }
      return status;
    }
    public static bool operator < (Box lhs, Box rhs) {
      bool status = false;
      if(lhs.length < rhs.length && lhs.height < rhs.height && lhs.breadth < rhs.breadth) {
        status = true;
      }
      return status;
    }
    public static bool operator > (Box lhs, Box rhs) {
      bool status = false;
      if(lhs.length > rhs.length && lhs.height > rhs.height && lhs.breadth > rhs.breadth) {
        status = true;
      }
      return status;
    }
    public static bool operator <= (Box lhs, Box rhs) {
      bool status = false;
      if(lhs.length <= rhs.length && lhs.height <= rhs.height && lhs.breadth <= rhs.breadth) {
        status = true;
      }
      return status;
    }
    public static bool operator >= (Box lhs, Box rhs) {
      bool status = false;
      if(lhs.length >= rhs.length && lhs.height >= rhs.height && lhs.breadth >= rhs.breadth) {
        status = true;
      }
      return status;
    }
    public override string ToString() {
      return String.Format("({0}, {1}, {2})", length, breadth, height);
    }

  }
  class Tester {
    static void Main(string[] args) {
      Box Box1 = new Box(); // 声明 Box1，类型为 Box
      Box Box2 = new Box(); // 声明 Box2，类型为 Box
      Box Box3 = new Box(); // 声明 Box3，类型为 Box
      Box Box4 = new Box();
      double volume = 0.0; // 体积

      // Box1 详述
      Box1.setLength(6.0);
      Box1.setBreadth(7.0);
      Box1.setHeight(5.0);

      // Box2 详述
      Box2.setLength(12.0);
      Box2.setBreadth(13.0);
      Box2.setHeight(10.0);

      // 使用重载的 ToString() 显示两个盒子
      Console.WriteLine("Box1： {0}", Box1.ToString());
      Console.WriteLine("Box2： {0}", Box2.ToString());

      // Box1 的体积
      volume = Box1.get

多态是同一个行为具有多个不同表现形式或形态的能力。

多态性意味着有多重形式。在面向对象编程范式中，多态性往往表现为"一个接口，多个功能"。

多态性可以是静态的或动态的。在静态多态性中，函数的响应是在编译时发生的。在动态多态性中，函数的响应是在运行时发生的。

在 C# 中，每个类型都是多态的，因为包括用户定义类型在内的所有类型都继承自 Object。

多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：

现实中，比如我们按下 F1 键这个动作：

• 如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；
• 如果当前在 Word 下弹出的就是 Word 帮助；
• 在 Windows 下弹出的就是 Windows 帮助和支持。

同一个事件发生在不同的对象上会产生不同的结果。

静态多态性

在编译时，函数和对象的连接机制被称为早期绑定，也被称为静态绑定。C# 提供了两种技术来实现静态多态性。分别为：

• 函数重载
• 运算符重载

运算符重载将在下一章节讨论，接下来我们将讨论函数重载。

函数重载

您可以在同一个范围内对相同的函数名有多个定义。函数的定义必须彼此不同，可以是参数列表中的参数类型不同，也可以是参数个数不同。不同重载只有返回类型不同的函数声明。

下面的实例演示了几个相同的函数 Add()，用于对不同个数参数进行相加处理：

using System;
namespace PolymorphismApplication
{
    public class TestData
    {
        public int Add(int a, int b, int c)
        {
            return a + b + c;
        }
        public int Add(int a, int b)
        {
            return a + b;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            TestData dataClass = new TestData();
            int add1 = dataClass.Add(1, 2);
            int add2 = dataClass.Add(1, 2, 3);

            Console.WriteLine("add1 :" + add1);
            Console.WriteLine("add2 :" + add2);
        }
    }
}

下面的实例演示了几个相同的函数 print()，用于打印不同的数据类型：

using System;
namespace PolymorphismApplication
{
    class Printdata
    {
        void print(int i)
        {
            Console.WriteLine("输出整型: {0}", i);
        }

        void print(double f)
        {
            Console.WriteLine("输出浮点型: {0}" , f);
        }

        void print(string s)
        {
            Console.WriteLine("输出字符串: {0}", s);
        }
        static void Main(string[] args)
        {
            Printdata p = new Printdata();
            // 调用 print 来打印整数
            p.print(1);
            // 调用 print 来打印浮点数
            p.print(1.23);
            // 调用 print 来打印字符串
            p.print("Hello Runoob");
            Console.ReadKey();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

输出整型: 1
输出浮点型: 1.23
输出字符串: Hello Runoob

动态多态性

C# 允许您使用关键字 abstract 创建抽象类，用于提供接口的部分类的实现。当一个派生类继承自该抽象类时，实现即完成。抽象类包含抽象方法，抽象方法可被派生类实现。派生类具有更专业的

继承是面向对象程序设计中最重要的概念之一。继承允许我们根据一个类来定义另一个类，这使得创建和维护应用程序变得更容易。同时也有利于重用代码和节省开发时间。当创建一个类时，程序员不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承了已有的类的成员即可。这个已有的类被称为的基类，这个新的类被称为派生类。继承的思想实现了 属于 关系。例如，哺乳动物 属于 动物，狗 属于 哺乳动物，因此狗 属于 动物。

基类和派生类

一个类可以继承自另一个类，被称为基类（父类）和派生类（子类）。C# 不支持类的多重继承，但支持接口的多重继承，一个类可以实现多个接口。概括来说：一个类可以继承多个接口，但只能继承自一个类。

C# 中创建派生类的语法如下：

class <基类> {
  ...
}
class <派生类> : <基类> {
  ...
}

派生类会继承基类的成员（字段、方法、属性等），除非它们被明确地标记为私有。派生类可以通过关键字base来调用基类的构造函数和方法。

实例

class BaseClass
{
  public void SomeMethod()
  {
    // Method implementation
  }
}

class DerivedClass : BaseClass
{
  public void AnotherMethod()
  {
    // Accessing base class method
    base.SomeMethod();

    // Method implementation
  }
}

假设，有一个基类 Shape，它的派生类是 Rectangle：

实例

using System;

namespace InheritanceApplication
{
  class Shape 
  {
    public void setWidth(int w)
    {
      width = w;
    }
    public void setHeight(int h)
    {
      height = h;
    }
    protected int width;
    protected int height;
  }

  // 派生类
  class Rectangle: Shape
  {
    public int getArea()
    { 
      return (width * height); 
    }
  }

  class RectangleTester
  {
    static void Main

当你定义一个类时，你定义了一个数据类型的蓝图。这实际上并没有定义任何的数据，但它定义了类的名称意味着什么，也就是说，类的对象由什么组成及在这个对象上可执行什么操作。对象是类的实例。构成类的方法和变量称为类的成员。

类的定义

类的定义是以关键字 class 开始，后跟类的名称。类的主体，包含在一对花括号内。下面是类定义的一般形式：

<access specifier> class  class_name 
{
   // member variables
   <access specifier> <data type> variable1;
   <access specifier> <data type> variable2;
   ...
   <access specifier> <data type> variableN;

   // member methods
   <access specifier> <return type> method1(parameter_list)
   {
      // method body 
   }

   <access specifier> <return type> method2(parameter_list)
   {
      // method body 
   }

   ...
   <access specifier> <return type> methodN(parameter_list) 
   {
      // method body 
   }
}

请注意：

• 访问标识符 <access specifier> 指定了对类及其成员的访问规则。如果没有指定，则使用默认的访问标识符。类的默认访问标识符是 internal，成员的默认访问标识符是 private。
• 数据类型 <data type> 指定了变量的类型，返回类型 <return type> 指定了返回的方法返回的数据类型。
• 如果要访问类的成员，你要使用点（.）运算符。
• 点运算符链接了对象的名称和成员的名称。

下面的实例说明了目前为止所讨论的概念：

using System;

namespace BoxApplication
{
   class Box
   {
      public double length;   // 长度
      public double breadth;  // 宽度
      public double height;   // 高度
   }

   class Boxtester
   {
      static void Main(string[] args)
      {
         Box Box1 = new Box();  // 声明 Box1，类型为 Box
         Box Box2 = new Box();  // 声明 Box2，类型为 Box
         double volume = 0.0;   // 体积

         // Box1 详述
         Box1.height = 5.0;
         Box1.length = 6.0;
         Box1.breadth = 7.0;

         // Box2 详述
         Box2.height = 10.0;
         Box2.length = 12.0;
         Box2.breadth = 13.0;

         // Box1 的体积
         volume = Box1.height * Box1.length * Box1.breadth;
         Console.WriteLine("Box1 的体积： {0}",  volume);

         // Box2 的体积
         volume = Box2.height * Box2.length * Box2.breadth;
         Console.WriteLine("Box2 的体积： {0}", volume);

         Console.ReadKey();
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

Box1 的体积： 210
Box2 的体积： 1560

成员函数和封装

类的成员函数是一个在类定义中有它的定义或原型的函数，就像其他变量一样。作为类的一个成员，它能在类的任何对象上操作，且能访问该对象的类的所有成员。

成员变量是对象的属性（从设计角度），且它们保持私有来实现封装。这些变量只能使用公共成员函数来访问。

让我们使用上面的概念来设置和获取一个类中不同的类成员的值：

using System;

namespace BoxApplication
{
   class Box
   {
      private double length;   // 长度
      private double breadth;  // 宽度
      private double height;   // 高度

      public void setLength(double len)
      {
         length = len;
      }

      public void setBreadth(double bre)
      {
         breadth = bre;
      }

      public void setHeight(double hei)
      {
         height = hei;
      }

      public double getVolume()
      {
         return length * breadth * height;
      }
   }

   class Boxtester
   {
      static void Main(string[] args)
      {
         Box Box1 = new Box();  // 声明 Box1，类型为 Box
         Box Box2 = new Box();  // 声明 Box2，类型为 Box
         double volume;          // 体积

         // Box1 详述
         Box1.setLength(6.0);
         Box1.setBreadth(7.0);
         Box1.setHeight(5.0);

         // Box2 详述
         Box2.setLength(12.0);
         Box2.setBreadth(13.0);
         Box2.setHeight(10.0);

         // Box1 的体积
         volume = Box1.getVolume();
         Console.WriteLine("Box1 的体积： {0}" ,volume);

         // Box2 的体积
         volume = Box2.getVolume();
         Console.WriteLine("Box2 的体积： {0}", volume);

         Console.ReadKey();
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

Box1 的体积： 210
Box2 的体积： 1560

C# 中的构造函数

类的 构造函数 是类的一个特殊的成员函数，当创建类的新对象时执行。

构造函数的名称与类的名称完全相同，它没有任何返回类型。

下面的实例说明了构造函数的概念：

using System;

namespace LineApplication
{
   class Line
   {
      private double length; // 线条的长度
      public Line()
      {
         Console.WriteLine("对象已创建");
      }
      public void setLength(double len)
      {
         length = len;
      }
      public double getLength()
      {
         return length;
      }

      static void Main(string[] args)
      {
         Line line = new Line();  
         // 设置线条长度
         line.setLength(6.0);
         Console.WriteLine("线条的长度： {0}", line.getLength());
         Console.ReadKey();
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

对象已创建
线条的长度： 6

默认的构造函数没有任何参数。但是如果你需要一个带有参数的构造函数可以有

枚举是一组命名整型常量。枚举类型是使用 enum 关键字声明的。
C# 枚举是值类型。换句话说，枚举包含自己的值，且不能继承或传递继承。

声明 enum 变量

声明枚举的一般语法：

enum <enum_name>
{
    enumeration list
};

其中，

• <enum_name> 指定枚举的类型名称。
• <enumeration list> 是一个用逗号分隔的标识符列表。

枚举列表中的每个符号代表一个整数值，一个比它前面的符号大的整数值。默认情况下，第一个枚举符号的值是 0。例如：

enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };

实例

下面的实例演示了枚举变量的用法：

using System;

public class EnumTest
{
    enum Day { Sun, Mon, Tue, Wed, Thu, Fri, Sat };

    static void Main()
    {
        int x = (int)Day.Sun;
        int y = (int)Day.Fri;
        Console.WriteLine("Sun = {0}", x);
        Console.WriteLine("Fri = {0}", y);
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

Sun = 0
Fri = 5

在 C# 中，结构体（struct）是一种值类型（value type），用于组织和存储相关数据。

在 C# 中，结构体是值类型数据结构，这样使得一个单一变量可以存储各种数据类型的相关数据。

struct 关键字用于创建结构体。

结构体是用来代表一个记录，假设您想跟踪图书馆中书的动态，您可能想跟踪每本书的以下属性：

• Title
• Author
• Subject
• Book ID

定义结构体

为了定义一个结构体，您必须使用 struct 语句。

struct 语句为程序定义了一个带有多个成员的新的数据类型。例如，您可以按照如下的方式声明 Book 结构：

struct Books
{
   public string title;
   public string author;
   public string subject;
   public int book_id;
};

下面的程序演示了结构的用法：

using System;
using System.Text;

struct Books
{
   public string title;
   public string author;
   public string subject;
   public int book_id;
};  

public class testStructure
{
   public static void Main(string[] args)
   {

      Books Book1;
      Books Book2;

      /* book 1 详述 */
      Book1.title = "C Programming";
      Book1.author = "Nuha Ali";
      Book1.subject = "C Programming Tutorial";
      Book1.book_id = 6495407;

      /* book 2 详述 */
      Book2.title = "Telecom Billing";
      Book2.author = "Zara Ali";
      Book2.subject = "Telecom Billing Tutorial";
      Book2.book_id = 6495700;

      /* 打印 Book1 信息 */
      Console.WriteLine("Book 1 title : {0}", Book1.title);
      Console.WriteLine("Book 1 author : {0}", Book1.author);
      Console.WriteLine("Book 1 subject : {0}", Book1.subject);
      Console.WriteLine("Book 1 book_id :{0}", Book1.book_id);

      /* 打印 Book2 信息 */
      Console.WriteLine("Book 2 title : {0}", Book2.title);
      Console.WriteLine("Book 2 author : {0}", Book2.author);
      Console.WriteLine("Book 2 subject : {0}", Book2.subject);
      Console.WriteLine("Book 2 book_id : {0}", Book2.book_id);   

      Console.ReadKey();
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

Book 1 title : C Programming
Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407
Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700

C# 结构的特点

结构提供了一种轻量级的数据类型，适用于表示简单的数据结构，具有较好的性能特性和值语义：

• 结构可带有方法、字段、索引、属性、运算符方法和事件，适用于表示轻量级数据的情况，如坐标、范围、日期、时间等。
• 结构可定义构造函数，但不能定义析构函数。但是，您不能为结构定义无参构造函数。无参构造函数(默认)是自动定义的，且不能被改变。
• 与类不同，结构不能继承其他的结构或类。
• 结构不能作为其他结构或类的基础结构。
• 结构可实现一个或多个接口。
• 结构成员不能指定为 abstract、virtual 或 protected。
• 当您使用 New 操作符创建一个结构对象时，会调用适当的构造函数来创建结构。与类不同，结构可以不使用 New 操作符即可被实例化。
• 如果不使用 New 操作符，只有在所有的字段都被初始化之后，字段才被赋值，对象才被使用。
• 结构变量通常分配在栈上，这使得它们的创建和销毁速度更快。但是，如果将结构用作类的字段，且这个类是引用类型，那么结构将存储在堆上。
• 结构默认情况下是可变的，这意味着你可以修改它们的字段。但是，如果结构定义为只读，那么它的字段将是不可变的。

类 vs 结构

类和结构在设计和使用时有不同的考虑因素，类适合表示复杂的对象和行为，支持继承和多态性，而结构则更适合表示轻量级数据和值类型，以提高性能并避免引用的管理开销。

类和结构有以下几个基本的不同点：

值类型 vs 引用类型：

• 结构是值类型（Value Type）： 结构是值类型，它们在栈上分配内存，而不是在堆上。当将结构实例传递给方法或赋值给另一个变量时，将复制整个结构的内容。
• 类是引用类型（Reference Type）： 类是引用类型，它们在堆上分配内存。当将类实例传递给方法或赋值给另一个变量时，实际上是传递引用（内存地址）而不是整个对象的副本。

继承和多态性：

• 结构不能继承： 结构不能继承其他结构或类，也不能作为其他结构或类的基类。
• 类支持继承： 类支持继承和多态性，可以通过派生新类来扩展现有类的功能。

默认构造函数：

• 结构不能有无参数的构造函数： 结构不能包含无参数的构造函数。
• 类可以有无参数的构造函数： 类可以包含无参数的构造函数，如果没有提供构造函数，系统会提供默认的无参数构造函数。

赋值行为：

• 类型为类的变量在赋值时存储的是引用，因此两个变量指向同一个对象。
• 结构变量在赋值时会复制整个结构，因此每个变量都有自己的独立副本。

传递方式：

• 类型为类的对象在方法调用时通过引用传递，这意味着在方法中对对象所做的更改会影响到原始对象。
• 结构对象通常通过值传递，这意味着传递的是结构的副本，而不是原始结构对象本身。因此，在方法中对结构所做的更改不会影响到原始对象。

可空性：

• 结构体是值类型，不能直接设置为 null：因为 null 是引用类型的默认值，而不是值类型的默认值。如果你需要表示结构体变量的缺失或无效状态，可以使用 Nullable 或称为 T? 的可空类型。
• 类默认可为null： 类的实例默认可以为 null，因为它们是引用类型。

性能和内存分配：

• 结构通常更轻量： 由于结构是值类型且在栈上分配内存，它们通常比类更轻量，适用于简单的数据表示。
• 类可能有更多开销： 由于类是引用类型，可能涉及更多的内存开销和管理。

以下实例中，MyStruct 是一个结构，而 MyClass 是一个类。

注释部分演示了结构不能包含无参数的构造函数、不能继承以及结构的实例复制是复制整个结构的内容。与之相反，类可以包含无参数的构造函数，可以继承，并且实例复制是复制引用。

// 结构声明
struct MyStruct
{
   public int X;
   public int Y;

   // 结构不能有无参数的构造函数
   // public MyStruct()
   // {
   // }

   // 有参数的构造函数
   public MyStruct(int x, int y)
   {
      X = x;
      Y = y;
   }

   // 结构不能继承
   // struct MyDerivedStruct : MyBaseStruct
   // {
   // }
}

// 类声明
class MyClass
{
   public int X;
   public int Y;

   // 类可以有无参数的构造函数
   public MyClass()
   {
   }

   // 有参数的构造函数
   public MyClass(int x, int y)
   {
      X = x;
      Y = y;
   }

   // 类支持继承
   // class MyDerivedClass : MyBaseClass
   // {
   // }
}

class Program
{
   static void Main()
   {
      // 结构是值类型，分配在栈上
      MyStruct structInstance1 = new MyStruct(1, 2);
      MyStruct structInstance2 = structInstance1; // 复制整个结构

      // 类是引用类型，分配在堆上
      MyClass classInstance1 = new MyClass(3, 4);
      MyClass classInstance2 = classInstance1; // 复制引用，指向同一个对象

      // 修改结构实例不影响其他实例
      structInstance1.X = 5;
      Console.WriteLine("Struct: {structInstance1.X}, {structInstance2.X}");

      // 修改类实例会影响其他实例
      classInstance1.X = 6;
      Console.WriteLine("Class: {classInstance1.X}, {classInstance2.X}");
   }
}

针对上述讨论，让我们重写前面的实例：

using System;
using System.Text;

struct Books
{
   private string title;
   private string author;
   private string subject;
   private int book_id;

   public void setValues(string t, string a, string s, int id)
   {
      title = t;
      author = a;
      subject = s;
      book_id =id; 
   }

   public void display()
   {
      Console.WriteLine("Title : {0}", title);
      Console.WriteLine("Author : {0}", author);
      Console.WriteLine("Subject : {0}", subject);