C#常见的设计模式-创建型模式

引言

在软件开发过程中，设计模式是一种被广泛采用的思想和实践，可以提供一种标准化的解决方案，以解决特定问题。设计模式分为三种类型：创建型模式、结构型模式和行为型模式。本篇文章将重点介绍C#中常见的创建型模式。

---

---

创建型模式的作用

创建型模式主要关注对象的创建过程，并提供一种机制来创建对象，以使代码更加灵活、可维护和可扩展。创建型模式可以帮助我们降低系统的耦合度，使系统更具弹性，并且促进面向对象的设计原则的实施。

---

常见的创建型模式

1. 简单工厂模式 (Simple Factory Pattern)

简单工厂模式通过一个类来封装对象的创建过程，根据不同的条件返回不同的对象。在C#中，我们可以通过使用静态方法或者工厂类来实现简单工厂模式。

public class SimpleFactory
{
    public static IProduct CreateProduct(string type)
    {
        switch (type)
        {
            case "A":
                return new ProductA();
            case "B":
                return new ProductB();
            default:
                throw new ArgumentException("Invalid type");
        }
    }
}

public interface IProduct
{
    void DoSomething();
}

public class ProductA : IProduct
{
    public void DoSomething()
    {
        Console.WriteLine("ProductA does something.");
    }
}

public class ProductB : IProduct
{
    public void DoSomething()
    {
        Console.WriteLine("ProductB does something.");
    }
}

public class Client
{
    public void Main()
    {
        IProduct product = SimpleFactory.CreateProduct("A");
        product.DoSomething();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

2. 工厂方法模式 (Factory Method Pattern)

工厂方法模式将对象的创建延迟到子类中进行，每个子类都负责创建自己的对象。这样可以通过使用多态性来实现在运行时动态地选择合适的对象。

public interface IProductFactory
{
    IProduct CreateProduct();
}

public interface IProduct
{
    void DoSomething();
}

public class ProductAFactory : IProductFactory
{
    public IProduct CreateProduct()
    {
        return new ProductA();
    }
}

public class ProductBFactory : IProductFactory
{
    public IProduct CreateProduct()
    {
        return new ProductB();
    }
}

public class ProductA : IProduct
{
    public void DoSomething()
    {
        Console.WriteLine("ProductA does something.");
    }
}

public class ProductB : IProduct
{
    public void DoSomething()
    {
        Console.WriteLine("ProductB does something.");
    }
}

public class Client
{
    public void Main(IProductFactory factory)
    {
        IProduct product = factory.CreateProduct();
        product.DoSomething();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

3. 抽象工厂模式 (Abstract Factory Pattern)

抽象工厂模式提供了一个接口来创建一系列相互依赖或者有关联的对象，而不用指定他们具体的类。在C#中，我们可以通过使用抽象类或者接口来实现抽象工厂模式。

public interface IAbstractFactory
{
    IProductA CreateProductA();
    IProductB CreateProductB();
}

public interface IProductA
{
    void DoSomething();
}

public interface IProductB
{
    void DoSomething();
}

public class ConcreteFactory1 : IAbstractFactory
{
    public IProductA CreateProductA()
    {
        return new ProductA1();
    }

    public IProductB CreateProductB()
    {
        return new ProductB1();
    }
}

public class ConcreteFactory2 : IAbstractFactory
{
    public IProductA CreateProductA()
    {
        return new ProductA2();
    }

    public IProductB CreateProductB()
    {
        return new ProductB2();
    }
}

public class ProductA1 : IProductA
{
    public void DoSomething()
    {
        Console.WriteLine("ProductA1 does something.");
    }
}

public class ProductB1 : IProductB
{
    public void DoSomething()
    {
        Console.WriteLine("ProductB1 does something.");
    }
}

public class ProductA2 : IProductA
{
    public void DoSomething()
    {
        Console.WriteLine("ProductA2 does something.");
    }
}

public class ProductB2 : IProductB
{
    public void DoSomething()
    {
        Console.WriteLine("ProductB2 does something.");
    }
}

public class Client
{
    public void Main(IAbstractFactory factory)
    {
        IProductA productA = factory.CreateProductA();
        IProductB productB = factory.CreateProductB();
        
        productA.DoSomething();
        productB.DoSomething();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

4. 单例模式 (Singleton Pattern)

单例模式保证一个类只有一个实例，并提供一个全局访问点来访问该实例。在C#中，可以通过使用静态变量或者静态属性来实现单例模式。

public sealed class Singleton
{
    private static Singleton instance;
    private static readonly object lockObject = new object();

    private Singleton() { }

    public static Singleton Instance
    {
        get
        {
            if (instance == null)
            {
                lock (lockObject)
                {
                    if (instance == null)
                    {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }
}

public class Client
{
    public void Main()
    {
        Singleton singleton = Singleton.Instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

5. 原型模式 (Prototype Pattern)

原型模式使用原型来创建对象，通过复制现有的对象来创建新的对象。在C#中，可以通过实现ICloneable接口来实现原型模式。

public abstract class Prototype : ICloneable
{
    public abstract object Clone();
}

public class ConcretePrototypeA : Prototype
{
    public override object Clone()
    {
        return (ConcretePrototypeA)this.MemberwiseClone();
    }
}

public class ConcretePrototypeB : Prototype
{
    public override object Clone()
    {
        return (ConcretePrototypeB)this.MemberwiseClone();
    }
}

public class Client
{
    public void Main()
    {
        Prototype prototypeA = new ConcretePrototypeA();
        Prototype prototypeB = new ConcretePrototypeB();

        Prototype cloneA = (Prototype)prototypeA.Clone();
        Prototype cloneB = (Prototype)prototypeB.Clone();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

6. 建造者模式 (Builder Pattern)

建造者模式将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。在C#中，可以通过使用链式调用或者指导者来实现建造者模式。

public class Product
{
    private string part1;
    private string part2;
    private string part3;

    public string Part1 { get { return part1; } }
    public string Part2 { get { return part2; } }
    public string Part3 { get { return part3; } }

    public Product(string part1, string part2, string part3)
    {
        this.part1 = part1;
        this.part2 = part2;
        this.part3 = part3;
    }
}

public interface IBuilder
{
    void BuildPart1(string value);
    void BuildPart2(string value);
    void BuildPart3(string value);
    Product GetResult();
}

public class ConcreteBuilder : IBuilder
{
    private string part1;
    private string part2;
    private string part3;

    public void BuildPart1(string value)
    {
        part1 = value;
    }

    public void BuildPart2(string value)
    {
        part2 = value;
    }

    public void BuildPart3(string value)
    {
        part3 = value;
    }

    public Product GetResult()
    {
        return new Product(part1, part2, part3);
    }
}

public class Director
{
    public Product Construct(IBuilder builder)
    {
        builder.BuildPart1("Part1");
        builder.BuildPart2("Part2");
        builder.BuildPart3("Part3");

        return builder.GetResult();
    }
}

public class Client
{
    public void Main()
    {
        IBuilder builder = new ConcreteBuilder();
        Director director = new Director();

        Product product = director.Construct(builder);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

---

总结

创建型模式是软件设计中的重要概念，可以帮助我们更好地组织和管理对象的创建过程。本篇文章介绍了C#中常见的创建型模式，包括简单工厂模式、工厂方法模式、抽象工厂模式、单例模式、原型模式和建造者模式。通过熟悉和灵活应用这些模式，我们可以写出更加可维护、可扩展和可测试的代码。

参考文献：

• Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides