[Unity] 单例化中泛型类继承问题笔记

unity进阶学习笔记：消息框架_unity 消息框架_Raine_Yang的博客-CSDN博客

这几天在学习这位大佬的消息框架时，也遇到了他所遇到的问题，产生了不一样的见解和解决方案，整个框架大致是：

消息中心（MessageCenter类）->功能管理器（ManagerBase类）->功能脚本（MonoBase类）

MessageCenter类：用List来管理每个ManagerBase类，进行消息广播，寻找功能对应的管理器。

ManagerBase类：用List来管理每个MonoBase类，进行消息广播，寻找功能对应的脚本。

MonoBase类：用来实现具体的功能，接受消息广播。

需要编写具体功能的管理类（如PlayerManager、AttributeManager），继承ManagerBase类；以及具体功能的脚本（如PlayerController、PlayerAttribute），继承MonoBase类。

并且对于MessageCenter类和每个具体功能的管理器类，需要进行单例化，保证每一个类仅有一个实例，并为它提供一个全局访问点。

单例化的模板脚本如下：

using UnityEngine;

public class SingletonBase<T> : MonoBehaviour where T : MonoBehaviour
{
    private static T instance;
    public static T Instance
    {
        get
        {
            return instance;
        }
    }
    protected virtual void Awake()
    {
        instance = this as T;
    }

    protected virtual void OnDestroy()
    {
        instance = null;
    }

}

对于MessagerCenter类，可以进行以下的单例化操作，随后在场景创建空的游戏物体，将脚本挂载上：

public class MessageCenter : SingletonBase<MessageCenter>
{
    public List<ManagerBase> Managers = new List<ManagerBase>();

    public void Register(ManagerBase manager)
    {
        if(!Managers.Contains(manager))
        {
            Managers.Add(manager);
        }
    }

    public void SendCustomMessage(Message message)
    {
        foreach(var manager in Managers)
        {
            manager.ReceiveMessage(message);
        }
    }
}

但对于ManagerBase类，如果进行以下类似的单例化操作：

public abstract class ManagerBase : SingletonBase<ManagerBase>
{
    public List<MonoBase> Monos = new List<MonoBase>();

    public void Register(MonoBase mono)
    {
        if (!Monos.Contains(mono))
        {
            Monos.Add(mono);
        }
    }

    public virtual void ReceiveMessage(Message message)
    {
        if (message.Type != GetMessageType())
        {
            return;
        }
        foreach (var mono in Monos)
        {
            mono.ReceiveMessage(message);
        }
    }

    public abstract byte GetMessageType();
}

会发现，当不同的功能管理类继承ManagerBase类时，不论编写了多少个功能管理类，他们都只有共同的一个实例（所有功能管理类的其中之一）。

原因是不论写了多少个功能管理类，他们都会作为ManagerBase类实例化（因为ManagerBase类指定了单例化的类型是ManagerBase类，而非具体的子类），导致所有继承至ManagerBase类的功能管理类都只有共同的一个实例（子类的其中之一）。

当我想利用泛型类来单独写一套单例化方法（如上文博主所述方法），

定义ManagerBase<T>类，继承MonoBehaviour并指定T继承至MonoBehaviour，

同时修改MessagerCenter的List类型为List<ManagerBase<MonoBehaviou>>时，

发现假如我定义了PlayerManager类，继承ManagerBase<PlayerManager>类，会发现ManagerBase<PlayerManager>并不能隐转成ManagerBase<MonoBehaviou> ，会导致并不能将此管理类加入到MessagerCenter的List当中，

原因是虽然PlayerManager派生自MonoBehaviour，但是ManagerBase<PlayerManager>和ManagerBase<MonoBehaviou>并不能画等号。

于是我想到了一个解决办法，MessagerCenter类按原来的不变，编写一个ManagerBase类，用于存储在MessagerCenter，随后编写一个ManagerBase<T>类，继承自ManagerBase，在此类当中实现单例化：

using System.Collections.Generic;
using UnityEngine;

public abstract class ManagerBase : MonoBehaviour
{
    public List<MonoBase> Monos = new List<MonoBase>();

    public void Register(MonoBase mono)
    {
        if (!Monos.Contains(mono))
        {
            Monos.Add(mono);
        }
    }

    public virtual void ReceiveMessage(Message message)
    {
        if (message.Type != GetMessageType())
        {
            return;
        }
        foreach (var mono in Monos)
        {
            mono.ReceiveMessage(message);
        }
    }

    public abstract byte GetMessageType();
}

public abstract class ManagerBase<T> : ManagerBase where T : MonoBehaviour
{
    protected static T instance;
    public static T Instance
    {
        get
        {
            return instance;
        }
    }

    protected void Awake()
    {
        instance = this as T;
    }

    protected void OnDestroy()
    {
        instance = null;
    }
}

随后可以发现，在对应的功能管理类当中，可以正常的将不同单例化对象存储到MessageCenter当中，至此问题解决。

using System.Collections.Generic;
using UnityEngine;

public class PlayerManager : ManagerBase<PlayerManager>
{
    private void Start()
    {
        MessageCenter.Instance.Register(this);
    }

    public override byte GetMessageType()
    {
        return MessageType.Type_Player;
    }
}