ShrinkSDK/ShrinkEventBus
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: 重构事件总线为可实例化架构并发布 1.3.0

Browse Source 
- 新增 IShrinkEventBus、ShrinkEventBusBuilder 与 ShrinkEventBusInstance，支持独立 bus、异常策略、启动开关、类型校验和按 phase 派发
- 新增 SubscribeEvent 可释放订阅句柄与订阅快照接口，保留 EventBus 静态门面并委托到默认实例
- 重构监听列表为父子事件链共享锁与快照缓存，支持父事件监听子事件、跨父子数字优先级归并和防御性快照拷贝
- 优化 EventBase 元数据缓存、懒生成 EventId、派发快照挂接与对象池双重归还保护，移除旧 EventCache 热路径
- 恢复本地 ILPostProcessor 兜底并生成静态订阅注册表，避免共享 CodeGen 覆盖外程序集自动注册失效
- 改进事件查看器、Benchmark、README 与 CHANGELOG，并新增 Dispatch/Priority/Registration/Subscription 测试覆盖核心行为

BREAKING CHANGE: 移除 EventBase.GetListenerList()，int 数字优先级重载不再提供默认值，数字优先级 0 现在映射为 NORMAL。
This commit is contained in:
cneicy committed 2026-06-18 17:05:16 +08:00
1 parent 2cea8a7ff5
commit 8acccdcc4b
41 files changed
+3168 -888
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Runtime/EventBus.cs
+105 -374
View File
@@ -1,398 +1,129 @@
using System;
#nullable enable
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.CompilerServices;
using Cysharp.Threading.Tasks;
using UnityEngine;
namespace ShrinkEventBus
{
public static class EventBus
{
public static event Action<EventBase, Type> OnEventTriggered;
private static readonly IShrinkEventBus DefaultBus = CreateDefaultBus();
public static IShrinkEventBus Default => DefaultBus;
public static event Action<EventBase, Type> OnEventTriggered
{
add => DefaultBus.OnEventTriggered += value;
remove => DefaultBus.OnEventTriggered -= value;
}
#if UNITY_EDITOR
public static bool EnableDebugRecord { get; set; }
public static event Action<EventBase, string, string> OnEventTriggeredForEditor;
public static bool EnableDebugRecord
{
get => DefaultBus.EnableDebugRecord;
set => DefaultBus.EnableDebugRecord = value;
}
public static event Action<EventBase, string, string, EventHandlerInfo[]> OnEventTriggeredForEditor
{
add => DefaultBus.OnEventTriggeredForEditor += value;
remove => DefaultBus.OnEventTriggeredForEditor -= value;
}
#endif
private static readonly Dictionary<Type, ListenerList> EventHandlers = new();
private static readonly HashSet<object> RegisteredInstances = new();
private static readonly object InstanceLock = new();
public static ShrinkEventBusBuilder Builder() => new();
static EventBus()
public static IShrinkEventBus CreateBus(Action<ShrinkEventBusBuilder>? configure = null)
{
EventBusRegHelper.RegStaticEventHandler();
var builder = new ShrinkEventBusBuilder();
configure?.Invoke(builder);
return builder.Build();
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static void EnsureAutoManagerInitialized() => EventAutoRegHelper.EnsureInitialized();
public static void Start() => DefaultBus.Start();
public static void AutoRegister(object target) => DefaultBus.AutoRegister(target);
public static void Register(object target) => DefaultBus.Register(target);
public static void Unregister(object target) => DefaultBus.Unregister(target);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void RegisterEvent<TEvent>(Func<TEvent, UniTask> handler, int priority = 0)
where TEvent : EventBase
{
var eventPriority = PriorityHelper.ConvertToEventPriority(priority);
RegisterEventInternal(typeof(TEvent), handler, eventPriority, priority, false,
$"Manual Async Handler (Priority: {priority})");
}
public static void RegisterEvent<TEvent>(Func<TEvent, UniTask> handler, int priority)
where TEvent : EventBase => DefaultBus.RegisterEvent(handler, priority);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void RegisterEvent<TEvent>(Action<TEvent> handler, EventPriority priority = EventPriority.NORMAL,
bool receiveCanceled = false) where TEvent : EventBase
{
RegisterEventInternal(typeof(TEvent), handler, priority, 0, receiveCanceled,
$"Manual Sync Handler (Priority: {priority})", handler.Method);
}
public static void RegisterEvent<TEvent>(Action<TEvent> handler,
EventPriority priority = EventPriority.NORMAL, bool receiveCanceled = false)
where TEvent : EventBase => DefaultBus.RegisterEvent(handler, priority, receiveCanceled);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void RegisterEvent<TEvent>(Action<TEvent> handler, int priority = 0) where TEvent : EventBase
{
var eventPriority = PriorityHelper.ConvertToEventPriority(priority);
RegisterEventInternal(typeof(TEvent), handler, eventPriority, priority, false,
$"Manual Sync Handler (Priority: {priority})", handler.Method);
}
public static void RegisterEvent<TEvent>(Action<TEvent> handler, int priority)
where TEvent : EventBase => DefaultBus.RegisterEvent(handler, priority);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void RegisterEvent<TEvent>(Func<TEvent, UniTask> handler,
EventPriority priority = EventPriority.NORMAL, bool receiveCanceled = false) where TEvent : EventBase
EventPriority priority = EventPriority.NORMAL, bool receiveCanceled = false)
where TEvent : EventBase => DefaultBus.RegisterEvent(handler, priority, receiveCanceled);
public static IShrinkEventSubscription SubscribeEvent<TEvent>(Action<TEvent> handler,
EventPriority priority = EventPriority.NORMAL, bool receiveCanceled = false)
where TEvent : EventBase => DefaultBus.SubscribeEvent(handler, priority, receiveCanceled);
public static IShrinkEventSubscription SubscribeEvent<TEvent>(Action<TEvent> handler, int priority)
where TEvent : EventBase => DefaultBus.SubscribeEvent(handler, priority);
public static IShrinkEventSubscription SubscribeEvent<TEvent>(Func<TEvent, UniTask> handler,
EventPriority priority = EventPriority.NORMAL, bool receiveCanceled = false)
where TEvent : EventBase => DefaultBus.SubscribeEvent(handler, priority, receiveCanceled);
public static IShrinkEventSubscription SubscribeEvent<TEvent>(Func<TEvent, UniTask> handler, int priority)
where TEvent : EventBase => DefaultBus.SubscribeEvent(handler, priority);
public static void UnregisterEvent<TEvent>(Func<TEvent, UniTask> handler) where TEvent : EventBase =>
DefaultBus.UnregisterEvent(handler);
public static void UnregisterEvent<TEvent>(Action<TEvent> handler) where TEvent : EventBase =>
DefaultBus.UnregisterEvent(handler);
public static void ClearAllSubscribersForEvent<TEvent>() where TEvent : EventBase =>
DefaultBus.ClearAllSubscribersForEvent<TEvent>();
public static void UnregisterAllEventsForObject(object targetObject) =>
DefaultBus.UnregisterAllEventsForObject(targetObject);
public static void UnregisterInstance(object targetObject) => DefaultBus.Unregister(targetObject);
public static void UnregisterAllEvents() => DefaultBus.UnregisterAllEvents();
public static UniTask<bool> TriggerEventAsync<TEvent>(TEvent eventArgs) where TEvent : EventBase =>
DefaultBus.TriggerEventAsync(eventArgs);
public static UniTask<bool> TriggerEventAsync<TEvent>(EventPriority phase, TEvent eventArgs)
where TEvent : EventBase => DefaultBus.TriggerEventAsync(phase, eventArgs);
public static bool TriggerEvent<TEvent>(TEvent eventArgs) where TEvent : EventBase =>
DefaultBus.TriggerEvent(eventArgs);
public static bool TriggerEvent<TEvent>(EventPriority phase, TEvent eventArgs) where TEvent : EventBase =>
DefaultBus.TriggerEvent(phase, eventArgs);
public static EventHandlerInfo[] GetEventSubscribers<TEvent>() where TEvent : EventBase =>
DefaultBus.GetEventSubscribers<TEvent>();
public static ListenerList GetListenerList<TEvent>() where TEvent : EventBase =>
DefaultBus.GetListenerList<TEvent>();
public static IReadOnlyDictionary<Type, EventHandlerInfo[]> GetAllSubscribersSnapshot() =>
DefaultBus.GetAllSubscribersSnapshot();
public static IReadOnlyList<ShrinkEventSubscriptionSnapshot> GetActiveSubscriptionsSnapshot() =>
DefaultBus.GetActiveSubscriptionsSnapshot();
public static bool IsInstanceRegistered(object target) => DefaultBus.IsInstanceRegistered(target);
public static int GetRegisteredInstanceCount() => DefaultBus.GetRegisteredInstanceCount();
public static int GetRegisteredEventTypeCount() => DefaultBus.GetRegisteredEventTypeCount();
private static IShrinkEventBus CreateDefaultBus()
{
RegisterEventInternal(typeof(TEvent), handler, priority, 0, receiveCanceled,
$"Manual Async Handler (Priority: {priority})");
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void RegisterEventInternal(Type eventType, Delegate handler, EventPriority priority,
int numericPriority, bool receiveCanceled, string debugInfo = "", MethodInfo originalMethod = null)
{
lock (EventHandlers)
{
if (!EventHandlers.TryGetValue(eventType, out var collection))
{
collection = new ListenerList();
EventHandlers[eventType] = collection;
var cacheType = typeof(EventCache<>).MakeGenericType(eventType);
cacheType.GetField("List", BindingFlags.Static | BindingFlags.Public)?.SetValue(null, collection);
}
collection.Add(handler, priority, numericPriority, receiveCanceled, debugInfo, originalMethod);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void UnregisterEvent<TEvent>(Func<TEvent, UniTask> handler) where TEvent : EventBase
{
var eventType = typeof(TEvent);
lock (EventHandlers)
{
if (!EventHandlers.TryGetValue(eventType, out var collection)) return;
collection.Remove(handler);
if (collection.Count == 0)
{
EventHandlers.Remove(eventType);
EventCache<TEvent>.List = null;
}
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void UnregisterEvent<TEvent>(Action<TEvent> handler) where TEvent : EventBase
{
var eventType = typeof(TEvent);
lock (EventHandlers)
{
if (!EventHandlers.TryGetValue(eventType, out var collection)) return;
collection.Remove(handler);
if (collection.Count == 0)
{
EventHandlers.Remove(eventType);
EventCache<TEvent>.List = null;
}
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void ClearAllSubscribersForEvent<TEvent>() where TEvent : EventBase
{
var eventType = typeof(TEvent);
lock (EventHandlers)
{
if (EventHandlers.Remove(eventType))
EventCache<TEvent>.List = null;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void UnregisterAllEventsForObject(object targetObject)
{
if (targetObject is null) return;
lock (EventHandlers)
{
var eventTypesToRemove = new List<Type>();
foreach (var kvp in EventHandlers)
{
kvp.Value.RemoveTarget(targetObject);
if (kvp.Value.Count == 0) eventTypesToRemove.Add(kvp.Key);
}
foreach (var eventType in eventTypesToRemove)
{
EventHandlers.Remove(eventType);
var cacheType = typeof(EventCache<>).MakeGenericType(eventType);
cacheType.GetField("List", BindingFlags.Static | BindingFlags.Public)?.SetValue(null, null);
}
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void UnregisterInstance(object targetObject)
{
if (targetObject is null) return;
lock (InstanceLock)
{
RegisteredInstances.Remove(targetObject);
}
UnregisterAllEventsForObject(targetObject);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void UnregisterAllEvents()
{
lock (EventHandlers)
{
foreach (var type in EventHandlers.Keys)
{
var cacheType = typeof(EventCache<>).MakeGenericType(type);
cacheType.GetField("List", BindingFlags.Static | BindingFlags.Public).SetValue(null, null);
}
EventHandlers.Clear();
}
lock (InstanceLock)
{
RegisteredInstances.Clear();
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static bool TryPrepareHandler<TEvent>(TEvent eventArgs, EventHandlerInfo handlerInfo)
where TEvent : EventBase
{
eventArgs.CurrentHandler = handlerInfo;
eventArgs.SetPhase(handlerInfo.Priority);
if (eventArgs.IsCancelable && eventArgs.IsCanceled && !handlerInfo.ReceiveCanceled)
return false;
return true;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static async UniTask<bool> TriggerEventAsync<TEvent>(TEvent eventArgs) where TEvent : EventBase
{
EnsureAutoManagerInitialized();
eventArgs.PrepareForDispatch();
var collection = EventCache<TEvent>.List;
var handlers = collection?.GetHandlers() ?? Array.Empty<EventHandlerInfo>();
var wasHandled = false;
for (var i = 0; i < handlers.Length; i++)
{
var handlerInfo = handlers[i];
if (!TryPrepareHandler(eventArgs, handlerInfo)) continue;
try
{
if (handlerInfo.Handler is Action<TEvent> syncHandler)
{
syncHandler(eventArgs);
wasHandled = true;
}
else if (handlerInfo.Handler is Func<TEvent, UniTask> asyncHandler)
{
await asyncHandler(eventArgs);
wasHandled = true;
}
}
catch (Exception ex)
{
Debug.LogException(ex);
Debug.LogError($"[EventBus] Async Handler Exception: {ex.Message}");
}
}
eventArgs.CurrentHandler = null;
CompleteEventDispatch(eventArgs, typeof(TEvent), handlers);
return wasHandled;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool TriggerEvent<TEvent>(TEvent eventArgs) where TEvent : EventBase
{
EnsureAutoManagerInitialized();
eventArgs.PrepareForDispatch();
var collection = EventCache<TEvent>.List;
var handlers = collection?.GetHandlers() ?? Array.Empty<EventHandlerInfo>();
var wasHandled = false;
for (var i = 0; i < handlers.Length; i++)
{
var handlerInfo = handlers[i];
if (!TryPrepareHandler(eventArgs, handlerInfo)) continue;
try
{
if (handlerInfo.Handler is Action<TEvent> syncHandler)
{
syncHandler(eventArgs);
wasHandled = true;
}
else if (handlerInfo.Handler is Func<TEvent, UniTask> asyncHandler)
{
var detachedEvent = EventCloneUtility.CloneForDetachedDispatch(eventArgs);
FireAndForgetSafe(() => asyncHandler(detachedEvent),
$"{handlerInfo.DisplayDeclaringType.Name}.{handlerInfo.DisplayMethodName}");
wasHandled = true;
}
}
catch (Exception ex)
{
Debug.LogException(ex);
Debug.LogError($"[EventBus] Sync Handler Exception: {ex.Message}");
}
}
eventArgs.CurrentHandler = null;
CompleteEventDispatch(eventArgs, typeof(TEvent), handlers);
return wasHandled;
}
private static void FireAndForgetSafe(Func<UniTask> action, string handlerName)
{
action().Forget(e =>
{
Debug.LogException(e);
Debug.LogError($"[EventBus] Async Handler {handlerName} threw exception: {e.Message}");
});
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static void CompleteEventDispatch(EventBase eventArgs, Type eventType, EventHandlerInfo[] handlers)
{
OnEventTriggered?.Invoke(eventArgs, eventType);
#if UNITY_EDITOR
if (!EnableDebugRecord) return;
PrepareEditorTrace(handlers, eventArgs);
OnEventTriggeredForEditor?.Invoke(eventArgs, eventType.Name, GetSenderInfo());
#endif
}
#if UNITY_EDITOR
private static void PrepareEditorTrace(EventHandlerInfo[] handlers, EventBase eventArgs)
{
if (!EnableDebugRecord) return;
var listenerList = eventArgs.GetListenerList();
listenerList.Clear();
for (var i = 0; i < handlers.Length; i++)
listenerList.Add(handlers[i]);
}
private static string GetSenderInfo()
{
var senderInfo = "Unknown";
try
{
var trace = new System.Diagnostics.StackTrace(0, false);
for (var i = 0; i < trace.FrameCount; i++)
{
var method = trace.GetFrame(i)?.GetMethod();
var declaringType = method?.DeclaringType;
if (declaringType == null) continue;
if (declaringType == typeof(EventBus) || declaringType.DeclaringType == typeof(EventBus)) continue;
var ns = declaringType.Namespace ?? "";
if (ns.StartsWith("System") || ns.StartsWith("Cysharp") || ns.StartsWith("UnityEngine")) continue;
var className = declaringType.Name;
var methodName = method.Name;
if (declaringType.DeclaringType != null && className.StartsWith("<") && className.Contains(">"))
{
className = declaringType.DeclaringType.Name;
var startIndex = declaringType.Name.IndexOf('<') + 1;
var endIndex = declaringType.Name.IndexOf('>');
if (startIndex > 0 && endIndex > startIndex)
methodName = declaringType.Name.Substring(startIndex, endIndex - startIndex);
}
return $"{className}.{methodName}()";
}
}
catch
{
}
return senderInfo;
}
#endif
public static EventHandlerInfo[] GetEventSubscribers<TEvent>() where TEvent : EventBase
{
var eventType = typeof(TEvent);
lock (EventHandlers)
{
return EventHandlers.TryGetValue(eventType, out var collection)
? collection.GetHandlers()
: Array.Empty<EventHandlerInfo>();
}
}
public static ListenerList GetListenerList<TEvent>() where TEvent : EventBase
{
var eventType = typeof(TEvent);
lock (EventHandlers)
{
EventHandlers.TryGetValue(eventType, out var collection);
return collection;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void AutoRegister(object target)
{
if (target == null) return;
if (IsInstanceRegistered(target)) return;
EventBusRegHelper.RegisterEventHandlers(target);
lock (InstanceLock)
{
if (!RegisteredInstances.Add(target)) return;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool IsInstanceRegistered(object target)
{
if (target == null) return false;
lock (InstanceLock)
{
return RegisteredInstances.Contains(target);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int GetRegisteredInstanceCount()
{
lock (InstanceLock)
{
return RegisteredInstances.Count;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int GetRegisteredEventTypeCount()
{
lock (EventHandlers)
{
return EventHandlers.Count;
}
var bus = (ShrinkEventBusInstance)new ShrinkEventBusBuilder()
.SetExceptionHandlingMode(ShrinkEventExceptionHandlingMode.LogAndContinue)
.AllowPerPhaseDispatch()
.Build();
EventBusRegHelper.RegStaticEventHandler(bus);
return bus;
}
}
}