常见设计模式

单例模式

单件模式(Singleton):保证一个类仅有一个实例,并提供一个访问它的全局访问点。

饿汉式

优点：对象提前创建好了，使用的时候无需等待，效率高

缺点：对象提前创建，所以会占据一定的内存，内存占用大

以空间换时间

public class Singleton
{
    // 私有静态变量来保存单例的实例
    private static Singleton instance = new Singleton();

	private Singleton
	{
		//私有构造函数
	}
 
	public static Singleton getInstance()
	{
		return instance;
	}
}

懒汉式

从线程安全性上讲，不加同步的懒汉式是线程不安全的

优点：使用对象时，对象才创建，所以不会提前占用内存，内存占用小

缺点：首次使用对象时，需要等待对象的创建，而且每次都需要判断对象是否为空，运行效率较低

以时间换空间

public class Singleton
{
    // 私有静态变量来保存单例的实例
    private static Singleton instance = null;
 
    // 私有构造函数，确保外部无法直接实例化
    private Singleton() { }
 
    // 静态方法，提供全局访问点
    public static Singleton GetInstance()
    {
        // 如果实例为null，则新建一个实例
        if (instance == null)
        {
            instance = new Singleton();
        }
        return instance;
    }
}

以下是线程安全的懒汉式单例

public class Singleton
{
    private static Lazy<Singleton> lazy = new Lazy<Singleton>(() => new Singleton(), LazyThreadSafetyMode.ExecutionAndPublication);
 
    public static Singleton Instance { get { return lazy.Value; } }
 
    // 私有构造函数确保外部无法直接实例化
    private Singleton() { }
 
    // 其他方法和属性
}

观察者模式

自定义接口ISubject和IObserver实现

首先定义两个接口，ISubject接口是被观察者，IObserver接口是观察者。

public interface ISubject
    {
        void RegisterObserver(IObserver observer);// 注册订阅
        void RemoveObserver(IObserver observer);// 注销订阅
        void NotifyObserver();// 通知观察者
    }

public interface IObserver
    {
        void Update(string message);
    }

以下例子实现这两个接口

public class ConcreteSubject : ISubject
    {
        private List<IObserver> observers = new List<IObserver>();
        private string subjectState;
        public void NotifyObserver()
        {
            foreach (var observer in observers)
            {
                observer.Update(subjectState);
            }
        }
        public void RegisterObserver(IObserver observer)
        {
            observers.Add(observer);
        }
        public void RemoveObserver(IObserver observer)
        {
            observers.Remove(observer);
        }
        public void SetState(string state)
        {
            subjectState = state;
            NotifyObserver();
        }
    }

public class ConcreteObserver : IObserver
    {
        private string name;
        private string observerState;
        public ConcreteObserver(string name)
        {
            this.name = name;
        }
        public void Update(string message)
        {
            observerState = message;
            Console.WriteLine($"Observer {name} received message: {observerState}");
        }
    }

class Program
    {
        static void Main(string[] args)
        {
            ConcreteSubject subject = new ConcreteSubject();

            IObserver observer1 = new ConcreteObserver("A");
            IObserver observer2 = new ConcreteObserver("B");

            subject.RegisterObserver(observer1);
            subject.RegisterObserver(observer2);

            subject.SetState("Good");

            Console.ReadKey();
        }
    }

发布订阅模式（事件代理）实现

这里等实际开发遇到了补充，暂时想不出例子

工厂模式

工厂模式通常用于封装对象的创建过程，使得代码更加灵活和可维护。当使用接口与工厂模式结合时，我们可以创建遵循特定接口的对象，而无需直接依赖于这些对象的实现。

自定义接口IProduct实现

定义产品接口

//抽象产品接口
    public interface IProduct
    {
         void Use();
    }

再写两个具体的产品：产品A和产品B

public class ConcreteProductA : IProduct
    {
        public void Use()
        {
            Console.WriteLine("具体产品A的操作");
        }
    }

    public class ConcreteProductB : IProduct
    {
        public void Use()
        {
            Console.WriteLine("具体产品B的操作");
        }
    }

定义一个工厂类，用于生成不同类型的产品

public class Factory
    {   
        //
        public IProduct CreateProduct(string productType)
        {
            //这里的productType可以用Enum
            switch (productType)
            {
                case "A":
                    return new ConcreteProductA();
                case "B":
                    return new ConcreteProductB();
                default:
                    throw new ArgumentException("无效的产品类型");
            }
        }
    }

以下是一个测试例子

class Program
    {
        static void Main(string[] args)
        {
            Factory factory = new Factory();

            IProduct productA = factory.CreateProduct("A");
            productA.Use();

            IProduct productB = factory.CreateProduct("B");
            productB.Use();

            Console.ReadKey();
        }
    }