c# 如何用组合替代继承

组合和继承都是面向对象编程中的两个重要概念。在某些情况下，使用组合可以更好地设计我们的类和对象结构。下面是一些完整的攻略，说明如何使用组合来替代继承。

什么是继承（Inheritance）？

在面向对象编程中，继承是一种实现代码复用的方式。通过继承，子类可以从父类中继承属性和方法，从而可以减少代码冗余并增加可维护性。C# 中使用 : 符号来表示继承关系。

class Animal {
    public void Eat() {
        Console.WriteLine("I'm eating");
    }
}

class Dog : Animal {
    public void Bark() {
        Console.WriteLine("Woof!");
    }
}

Dog dog = new Dog();
dog.Eat(); // "I'm eating"
dog.Bark(); // "Woof!"

什么是组合（Composition）？

组合是一种将对象作为属性包含在其他类中的方式。这种方法可以避免继承导致的“函数膨胀”和继承歧义问题。

class Animal {
    public void Eat() {
        Console.WriteLine("I'm eating");
    }
}

class Dog {
    private Animal animal = new Animal();

    public void Bark() {
        Console.WriteLine("Woof!");
    }

    public void Eat() {
        animal.Eat();
    }
}

Dog dog = new Dog();
dog.Eat(); // "I'm eating"
dog.Bark(); // "Woof!"

在上面的示例中，Dog 类包含一个 Animal 对象作为它的属性。在 Dog 类中，我们可以调用 Bark() 方法和 Eat() 方法，这两个方法都继承自 Dog 的父类 Animal。这种方法可以保持 Dog 类的简单性，并且使 Dog 类有了更好的可扩展性和灵活性。

原则

使用组合代替继承有以下几个重要原则：

1. 优先使用组合。只有当你需要从现有代码中继承一些行为时，才使用继承。当你使用组合时，你可以更好地控制你的对象图，避免不必要的模板方法和类爆炸问题。

2. 优先使用接口。使用接口可以让你定义更清晰的 API，而不是依赖继承关系。当你需要从不同的类中复用一些代码时，使用接口是更灵活的方法。

在设计类和对象结构时，应该根据具体情况综合考虑上述原则。根据不同的需求，选择合适的行为规则来构建类的关系，这是编写高质量代码的关键。

示例1：利用组合重构游戏实例代码

使用组合重构游戏实例代码，并使其满足以下需求：

1. 游戏分为“游戏场景”（GameScene）和“游戏对象”（GameObject）两个部分。

2. 每个游戏场景都包含多个游戏对象。

3. 游戏场景需要每个游戏对象操作函数的集合，用于遍历所有对象并调用操作函数。

// 游戏对象
class GameObject {  
    public void Draw() {
        Console.WriteLine("Draw");
    }
}

// 游戏场景
class GameScene {
    private List<GameObject> objects;

    public GameScene() {
        objects = new List<GameObject>();
    }

    // 将游戏对象添加到场景中
    public void AddObject(GameObject obj) {
        objects.Add(obj);
    }

    // 遍历所有对象并调用操作函数
    public void ForEach(Action<GameObject> action) {
        foreach (var obj in objects) {
            action(obj);
        }
    }
}

// 使用示例
GameScene scene = new GameScene();
scene.AddObject(new GameObject());
scene.AddObject(new GameObject());

scene.ForEach(obj => obj.Draw());

在上面的代码中，我们使用组合将游戏场景和游戏对象分开，并用 GameScene.ForEach() 方法处理了游戏场景中的所有游戏对象。

示例2：使用接口代替多层继承

在某些情况下，继承层数可能会很深，这会使代码解决起来非常困难。C# 语言中，接口（interface）可以用于代替多层继承。在下面的示例中，我们将 Bird 类和 Airplane 类的行为重构为接口。

// 飞行接口
interface IFlyable {
    void TakeOff();
    void Fly();
    void Land();
}

// 实现飞行接口的鸟类
class Bird : IFlyable {
    public void TakeOff() {
        Console.WriteLine("Bird taking off");
    }

    public void Fly() {
        Console.WriteLine("Bird flying");
    }

    public void Land() {
        Console.WriteLine("Bird landing");
    }
}

// 实现飞行接口的飞机类
class Airplane : IFlyable {
    public void TakeOff() {
        Console.WriteLine("Airplane taking off");
    }

    public void Fly() {
        Console.WriteLine("Airplane flying");
    }

    public void Land() {
        Console.WriteLine("Airplane landing");
    }
}

// 使用示例
IFlyable[] flyables = new IFlyable[] {
    new Bird(),
    new Airplane()
};

foreach (var flyable in flyables) {
    flyable.TakeOff();
    flyable.Fly();
    flyable.Land();
}

在上面的代码中，我们将 Bird 和 Airplane 类的行为重构为接口，并在 IFlyable[] 数组中使用了这两个类的实例。我们在 foreach 循环中遍历了数组中的所有元素，并使用 IFlyable 接口来调用它们的方法。这种做法可以简化继承层数，并使代码更加易于维护和扩展。

总的来说，使用组合来替代继承是一种很好的方式来改进我们代码的可读性、可维护性和可扩展性。需要根据具体情况来选择不同的实现方式。