工厂方法模式(Factory Method Pattern)
工厂方法模式是一种创建型设计模式,它定义了一个用于创建对象的接口,但由子类决定要实例化的类是哪一个。工厂方法把对象的实例化推迟到子类。
代码示例:
csharpCopy codepublic interface IProduct
{
void Operation();
}
public class ProductA : IProduct
{
public void Operation()
{
Console.WriteLine("Product A operation");
}
}
public class ProductB : IProduct
{
public void Operation()
{
Console.WriteLine("Product B operation");
}
}
public abstract class Creator
{
public abstract IProduct FactoryMethod();
}
public class ConcreteCreatorA : Creator
{
public override IProduct FactoryMethod()
{
return new ProductA();
}
}
public class ConcreteCreatorB : Creator
{
public override IProduct FactoryMethod()
{
return new ProductB();
}
}
抽象工厂模式(Abstract Factory Pattern)
抽象工厂模式是一种创建型设计模式,它提供一个接口,用于创建相关或依赖对象的家族,而不需要指定具体类。
代码示例:
csharpCopy codepublic interface IProductA
{
void OperationA();
}
public interface IProductB
{
void OperationB();
}
public class ProductA1 : IProductA
{
public void OperationA()
{
Console.WriteLine("Product A1 operation");
}
}
public class ProductA2 : IProductA
{
public void OperationA()
{
Console.WriteLine("Product A2 operation");
}
}
public class ProductB1 : IProductB
{
public void OperationB()
{
Console.WriteLine("Product B1 operation");
}
}
public class ProductB2 : IProductB
{
public void OperationB()
{
Console.WriteLine("Product B2 operation");
}
}
public interface IAbstractFactory
{
IProductA CreateProductA();
IProductB CreateProductB();
}
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();
}
}
单例模式(Singleton Pattern)
单例模式是一种创建型设计模式,它确保一个类只有一个实例,并提供全局访问点。
代码示例:
csharpCopy codepublic sealed class Singleton
{
private static Singleton instance = null;
private Singleton() { }
public static Singleton Instance
{
get
{
if (instance == null)
{
instance = new Singleton();
}
return instance;
}
}
}
建造者模式(Builder Pattern)
建造者模式是一种创建型设计模式,它可以将一个复杂对象的构建过程和它的表示分离,使得同样的构建过程可以创建不同的表示。
代码示例:
csharpCopy codepublic class Product
{
public string PartA { get; set; }
public string PartB { get; set; }
public string PartC { get; set; }
public override string ToString()
{
return $"{PartA}, {PartB}, {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)
{
this.builder = builder;
}
public void Construct()
{
builder.BuildPartA();
builder.BuildPartB();
builder.BuildPartC();
}
}
原型模式(Prototype Pattern)
原型模式是一种创建型设计模式,它允许通过复制现有对象来创建新对象,而不是通过实例化的方式。
代码示例:
csharpCopy codepublic class Prototype : ICloneable
{
public string Value { get; set; }
public object Clone()
{
return MemberwiseClone();
}
}
适配器模式(Adapter Pattern)
适配器模式是一种结构型设计模式,它可以将一种类的接口转换成客户端希望的另一种接口。适配器模式允许接口不兼容的类能够合作。
代码示例:
csharpCopy codepublic interface ITarget
{
void Request();
}
public class Adaptee
{
public void SpecificRequest()
{
Console.WriteLine("Adaptee specific request");
}
}
public class Adapter : ITarget
{
private readonly Adaptee adaptee;
public Adapter(Adaptee adaptee)
{
this.adaptee = adaptee;
}
public void Request()
{
adaptee.SpecificRequest();
}
}
桥接模式(Bridge Pattern)
桥接模式是一种结构型设计模式,它可以将一个大类或一系列紧密相关的类拆分为抽象和实现两个独立的层次结构,从而能在开发时分别使用。
代码示例:
csharpCopy codepublic interface IImplementor
{
void OperationImp();
}
public class ConcreteImplementorA : IImplementor
{
public void OperationImp()
{
Console.WriteLine("ConcreteImplementorA OperationImp");
}
}
public class ConcreteImplementorB : IImplementor
{
public void OperationImp()
{
Console.WriteLine("ConcreteImplementorB OperationImp");
}
}
public abstract class Abstraction
{
protected IImplementor implementor;
protected Abstraction(IImplementor implementor)
{
this.implementor = implementor;
}
public abstract void Operation();
}
public class RefinedAbstraction : Abstraction
{
public RefinedAbstraction(IImplementor implementor) : base(implementor)
{
}
public override void Operation()
{
implementor.OperationImp();
}
}