BITKit/Core/Utility/GenericEvent.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Collections.Concurrent;
using System.Text;
namespace BITKit
{
    /// <summary>泛型事件，简单的事件接口</summary>
    public interface IGenericEvent<TKey>
    {
        void AddListener<T>(Action<T> action);
        void Invoke<T>(T value);
        void Invoke<T>() where T : new();
        void RemoveListener<T>(Action<T> action);
        void AddListener<T>(TKey key, Action<T> action);
        void Invoke<T>(TKey key, T value);
        void RemoveListener<T>(TKey key, Action<T> action);
    }
    /// <summary>泛型数据库，主要使用方式为Get和Set</summary>
    public interface IDatabase
    {
        T Get<T>(string key = Constant.System.Internal);
        void Set<T>(T value);
        void Set<T>(string key = Constant.System.Internal, T value = default);
    }
    public class GenericEvent : IGenericEvent<string>, IDatabase, IDiagnostics
    {
        Dictionary<string, List<object>> events = new();
        Dictionary<string, object> dictionary = new();
        public const string defaultEventName = nameof(GenericEvent);
        public void AddListener<T>(Action<T> action) =>
            AddListener<T>(defaultEventName, action);
        public void Invoke<T>(T value) =>
            Invoke<T>(defaultEventName, value);
        public void RemoveListener<T>(Action<T> action) =>
            RemoveListener<T>(defaultEventName, action);
        public void AddListener<T>(string key, Action<T> action)
        {
            key = key.GetType<T>();
            var list = events.Get(key);
            list.Add(action);
        }
        public void Invoke<T>(string key, T value)
        {
            key = key.GetType<T>();
            var list = events.Get(key);
            dictionary.Set(key, value);
            list.ToArray().ForEach(x =>
            {
                if (x is Action<T> action)
                {
                    action.Invoke(value);
                }
            });
        }
        public void Invoke(string typeName, object value)
        {
            var key = $"{typeName}.{defaultEventName}";
            var list = events.Get(key);
            //BIT4Log.Log<GenericEvent>($"{key}\t@\t{list.Count}");
            foreach (var item in list.ToArray())
            {
                //BIT4Log.Log<GenericEvent>($"event:{item}");
                item.GetType().GetMethod("Invoke").Invoke(item, new object[] { value });
            }
        }
        public T Get<T>(string key = Constant.System.Internal)
        {
            key = key.GetType<T>();
            var value = dictionary.Get(key);
            if (value is T t)
            {
                return t;
            }
            return default;
        }
        public object Get(string key = Constant.System.Internal)
        {
            return dictionary[key];
        }
        public void Set<T>(T value) => dictionary.Set(Constant.System.Internal.GetType<T>(), value);
        public void Set<T>(string key, T value) => dictionary.Set(key.GetType<T>(), value);
        public void RemoveListener<T>(string key, Action<T> action)
        {
            key = key.GetType<T>();
            var list = events.Get(key);
            list.TryRemove(action);
        }
        public void DebugAllValues()
        {
            StringBuilder stringBuilder = new();
            stringBuilder.AppendLine($"Event Count:{events.Count}");
            foreach (var x in events)
            {
                stringBuilder.AppendLine(x.ToString());
            }
            BIT4Log.Log<GenericEvent>(stringBuilder);
        }

        public string GetName() => nameof(GenericEvent);

        public object GetDiagnostics()
        {
            StringBuilder stringBuilder = new("——————Dictionary");
            foreach (var x in dictionary)
            {
                stringBuilder.AppendLine(x.ToString());
            }
            stringBuilder.AppendLine("——————Events");
            foreach (var x in events)
            {
                stringBuilder.AppendLine($"{x.Key}\t{x.Value.Count}");
            }
            return stringBuilder;
        }

        public void Invoke<T>() where T : new() => Invoke(new T());
    }

    public interface MyAOE
    {
        float remingTime { get; }
    }
    public interface MyAOESystem
    {
        AOE GetAOE<AOE>() where AOE : MyAOE;
        bool AddAoe(MyAOE e);
    }
    public class MovementEffect : MyAOE
    {
        public float remingTime => throw new NotImplementedException();
        public float addSpeed = 0;
        public float speedMultiple = 1;
    }

    public class MyMovement
    {
        MyAOESystem system;
        void Start()
        {
            system.AddAoe(new MovementEffect()
            {
                addSpeed = 2,
            });
        }
        void Update()
        {
            float speed = 3;
            var effecot = system.GetAOE<MovementEffect>();
            speed += effecot.addSpeed;
            speed *= effecot.speedMultiple;
        }
    }
}