工厂模式中使用的策略模式？

Question

我正在使用工厂模式编写代码。在 switch 情况下，我实际上是在返回 Class 对象。使用这个返回类，我将调用一个方法。这是策略模式的一个例子吗？

using System;
using System.Linq;

namespace ConsoleApplication1
{
    public interface IVehicle
    {
          void Manufacture();
    }

    public class Car : IVehicle
    {
        public void Manufacture()
        {
            Console.WriteLine("Car Manufacturing");
         }
     }

     public class Bike : IVehicle
     {
         public void Manufacture()
         {
            Console.WriteLine("Bike Manufacturing");
         }
     }

     public static class factory
     {
         public static IVehicle GetVehicle(string name)
         {
            switch(name)
            {
                case "Car":
                    return new Car();
                case "Bike":
                    return new Bike();
                default:
                    throw new ArgumentException();
            }
        }
    }

    public class program
    {
        public static void Main()
        {
            Console.WriteLine("Please enter Car or Bike for manufacture");
            var vehicleName = Console.ReadLine();
            factory.GetVehicle(vehicleName).Manufacture();
            Console.ReadLine();
        }
    }

}

你能解开我的误解吗？这段代码是工厂模式和策略模式的例子吗？ 提前谢谢你。

编辑

这是策略模式的一个例子吗？我刚刚编辑了 Program.cs

public class program
{
    public static void Main()
    {
        Console.WriteLine("Please enter Car or Bike for manufacture");
        var vehicleName = Console.ReadLine();
        var vehicle = factory.GetVehicle(vehicleName);


    }

    public void manufacture(IVehicle vehicle)
    {
        // assume that this method is in different class and method is calling with strategy as i understood.
        vehicle.Manufacture();
    }
}

Answer 1

您的代码是带有参数的工厂方法的示例。您可以在没有参数的情况下执行工厂方法，这是更好的做法。

策略模式编辑算法，我喜欢 Abstract class 的策略，而不是 Interface。

例如，您的策略可能如下所示：

首先，Strategy 类。例如计算油耗：

public abstract class Strategy
{
    public abstract int FuelConsumption(int km);
}

现在，您可以使用strategies。我会做其中两个，快速驾驶和慢速驾驶：

public class FastDriving : Strategy
{
    //you need to override abstract methods from abstract class that
    // are mentioned in Strategy as acstract, or any else abstract class
    public override double FuelComsumption(int km) => km * fuelPer100Km;

    private int fuelPer100Km = 30;
}

public class SlowDriving : Strategy
{
    //same history as above
    public override double FuelComsumption(int km) => km * fuelPer100Km - 100;

    private int fuelPer100Km = 10;
    //u need to edit alghoritm to strategy be a strategy
}

现在，您可以在每辆车中为您的Abstract Class Strategy 设置一个属性：

public class Bike : IVehicle
 {
     public void Manufacture()
     {
        Console.WriteLine("Bike Manufacturing");
     }

     int i = 1000; //some propertys needed to calculate alghoritm

     // method in vehicle class that we use to strategy, to edit our alghoritm
     public int CaluculateFuelConsumption() => Strategy.FuelConsumption() - i;

     //here is a property of your strategy
     public Strategy strategy {get; set;};
 }

现在，您需要填充您的策略。如果你愿意，你可以在类正文中或在 main 中进行：

Strategy strategy = new FastDriving();
Strategy strategy = new SlowDriving();

但你可以做得更好。

只做一个抽象类，比如Vehicle：

public abstract class Vehicle 
{
    public Strategy strategy {get; set;};
}

然后，您的车辆可以如下所示：

 public class Bike : Vehicle, IVehicle
 {
      public void Manufacture()
     {
     Console.WriteLine("Bike Manufacturing");
     }

     int i = 1000; //some propertys needed to calculate alghoritm

     // method in vehicle class that we use to strategy, to edit our alghoritm
     public int CaluculateFuelConsumption() => Strategy.FuelConsumption() - i;

     //We deleted Strategy, because abstract Car class have already Strategy
     //We dont need override non abstract method. Only abstract propertys
     //need to be overrided
   }  

现在，在你的主类中，你可以做汽车列表，通过工厂方法填充它并附加Strategy

List<Vehicle> vehicles= new List<Vehicle>();

foreach(Vehicle vehicle in vehicles)
    {
        //its not factory, but you can use factory for your post here
        switch(name)
        {
            case "Car":
                vehicle =  new Car();
            case "Bike":
                vehicle = new Bike();
            default:
                throw new ArgumentException();
        }
        //now, we populate strategy
        vehicle.strategy = new FastDriving():

    }

然后你可以通过一个循环计算所有的油耗：

 foreach(Vehicle vehicle in vehicles)       
        int fuel += vehicle.CalculateFuelConsumption();

策略，我写的是PUSH 策略。还有PULL 策略。你可以在网上阅读。我相信，我的回答足以让你理解，策略是如何运作的:)

如果您想了解更多关于模式的信息，我向您推荐该网站：

Design Patterns

Answer 2

我会说是的，GetVehicle 方法是称为simple factory 的专用工厂模式的一个示例，您正在使用它返回的东西以使用策略模式的方式 - 调用代码不知道战略的具体实施。