From dcc6bd86cbb3070aac6eaa4a6300757ad179307e Mon Sep 17 00:00:00 2001 From: "DESKTOP-B25GA9E\\W35" <1733709035@qq.com> Date: Sun, 29 Jan 2023 11:36:23 +0800 Subject: [PATCH] =?UTF-8?q?=E6=B7=BB=E5=8A=A0cp=EF=BC=8C=E7=94=A8=E4=BA=8E?= =?UTF-8?q?=E4=BF=AE=E6=94=B9=E5=8E=9F=E6=9C=AC=E7=9A=84qframe?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Assets/MsgTransmitTools/src/QFrameCopy.cs | 733 ++++++++++++++++++ .../MsgTransmitTools/src/QFrameCopy.cs.meta | 11 + 2 files changed, 744 insertions(+) create mode 100644 Assets/MsgTransmitTools/src/QFrameCopy.cs create mode 100644 Assets/MsgTransmitTools/src/QFrameCopy.cs.meta diff --git a/Assets/MsgTransmitTools/src/QFrameCopy.cs b/Assets/MsgTransmitTools/src/QFrameCopy.cs new file mode 100644 index 0000000..9fc8bd0 --- /dev/null +++ b/Assets/MsgTransmitTools/src/QFrameCopy.cs @@ -0,0 +1,733 @@ +/**************************************************************************** + * Copyright (c) 2015 ~ 2022 liangxiegame MIT License + * + * QFramework v1.0 + * + * https://qframework.cn + * https://github.com/liangxiegame/QFramework + * https://gitee.com/liangxiegame/QFramework + * + * Author: + * liangxie https://github.com/liangxie + * soso https://github.com/so-sos-so + * + * Contributor + * TastSong https://github.com/TastSong + * 京产肠饭 https://gitee.com/JingChanChangFan/hk_-unity-tools + * 猫叔(一只皮皮虾) https://space.bilibili.com/656352/ + * + * Community + * QQ Group: 623597263 + * Latest Update: 2022.8.8 10:24 List=>HashSet + ****************************************************************************/ + +using System; +using System.Collections.Generic; +using UnityEngine; + +namespace QFrameworkCP +{ + #region Architecture + + public interface IArchitecture + { + + void RegisterModel<T>(T model) where T : IModel; + + void RegisterUtility<T>(T utility) where T : IUtility; + + + T GetModel<T>() where T : class, IModel; + + T GetUtility<T>() where T : class, IUtility; + + void SendCommand<T>() where T : ICommand, new(); + void SendCommand<T>(T command) where T : ICommand; + + TResult SendQuery<TResult>(IQuery<TResult> query); + + void SendEvent<T>() where T : new(); + void SendEvent<T>(T e); + + IUnRegister RegisterEvent<T>(Action<T> onEvent); + void UnRegisterEvent<T>(Action<T> onEvent); + } + + public abstract class Architecture<T> : IArchitecture where T : Architecture<T>, new() + { + private bool mInited = false; + + private HashSet<IModel> mModels = new HashSet<IModel>(); + + public static Action<T> OnRegisterPatch = architecture => { }; + + private static T mArchitecture; + + public static IArchitecture Interface + { + get + { + if (mArchitecture == null) + { + MakeSureArchitecture(); + } + + return mArchitecture; + } + } + + + static void MakeSureArchitecture() + { + if (mArchitecture == null) + { + mArchitecture = new T(); + mArchitecture.Init(); + + OnRegisterPatch?.Invoke(mArchitecture); + + foreach (var architectureModel in mArchitecture.mModels) + { + architectureModel.Init(); + } + + mArchitecture.mModels.Clear(); + + mArchitecture.mInited = true; + } + } + + protected abstract void Init(); + + private IOCContainer mContainer = new IOCContainer(); + + public void RegisterModel<TModel>(TModel model) where TModel : IModel + { + model.SetArchitecture(this); + mContainer.Register<TModel>(model); + + if (!mInited) + { + mModels.Add(model); + } + else + { + model.Init(); + } + } + + public void RegisterUtility<TUtility>(TUtility utility) where TUtility : IUtility + { + mContainer.Register<TUtility>(utility); + } + + public TModel GetModel<TModel>() where TModel : class, IModel + { + return mContainer.Get<TModel>(); + } + + public TUtility GetUtility<TUtility>() where TUtility : class, IUtility + { + return mContainer.Get<TUtility>(); + } + + public void SendCommand<TCommand>() where TCommand : ICommand, new() + { + var command = new TCommand(); + ExecuteCommand(command); + } + + public void SendCommand<TCommand>(TCommand command) where TCommand : ICommand + { + ExecuteCommand(command); + } + + protected virtual void ExecuteCommand(ICommand command) + { + command.SetArchitecture(this); + command.Execute(); + } + + public TResult SendQuery<TResult>(IQuery<TResult> query) + { + return DoQuery<TResult>(query); + } + + protected virtual TResult DoQuery<TResult>(IQuery<TResult> query) + { + query.SetArchitecture(this); + return query.Do(); + } + + private TypeEventSystem mTypeEventSystem = new TypeEventSystem(); + + public void SendEvent<TEvent>() where TEvent : new() + { + mTypeEventSystem.Send<TEvent>(); + } + + public void SendEvent<TEvent>(TEvent e) + { + mTypeEventSystem.Send<TEvent>(e); + } + + public IUnRegister RegisterEvent<TEvent>(Action<TEvent> onEvent) + { + return mTypeEventSystem.Register<TEvent>(onEvent); + } + + public void UnRegisterEvent<TEvent>(Action<TEvent> onEvent) + { + mTypeEventSystem.UnRegister<TEvent>(onEvent); + } + } + + public interface IOnEvent<T> + { + void OnEvent(T e); + } + + public static class OnGlobalEventExtension + { + public static IUnRegister RegisterEvent<T>(this IOnEvent<T> self) where T : struct + { + return TypeEventSystem.Global.Register<T>(self.OnEvent); + } + + public static void UnRegisterEvent<T>(this IOnEvent<T> self) where T : struct + { + TypeEventSystem.Global.UnRegister<T>(self.OnEvent); + } + } + + #endregion + + #region Controller + + public interface IController : IBelongToArchitecture, ICanSendCommand, ICanGetSystem, ICanGetModel, + ICanRegisterEvent, ICanSendQuery + { + } + + #endregion + + #region Model + + public interface IModel : IBelongToArchitecture, ICanSetArchitecture, ICanGetUtility, ICanSendEvent + { + void Init(); + } + + public abstract class AbstractModel : IModel + { + private IArchitecture mArchitecturel; + + IArchitecture IBelongToArchitecture.GetArchitecture() + { + return mArchitecturel; + } + + void ICanSetArchitecture.SetArchitecture(IArchitecture architecture) + { + mArchitecturel = architecture; + } + + void IModel.Init() + { + OnInit(); + } + + protected abstract void OnInit(); + } + + #endregion + + #region Utility + + public interface IUtility + { + } + + #endregion + + #region Command + + public interface ICommand : IBelongToArchitecture, ICanSetArchitecture, ICanGetSystem, ICanGetModel, ICanGetUtility, + ICanSendEvent, ICanSendCommand, ICanSendQuery + { + void Execute(); + } + + public abstract class AbstractCommand : ICommand + { + private IArchitecture mArchitecture; + + IArchitecture IBelongToArchitecture.GetArchitecture() + { + return mArchitecture; + } + + void ICanSetArchitecture.SetArchitecture(IArchitecture architecture) + { + mArchitecture = architecture; + } + + void ICommand.Execute() + { + OnExecute(); + } + + protected abstract void OnExecute(); + } + + #endregion + + #region Query + + public interface IQuery<TResult> : IBelongToArchitecture, ICanSetArchitecture, ICanGetModel, ICanGetSystem, + ICanSendQuery + { + TResult Do(); + } + + public abstract class AbstractQuery<T> : IQuery<T> + { + public T Do() + { + return OnDo(); + } + + protected abstract T OnDo(); + + + private IArchitecture mArchitecture; + + public IArchitecture GetArchitecture() + { + return mArchitecture; + } + + public void SetArchitecture(IArchitecture architecture) + { + mArchitecture = architecture; + } + } + + #endregion + + #region Rule + + public interface IBelongToArchitecture + { + IArchitecture GetArchitecture(); + } + + public interface ICanSetArchitecture + { + void SetArchitecture(IArchitecture architecture); + } + + public interface ICanGetModel : IBelongToArchitecture + { + } + + public static class CanGetModelExtension + { + public static T GetModel<T>(this ICanGetModel self) where T : class, IModel + { + return self.GetArchitecture().GetModel<T>(); + } + } + + public interface ICanGetSystem : IBelongToArchitecture + { + } + + public interface ICanGetUtility : IBelongToArchitecture + { + } + + public static class CanGetUtilityExtension + { + public static T GetUtility<T>(this ICanGetUtility self) where T : class, IUtility + { + return self.GetArchitecture().GetUtility<T>(); + } + } + + public interface ICanRegisterEvent : IBelongToArchitecture + { + } + + public static class CanRegisterEventExtension + { + public static IUnRegister RegisterEvent<T>(this ICanRegisterEvent self, Action<T> onEvent) + { + return self.GetArchitecture().RegisterEvent<T>(onEvent); + } + + public static void UnRegisterEvent<T>(this ICanRegisterEvent self, Action<T> onEvent) + { + self.GetArchitecture().UnRegisterEvent<T>(onEvent); + } + } + + public interface ICanSendCommand : IBelongToArchitecture + { + } + + public static class CanSendCommandExtension + { + public static void SendCommand<T>(this ICanSendCommand self) where T : ICommand, new() + { + self.GetArchitecture().SendCommand<T>(); + } + + public static void SendCommand<T>(this ICanSendCommand self, T command) where T : ICommand + { + self.GetArchitecture().SendCommand<T>(command); + } + } + + public interface ICanSendEvent : IBelongToArchitecture + { + } + + public static class CanSendEventExtension + { + public static void SendEvent<T>(this ICanSendEvent self) where T : new() + { + self.GetArchitecture().SendEvent<T>(); + } + + public static void SendEvent<T>(this ICanSendEvent self, T e) + { + self.GetArchitecture().SendEvent<T>(e); + } + } + + public interface ICanSendQuery : IBelongToArchitecture + { + } + + public static class CanSendQueryExtension + { + public static TResult SendQuery<TResult>(this ICanSendQuery self, IQuery<TResult> query) + { + return self.GetArchitecture().SendQuery(query); + } + } + + #endregion + + #region TypeEventSystem + + public interface IUnRegister + { + void UnRegister(); + } + + public interface IUnRegisterList + { + List<IUnRegister> UnregisterList { get; } + } + + public static class IUnRegisterListExtension + { + public static void AddToUnregisterList(this IUnRegister self, IUnRegisterList unRegisterList) + { + unRegisterList.UnregisterList.Add(self); + } + + public static void UnRegisterAll(this IUnRegisterList self) + { + foreach (var unRegister in self.UnregisterList) + { + unRegister.UnRegister(); + } + + self.UnregisterList.Clear(); + } + } + + /// <summary> + /// 自定义可注销的类 + /// </summary> + public struct CustomUnRegister : IUnRegister + { + /// <summary> + /// 委托对象 + /// </summary> + private Action mOnUnRegister { get; set; } + + /// <summary> + /// 带参构造函数 + /// </summary> + /// <param name="onDispose"></param> + public CustomUnRegister(Action onUnRegsiter) + { + mOnUnRegister = onUnRegsiter; + } + + /// <summary> + /// 资源释放 + /// </summary> + public void UnRegister() + { + mOnUnRegister.Invoke(); + mOnUnRegister = null; + } + } + + public class UnRegisterOnDestroyTrigger : MonoBehaviour + { + private readonly HashSet<IUnRegister> mUnRegisters = new HashSet<IUnRegister>(); + + public void AddUnRegister(IUnRegister unRegister) + { + mUnRegisters.Add(unRegister); + } + + public void RemoveUnRegister(IUnRegister unRegister) + { + mUnRegisters.Remove(unRegister); + } + + private void OnDestroy() + { + foreach (var unRegister in mUnRegisters) + { + unRegister.UnRegister(); + } + + mUnRegisters.Clear(); + } + } + + public static class UnRegisterExtension + { + public static IUnRegister UnRegisterWhenGameObjectDestroyed(this IUnRegister unRegister, GameObject gameObject) + { + var trigger = gameObject.GetComponent<UnRegisterOnDestroyTrigger>(); + + if (!trigger) + { + trigger = gameObject.AddComponent<UnRegisterOnDestroyTrigger>(); + } + + trigger.AddUnRegister(unRegister); + + return unRegister; + } + } + + public class TypeEventSystem + { + private readonly EasyEvents mEvents = new EasyEvents(); + + + public static readonly TypeEventSystem Global = new TypeEventSystem(); + + public void Send<T>() where T : new() + { + mEvents.GetEvent<EasyEvent<T>>()?.Trigger(new T()); + } + + public void Send<T>(T e) + { + mEvents.GetEvent<EasyEvent<T>>()?.Trigger(e); + } + + public IUnRegister Register<T>(Action<T> onEvent) + { + var e = mEvents.GetOrAddEvent<EasyEvent<T>>(); + return e.Register(onEvent); + } + + public void UnRegister<T>(Action<T> onEvent) + { + var e = mEvents.GetEvent<EasyEvent<T>>(); + if (e != null) + { + e.UnRegister(onEvent); + } + } + } + + #endregion + + #region IOC + + public class IOCContainer + { + private Dictionary<Type, object> mInstances = new Dictionary<Type, object>(); + + public void Register<T>(T instance) + { + var key = typeof(T); + + if (mInstances.ContainsKey(key)) + { + mInstances[key] = instance; + } + else + { + mInstances.Add(key, instance); + } + } + + public T Get<T>() where T : class + { + var key = typeof(T); + + if (mInstances.TryGetValue(key, out var retInstance)) + { + return retInstance as T; + } + + return null; + } + } + + #endregion + + #region EasyEvent + + public interface IEasyEvent + { + } + + public class EasyEvent : IEasyEvent + { + private Action mOnEvent = () => { }; + + public IUnRegister Register(Action onEvent) + { + mOnEvent += onEvent; + return new CustomUnRegister(() => { UnRegister(onEvent); }); + } + + public void UnRegister(Action onEvent) + { + mOnEvent -= onEvent; + } + + public void Trigger() + { + mOnEvent?.Invoke(); + } + } + + public class EasyEvent<T> : IEasyEvent + { + private Action<T> mOnEvent = e => { }; + + public IUnRegister Register(Action<T> onEvent) + { + mOnEvent += onEvent; + return new CustomUnRegister(() => { UnRegister(onEvent); }); + } + + public void UnRegister(Action<T> onEvent) + { + mOnEvent -= onEvent; + } + + public void Trigger(T t) + { + mOnEvent?.Invoke(t); + } + } + + public class EasyEvent<T, K> : IEasyEvent + { + private Action<T, K> mOnEvent = (t, k) => { }; + + public IUnRegister Register(Action<T, K> onEvent) + { + mOnEvent += onEvent; + return new CustomUnRegister(() => { UnRegister(onEvent); }); + } + + public void UnRegister(Action<T, K> onEvent) + { + mOnEvent -= onEvent; + } + + public void Trigger(T t, K k) + { + mOnEvent?.Invoke(t, k); + } + } + + public class EasyEvent<T, K, S> : IEasyEvent + { + private Action<T, K, S> mOnEvent = (t, k, s) => { }; + + public IUnRegister Register(Action<T, K, S> onEvent) + { + mOnEvent += onEvent; + return new CustomUnRegister(() => { UnRegister(onEvent); }); + } + + public void UnRegister(Action<T, K, S> onEvent) + { + mOnEvent -= onEvent; + } + + public void Trigger(T t, K k, S s) + { + mOnEvent?.Invoke(t, k, s); + } + } + + public class EasyEvents + { + private static EasyEvents mGlobalEvents = new EasyEvents(); + + public static T Get<T>() where T : IEasyEvent + { + return mGlobalEvents.GetEvent<T>(); + } + + + public static void Register<T>() where T : IEasyEvent, new() + { + mGlobalEvents.AddEvent<T>(); + } + + private Dictionary<Type, IEasyEvent> mTypeEvents = new Dictionary<Type, IEasyEvent>(); + + public void AddEvent<T>() where T : IEasyEvent, new() + { + mTypeEvents.Add(typeof(T), new T()); + } + + public T GetEvent<T>() where T : IEasyEvent + { + IEasyEvent e; + + if (mTypeEvents.TryGetValue(typeof(T), out e)) + { + return (T)e; + } + + return default; + } + + public T GetOrAddEvent<T>() where T : IEasyEvent, new() + { + var eType = typeof(T); + if (mTypeEvents.TryGetValue(eType, out var e)) + { + return (T)e; + } + + var t = new T(); + mTypeEvents.Add(eType, t); + return t; + } + } + + #endregion +} \ No newline at end of file diff --git a/Assets/MsgTransmitTools/src/QFrameCopy.cs.meta b/Assets/MsgTransmitTools/src/QFrameCopy.cs.meta new file mode 100644 index 0000000..607a8b4 --- /dev/null +++ b/Assets/MsgTransmitTools/src/QFrameCopy.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3a4d8fc08cd737547b2581b6af6a13f6 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: