C# 工厂模式学习

工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种创建对象的接口，而不是通过具体类来实例化对象。工厂模式可以将对象的创建过程封装起来，使代码更具有机动性和可扩展性。
工厂模式有几种常见的实现方式：

• 简朴工厂模式（Simple Factory Pattern）： 简朴工厂模式通过一个工厂类来决定创建哪种具体类的实例。这个工厂类通常提供一个静态方法，根据传入的参数创建相应的对象。
  
• 工厂方法模式（Factory Method Pattern）： 工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法使一个类的实例化延迟到其子类。
  
• 抽象工厂模式（Abstract Factory Pattern）： 抽象工厂模式提供一个接口，用于创建相干或依赖对象的家属，而无需明确指定具体类。通过使用抽象工厂模式，一个类可以实例化一组相干对象，而不必要知道它们的具体类。
  

简朴工厂模式示例

假设我们有一个动物园项目，必要创建差别的动物对象：

1. // 动物接口
2. public interface IAnimal
3. {
4.     void Speak();
5. }
7. // 具体的动物类
8. public class Dog : IAnimal
9. {
10.     public void Speak()
11.     {
12.         Console.WriteLine("Woof!");
13.     }
14. }
16. public class Cat : IAnimal
17. {
18.     public void Speak()
19.     {
20.         Console.WriteLine("Meow!");
21.     }
22. }
24. // 简单工厂类
25. public static class AnimalFactory
26. {
27.     public static IAnimal CreateAnimal(string animalType)
28.     {
29.         switch (animalType.ToLower())
30.         {
31.             case "dog":
32.                 return new Dog();
33.             case "cat":
34.                 return new Cat();
35.             default:
36.                 throw new ArgumentException("Unknown animal type");
37.         }
38.     }
39. }
41. // 使用示例
42. class Program
43. {
44.     static void Main(string[] args)
45.     {
46.         IAnimal animal = AnimalFactory.CreateAnimal("dog");
47.         animal.Speak();  // 输出：Woof!
48.     }
49. }

复制代码

 
工厂方法模式示例

假设我们有一个动物园项目，差别的子类必要创建差别的动物对象：

1. // 动物接口
2. public interface IAnimal
3. {
4.     void Speak();
5. }
7. // 具体的动物类
8. public class Dog : IAnimal
9. {
10.     public void Speak()
11.     {
12.         Console.WriteLine("Woof!");
13.     }
14. }
16. public class Cat : IAnimal
17. {
18.     public void Speak()
19.     {
20.         Console.WriteLine("Meow!");
21.     }
22. }
24. // 工厂接口
25. public interface IAnimalFactory
26. {
27.     IAnimal CreateAnimal();
28. }
30. // 具体工厂类
31. public class DogFactory : IAnimalFactory
32. {
33.     public IAnimal CreateAnimal()
34.     {
35.         return new Dog();
36.     }
37. }
39. public class CatFactory : IAnimalFactory
40. {
41.     public IAnimal CreateAnimal()
42.     {
43.         return new Cat();
44.     }
45. }
47. // 使用示例
48. class Program
49. {
50.     static void Main(string[] args)
51.     {
52.         IAnimalFactory factory = new DogFactory();
53.         IAnimal animal = factory.CreateAnimal();
54.         animal.Speak();  // 输出：Woof!
55.     }
56. }

复制代码

抽象工厂模式示例

假设我们有一个动物园项目，必要创建一组相干的对象（例如，动物及其食物）：

1. // 动物接口
2. public interface IAnimal
3. {
4.     void Speak();
5. }
7. // 具体的动物类
8. public class Dog : IAnimal
9. {
10.     public void Speak()
11.     {
12.         Console.WriteLine("Woof!");
13.     }
14. }
16. public class Cat : IAnimal
17. {
18.     public void Speak()
19.     {
20.         Console.WriteLine("Meow!");
21.     }
22. }
24. // 食物接口
25. public interface IFood
26. {
27.     void Get();
28. }
30. // 具体的食物类
31. public class DogFood : IFood
32. {
33.     public void Get()
34.     {
35.         Console.WriteLine("Dog food");
36.     }
37. }
39. public class CatFood : IFood
40. {
41.     public void Get()
42.     {
43.         Console.WriteLine("Cat food");
44.     }
45. }
47. // 抽象工厂接口
48. public interface IAnimalFactory
49. {
50.     IAnimal CreateAnimal();
51.     IFood CreateFood();
52. }
54. // 具体工厂类
55. public class DogFactory : IAnimalFactory
56. {
57.     public IAnimal CreateAnimal()
58.     {
59.         return new Dog();
60.     }
62.     public IFood CreateFood()
63.     {
64.         return new DogFood();
65.     }
66. }
68. public class CatFactory : IAnimalFactory
69. {
70.     public IAnimal CreateAnimal()
71.     {
72.         return new Cat();
73.     }
75.     public IFood CreateFood()
76.     {
77.         return new CatFood();
78.     }
79. }
81. // 使用示例
82. class Program
83. {
84.     static void Main(string[] args)
85.     {
86.         IAnimalFactory factory = new DogFactory();
87.         IAnimal animal = factory.CreateAnimal();
88.         IFood food = factory.CreateFood();
89.         animal.Speak();  // 输出：Woof!
90.         food.Get();      // 输出：Dog food
91.     }
92. }

复制代码

以上是三种工厂模式的基本示例，可以根据具体需求选择符合的工厂模式来实现代码的创建和管理。如果希望在增长新动物类型时尽量减少对现有类的修改，推荐使用工厂方法模式。工厂方法模式的设计使得每新增一种动物，只需增长一个对应的工厂类和具体的动物类，而无需修改已有的代码，从而符合开闭原则（即对扩展开放，对修改关闭）。
使用工厂方法模式

下面是一个更完善的工厂方法模式示例，展示了怎样在增长新动物时，尽量减少对现有代码的修改。

1. // 动物接口
2. public interface IAnimal
3. {
4.     void Speak();
5. }
7. // 具体的动物类
8. public class Dog : IAnimal
9. {
10.     public void Speak()
11.     {
12.         Console.WriteLine("Woof!");
13.     }
14. }
16. public class Cat : IAnimal
17. {
18.     public void Speak()
19.     {
20.         Console.WriteLine("Meow!");
21.     }
22. }
24. // 新增的动物类
25. public class Bird : IAnimal
26. {
27.     public void Speak()
28.     {
29.         Console.WriteLine("Tweet!");
30.     }
31. }
33. // 工厂接口
34. public interface IAnimalFactory
35. {
36.     IAnimal CreateAnimal();
37. }
39. // 具体工厂类
40. public class DogFactory : IAnimalFactory
41. {
42.     public IAnimal CreateAnimal()
43.     {
44.         return new Dog();
45.     }
46. }
48. public class CatFactory : IAnimalFactory
49. {
50.     public IAnimal CreateAnimal()
51.     {
52.         return new Cat();
53.     }
54. }
56. // 新增的动物工厂类
57. public class BirdFactory : IAnimalFactory
58. {
59.     public IAnimal CreateAnimal()
60.     {
61.         return new Bird();
62.     }
63. }
65. // 使用示例
66. class Program
67. {
68.     static void Main(string[] args)
69.     {
70.         List<IAnimalFactory> factories = new List<IAnimalFactory>
71.         {
72.             new DogFactory(),
73.             new CatFactory(),
74.             new BirdFactory()  // 新增的工厂只需在这里添加
75.         };
77.         foreach (var factory in factories)
78.         {
79.             IAnimal animal = factory.CreateAnimal();
80.             animal.Speak();
81.         }
82.     }
83. }

复制代码

在这个示例中，新增一种动物只需：

• 创建新的具体动物类，例如 Bird。
  
• 创建对应的工厂类，例如 BirdFactory。
  
• 在使用的地方添加新的工厂实例，例如在 factories 列表中添加 new BirdFactory()。
  

这样做的长处是每增长一个新动物类型，不必要修改现有的工厂类或具体的动物类，只必要添加新的类和工厂即可，从而降低了代码修改的风险和复杂度。
使用反射和配置来进一步减少修改

如果希望在增长动物时连代码都不必要改动，可以考虑使用反射和配置文件的方式。通过配置文件定义动物类型和对应的工厂类，然后使用反射动态加载：

1. // 动物接口和具体的动物类（同上）
3. // 工厂接口和具体工厂类（同上）
5. // 使用反射加载工厂类
6. class Program
7. {
8.     static void Main(string[] args)
9.     {
10.         // 假设配置文件中定义了动物类型和对应的工厂类
11.         var factoryTypes = new List<string>
12.         {
13.             "DogFactory",
14.             "CatFactory",
15.             "BirdFactory"  // 配置文件中新增的工厂类
16.         };
18.         var factories = new List<IAnimalFactory>();
20.         foreach (var factoryType in factoryTypes)
21.         {
22.             var type = Type.GetType(factoryType);
23.             if (type != null && typeof(IAnimalFactory).IsAssignableFrom(type))
24.             {
25.                 var factory = (IAnimalFactory)Activator.CreateInstance(type);
26.                 factories.Add(factory);
27.             }
28.         }
30.         foreach (var factory in factories)
31.         {
32.             IAnimal animal = factory.CreateAnimal();
33.             animal.Speak();
34.         }
35.     }
36. }

复制代码

接口与继承联合使用

工厂模式紧张使用了接口、继承，在C#中，接口和继承是面向对象编程的紧张概念。接口定义了一组方法和属性，而继承允许一个类从另一个类继承其成员。接口可以实现多重继承，而类只能继承一个基类。通常情况下，接口和继承可以联合使用，以充实利用它们各自的优点。通过这种方式，基类可以提供一些通用的实现，而接口可以定义特定的举动。

1. // 接口
2. public interface IAnimal
3. {
4.     void Speak();
5.     void Eat();
6. }
8. // 基类
9. public class Animal
10. {
11.     public void Sleep()
12.     {
13.         Console.WriteLine("Sleeping...");
14.     }
15. }
17. // 派生类实现接口
18. public class Dog : Animal, IAnimal
19. {
20.     public void Speak()
21.     {
22.         Console.WriteLine("Woof!");
23.     }
25.     public void Eat()
26.     {
27.         Console.WriteLine("Dog is eating.");
28.     }
29. }
31. public class Cat : Animal, IAnimal
32. {
33.     public void Speak()
34.     {
35.         Console.WriteLine("Meow!");
36.     }
38.     public void Eat()
39.     {
40.         Console.WriteLine("Cat is eating.");
41.     }
42. }
44. // 使用示例
45. class Program
46. {
47.     static void Main(string[] args)
48.     {
49.         IAnimal dog = new Dog();
50.         dog.Speak(); // 输出：Woof!
51.         dog.Eat();   // 输出：Dog is eating.
53.         IAnimal cat = new Cat();
54.         cat.Speak(); // 输出：Meow!
55.         cat.Eat();   // 输出：Cat is eating.
57.         // 使用基类方法
58.         Animal animalDog = (Animal)dog;
59.         animalDog.Sleep(); // 输出：Sleeping...
61.         Animal animalCat = (Animal)cat;
62.         animalCat.Sleep(); // 输出：Sleeping...
63.     }
64. }

复制代码

总结

• 接口：定义了一组必须实现的方法和属性，没有实现代码。支持多重继承，使得类可以实现多个接口。
  
• 继承：用于从现有类创建新类，继承基类的成员。每个类只能有一个基类，但可以实现多个接口。
  
• 联合使用：通过将接口和继承联合使用，可以实现代码的高复用性和机动性。
  

通过上述示例，可以看到怎样使用接口和继承来设计机动且可扩展的应用程序结构。这样既能充实利用基类的通用功能，又能通过接口实现特定的举动。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。