工厂设计模式是否违反了C#中实体原则的依赖倒置原则？ [重复]

Question

根据定义，依赖注入促进了松散耦合、可维护和可测试的代码，并且使用接口和构造函数注入我们可以获得实现接口的类的对象。

但是当我们实现工厂时，我们根据工厂方法中传递的 Type 创建对象 例如：

interface IVehicle
{
    int WheelCount();
}

class car : IVehicle
{
    int WheelCount() 
    { }
}

class bike : IVehicle
{
    int WheelCount()
    { }
}

class factory
{
    public IVehicle factoryMethod(string type)
    {
        switch(type)
        {
            case "bike":
                new bike();
                break;

            case "car":
                new car();
                break;
        }
    }
}

在

main()

：

factory obj = new factory();
IVehicle vehicle = obj.factoryMethod("bike");

当我们通过在工厂方法中直接实例化具体类来创建对象时。

那么工厂设计模式是否违反了依赖倒置原则？

Answer 1

不，它没有。但是你的代码编写方式确实违反了。

相反，如果你简单地修改一下 Factory 类的代码，它将遵循 DI 原则。

像这样：

Class Factory{

 private IVehicle bikeInstance;
private IVehicle carInstance;

public Factory(IVehicle bike, IVehicle car)
{
    bikeInstance = bike;
    carInstance = car;
}

}

通过Factory类构造函数注入实例并通过faxctoryMethod()返回它们

Answer 2

工厂知道类型，但依赖注入的类不知道。

public interface IEngine
{
    void Start();
    void Stop();
}
public class DieselEngine : IEngine
{
    public void Start() { Console.WriteLine("Diesel engine started"); }
    public void Stop() { Console.WriteLine("Diesel engine stopped"); }
}
public class GasEngine : IEngine
{
    public void Start() { Console.WriteLine("Gas engine started"); }
    public void Stop() { Console.WriteLine("Gas engine stopped"); }
}
public static class EngineFactory
{
    public static IEngine CreateEngine(string type)
    {
        switch (type)
        {
            case "diesel":
                return new DieselEngine();
            case "gas":
                return new GasEngine();
            default:
                throw new ArgumentException("Invalid engine type");
        }
    }
}

class Car
{
    private IEngine engine;
    public Car(IEngine engine)
    {
        this.engine = engine;
    }
    public void Start()
    {
        engine.Start();
    }
    public void Stop()
    {
        engine.Stop();
    }
}

在此示例中，我们有一个工厂，它根据传入的类型创建不同的引擎。但对于依赖注入的类汽车来说，这并不重要，因为我们注入的是 IEngine 而不是任何特定类型。

基本上一辆汽车可以这样创建

Car car = new(EngineFactory.CreateEngine("diesel"));
car.Start();
car.Stop();