# C# 面向对象编程

> 原文： [https://zetcode.com/lang/csharp/oopi/](https://zetcode.com/lang/csharp/oopi/)

在 C# 教程的这一部分中，我们将讨论 C# 中的面向对象编程。

共有三种广泛使用的编程范例：过程编程，函数编程和面向对象的编程。 C# 支持过程式编程和面向对象的编程。

## OOP 定义

面向对象编程（OOP）是一种使用对象及其相互作用设计应用和计算机程序的编程范例。

OOP 中有一些基本的编程概念：

*   抽象
*   多态
*   封装
*   继承

抽象通过建模适合该问题的类来简化复杂的现实。 多态是将运算符或函数以不同方式用于不同数据输入的过程。 封装对其他对象隐藏了类的实现细节。 继承是一种使用已经定义的类形成新类的方法。

## C# 对象

对象是 C# OOP 程序的基本构建块。 对象是数据和方法的组合。 数据和方法称为对象的成员。 在 OOP 程序中，我们创建对象。 这些对象通过方法进行通信。 每个对象都可以接收消息，发送消息和处理数据。

创建对象有两个步骤。 首先，我们定义一个类。 类是对象的模板。 它是一个蓝图，描述了类对象共享的状态和行为。 一个类可以用来创建许多对象。 在运行时从类创建的对象称为该特定类的实例。

`Program.cs`

```cs
using System;

namespace Being
{
    class Being {}

    class Program
    {
        static void Main(string[] args)
        {
            var b = new Being();
            Console.WriteLine(b);
        }
    }
}

```

在第一个示例中，我们创建一个简单的对象。

```cs
class Being {}

```

这是一个简单的类定义。 模板的主体为空。 它没有任何数据或方法。

```cs
var b = new Being();

```

我们创建`Being`类的新实例。 为此，我们使用了`new`关键字。 `b`变量是创建对象的句柄。

```cs
Console.WriteLine(b);

```

我们将对象打印到控制台以获取该对象的一些基本描述。 打印对象是什么意思？ 实际上，当我们打印对象时，我们将其称为`ToString()`方法。 但是我们还没有定义任何方法。 这是因为创建的每个对象都继承自基本`object`。 它具有一些基本功能，可以在所有创建的对象之间共享。 其中之一是`ToString()`方法。

```cs
$ dotnet run
Being.Being

```

我们得到对象类名。

## C# 对象属性

对象属性是捆绑在类实例中的数据。 对象属性称为实例变量或成员字段。 实例变量是在类中定义的变量，该类中的每个对象都有一个单独的副本。

`Program.cs`

```cs
using System;

namespace ObjectAttributes
{
    class Person
    {
        public string name;
    }

    class Program
    {
        static void Main(string[] args)
        {
            var p1 = new Person();
            p1.name = "Jane";

            var p2 = new Person();
            p2.name = "Beky";

            Console.WriteLine(p1.name);
            Console.WriteLine(p2.name);
        }
    }
}

```

在上面的 C# 代码中，我们有一个带有一个成员字段的`Person`类。

```cs
class Person
{
    public string name;
}

```

我们声明一个名称成员字段。 `public`关键字指定可以在类块之外访问成员字段。

```cs
var p1 = new Person();
p1.name = "Jane";

```

我们创建`Person`类的实例，并将名称变量设置为`"Jane"`。 我们使用点运算符来访问对象的属性。

```cs
var p2 = new Person();
p2.name = "Beky";

```

我们创建`Person`类的另一个实例。 在这里，我们将变量设置为`"Beky"`。

```cs
Console.WriteLine(p1.name);
Console.WriteLine(p2.name);

```

我们将变量的内容打印到控制台。

```cs
$ dotnet run
Jane
Beky

```

我们看到了程序的输出。 `Person`类的每个实例都有一个单独的名称成员字段副本。

## C# 方法

方法是在类主体内定义的函数。 它们用于通过对象的属性执行操作。 方法将模块化带入我们的程序。

在 OOP 范式的封装概念中，方法至关重要。 例如，我们的`AccessDatabase`类中可能有一个`Connect()`方法。 我们无需知道方法`Connect()`如何精确地连接到数据库。 我们只需要知道它用于连接数据库。 这对于划分编程中的职责至关重要，尤其是在大型应用中。

对象将状态和行为分组，方法代表对象的行为部分。

`Program.cs`

```cs
using System;

namespace Methods
{
    class Circle
    {
        private int radius;

        public void SetRadius(int radius)
        {
            this.radius = radius;
        }

        public double Area()
        {
            return this.radius * this.radius * Math.PI;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var c = new Circle();
            c.SetRadius(5);

            Console.WriteLine(c.Area());
        }
    }
}

```

在代码示例中，我们有一个`Circle`类。 我们定义了两种方法。

```cs
private int radius;

```

我们只有一个成员字段。 它是圆的半径。 `private`关键字是访问说明符。 它表明变量仅限于外部世界。 如果要从外部修改此变量，则必须使用公共可用的`SetRadius()`方法。 这样我们可以保护我们的数据。

```cs
public void SetRadius(int radius)
{
    this.radius = radius;
}

```

这是`SetRadius()`方法。 `this`变量是一个特殊变量，我们用它来访问方法中的成员字段。 `this.radius`是实例变量，而半径是局部变量，仅在`SetRadius()`方法内部有效。

```cs
var c = new Circle();
c.SetRadius(5);

```

我们创建`Circle`类的实例，并通过在圆对象上调用`SetRadius()`方法来设置其半径。 我们使用点运算符来调用该方法。

```cs
public double Area()
{
    return this.radius * this.radius * Math.PI;
}

```

`Area()`方法返回圆的面积。 `Math.PI`是内置常数。

```cs
$ dotnet run
78.5398163397448

```

运行该示例可得出此结果。

## C# 访问修饰符

访问修饰符设置方法和成员字段的可见性。 C# 具有四个基本访问修饰符：`public`，`protected`，`private`和`internal`。 可以从任何地方访问`public`成员。 `protected`成员只能在类本身内部以及继承的和父类访问。 `private`成员仅限于包含类型，例如仅在其类或接口内。 可以从同一程序集（exe 或 DLL）中访问`internal`成员。

修饰符还有两种组合：`protected internal`和`private protected`。 `protected internal`类型或成员可以由声明它的程序集中的任何代码访问，也可以从另一个程序集中的派生类中访问。 `private protected`类型或成员只能在其声明程序集中通过同一个类或从该类派生的类型的代码进行访问。

访问修饰符可防止意外修改数据。 它们使程序更强大。

|  | 类 | 当前程序集 | 派生类 | 当前程序集中的派生类 | 整个程序 |
| --- | --- | --- | --- | --- | --- |
| `public` | `+` | `+` | `+` | `+` | `+` |
| `protected` | `+` | `o` | `+` | `+` | `o` |
| `internal` | `+` | `+` | `o` | `o` | `o` |
| `private` | `+` | `o` | `o` | `o` | `o` |
| `protected internal` | `+` | `+` | `+` | `+` | `o` |
| `private protected` | `+` | `o` | `o` | `+` | `o` |

上表总结了 C# 访问修饰符（`+`是可访问的，`o`是不可访问的）。

`Program.cs`

```cs
using System;

namespace AccessModifiers
{
    class Person
    {
        public string name;
        private int age;

        public int GetAge()
        {
            return this.age;
        }

        public void SetAge(int age)
        {
            this.age = age;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var p = new Person();
            p.name = "Jane";

            p.SetAge(17);

            Console.WriteLine("{0} is {1} years old",
                p.name, p.GetAge());
            }
    }
}

```

在上面的程序中，我们有两个成员字段。 一个被宣布为公开，另一个被宣布为私有。

```cs
public int GetAge()
{
    return this.age;
}

```

如果成员字段是`private`，则访问它的唯一方法是通过方法。 如果要在类外部修改属性，则必须将方法声明为`public`。 这是数据保护的重要方面。

```cs
public void SetAge(int age)
{
    this.age = age;
}

```

`SetAge()`方法使我们能够从类定义之外更改`private`年龄变量。

```cs
var p = new Person();
p.name = "Jane";

```

我们创建`Person`类的新实例。 因为名称属性是`public`，所以我们可以直接访问它。 但是，不建议这样做。

```cs
p.SetAge(17);

```

`SetAge()`方法修改年龄成员字段。 由于已声明`private`，因此无法直接访问或修改。

```cs
Console.WriteLine("{0} is {1} years old",
    p.name, p.GetAge());

```

最后，我们访问两个成员以构建一个字符串。

```cs
$ dotnet run
Jane is 17 years old

```

运行示例将给出此输出。

具有`private`访问修饰符的成员字段不被派生类继承。

`Program.cs`

```cs
using System;

namespace Protected
{
    class Base
    {
        public string name = "Base";
        protected int id = 5323;
        private bool isDefined = true;
    }

    class Derived : Base
    {
        public void info()
        {
            Console.WriteLine("This is Derived class");
            Console.WriteLine("Members inherited");
            Console.WriteLine(this.name);
            Console.WriteLine(this.id);
            // Console.WriteLine(this.isDefined);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var derived = new Derived();
            derived.info();
        }
    }
}

```

在前面的程序中，我们有一个`Derived`类，该类继承自`Base`类。 `Base`类具有三个成员字段。 全部具有不同的访问修饰符。 `isDefined`成员不继承。 `private`修饰符可以防止这种情况。

```cs
class Derived : Base

```

类`Derived`继承自`Base`类。 要从另一个类继承，我们使用冒号（:)运算符。

```cs
Console.WriteLine(this.name);
Console.WriteLine(this.id);
// Console.WriteLine(this.isDefined);

```

`public`和`protected`成员由`Derived`类继承。 可以访问它们。 `private`成员未继承。 访问成员字段的行被注释。 如果我们取消注释该行，则代码将无法编译。

```cs
$ dotnet run
Program.cs(9,22): warning CS0414: The field 'Base.isDefined' is assigned but its value
is never used [C:\Users\Jano\Documents\csharp\tutorial\oop\Protected\Protected.csproj]
This is Derived class
Members inherited
Base
5323

```

运行程序，我们收到此输出。

## C# 构造器

构造器是一种特殊的方法。 创建对象时会自动调用它。 构造器不返回值。 构造器的目的是初始化对象的状态。 构造器与类具有相同的名称。 构造器是方法，因此它们也可以重载。

构造器不能被继承。 它们按继承顺序被调用。 如果我们不为类编写任何构造器，则 C# 提供一个隐式默认构造器。 如果提供任何类型的构造器，则不提供默认值。

`Program.cs`

```cs
using System;

namespace Constructor
{
    class Being
    {
        public Being()
        {
            Console.WriteLine("Being is created");
        }

        public Being(string being)
        {
            Console.WriteLine("Being {0} is created", being);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            new Being();
            new Being("Tom");
        }
    }
}

```

我们有一个`Being`类。 此类具有两个构造器。 第一个不带参数； 第二个采用一个参数。

```cs
public Being(string being)
{
    Console.WriteLine("Being {0} is created", being);
}

```

此构造器采用一个字符串参数。

```cs
new Being();

```

创建`Being`类的实例。 这次，在创建对象时调用没有参数的构造器。

```cs
$ dotnet run
Being is created
Being Tom is created

```

这是程序的输出。

在下一个示例中，我们初始化类的数据成员。 变量的初始化是构造器的典型工作。

`Program.cs`

```cs
using System;

namespace Constructor2
{
    class MyFriend
    {
        private DateTime born;
        private string name;

        public MyFriend(string name, DateTime born)
        {
            this.name = name;
            this.born = born;
        }

        public void Info()
        {
            Console.WriteLine("{0} was born on {1}",
                this.name, this.born.ToShortDateString());
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var name = "Lenka";
            var born = new DateTime(1990, 3, 5);

            var friend = new MyFriend(name, born);
            friend.Info();
        }
    }
}

```

我们有一个带有数据成员和方法的`MyFriend`类。

```cs
private DateTime born;
private string name;

```

类定义中有两个私有变量。

```cs
public MyFriend(string name, DateTime born)
{
    this.name = name;
    this.born = born;
}

```

在构造器中，我们启动两个数据成员。 `this`变量是用于引用对象变量的处理器。

```cs
var friend = new MyFriend(name, born);
friend.Info();

```

我们创建带有两个参数的`MyFriend`对象。 然后我们调用对象的`Info()`方法。

```cs
$ dotnet run
Lenka was born on 3/5/1990

```

这是输出。

## C# 构造器链接

构造器链接是类从构造器调用另一个构造器的能力。 要从同一类调用另一个构造器，我们使用`this`关键字。

`Program.cs`

```cs
using System;

namespace ConstructorChaining
{
    class Circle
    {
        public Circle(int radius)
        {
            Console.WriteLine("Circle, r={0} is created", radius);
        }

        public Circle() : this(1)
        {

        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            new Circle(5);
            new Circle();
        }
    }
}

```

我们有一个`Circle`类。 该类具有两个构造器。 一种采用一个参数，一种不采用任何参数。

```cs
public Circle(int radius)
{
    Console.WriteLine("Circle, r={0} is created", radius);
}

```

此构造器采用一个参数-`radius`。

```cs
public Circle() : this(1)
{

}

```

这是没有参数的构造器。 它只是简单地调用另一个构造器，并为其提供默认半径 1。

```cs
$ dotnet run
Circle, r=5 is created
Circle, r=1 is created

```

This is the output.

## C# `ToString`方法

每个对象都有一个`ToString()`方法。 它返回人类可读的对象表示形式。 默认实现返回`Object`类型的标准名称。 请注意，当我们使用对象作为参数调用`Console.WriteLine()`方法时，将调用`ToString()`。

`Program.cs`

```cs
using System;

namespace ToStringMethod
{
    class Being
    {
        public override string ToString()
        {
            return "This is Being class";
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var b = new Being();
            var o = new Object();

            Console.WriteLine(o.ToString());
            Console.WriteLine(b.ToString());
            Console.WriteLine(b);
        }
    }
}

```

我们有一个`Being`类，其中我们重写了`ToString()`方法的默认实现。

```cs
public override string ToString()
{
    return "This is Being class";
}

```

创建的每个类都从基`object`继承。 `ToString()`方法属于此对象类。 我们使用`override`关键字来通知我们正在覆盖方法。

```cs
var b = new Being();
var o = new Object();

```

我们创建一个自定义对象和一个内置对象。

```cs
Console.WriteLine(o.ToString());
Console.WriteLine(b.ToString());

```

我们在这两个对象上调用`ToString()`方法。

```cs
Console.WriteLine(b);

```

正如我们之前指定的，将对象作为`Console.WriteLine()`的参数将调用其`ToString()`方法。 这次，我们隐式调用了该方法。

```cs
$ dotnet run
System.Object
This is Being class
This is Being class

```

这是我们运行示例时得到的。

## C# 对象初始化器

对象初始化器让我们在创建时将值分配给对象的任何可访问字段或属性，而无需调用构造器。 属性或字段在`{}`括号内分配。 另外，我们可以为构造器指定参数，也可以省略参数。

`Program.cs`

```cs
using System;

namespace ObjectInitializers
{
    class User
    {
        public User() {}

        public string Name { set; get; }
        public string Occupation { set; get; }

        public override string ToString()
        {
            return $"{Name} is a {Occupation}";
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var u = new User { Name = "John Doe", Occupation = "gardener" };
            Console.WriteLine(u);
        }
    }
}

```

在示例中，我们使用对象初始化器语法创建一个新用户。

```cs
public User() {}

```

我们定义一个空的构造器。

```cs
public string Name { set; get; }
public string Occupation { set; get; }

```

我们有两个属性：`Name`和`Occupation`。

```cs
var u = new User { Name = "John Doe", Occupation = "gardener" };

```

我们将值分配给`{}`括号中的属性。

```cs
$ dotnet run
John Doe is a gardener

```

This is the output.

## C# 类常量

C# 可以创建类常量。 这些常量不属于具体对象。 他们属于类。 按照约定，常量用大写字母表示。

`Program.cs`

```cs
using System;

namespace ClassConstants
{
    class Math
    {
        public const double PI = 3.14159265359;
    }

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(Math.PI);
        }
    }
}

```

我们有一个带有`PI`常量的`Math`类。

```cs
public const double PI = 3.14159265359;

```

`const`关键字用于定义常数。 `public`关键字使它可以在类的主体之外访问。

```cs
$ dotnet run
3.14159265359

```

运行示例，我们看到此输出。

## C# 继承

继承是使用已经定义的类形成新类的方法。 新形成的类称为派生的类，我们派生的类称为基类。 继承的重要好处是代码重用和降低程序的复杂性。 派生类（后代）将覆盖或扩展基类（祖先）的功能。

`Program.cs`

```cs
using System;

namespace Inheritance
{
    class Being
    {
        public Being()
        {
            Console.WriteLine("Being is created");
        }
    }

    class Human : Being
    {
        public Human()
        {
            Console.WriteLine("Human is created");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            new Human();
        }
    }
}

```

在此程序中，我们有两个类。 基类`Being`和派生的`Human`类。 派生类继承自基类。

```cs
class Human : Being

```

在 C# 中，我们使用冒号（`:`）运算符创建继承关系。

```cs
new Human();

```

我们实例化派生的`Human`类。

```cs
$ dotnet run
Being is created
Human is created

```

我们可以看到两个构造器都被调用了。 首先，调用基类的构造器，然后调用派生类的构造器。

接下来是一个更复杂的示例。

`Program.cs`

```cs
using System;

namespace Inheritance2
{
    class Being
    {
        static int count = 0;

        public Being()
        {
            count++;
            Console.WriteLine("Being is created");
        }

        public void GetCount()
        {
            Console.WriteLine("There are {0} Beings", count);
        }
    }

    class Human : Being
    {
        public Human()
        {
            Console.WriteLine("Human is created");
        }
    }

    class Animal : Being
    {
        public Animal()
        {
            Console.WriteLine("Animal is created");
        }
    }

    class Dog : Animal
    {
        public Dog()
        {
            Console.WriteLine("Dog is created");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            new Human();

            var dog = new Dog();
            dog.GetCount();
        }
    }
}

```

我们有四个类。 继承层次更加复杂。 `Human`和`Animal`类继承自`Being`类。 Dog 类直接继承自`Animal`类，并间接继承自`Being`类。 我们还介绍了`static`变量的概念。

```cs
static int count = 0;

```

我们定义一个`static`变量。 静态成员是类的所有实例共享的成员。

```cs
Being()
{
    count++;
    Console.WriteLine("Being is created");
}

```

每次实例化`Being`类时，我们将`count`变量增加一。 这样，我们就可以跟踪创建的实例数。

```cs
class Animal : Being
...

class Dog : Animal
...

```

`Animal`继承自`Being`，`Dog`继承自`Animal`。 `Dog`也间接继承自`Being`。

```cs
new Human();
var dog = new Dog();
dog.GetCount();

```

我们从`Human`和`Dog`类创建实例。 我们称为`Dog`对象的`GetCount()`方法。

```cs
$ dotnet run
Being is created
Human is created
Being is created
Animal is created
Dog is created
There are 2 Beings

```

`Human`调用两个构造器。 `Dog`调用三个构造器。 有两个实例化的存在。

我们使用`base`关键字显式调用父级的构造器。

`Program.cs`

```cs
using System;

namespace Shapes
{
    class Shape
    {
        protected int x;
        protected int y;

        public Shape()
        {
            Console.WriteLine("Shape is created");
        }

        public Shape(int x, int y)
        {
            this.x = x;
            this.y = y;
        }
    }

    class Circle : Shape
    {
        private int r;

        public Circle(int r, int x, int y) : base(x, y)
        {
            this.r = r;
        }

        public override string ToString()
        {
            return String.Format("Circle, r:{0}, x:{1}, y:{2}", r, x, y);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var c = new Circle(2, 5, 6);
            Console.WriteLine(c);
        }
    }
}

```

我们有两个类：`Shape`类和`Circle`类。 `Shape`类是几何形状的基类。 我们可以在此类中加入一些常见形状的共同点，例如`x`和`y`坐标。

```cs
public Shape()
{
    Console.WriteLine("Shape is created");
}

public Shape(int x, int y)
{
    this.x = x;
    this.y = y;
}

```

`Shape`类具有两个构造器。 第一个是默认构造器。 第二个参数有两个参数：`x`，`y`坐标。

```cs
public Circle(int r, int x, int y) : base(x, y)
{
    this.r = r;
}

```

这是`Circle`类的构造器。 此构造器启动`r`成员并调用父级的第二个构造器，并向其传递`x`和`y`坐标。 如果不使用`base`关键字显式调用构造器，则将调用`Shape`类的默认构造器。

```cs
$ dotnet run
Circle, r:2, x:5, y:6

```

这是示例的输出。

## C# 抽象类和方法

抽象类无法实例化。 如果一个类至少包含一个抽象方法，则也必须将其声明为抽象方法。 抽象方法无法实现； 他们只是声明方法的签名。 当我们从抽象类继承时，所有抽象方法都必须由派生类实现。 此外，必须以较少受限制的可见性声明这些方法。

与接口不同，抽象类可能具有完全实现的方法，并且可能具有定义的成员字段。 因此，抽象类可以提供部分实现。 程序员经常将一些通用功能放入抽象类中。 这些抽象类随后会被子类化以提供更具体的实现。 例如，Qt 图形库具有`QAbstractButton`，它是按钮小部件的抽象基类，提供按钮所共有的功能。 按钮`Q3Button`，`QCheckBox`，`QPushButton`，`QRadioButton`和`QToolButton`都从此基本抽象类继承。

正式地说，抽象类用于强制执行协议。 协议是所有实现对象都必须支持的一组操作。

`Program.cs`

```cs
using System;

namespace AbstractClass
{
    abstract class Drawing
    {
        protected int x = 0;
        protected int y = 0;

        public abstract double Area();

        public string GetCoordinates()
        {
            return string.Format("x: {0}, y: {1}", this.x, this.y);
        }
    }

    class Circle : Drawing
    {
        private int r;

        public Circle(int x, int y, int r)
        {
            this.x = x;
            this.y = y;
            this.r = r;
        }

        public override double Area()
        {
            return this.r * this.r * Math.PI;
        }

        public override string ToString()
        {
            return string.Format("Circle at x: {0}, y: {1}, radius: {2}",
                this.x, this.y, this.r);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var c = new Circle(12, 45, 22);

            Console.WriteLine(c);
            Console.WriteLine("Area of circle: {0}", c.Area());
            Console.WriteLine(c.GetCoordinates());
        }
    }
}

```

我们有一个抽象基类`Drawing`。 该类定义两个成员字段，定义一个方法并声明一个方法。 一种方法是抽象的，另一种是完全实现的。 `Drawing`类是抽象的，因为我们无法绘制它。 我们可以画一个圆，一个点或一个正方形。 `Drawing`类对我们可以绘制的对象具有一些通用功能。

```cs
abstract class Drawing

```

我们使用`abstract`关键字定义一个抽象类。

```cs
public abstract double Area();

```

抽象方法之前还带有`abstract`关键字。

```cs
class Circle : Drawing

```

圆是`Drawing`类的子类。 它必须实现抽象的`Area()`方法。

```cs
public override double Area()
{
    return this.r * this.r * Math.PI;
}

```

当我们实现`Area()`方法时，必须使用`override`关键字。 这样，我们通知编译器我们将覆盖现有的（继承的）方法。

```cs
$ dotnet run
Circle at x: 12, y: 45, radius: 22
Area of circle: 1520.53084433746
x: 12, y: 45

```

This is the output of the program.

## C# 部分类

使用`partial`关键字，可以将类的定义拆分到同一名称空间中的几个部分中。 该类也可以在多个文件中定义。

当使用非常大的代码库时可以使用部分类，这些代码库可以拆分为较小的单元。 局部类也与自动代码生成器一起使用。

`Program.cs`

```cs
using System;

namespace PartialClass
{
    partial class Worker
    {
        public string DoWork()
        {
            return "Doing work";
        }
    }

    partial class Worker
    {
        public string DoPause()
        {
            return "Pausing";
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var worker = new Worker();

            Console.WriteLine(worker.DoWork());
            Console.WriteLine(worker.DoWork());
            Console.WriteLine(worker.DoPause());
        }
    }
}

```

在示例中，我们将`Worker`类定义为两部分。 这些部分由编译器连接在一起以形成最终类。

```cs
$ dotnet run
Doing work
Doing work
Pausing

```

这是输出。

这是 C# 中 OOP 描述的第一部分。