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");
    }
相关推荐
workflower12 小时前
人形机器人灵巧手产业链
人工智能·设计模式·机器人·云计算·无人机
Java后端的Ai之路13 小时前
03、Python - 抽象工厂模式
开发语言·python·设计模式·抽象工厂模式·通用智慧
格林威15 小时前
C# 相机Burst模式图像采集：使用相机内存配合OpenCvSharp和Halcon实现短时间的高速采集的方法
开发语言·人工智能·数码相机·计算机视觉·c#·视觉检测·工业相机
J总裁的小芒果16 小时前
参数过多-分批传参
c#
典典分享指南17 小时前
短视频分镜提示词：让 AI 出片的产品口播
java·c#·bash·composer·symfony
Z59981784118 小时前
c#软件开发学习笔记--WPF(Canvas、数据绑定、MVVM模式、值转换器)
笔记·学习·c#
AI人工智能+电脑小能手18 小时前
大白话说Java设计模式-45-解释器模式（源码剖析篇）
java·设计模式·解释器模式·源码分析·pattern·spel·javacc
淡海水19 小时前
05-03-栈队列-PriorityQueue-TElement-TPriority-NET6优先队列语义与四叉堆实现
服务器·前端·c#·priorityqueue·clr·telement
码匠许师傅1 天前
【设计模式精讲】4.单例模式（Singleton）
c++·单例模式·设计模式
雾削木1 天前
2026 编程领域热点知识速览：AI 辅助开发、设计模式实战与嵌入式高效迭代
人工智能·设计模式
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02GitHub 镜像站点03ZCode 周末送额度活动开启：3 亿 Token 免费领取042026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？05历年考研数学一、数学二、数学三真题试卷及答案PDF06微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新07蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接08Agnes AI 免费 API 接入指南：文本、生图、生视频，一套接口全免费09AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路10VSCode+CodeX扩展，无法启动