C#设计模式

我要打打代码2025-06-11 11:36

在C#开发中，设计模式是解决常见问题的一种可复用的解决方案。以下是一些常用的C#设计模式：

一、创建型模式

  1. 单例模式（Singleton）

    • 目的：确保一个类只有一个实例，并提供一个全局访问点。

    • 实现方式：通过私有化构造函数和静态字段来控制实例的创建。例如：

      csharp 复制代码 
      public class Singleton
{
    private static Singleton instance;
    private Singleton() { }
    public static Singleton Instance
    {
        get
        {
            if (instance == null)
                instance = new Singleton();
            return instance;
        }
    }
}

    • 适用场景：日志记录器、配置管理器等需要全局唯一实例的场景。

  2. 工厂模式（Factory）

    • 目的：封装对象的创建逻辑，提供统一的接口来创建对象。

    • 实现方式 ：定义一个工厂类，通过工厂方法来创建对象。例如：

      csharp 复制代码 
      public interface IProduct
{
    void Show();
}

public class ConcreteProductA : IProduct
{
    public void Show()
    {
        Console.WriteLine("Product A");
    }
}

public class ConcreteProductB : IProduct
{
    public void Show()
    {
        Console.WriteLine("Product B");
    }
}

public class Factory
{
    public IProduct CreateProduct(string type)
    {
        if (type == "A")
            return new ConcreteProductA();
        else if (type == "B")
            return new ConcreteProductB();
        return null;
    }
}

    • 适用场景：当需要根据不同的条件创建不同类型的对象时。

  3. 抽象工厂模式（Abstract Factory）

    • 目的：创建一组相关或依赖的对象，而无需指定它们的具体类。

    • 实现方式 ：定义一个抽象工厂接口和多个具体工厂类。例如：

      csharp 复制代码 
      public interface IProductA
{
    void Show();
}

public interface IProductB
{
    void Show();
}

public class ConcreteProductA1 : IProductA
{
    public void Show()
    {
        Console.WriteLine("Product A1");
    }
}

public class ConcreteProductB1 : IProductB
{
    public void Show()
    {
        Console.WriteLine("Product B1");
    }
}

public class ConcreteProductA2 : IProductA
{
    public void Show()
    {
        Console.WriteLine("Product A2");
    }
}

public class ConcreteProductB2 : IProductB
{
    public void Show()
    {
        Console.WriteLine("Product B2");
    }
}

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

public class ConcreteFactory1 : IFactory
{
    public IProductA CreateProductA()
    {
        return new ConcreteProductA1();
    }

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

public class ConcreteFactory2 : IFactory
{
    public IProductA CreateProductA()
    {
        return new ConcreteProductA2();
    }

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

    • 适用场景：当需要创建一系列相关的产品对象时。

  4. 建造者模式（Builder）

    • 目的：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

    • 实现方式 ：定义一个建造者接口和多个具体建造者类。例如：

      csharp 复制代码 
      public class Product
{
    private List<string> parts = new List<string>();
    public void Add(string part)
    {
        parts.Add(part);
    }

    public void Show()
    {
        foreach (string part in parts)
        {
            Console.WriteLine(part);
        }
    }
}

public interface IBuilder
{
    void BuildPartA();
    void BuildPartB();
    Product GetResult();
}

public class ConcreteBuilder : IBuilder
{
    private Product product = new Product();

    public void BuildPartA()
    {
        product.Add("PartA");
    }

    public void BuildPartB()
    {
        product.Add("PartB");
    }

    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();
    }
}

    • 适用场景：当需要构建一个复杂的对象时。

  5. 原型模式（Prototype）

    • 目的：通过复制现有的实例来创建新的实例，而不是通过新建实例。

    • 实现方式 ：定义一个原型接口，实现克隆方法。例如：

      csharp 复制代码 
      public interface IPrototype
{
    IPrototype Clone();
}

public class ConcretePrototype : IPrototype
{
    private string field;

    public ConcretePrototype(string field)
    {
        this.field = field;
    }

    public IPrototype Clone()
    {
        return (IPrototype)this.MemberwiseClone();
    }

    public void Show()
    {
        Console.WriteLine(field);
    }
}

    • 适用场景：当需要创建大量相似的对象时。

二、结构型模式

  1. 适配器模式（Adapter）

    • 目的：将一个类的接口转换成客户端所期望的另一种接口。

    • 实现方式 ：定义一个适配器类，实现客户端期望的接口，并在内部封装被适配的类。例如：

      csharp 复制代码 
      public interface ITarget
{
    void Request();
}

public class Adaptee
{
    public void SpecificRequest()
    {
        Console.WriteLine("Adaptee SpecificRequest");
    }
}

public class Adapter : ITarget
{
    private Adaptee adaptee;

    public Adapter()
    {
        adaptee = new Adaptee();
    }

    public void Request()
    {
        adaptee.SpecificRequest();
    }
}

    • 适用场景：当需要使用一个不符合接口要求的类时。

  2. 装饰器模式（Decorator）

    • 目的：动态地给一个对象添加额外的功能。

    • 实现方式 ：定义一个装饰器类，继承被装饰的类，并在内部封装被装饰的对象。例如：

      csharp 复制代码 
      public interface IComponent
{
    void Operation();
}

public class ConcreteComponent : IComponent
{
    public void Operation()
    {
        Console.WriteLine("ConcreteComponent Operation");
    }
}

public abstract class Decorator : IComponent
{
    protected IComponent component;

    public Decorator(IComponent component)
    {
        this.component = component;
    }

    public virtual void Operation()
    {
        component.Operation();
    }
}

public class ConcreteDecoratorA : Decorator
{
    public ConcreteDecoratorA(IComponent component) : base(component) { }

    public override void Operation()
    {
        base.Operation();
        AddedBehavior();
    }

    private void AddedBehavior()
    {
        Console.WriteLine("ConcreteDecoratorA AddedBehavior");
    }
}

public class ConcreteDecoratorB : Decorator
{
    public ConcreteDecoratorB(IComponent component) : base(component) { }

    public override void Operation()
    {
        base.Operation();
        AddedBehavior();
    }

    private void AddedBehavior()
    {
        Console.WriteLine("ConcreteDecoratorB AddedBehavior");
    }
}

    • 适用场景：当需要动态地给对象添加功能时。

  3. 代理模式（Proxy）

    • 目的：为其他对象提供一种代理以控制对这个对象的访问。

    • 实现方式 ：定义一个代理类，实现与被代理类相同的接口，并在内部封装被代理的对象。例如：

      csharp 复制代码 
      public interface ISubject
{
    void Request();
}

public class RealSubject : ISubject
{
    public void Request()
    {
        Console.WriteLine("RealSubject Request");
    }
}

public class Proxy : ISubject
{
    private RealSubject realSubject;

    public void Request()
    {
        if (realSubject == null)
        {
            realSubject = new RealSubject();
        }
        PreRequest();
        realSubject.Request();
        PostRequest();
    }

    private void PreRequest()
    {
        Console.WriteLine("Proxy PreRequest");
    }

    private void PostRequest()
    {
        Console.WriteLine("Proxy PostRequest");
    }
}

    • 适用场景：当需要控制对对象的访问时。

  4. 外观模式（Facade）

    • 目的：为复杂的子系统提供一个简单的接口。

    • 实现方式 ：定义一个外观类，封装子系统的复杂逻辑。例如：

      csharp 复制代码 
      public class SubSystemA
{
    public void OperationA()
    {
        Console.WriteLine("SubSystemA OperationA");
    }
相关推荐
Rose 使者1 小时前
全国天气预报查询接口如何用C#进行调用？
c#·api·天气预报
夕泠爱吃糖2 小时前
Linux 文件内容的查询与统计
android·linux·c#
小码编匠2 小时前
WinForm 工业自动化上位机通用框架：注册登录及主界面切换实现
后端·c#·.net
码小跳2 小时前
Halcon案例(三):C#联合Halcon识别排线
计算机视觉·c#·halcon
l1o3v1e4ding2 小时前
python-docx 库教程
开发语言·python·c#
m0_516484673 小时前
C#winform多选框代码
开发语言·c#
电子科技圈3 小时前
IAR开发平台升级Arm和RISC-V开发工具链，加速现代嵌入式系统开发
arm开发·嵌入式硬件·设计模式·性能优化·软件工程·代码规范·risc-v
I'mSQL3 小时前
Visual Studio 2022打包程序流程
ide·c#·自动化·.net·visual studio
昕冉4 小时前
利用 Axrue9 中继器实现表格数据的查询
设计模式·设计
热门推荐
01Coze扣子平台完整体验和实践（附国内和国际版对比）02【图像处理与机器视觉】XJTU期末考点03KGG转MP3工具|非KGM文件|解密音频04DeepSeek各版本说明与优缺点分析05从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑06YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】07海康Visionmaster-常见问题排查方法-启动阶段08R-tree详解09【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！10零代码入门 | Coze——让大模型接入自己的数据库