出处：http://blog.csdn.net/u010019717
author：孙广东 时间：2015.3.21 23：00
不使用C#中的event关键字： 只是使用delegate和hashtable 进行事件的分发。
基本库如下：
namespace EventDispatcher
{
/// <summary>
/// IEvent接口
/// </summary>
public interface IEvent
{
/// <summary>
/// Gets or sets the type.
/// </summary>
/// <value>
/// type类型.
/// </value>
string type { get; set;}
/// <summary>
/// Gets or sets the target.
/// </summary>
/// <value>
/// target目标.
/// </value>
object target { get; set; }
}
}namespace EventDispatcher
{
/// <summary>
/// 事件事件接口
/// </summary>
public class Event : IEvent
{
// GETTER / SETTER
/// <summary>
/// The _type_string.
/// </summary>
private string _type_string;
string IEvent.type {
get
{
return _type_string;
}
set
{
_type_string = value;
}
}
/// <summary>
/// The _target_object.
/// </summary>
private object _target_object;
object IEvent.target {
get
{
return _target_object;
}
set
{
_target_object = value;
}
}
///<summary>
/// Constructor
///</summary>
public Event (string aType_str )
{
//
_type_string = aType_str;
}
/// <summary>
/// Deconstructor
/// </summary>
//~Event ( )
//{
// Debug.Log ("Event.deconstructor()");
//}
}
}namespace EventDispatcher
{
/// <summary>
/// IEventDispatcher 事件分发接口，添加移除分发
/// </summary>
public interface IEventDispatcher
{
/// <summary>
/// 添加事件监听
/// </summary>
/// <returns><c>true</c>, 如果事件成功被监听， <c>false</c> 失败 </returns>
/// <param name="aEventType_string">A event type_string.</param>
/// <param name="aEventDelegate">一个事件委托</param>
bool addEventListener(string aEventType_string, EventDelegate aEventDelegate);
/// <summary>
/// 添加事件监听
/// </summary>
/// <returns><c>true</c>, 如果事件成功被监听, <c>false</c> 失败 </returns>
/// <param name="aEventType_string">A event type_string.</param>
/// <param name="aEventDelegate">一个事件委托</param>
/// <param name="eventDispatcherAddMode">Event dispatcher add mode.</param>
bool addEventListener(string aEventType_string, EventDelegate aEventDelegate, EventDispatcherAddMode eventDispatcherAddMode);
/// <summary>
/// 是否有这个事件监听
/// </summary>
/// <returns><c>true</c>, 这个监听已经有了, <c>false</c> 没有.</returns>
/// <param name="aEventType_string">A event type_string.</param>
/// <param name="aEventDelegate">一个事件委托</param>
bool hasEventListener(string aEventType_string, EventDelegate aEventDelegate);
/// <summary>
/// 移除事件监听
/// </summary>
/// <returns><c>true</c>, 被成功移除 <c>false</c> 失败</returns>
/// <param name="aEventType_string">A event type_string.</param>
/// <param name="aEventDelegate">一个事件委托</param>
bool removeEventListener(string aEventType_string, EventDelegate aEventDelegate);
/// <summary>
/// 移除所有事件监听
/// </summary>
/// <returns><c>true</c>, 成功, <c>false</c> 失败 </returns>
bool removeAllEventListeners();
/// <summary>
/// 分发广播事件
/// </summary>
/// <returns><c>true</c>, 成功, <c>false</c> 失败</returns>
/// <param name="aIEvent">A I event.</param>
bool dispatchEvent(IEvent aIEvent);
}
}// C# unity事件管理器 在哈希表中使用字符串，对委托和事件管理
// 不知道他们何时何地declared/defined 也允许使用事件。
using UnityEngine;
using System.Collections;
namespace EventDispatcher
{
/// <summary>
/// Event delegateN事件委托
/// </summary>
public delegate void EventDelegate ( IEvent iEvent );
/// <summary>
/// Event listening mode.
/// </summary>
public enum EventDispatcherAddMode
{
DEFAULT,
SINGLE_SHOT
}
public class EventDispatcher : IEventDispatcher
{
/// <summary>
/// The mom_serialized object.
/// </summary>
private Hashtable _eventListenerDatas_hashtable = new Hashtable();
/// <summary>
/// The _target_object.
/// </summary>
private object _target_object;
///<summary>
/// Constructor
///</summary>
public EventDispatcher (object aTarget_object )
{
//
_target_object = aTarget_object;
}
/// <summary>
/// Deconstructor
/// </summary>
//~EventDispatcher ( )
//{
// Debug.Log ("EventDispatcher.deconstructor()");
//}
/// <summary>
/// Adds the event listener.
/// </summary>
/// <returns>
/// The event listener.
/// </returns>
/// <param name=‘aEventName_string‘>
/// If set to <c>true</c> a event name_string.
/// </param>
/// <param name=‘aEventDelegate‘>
/// If set to <c>true</c> a event delegate.
/// </param>
public bool addEventListener(string aEventName_string, EventDelegate aEventDelegate)
{
return addEventListener (aEventName_string, aEventDelegate, EventDispatcherAddMode.DEFAULT);
}
/// <summary>
/// Adds the event listener.
/// </summary>
/// <returns>
/// The event listener.
/// </returns>
/// <param name=‘aEventName_string‘>
/// If set to <c>true</c> a event type_string.
/// </param>
/// <param name=‘aEventDelegate‘>
/// If set to <c>true</c> a event delegate.
/// </param>
/// <param name=‘aEventDispatcherAddMode‘>
/// If set to <c>true</c> event listening mode.
/// </param>
public bool addEventListener(string aEventName_string, EventDelegate aEventDelegate, EventDispatcherAddMode aEventDispatcherAddMode)
{
//
bool wasSuccessful_boolean = false;
//
object aIEventListener = _getArgumentsCallee(aEventDelegate);
//
if (aIEventListener != null && aEventName_string != null) {
// OUTER
string keyForOuterHashTable_string = _getKeyForOuterHashTable (aEventName_string);
if (!_eventListenerDatas_hashtable.ContainsKey(keyForOuterHashTable_string) ) {
_eventListenerDatas_hashtable.Add(keyForOuterHashTable_string, new Hashtable());
}
// INNER
Hashtable inner_hashtable = _eventListenerDatas_hashtable[keyForOuterHashTable_string] as Hashtable;
EventListenerData eventListenerData = new EventListenerData (aIEventListener, aEventName_string, aEventDelegate, aEventDispatcherAddMode);
//
string keyForInnerHashTable_string = _getKeyForInnerHashTable (eventListenerData);
if (inner_hashtable.Contains(keyForInnerHashTable_string)) {
//THIS SHOULD *NEVER* HAPPEN - REMOVE AFTER TESTED WELL
Debug.Log("TODO (FIX THIS): Event Manager: Listener: " + keyForInnerHashTable_string + " is already in list for event: " + keyForOuterHashTable_string);
} else {
// ADD
inner_hashtable.Add(keyForInnerHashTable_string, eventListenerData);
wasSuccessful_boolean = true;
//Debug.Log (" ADDED AT: " + keyForInnerHashTable_string + " = " + eventListenerData);
}
}
return wasSuccessful_boolean;
}
/// <summary>
/// Hases the event listener.
/// </summary>
/// <returns>
/// The event listener.
/// </returns>
/// <param name=‘aIEventListener‘>
/// If set to <c>true</c> a I event listener.
/// </param>
/// <param name=‘aEventName_string‘>
/// If set to <c>true</c> a event name_string.
/// </param>
/// <param name=‘aEventDelegate‘>
/// If set to <c>true</c> a event delegate.
/// </param>
public bool hasEventListener(string aEventName_string, EventDelegate aEventDelegate)
{
//
bool hasEventListener_boolean = false;
//
object aIEventListener = _getArgumentsCallee(aEventDelegate);
// OUTER
string keyForOuterHashTable_string = _getKeyForOuterHashTable (aEventName_string);
if (_eventListenerDatas_hashtable.ContainsKey(keyForOuterHashTable_string)) {
// INNER
Hashtable inner_hashtable = _eventListenerDatas_hashtable[keyForOuterHashTable_string] as Hashtable;
string keyForInnerHashTable_string = _getKeyForInnerHashTable (new EventListenerData (aIEventListener, aEventName_string, aEventDelegate, EventDispatcherAddMode.DEFAULT));
//
if (inner_hashtable.Contains(keyForInnerHashTable_string)) {
hasEventListener_boolean = true;
}
}
return hasEventListener_boolean;
}
/// <summary>
/// Removes the event listener.
/// </summary>
/// <returns>
/// The event listener.
/// </returns>
/// <param name=‘aIEventListener‘>
/// If set to <c>true</c> a I event listener.
/// </param>
/// <param name=‘aEventName_string‘>
/// If set to <c>true</c> a event name_string.
/// </param>
/// <param name=‘aEventDelegate‘>
/// If set to <c>true</c> a event delegate.
/// </param>
public bool removeEventListener(string aEventName_string, EventDelegate aEventDelegate)
{
//
bool wasSuccessful_boolean = false;
//
if (hasEventListener (aEventName_string, aEventDelegate)) {
// OUTER
string keyForOuterHashTable_string = _getKeyForOuterHashTable (aEventName_string);
Hashtable inner_hashtable = _eventListenerDatas_hashtable[keyForOuterHashTable_string] as Hashtable;
//
object aIEventListener = _getArgumentsCallee(aEventDelegate);
// INNER
string keyForInnerHashTable_string = _getKeyForInnerHashTable (new EventListenerData (aIEventListener, aEventName_string, aEventDelegate, EventDispatcherAddMode.DEFAULT));
inner_hashtable.Remove(keyForInnerHashTable_string);
wasSuccessful_boolean = true;
}
return wasSuccessful_boolean;
}
/// <summary>
/// Removes all event listeners.
/// </summary>
/// <returns>
/// The all event listeners.
/// </returns>
public bool removeAllEventListeners()
{
//
bool wasSuccessful_boolean = false;
//TODO, IS IT A MEMORY LEAK TO JUST RE-CREATE THE TABLE? ARE THE INNER HASHTABLES LEAKING?
_eventListenerDatas_hashtable = new Hashtable();
return wasSuccessful_boolean;
}
/// <summary>
/// Dispatchs the event.
/// </summary>
/// <returns>
/// The event.
/// </returns>
/// <param name=‘aIEvent‘>
/// If set to <c>true</c> a I event.
/// </param>
public bool dispatchEvent(IEvent aIEvent)
{
//
bool wasSuccessful_boolean = false;
//
_doAddTargetValueToIEvent (aIEvent);
// OUTER
string keyForOuterHashTable_string = _getKeyForOuterHashTable (aIEvent.type);
int dispatchedCount_int = 0;
if (_eventListenerDatas_hashtable.ContainsKey(keyForOuterHashTable_string)) {
// INNER
Hashtable inner_hashtable = _eventListenerDatas_hashtable[keyForOuterHashTable_string] as Hashtable;
IEnumerator innerHashTable_ienumerator = inner_hashtable.GetEnumerator();
DictionaryEntry dictionaryEntry;
EventListenerData eventListenerData;
ArrayList toBeRemoved_arraylist = new ArrayList ();
//
while (innerHashTable_ienumerator.MoveNext()) {
dictionaryEntry = (DictionaryEntry)innerHashTable_ienumerator.Current;
eventListenerData = dictionaryEntry.Value as EventListenerData;
//***DO THE DISPATCH***
//Debug.Log ("DISPATCH : ");
//Debug.Log (" n : " + eventListenerData.eventName );
//Debug.Log (" from : " + aIEvent.target );
//Debug.Log (" to : " + eventListenerData.eventListener );
//Debug.Log (" del : " + eventListenerData.eventDelegate + " " + (eventListenerData.eventDelegate as System.Delegate).Method.DeclaringType.Name + " " + (eventListenerData.eventDelegate as System.Delegate).Method.Name.ToString());
eventListenerData.eventDelegate (aIEvent);
//TODO - THIS IS PROBABLY FUNCTIONAL BUT NOT OPTIMIZED, MY APPROACH TO HOW/WHY SINGLE SHOTS ARE REMOVED
//REMOVE IF ONESHOT
if (eventListenerData.eventListeningMode == EventDispatcherAddMode.SINGLE_SHOT) {
toBeRemoved_arraylist.Add (eventListenerData);
}
//MARK SUCCESS, BUT ALSO CONTINUE LOOPING TOO
wasSuccessful_boolean = true;
dispatchedCount_int++;
}
//CLEANUP ANY ONE-SHOT, SINGLE-USE
EventListenerData toBeRemoved_eventlistenerdata;
for (int count_int = toBeRemoved_arraylist.Count -1; count_int >= 0; count_int --) {
toBeRemoved_eventlistenerdata = toBeRemoved_arraylist[count_int] as EventListenerData;
removeEventListener (toBeRemoved_eventlistenerdata.eventName, toBeRemoved_eventlistenerdata.eventDelegate);
}
}
return wasSuccessful_boolean;
}
/// <summary>
/// _dos the add target value to I event.
/// </summary>
/// <param name=‘aIEvent‘>
/// A I event.
/// </param>
/// <exception cref=‘System.NotImplementedException‘>
/// Is thrown when a requested operation is not implemented for a given type.
/// </exception>
public void _doAddTargetValueToIEvent (IEvent aIEvent)
{
aIEvent.target = _target_object;
}
public void OnApplicationQuit()
{
//TODO, DO THIS CLEANUP HERE, OR OBLIGATE API-USER TO DO IT??
_eventListenerDatas_hashtable.Clear();
}
private string _getKeyForOuterHashTable (string aEventName_string)
{
//SIMPLY USING THE EVENT NAME - METHOD USED HERE, IN CASE I WANT TO TWEAK THIS MORE...
return aEventName_string;
}
private string _getKeyForInnerHashTable (EventListenerData aEventListenerData)
{
//VERY UNIQUE - NICE!
return aEventListenerData.eventListener.GetType().FullName + "_" + aEventListenerData.eventListener.GetType().GUID + "_" + aEventListenerData.eventName + "_" + (aEventListenerData.eventDelegate as System.Delegate).Method.Name.ToString();
}
public object _getArgumentsCallee (EventDelegate aEventDelegate)
{
return (aEventDelegate as System.Delegate).Target;
}
}
}namespace EventDispatcher
{
/// <summary>
/// EventListenerData
/// </summary>
public class EventListenerData
{
/// <summary>
/// The _event listener.
/// </summary>
private object _eventListener;
public object eventListener
{
get
{
return _eventListener;
}
set
{
_eventListener = value;
}
}
/// <summary>
/// 事件名
/// </summary>
private string _eventName_string;
public string eventName
{
get
{
return _eventName_string;
}
set
{
_eventName_string = value;
}
}
/// <summary>
/// 事件委托
/// </summary>
private EventDelegate _eventDelegate;
public EventDelegate eventDelegate
{
get
{
return _eventDelegate;
}
set
{
_eventDelegate = value;
}
}
private EventDispatcherAddMode _eventListeningMode;
public EventDispatcherAddMode eventListeningMode
{
get
{
return _eventListeningMode;
}
set
{
_eventListeningMode = value;
}
}
///<summary>
/// Constructor
///</summary>
public EventListenerData (object aEventListener, string aEventName_string, EventDelegate aEventDelegate, EventDispatcherAddMode aEventListeningMode )
{
_eventListener = aEventListener;
_eventName_string = aEventName_string;
_eventDelegate = aEventDelegate;
_eventListeningMode = aEventListeningMode;
}
/// <summary>
/// Deconstructor
/// </summary>
//~EventListenerData ( )
//{
//Debug.Log ("EventListenerData.deconstructor()");
//}
}
}
使用的例子：新建两个游戏对象然后挂上脚本！
namespace EventDispatcher
{
/// <summary>
/// Test event.
/// </summary>
public class SampleEvent : Event
{
// GETTER / SETTER
/// <summary>
/// An example of event-specific data you can add in.
/// </summary>
private string _customValue_string;
public string customValue
{
get {
return _customValue_string;
}
set {
_customValue_string = value;
}
}
/// <summary>
/// The Event Type Name
/// </summary>
public static string SAMPLE_EVENT = "SAMPLE_EVENT";
/// <summary>
/// Initializes a new instance of the <see cref="com.rmc.projects.event_dispatcher.SampleEvent"/> class.
/// </summary>
/// <param name="aType_str">A type_str.</param>
public SampleEvent (string aType_str ) : base (aType_str)
{
}
/// <summary>
/// Releases unmanaged resources and performs other cleanup operations before the
/// <see cref="com.rmc.projects.event_dispatcher.SampleEvent"/> is reclaimed by garbage collection.
/// </summary>
//~SampleEvent ( )
//{
// Debug.Log ("SampleEvent.deconstructor()");
//}
}
}using UnityEngine;
namespace EventDispatcher
{
public class SampleObservedComponent : MonoBehaviour
{
/// <summary>
/// The event dispatcher.
/// </summary>
public EventDispatcher eventDispatcher;
/// <summary>
/// Initializes a new instance of the <see cref="com.rmc.projects.event_dispatcher.SampleObservedComponent"/> class.
/// </summary>
public SampleObservedComponent ()
{
eventDispatcher = new EventDispatcher (this);
}
///<summary>
/// Use this for initialization
///</summary>
public void Start ()
{
SampleEvent sampleEvent = new SampleEvent (SampleEvent.SAMPLE_EVENT);
sampleEvent.customValue = "foo";
Debug.Log ("Dispatching: SampleEvent " + sampleEvent);
eventDispatcher.dispatchEvent (sampleEvent);
}
/// <summary>
/// Raises the destroy event.
/// </summary>
public void OnDestroy ()
{
// CLEANUP MEMORY
eventDispatcher.removeAllEventListeners();
eventDispatcher = null;
}
}
}using UnityEngine;
namespace EventDispatcher
{
public class SampleObserverComponent : MonoBehaviour
{
/// <summary>
/// The sample observed game object.
/// </summary>
public SampleObservedComponent sampleObservedGameObject;
public void Start ()
{
/*
* 注意： 这里observer和observed是 MonoBehavior 子类
**/
sampleObservedGameObject.eventDispatcher.addEventListener (SampleEvent.SAMPLE_EVENT, _onSampleEvent);
}
void Update ()
{
//Debug.Log (sampleObservedGameObject.eventDispatcher);
}
/// <summary>
/// Raises the destroy event.
/// </summary>
public void OnDestroy ()
{
// CLEANUP MEMORY
sampleObservedGameObject.eventDispatcher.removeEventListener (SampleEvent.SAMPLE_EVENT, _onSampleEvent);
}
//--------------------------------------
// Events
//--------------------------------------
/// <summary>
/// _ons the sample event.
/// </summary>
/// <param name="aIEvent">A I event.</param>
public void _onSampleEvent (IEvent aIEvent)
{
Debug.Log ("\tListening: _onSampleEvent() aIEvent: " + aIEvent + " with customValue: " + (aIEvent as SampleEvent).customValue);
}
}
}原文：http://blog.csdn.net/u010019717/article/details/44537477