设计模式

2022-06-06

面向对象的设计原则

单一职责原则：一个类，最好只做一件事，只有一个引起它的变化。
开放-封闭原则：对于扩展是开放的，对于更改是封闭的。
里氏替换原则：子类必须能够替换其基类。
依赖倒置原则：设计应该依赖于抽象而不是具体实现。
接口隔离原则：使用多个小的专门的接口而不要使用一个大的总接口。
合成复用原则：组合优于继承。（白盒复用&&黑盒复用）
最少知道原则：实体之间减少相互作用。

单例模式

简述：
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。
这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
优点：

在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例。
避免对资源的多重占用。
缺点：
没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

懒汉式

C++:

class Singleton
{
private:
    Singleton() { };
    ~Singleton() { };
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);
public:
    static Singleton& getInstance() 
    {
        static Singleton instance;
        return instance;
    }
};

C#:

public class Singleton
 {
        private static Singleton Instance;
        private static readonly object locker = new object();
        private Singleton()
        {
        }
        public static Singleton GetInstance()
        {
            // 当第一个线程运行到这里时，此时会对locker对象 "加锁"，
            // 当第二个线程运行该方法时，首先检测到locker对象为"加锁"状态，该线程就会挂起等待第一个线程解锁
            // lock语句运行完之后（即线程运行完之后）会对该对象"解锁"
            // 双重锁定只需要一句判断就可以了
            if (uniqueInstance == null)
            {
                lock (locker)
                {
                    if (uniqueInstance == null)
                    {
                        uniqueInstance = new Singleton();
                    }
                }
            }
            return uniqueInstance;
        }
    }

饿汉式

C++:

class Singleton {
public:
    static Singleton* GetInstance() {
        return instance_;
    }

private:
    Singleton() {}
    static Singleton* instance_;
};
Singleton* Singleton::instance = new Singleton();

C#:

public class Singleton<T> where T : new()
{
    public static T _instance = default(T);

    public static T instance
    {
        get
        {
            if(_instance == null)
            {
                _instance = new T();
            }
            return _instance;
        }
    }
}

观察者模式（Observer模式）：

简述：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
优点：
降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。符合依赖倒置原则。
目标与观察者之间建立了一套触发机制。
缺点
目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。
当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。
实现：
C#为例，以委托为基础，实现订阅发布机制，然后…再修修改改就差不多了。

public interface IEventInfo { }
    public class EventInfo : IEventInfo
    {
        public UnityAction action;
    }
    public class EventInfo<T> : IEventInfo
    {
        public UnityAction<T> action;
    }

    /// <summary>
    /// 事件管理模块
    /// 基于观察者模式
    /// </summary>
public class EventManger : Singleton<EventManger>
{
    public Dictionary<string, IEventInfo> actionDic = new Dictionary<string, IEventInfo>();

    public void AddEventListener(string name, UnityAction action)
    {
        if (actionDic.ContainsKey(name))
        {
            (actionDic[name] as EventInfo).action += action;
        }
        else
        {
        actionDic.Add(name, new EventInfo() { action = action });
        }
    }

    public void AddEventListener<T>(string name, UnityAction<T> action)
    {
        if (actionDic.ContainsKey(name))
        {
            (actionDic[name] as EventInfo<T>).action += action;
        }
        else
        {
            actionDic.Add(name, new EventInfo<T>() { action = action });
        }
    }

    public void RemoveEventListener(string name, UnityAction action)
    {
        if (actionDic.ContainsKey(name))
        {
            (actionDic[name] as EventInfo).action -= action;
        }
    }

    public void RemoveEventListener<T>(string name, UnityAction<T> action)
    {
        if (actionDic.ContainsKey(name))
        {
            (actionDic[name] as EventInfo<T>).action -= action;
        }
    }

    public void TriggerEventListener(string name)
    {
        if (actionDic.ContainsKey(name))
        {
            (actionDic[name] as EventInfo).action?.Invoke();
        }
    }

    public void TriggerEventListener<T>(string name, T par)
    {
        if (actionDic.ContainsKey(name))
        {
            (actionDic[name] as EventInfo<T>).action?.Invoke(par);
        }
    }

    public void Clean()
    {
        actionDic.Clear();
    }
}