设计模式是在软件开发中经常使用的最佳实践，用于解决在软件设计中经常遇到的问题。它们提供了可重用的设计，使得代码更加灵活、可维护和可扩展。下面我将为你讲解几种常见的设计模式，并提供相应的C#代码示例。

 

1. 单例模式（Singleton Pattern）

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

public class Singleton

{

    private static Singleton _instance;

    private static readonly object _lock = new object();

 

    private Singleton() { } // 私有构造函数，防止外部直接实例化

 

    public static Singleton Instance

    {

        get

        {

            lock (_lock)

            {

                if (_instance == null)

                {

                    _instance = new Singleton();

                }

            }

            return _instance;

        }

    }

}

 

2. 工厂模式（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 ProductFactory

{

    public IProduct CreateProduct(string type)

    {

        if (type == "A")

        {

            return new ConcreteProductA();

        }

        else if (type == "B")

        {

            return new ConcreteProductB();

        }

        else

        {

            throw new ArgumentException("Invalid product type");

        }

    }

}

 

3. 观察者模式（Observer Pattern）

定义对象之间的一对多依赖关系，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。

public interface IObserver

{

    void Update(string message);

}

 

public class ConcreteObserver : IObserver

{

    public void Update(string message)

    {

        Console.WriteLine($"Observer received: {message}");

    }

}

 

public class Subject

{

    private List<IObserver> _observers = new List<IObserver>();

    private string _state;

 

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

        }

    }

 

    public void SetState(string state)

    {

        _state = state;

        Notify();

    }

}

 

4. 策略模式（Strategy Pattern）

定义一系列的算法，并将每一个算法封装起来，使它们可以互相替换。策略模式使得算法可以独立于使用它的客户变化。

public interface ISortingStrategy

{

    void Sort(List<int> numbers);

}

 

public class BubbleSortStrategy : ISortingStrategy

{

    public void Sort(List<int> numbers)

    {

        // Bubble sort implementation

    }

}

 

public class QuickSortStrategy : ISortingStrategy

{

    public void Sort(List<int> numbers)

    {

        // Quick sort implementation

    }

}

 

public class Context

{

    private ISortingStrategy _sortingStrategy;

 

    public Context(ISortingStrategy sortingStrategy)

    {

        _sortingStrategy = sortingStrategy;

    }

 

    public void SetSortingStrategy(ISortingStrategy sortingStrategy)

    {

        _sortingStrategy = sortingStrategy;

    }

 

    public void SortNumbers(List<int> numbers)

    {

        _sortingStrategy.Sort(numbers);

    }

}

这些只是设计模式中的一小部分，每种设计模式都有其特定的应用场景和优势。通过学习和实践这些设计模式，你可以更好地解决软件开发中遇到的各种问题，提高代码的质量和可维护性。