创造型设计模式

创造型设计模式：单例、原型、三大工厂、建造者

在软件开辟中，设计模式是办理常见问题的经典办理方案。创造性设计模式主要关注对象的创建机制，确保系统在创建对象时具有灵活性和可扩展性。本文将介绍几种常见的创造型设计模式，包括单例模式、原型模式、三大工厂模式（简单工厂、工厂方法、抽象工厂）以及建造者模式。
1. 单例模式（Singleton Pattern）

单例模式确保一个类只有一个实例，并提供一个全局访问点。这在需要控制资源访问或共享资源时非常有效。
示例代码

1. public class Singleton
2. {
3.     private static Singleton _instance;
5.     // 私有构造函数，防止外部实例化
6.     private Singleton() { }
8.     public static Singleton Instance
9.     {
10.         get
11.         {
12.             if (_instance == null)
13.             {
14.                 _instance = new Singleton();
15.             }
16.             return _instance;
17.         }
18.     }
20.     public void DoSomething()
21.     {
22.         Console.WriteLine("Singleton is doing something.");
23.     }
24. }
26. // 使用单例
27. class Program
28. {
29.     static void Main(string[] args)
30.     {
31.         Singleton singleton = Singleton.Instance;
32.         singleton.DoSomething();
33.     }
34. }

复制代码

2. 原型模式（Prototype Pattern）

原型模式通过复制现有对象来创建新对象，而不是通过实例化类。这在创建成本较高的对象时非常有效。
示例代码

1. public abstract class Prototype
2. {
3.     public abstract Prototype Clone();
4. }
6. public class ConcretePrototype : Prototype
7. {
8.     public int Id { get; set; }
10.     public override Prototype Clone()
11.     {
12.         return (Prototype)this.MemberwiseClone();
13.     }
14. }
16. // 使用原型
17. class Program
18. {
19.     static void Main(string[] args)
20.     {
21.         ConcretePrototype prototype = new ConcretePrototype { Id = 1 };
22.         ConcretePrototype clone = (ConcretePrototype)prototype.Clone();
24.         Console.WriteLine($"Original ID: {prototype.Id}");
25.         Console.WriteLine($"Clone ID: {clone.Id}");
26.     }
27. }

复制代码

3. 三大工厂模式

3.1 简单工厂模式（Simple Factory Pattern）

简单工厂模式通过一个工厂类来创建对象，而不是直接在客户端代码中实例化对象。
示例代码

1. public interface IProduct
2. {
3.     void Use();
4. }
6. public class ConcreteProductA : IProduct
7. {
8.     public void Use()
9.     {
10.         Console.WriteLine("Using Product A");
11.     }
12. }
14. public class ConcreteProductB : IProduct
15. {
16.     public void Use()
17.     {
18.         Console.WriteLine("Using Product B");
19.     }
20. }
22. public class SimpleFactory
23. {
24.     public static IProduct CreateProduct(string type)
25.     {
26.         switch (type)
27.         {
28.             case "A":
29.                 return new ConcreteProductA();
30.             case "B":
31.                 return new ConcreteProductB();
32.             default:
33.                 throw new ArgumentException("Invalid product type");
34.         }
35.     }
36. }
38. // 使用简单工厂
39. class Program
40. {
41.     static void Main(string[] args)
42.     {
43.         IProduct productA = SimpleFactory.CreateProduct("A");
44.         productA.Use();
46.         IProduct productB = SimpleFactory.CreateProduct("B");
47.         productB.Use();
48.     }
49. }

复制代码

3.2 工厂方法模式（Factory Method Pattern）

工厂方法模式定义了一个创建对象的接口，但由子类决定实例化哪个类。
示例代码

1. public interface IProduct
2. {
3.     void Use();
4. }
6. public class ConcreteProductA : IProduct
7. {
8.     public void Use()
9.     {
10.         Console.WriteLine("Using Product A");
11.     }
12. }
14. public class ConcreteProductB : IProduct
15. {
16.     public void Use()
17.     {
18.         Console.WriteLine("Using Product B");
19.     }
20. }
22. public abstract class Creator
23. {
24.     public abstract IProduct FactoryMethod();
25. }
27. public class ConcreteCreatorA : Creator
28. {
29.     public override IProduct FactoryMethod()
30.     {
31.         return new ConcreteProductA();
32.     }
33. }
35. public class ConcreteCreatorB : Creator
36. {
37.     public override IProduct FactoryMethod()
38.     {
39.         return new ConcreteProductB();
40.     }
41. }
43. // 使用工厂方法
44. class Program
45. {
46.     static void Main(string[] args)
47.     {
48.         Creator creatorA = new ConcreteCreatorA();
49.         IProduct productA = creatorA.FactoryMethod();
50.         productA.Use();
52.         Creator creatorB = new ConcreteCreatorB();
53.         IProduct productB = creatorB.FactoryMethod();
54.         productB.Use();
55.     }
56. }

复制代码

3.3 抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们详细的类。
示例代码

1. public interface IProductA
2. {
3.     void Use();
4. }
6. public interface IProductB
7. {
8.     void Use();
9. }
11. public class ConcreteProductA1 : IProductA
12. {
13.     public void Use()
14.     {
15.         Console.WriteLine("Using Product A1");
16.     }
17. }
19. public class ConcreteProductA2 : IProductA
20. {
21.     public void Use()
22.     {
23.         Console.WriteLine("Using Product A2");
24.     }
25. }
27. public class ConcreteProductB1 : IProductB
28. {
29.     public void Use()
30.     {
31.         Console.WriteLine("Using Product B1");
32.     }
33. }
35. public class ConcreteProductB2 : IProductB
36. {
37.     public void Use()
38.     {
39.         Console.WriteLine("Using Product B2");
40.     }
41. }
43. public interface IAbstractFactory
44. {
45.     IProductA CreateProductA();
46.     IProductB CreateProductB();
47. }
49. public class ConcreteFactory1 : IAbstractFactory
50. {
51.     public IProductA CreateProductA()
52.     {
53.         return new ConcreteProductA1();
54.     }
56.     public IProductB CreateProductB()
57.     {
58.         return new ConcreteProductB1();
59.     }
60. }
62. public class ConcreteFactory2 : IAbstractFactory
63. {
64.     public IProductA CreateProductA()
65.     {
66.         return new ConcreteProductA2();
67.     }
69.     public IProductB CreateProductB()
70.     {
71.         return new ConcreteProductB2();
72.     }
73. }
75. // 使用抽象工厂
76. class Program
77. {
78.     static void Main(string[] args)
79.     {
80.         IAbstractFactory factory1 = new ConcreteFactory1();
81.         IProductA productA1 = factory1.CreateProductA();
82.         IProductB productB1 = factory1.CreateProductB();
83.         productA1.Use();
84.         productB1.Use();
86.         IAbstractFactory factory2 = new ConcreteFactory2();
87.         IProductA productA2 = factory2.CreateProductA();
88.         IProductB productB2 = factory2.CreateProductB();
89.         productA2.Use();
90.         productB2.Use();
91.     }
92. }

复制代码

4. 建造者模式（Builder Pattern）

建造者模式将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。
示例代码

1. public class Product
2. {
3.     public string PartA { get; set; }
4.     public string PartB { get; set; }
5.     public string PartC { get; set; }
7.     public void Show()
8.     {
9.         Console.WriteLine($"PartA: {PartA}, PartB: {PartB}, PartC: {PartC}");
10.     }
11. }
13. public interface IBuilder
14. {
15.     void BuildPartA();
16.     void BuildPartB();
17.     void BuildPartC();
18.     Product GetResult();
19. }
21. public class ConcreteBuilder : IBuilder
22. {
23.     private Product _product = new Product();
25.     public void BuildPartA()
26.     {
27.         _product.PartA = "Part A";
28.     }
30.     public void BuildPartB()
31.     {
32.         _product.PartB = "Part B";
33.     }
35.     public void BuildPartC()
36.     {
37.         _product.PartC = "Part C";
38.     }
40.     public Product GetResult()
41.     {
42.         return _product;
43.     }
44. }
46. public class Director
47. {
48.     private IBuilder _builder;
50.     public Director(IBuilder builder)
51.     {
52.         _builder = builder;
53.     }
55.     public void Construct()
56.     {
57.         _builder.BuildPartA();
58.         _builder.BuildPartB();
59.         _builder.BuildPartC();
60.     }
61. }
63. // 使用建造者模式
64. class Program
65. {
66.     static void Main(string[] args)
67.     {
68.         IBuilder builder = new ConcreteBuilder();
69.         Director director = new Director(builder);
70.         director.Construct();
72.         Product product = builder.GetResult();
73.         product.Show();
74.     }
75. }

复制代码

总结

创造性设计模式提供了多种灵活的对象创建方式，资助我们在不同的场景下更好地管理对象的创建过程。单例模式确保全局唯一实例，原型模式通过复制对象来创建新对象，三大工厂模式（简单工厂、工厂方法、抽象工厂）提供了不同层次的抽象来创建对象，而建造者模式则将复杂对象的构建过程分离出来。通过合理使用这些设计模式，我们可以提高代码的可维护性和可扩展性。

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