C#面向对象编程中开闭原则的示例详解

什么是开闭原则

开闭原则（Open-Closed Principle）是面向对象编程中的一个重要原则，其定义如下：

软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。

也就是说，在软件设计的过程中，可以通过扩展已有的代码来增加新的功能，而不需要修改原有的代码。

如何实现开闭原则

使用抽象类或接口

使用抽象类或接口可以实现对扩展开放，对修改关闭的原则。这是因为抽象类或接口定义的方法、属性是抽象的，具体的实现是在子类中实现的，这样子类就可以根据需要自定义实现方法，而不需要修改父类或接口的实现。

利用多态性

利用多态性也可以实现对扩展开放，对修改关闭的原则。多态性的实现是通过父类或接口引用子类对象的方式来实现的，这样可以实现代码的灵活性和可扩展性。

示例说明1：汽车品牌展示

假设现在需要在一个网站上展示不同品牌的汽车，并需支持新增车型。如果按照开闭原则的设计思想，可以使用抽象类或接口来定义汽车和品牌，并利用多态性来实现对扩展开放，对修改关闭的原则。具体实现如下：

public abstract class Car
{
    public abstract string Brand { get; }
    public abstract string Model { get; }
    public abstract double Price { get; }
}

public class BMW : Car
{
    public override string Brand => "BMW";
    public override string Model => "X5";
    public override double Price => 300000;
}

public class Benz : Car
{
    public override string Brand => "Benz";
    public override string Model => "S600";
    public override double Price => 400000;
}

public interface ICarFactory
{
    Car CreateCar();
}

public class BMWFactory : ICarFactory
{
    public Car CreateCar()
    {
        return new BMW();
    }
}

public class BenzFactory : ICarFactory
{
    public Car CreateCar()
    {
        return new Benz();
    }
}

public class CarShop
{
    private List<ICarFactory> factories = new List<ICarFactory>();

    public CarShop()
    {
        factories.Add(new BMWFactory());
        factories.Add(new BenzFactory());
    }

    public void DisplayCars()
    {
        foreach (var factory in factories)
        {
            var car = factory.CreateCar();
            Console.WriteLine("Brand: {0}, Model: {1}, Price: {2}", car.Brand, car.Model, car.Price);
        }
    }
}

这里定义了一个抽象类Car和两个实现类BMW和Benz，同时定义了一个工厂接口ICarFactory，以及两个工厂类BMWFactory和BenzFactory，通过实现工厂类的CreateCar()方法返回对应的汽车对象。最后在CarShop中使用工厂类来展示汽车信息。

如果新增一个品牌比如Audi，只需要新增一个类AudiFactory实现ICarFactory接口即可，而不需修改已有的代码。

示例说明2：图标组件功能扩展

假设现在需要开发一个图标组件，支持多种类型的图标，如圆形、矩形、三角形等，并且需要支持新增图标类型。按照开闭原则的设计思想，可以使用抽象类或接口来定义图标和图标类型，并利用多态性来实现对扩展开放，对修改关闭的原则。具体实现如下：

public abstract class Shape
{
    public abstract void Draw();
}

public class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Draw a circle.");
    }
}

public class Rect : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Draw a rectangle.");
    }
}

public interface IShapeFactory
{
    Shape CreateShape();
}

public class CircleFactory : IShapeFactory
{
    public Shape CreateShape()
    {
        return new Circle();
    }
}

public class RectFactory : IShapeFactory
{
    public Shape CreateShape()
    {
        return new Rect();
    }
}

public class Component
{
    private List<IShapeFactory> factories = new List<IShapeFactory>();

    public Component()
    {
        factories.Add(new CircleFactory());
        factories.Add(new RectFactory());
    }

    public void AddShapeFactory(IShapeFactory factory)
    {
        factories.Add(factory);
    }

    public void DrawShapes()
    {
        foreach (var factory in factories)
        {
            var shape = factory.CreateShape();
            shape.Draw();
        }
    }
}

这里定义了一个抽象类Shape和两个实现类Circle和Rect，同时定义了一个工厂接口IShapeFactory，以及两个工厂类CircleFactory和RectFactory，通过实现工厂类的CreateShape()方法返回对应的图标对象。最后在Component组件中使用工厂类来展示图标信息。

如果新增一个图标类型比如Triangle，只需要新增一个类TriangleFactory实现IShapeFactory接口即可，而不需修改已有的代码。