创造型设计模式：单例、原型、三大工厂、建造者
在软件开发中，设计模式是解决常见问题的经典解决方案。创造性设计模式主要关注对象的创建机制，确保系统在创建对象时具有灵活性和可扩展性。本文将介绍几种常见的创造型设计模式，包括单例模式、原型模式、三大工厂模式（简单工厂、工厂方法、抽象工厂）以及建造者模式。
1. 单例模式（Singleton Pattern）
单例模式确保一个类只有一个实例，并提供一个全局访问点。这在需要控制资源访问或共享资源时非常有用。
示例代码
public class Singleton
{private static Singleton _instance;// 私有构造函数，防止外部实例化private Singleton() { }public static Singleton Instance{get{if (_instance == null){_instance = new Singleton();}return _instance;}}public void DoSomething(){Console.WriteLine("Singleton is doing something.");}
}// 使用单例
class Program
{static void Main(string[] args){Singleton singleton = Singleton.Instance;singleton.DoSomething();}
}
2. 原型模式（Prototype Pattern）
原型模式通过复制现有对象来创建新对象，而不是通过实例化类。这在创建成本较高的对象时非常有用。
示例代码
public abstract class Prototype
{public abstract Prototype Clone();
}public class ConcretePrototype : Prototype
{public int Id { get; set; }public override Prototype Clone(){return (Prototype)this.MemberwiseClone();}
}// 使用原型
class Program
{static void Main(string[] args){ConcretePrototype prototype = new ConcretePrototype { Id = 1 };ConcretePrototype clone = (ConcretePrototype)prototype.Clone();Console.WriteLine($"Original ID: {prototype.Id}");Console.WriteLine($"Clone ID: {clone.Id}");}
}
3. 三大工厂模式
3.1 简单工厂模式（Simple Factory Pattern）
简单工厂模式通过一个工厂类来创建对象，而不是直接在客户端代码中实例化对象。
示例代码
public interface IProduct
{void Use();
}public class ConcreteProductA : IProduct
{public void Use(){Console.WriteLine("Using Product A");}
}public class ConcreteProductB : IProduct
{public void Use(){Console.WriteLine("Using Product B");}
}public class SimpleFactory
{public static IProduct CreateProduct(string type){switch (type){case "A":return new ConcreteProductA();case "B":return new ConcreteProductB();default:throw new ArgumentException("Invalid product type");}}
}// 使用简单工厂
class Program
{static void Main(string[] args){IProduct productA = SimpleFactory.CreateProduct("A");productA.Use();IProduct productB = SimpleFactory.CreateProduct("B");productB.Use();}
}
3.2 工厂方法模式（Factory Method Pattern）
工厂方法模式定义了一个创建对象的接口，但由子类决定实例化哪个类。
示例代码
public interface IProduct
{void Use();
}public class ConcreteProductA : IProduct
{public void Use(){Console.WriteLine("Using Product A");}
}public class ConcreteProductB : IProduct
{public void Use(){Console.WriteLine("Using Product B");}
}public abstract class Creator
{public abstract IProduct FactoryMethod();
}public class ConcreteCreatorA : Creator
{public override IProduct FactoryMethod(){return new ConcreteProductA();}
}public class ConcreteCreatorB : Creator
{public override IProduct FactoryMethod(){return new ConcreteProductB();}
}// 使用工厂方法
class Program
{static void Main(string[] args){Creator creatorA = new ConcreteCreatorA();IProduct productA = creatorA.FactoryMethod();productA.Use();Creator creatorB = new ConcreteCreatorB();IProduct productB = creatorB.FactoryMethod();productB.Use();}
}
3.3 抽象工厂模式（Abstract Factory Pattern）
抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
示例代码
public interface IProductA
{void Use();
}public interface IProductB
{void Use();
}public class ConcreteProductA1 : IProductA
{public void Use(){Console.WriteLine("Using Product A1");}
}public class ConcreteProductA2 : IProductA
{public void Use(){Console.WriteLine("Using Product A2");}
}public class ConcreteProductB1 : IProductB
{public void Use(){Console.WriteLine("Using Product B1");}
}public class ConcreteProductB2 : IProductB
{public void Use(){Console.WriteLine("Using Product B2");}
}public interface IAbstractFactory
{IProductA CreateProductA();IProductB CreateProductB();
}public class ConcreteFactory1 : IAbstractFactory
{public IProductA CreateProductA(){return new ConcreteProductA1();}public IProductB CreateProductB(){return new ConcreteProductB1();}
}public class ConcreteFactory2 : IAbstractFactory
{public IProductA CreateProductA(){return new ConcreteProductA2();}public IProductB CreateProductB(){return new ConcreteProductB2();}
}// 使用抽象工厂
class Program
{static void Main(string[] args){IAbstractFactory factory1 = new ConcreteFactory1();IProductA productA1 = factory1.CreateProductA();IProductB productB1 = factory1.CreateProductB();productA1.Use();productB1.Use();IAbstractFactory factory2 = new ConcreteFactory2();IProductA productA2 = factory2.CreateProductA();IProductB productB2 = factory2.CreateProductB();productA2.Use();productB2.Use();}
}
4. 建造者模式（Builder Pattern）
建造者模式将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。
示例代码
public class Product
{public string PartA { get; set; }public string PartB { get; set; }public string PartC { get; set; }public void Show(){Console.WriteLine($"PartA: {PartA}, PartB: {PartB}, PartC: {PartC}");}
}public interface IBuilder
{void BuildPartA();void BuildPartB();void BuildPartC();Product GetResult();
}public class ConcreteBuilder : IBuilder
{private Product _product = new Product();public void BuildPartA(){_product.PartA = "Part A";}public void BuildPartB(){_product.PartB = "Part B";}public void BuildPartC(){_product.PartC = "Part C";}public Product GetResult(){return _product;}
}public class Director
{private IBuilder _builder;public Director(IBuilder builder){_builder = builder;}public void Construct(){_builder.BuildPartA();_builder.BuildPartB();_builder.BuildPartC();}
}// 使用建造者模式
class Program
{static void Main(string[] args){IBuilder builder = new ConcreteBuilder();Director director = new Director(builder);director.Construct();Product product = builder.GetResult();product.Show();}
}
总结
创造性设计模式提供了多种灵活的对象创建方式，帮助我们在不同的场景下更好地管理对象的创建过程。单例模式确保全局唯一实例，原型模式通过复制对象来创建新对象，三大工厂模式（简单工厂、工厂方法、抽象工厂）提供了不同层次的抽象来创建对象，而建造者模式则将复杂对象的构建过程分离出来。通过合理使用这些设计模式，我们可以提高代码的可维护性和可扩展性。