C# 泛型编程和常见设计模式

最新推荐文章于 2024-08-11 10:29:56 发布

hhhhhhahhhh.....

最新推荐文章于 2024-08-11 10:29:56 发布

阅读量472

点赞数 14

文章标签： c# 设计模式 java

本文链接：https://blog.csdn.net/Lsss123aa/article/details/135284069

版权

泛型编程和设计模式是 C# 中提高代码灵活性、可维护性和可扩展性的关键技术。在这篇文章中，我们将深入探讨泛型编程的基础知识，以及一些常见的设计模式在 C# 中的应用。

1. 泛型编程基础

1.1 什么是泛型？

泛型是一种在编写通用代码时提供类型安全的方式。通过泛型，可以编写具有通用性的类、方法和数据结构，而不需要在编译时指定具体的数据类型。

1.1.1 泛型方法和泛型类

// 泛型方法
public T GetMax<T>(T a, T b) where T : IComparable<T>
{
    return a.CompareTo(b) > 0 ? a : b;
}

// 泛型类
public class Box<T>
{
    public T Value { get; set; }
}

1.2 泛型集合

泛型集合提供了类型安全的集合操作，相对于非泛型集合，它避免了装箱和拆箱的性能损耗。

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
Dictionary<string, int> keyValuePairs = new Dictionary<string, int>();

2. 常见设计模式

2.1 单例模式

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

public class Singleton
{
    private static Singleton instance;

    private Singleton() { }

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

2.2 工厂模式

通过工厂类创建对象，而不是直接使用构造函数。

public interface IProduct
{
    void Display();
}

public class ConcreteProductA : IProduct
{
    public void Display() { /* Implementation for ProductA */ }
}

public class ConcreteProductB : IProduct
{
    public void Display() { /* Implementation for ProductB */ }
}

public interface IFactory
{
    IProduct CreateProduct();
}

public class ConcreteFactoryA : IFactory
{
    public IProduct CreateProduct()
    {
        return new ConcreteProductA();
    }
}

public class ConcreteFactoryB : IFactory
{
    public IProduct CreateProduct()
    {
        return new ConcreteProductB();
    }
}

2.3 观察者模式

定义一种一对多的依赖关系，使得当一个对象的状态发生改变时，所有依赖它的对象都会得到通知并被自动更新。

public interface IObserver
{
    void Update();
}

public class ConcreteObserver : IObserver
{
    public void Update() { /* Implementation of update */ }
}

public interface ISubject
{
    void Attach(IObserver observer);
    void Detach(IObserver observer);
    void Notify();
}

public class ConcreteSubject : ISubject
{
    private List<IObserver> observers = new List<IObserver>();

    public void Attach(IObserver observer)
    {
        observers.Add(observer);
    }

    public void Detach(IObserver observer)
    {
        observers.Remove(observer);
    }

    public void Notify()
    {
        foreach (var observer in observers)
        {
            observer.Update();
        }
    }
}

2.4 策略模式

定义一系列算法，将每个算法封装起来，并使它们可以互换。

public interface IStrategy
{
    void Execute();
}

public class ConcreteStrategyA : IStrategy
{
    public void Execute() { /* Implementation of Strategy A */ }
}

public class ConcreteStrategyB : IStrategy
{
    public void Execute() { /* Implementation of Strategy B */ }
}

public class Context
{
    private IStrategy strategy;

    public Context(IStrategy strategy)
    {
        this.strategy = strategy;
    }

    public void SetStrategy(IStrategy strategy)
    {
        this.strategy = strategy;
    }

    public void ExecuteStrategy()
    {
        strategy.Execute();
    }
}

2.5 装饰器模式

动态地给一个对象添加一些额外的职责，就增加功能来说，装饰器模式比生成子类更为灵活。

public interface IComponent
{
    void Operation();
}

public class ConcreteComponent : IComponent
{
    public void Operation() { /* Implementation of Operation */ }
}

public 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();
        // Additional operation for ConcreteDecoratorA
    }
}

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

    public override void Operation()
    {
        base.Operation();
        // Additional operation for ConcreteDecoratorB
    }
}

3. 实际应用示例

3.1 使用泛型编写通用库

public class GenericList<T>
{
    private List<T> items = new List<T>();

    public void Add(T item)
    {
        items.Add(item);
    }

    public T Get(int index)
    {
        return items[index];
    }
}