【unity】ngui事件系统实现参考

时间  2020-01-27
标签 unity ngui 事件 系统 实现 参考 繁體版
原文   原文链接

http://blog.csdn.net/abcdtty/article/details/13021237html

事件系统是个好东西,不只调用方便,并且能最大程度的下降系统各部分的耦合度. 网上有关这方面的东西不少不少,我也用过很多,最近发现一个比较优秀的,即快速(不用遍历大串的方法列表)又简洁(代码不多). 分享上来和新手同窗们共勉.ide

 

具体实现以下:this


1.先定义事件参数类: EventArgs 是基类,不建议直接使用,由于通用的东西针对性不强,容易混乱(特别是找bug 的时候)... MyEvent 的具体的派生类,建议的使用方法就是每一个种类的事件派生一个类,好比UIEvent,ServerEvent神马的,根据具体做用来命名.spa

 

[csharp] view plaincopyprint?.net

  1. /// <summary>  orm

  2. /// 事件参数基类  htm

  3. /// </summary>  blog

  4. public class EventArgs  事件

  5. {  ip

  6.     public object Parameter;  

  7. }  

  8.   

  9. /// <summary>  

  10. /// 自定义事件参数  

  11. /// </summary>  

  12. public class MyEvent : EventArgs  

  13. {  

  14.     public int ID;  

  15.     public string Name; // ...etc   

  16. }  

    /// <summary>
    /// 事件参数基类
    /// </summary>
    public class EventArgs
    {
        public object Parameter;
    }

    /// <summary>
    /// 自定义事件参数
    /// </summary>
    public class MyEvent : EventArgs
    {
        public int ID;
        public string Name; // ...etc 
    }

 


2. 事件管理类: 能够看出是一个单例类,世界各地都能直接调用. _delegates负责保存全部事件接收方法,事件被按类型存在里面,同一个类型不管几条记录都只占一个项(因此不用遍历大串的方法列表)

 

[csharp] view plaincopyprint?

  1. /// <summary>  

  2. /// 事件管理类  

  3. /// </summary>  

  4. public class EventManager  

  5. {  

  6.     //单例模式.  

  7.     public static readonly EventManager Instance = new EventManager();  

  8.     private EventManager() { }  

  9.   

  10.     //事件委托.  

  11.     public delegate void EventDelegate<T>(T e) where T : EventArgs;  

  12.   

  13.     //保存全部事件<span style="font-family: Arial,Helvetica,sans-serif;">接收方法</span>.  

  14.     readonly Dictionary<Type, Delegate> _delegates = new Dictionary<Type, Delegate>();  

  15.   

  16.     //添加一个事件接收方法.  

  17.     public void AddListener<T>(EventDelegate<T> listener) where T : EventArgs  

  18.     {  

  19.         Delegate d;  

  20.         if (_delegates.TryGetValue(typeof(T), out d))  

  21.         {  

  22.             _delegates[typeof(T)] = Delegate.Combine(d, listener);  

  23.         }  

  24.         else  

  25.         {  

  26.             _delegates[typeof(T)] = listener;  

  27.         }  

  28.     }  

  29.   

  30.     //删除一个事件接受方法  

  31.     public void RemoveListener<T>(EventDelegate<T> listener) where T : EventArgs  

  32.     {  

  33.         Delegate d;  

  34.         if (_delegates.TryGetValue(typeof(T), out d))  

  35.         {  

  36.             Delegate currentDel = Delegate.Remove(d, listener);  

  37.   

  38.             if (currentDel == null)  

  39.             {  

  40.                 _delegates.Remove(typeof(T));  

  41.             }  

  42.             else  

  43.             {  

  44.                 _delegates[typeof(T)] = currentDel;  

  45.             }  

  46.         }  

  47.     }  

  48.   

  49.     //发送事件.  

  50.     public void Send<T>(T e) where T : EventArgs  

  51.     {  

  52.         if (e == null)  

  53.         {  

  54.             throw new ArgumentNullException("e");  

  55.         }  

  56.   

  57.         Delegate d;  

  58.         if (_delegates.TryGetValue(typeof(T), out d))  

  59.         {  

  60.             EventDelegate<T> callback = d as EventDelegate<T>;  

  61.             if (callback != null)  

  62.             {  

  63.                 callback(e);  

  64.             }  

  65.         }  

  66.     }  

  67. }  

    /// <summary>
    /// 事件管理类
    /// </summary>
    public class EventManager
    {
        //单例模式.
        public static readonly EventManager Instance = new EventManager();
        private EventManager() { }

        //事件委托.
        public delegate void EventDelegate<T>(T e) where T : EventArgs;

        //保存全部事件接收方法.
        readonly Dictionary<Type, Delegate> _delegates = new Dictionary<Type, Delegate>();

        //添加一个事件接收方法.
        public void AddListener<T>(EventDelegate<T> listener) where T : EventArgs
        {
            Delegate d;
            if (_delegates.TryGetValue(typeof(T), out d))
            {
                _delegates[typeof(T)] = Delegate.Combine(d, listener);
            }
            else
            {
                _delegates[typeof(T)] = listener;
            }
        }

        //删除一个事件接受方法
        public void RemoveListener<T>(EventDelegate<T> listener) where T : EventArgs
        {
            Delegate d;
            if (_delegates.TryGetValue(typeof(T), out d))
            {
                Delegate currentDel = Delegate.Remove(d, listener);

                if (currentDel == null)
                {
                    _delegates.Remove(typeof(T));
                }
                else
                {
                    _delegates[typeof(T)] = currentDel;
                }
            }
        }

        //发送事件.
        public void Send<T>(T e) where T : EventArgs
        {
            if (e == null)
            {
                throw new ArgumentNullException("e");
            }

            Delegate d;
            if (_delegates.TryGetValue(typeof(T), out d))
            {
                EventDelegate<T> callback = d as EventDelegate<T>;
                if (callback != null)
                {
                    callback(e);
                }
            }
        }
    }

3. 使用示例: 使用灰常简单,以下: 先添加一个事件接收方法(就是当事件被发出的时候会调用的接收方法), 而后须要触发事件时使用Send方法发送便可.

 

[csharp] view plaincopyprint?

  1. /// <summary>  

  2. /// 使用示例  

  3. /// </summary>  

  4. public class Test  

  5. {  

  6.     public Test()  

  7.     {  

  8.         //添加事件接收方法  

  9.         EventManager.Instance.AddListener<MyEvent>(ReceiveEvent);  

  10.   

  11.   

  12.         //发送MyEvent事件, 以后ReceiveEvent(MyEvent e)方法将被调用.  

  13.         MyEvent e = new MyEvent(); //事件参数.  

  14.         e.ID =0;  

  15.         e.Name = "XOXOOX";  

  16.         //事件发送  

  17.         EventManager.Instance.Send<MyEvent>(e);  

  18.     }  

  19.   

  20.     //接收MyEvent事件的方法.  

  21.     public void ReceiveEvent(MyEvent e)  

  22.     {  

  23.           

  24.     }  

  25.   

  26. }  

 

    /// <summary>
    /// 使用示例
    /// </summary>
    public class Test
    {
        public Test()
        {
            //添加事件接收方法
            EventManager.Instance.AddListener<MyEvent>(ReceiveEvent);


            //发送MyEvent事件, 以后ReceiveEvent(MyEvent e)方法将被调用.
            MyEvent e = new MyEvent(); //事件参数.
            e.ID =0;
            e.Name = "XOXOOX";
            //事件发送
            EventManager.Instance.Send<MyEvent>(e);
        }

        //接收MyEvent事件的方法.
        public void ReceiveEvent(MyEvent e)
        {
            
        }

    }

http://www.xuebuyuan.com/1562272.html

窗体有三种:几秒后消失的,按肯定后消失的,选择是或者否而后消失的

 

一个比较简单高效的事件系统,
EventManager.Instance.AddListener<UINotificaionArgs>(CallNotification);//注册事件
//触发弹窗的方法
EventManager.Instance.Send(new UINotificationArgs(){NMessageType = NMessageType.AskForYesOrNot,del = 你要执行的方法 ,Infomation  = 你要显示的信息});//这个是带有按下肯定后执行相应方法的弹窗
EventManager.Instance.Send(new UINotificationArgs(){NMessageType = NMessageType.AskForOk,Infomation  = 你要显示的信息});//这个是没有方法,但要你按下确认才会消失的弹窗
EventManager.Instance.Send(new UINotificationArgs(){NMessageType = NMessageType.NoAsk,Infomation  = 你要显示的信息,WaitTime = 4f});//这个是没有按钮,可是会在几秒后弹窗消失的模式

//理解了这个事件系统就容易理解原理了
//至于具体的NGUI实现,看下面的变量名称也大约能明白了,工程无法上传

 

 

using UnityEngine;
using System.Collections;

public class UINotificaionArgs : EventArgs {
	private NMessageType nMessageType;
	public NMessageType NMessageType {
		get {
			return nMessageType;
		}
		set {
			nMessageType = value;
		}
	}
	private string infomation;
	public string Infomation {
				get {
						return infomation;
				}
				set {
						infomation = value;
				}
		}
	private float  waitTime;
	public float WaitTime {
		get {
			return waitTime;
		}
		set {
			waitTime = value;
		}
	}


	//public  delegate void NotificationDel();
	public DelegateManage.NotificationDel del;
}



public  class DelegateManage
{
	public  delegate void NotificationDel();
}

public enum NMessageType
{
	NoAsk,
	AskForOk,
	AskForYesOrNot

}

 

 

以上是事件的内容部分,传递三个参数,一个是弹窗的类型,一个是须要等待的时间(第一种窗体须要),一个按下肯定后执行的方法的委托

 

下面的是弹窗的具体管理组件

首先注册事件

而后是根据传递来的事件的具体内容,执行相关的方法

最后的两个方法是为按钮准备的

按下yes以后执行pressOk()

就调用了经过事件传递的,按下肯定后,须要执行的方法了

 

using UnityEngine;
using System.Collections;

public class NotifacationManager : MonoBehaviour {
	public UILabel  Info;
	public GameObject Ask;
	public GameObject AskOrNot;
	private NMessageType messageType;
	private float WaitTime;
	private DelegateManage.NotificationDel del;


	void Start()
	{
		EventManager.Instance.AddListener<UINotificaionArgs>(CallNotification);

	}

	public void DisplayWindow()
	{
		foreach (Transform child in this.transform) {
			child.gameObject.SetActive(true);
				}
	}

	public void HideWindow()
	{
		foreach (Transform child in this.transform) {
			child.gameObject.SetActive(false);
		}
	}

	private void CallNotification(UINotificaionArgs e)
	{
		DisplayWindow ();
		Info.text = e.Infomation;
		switch (e.NMessageType) 
		{
		case NMessageType.NoAsk:
			WaitTime = e.WaitTime;
			StartCoroutine(NoAsk());
			break;
		case NMessageType.AskForOk:
			del = e.del;
			AskForOk();
			break;
		case NMessageType.AskForYesOrNot:
			del = e.del;
			AskOkOrNot();
			break;
		}
	}

	IEnumerator  NoAsk()
	{
		Ask.SetActive (false);
		AskOrNot.SetActive (false);
		yield return new WaitForSeconds(WaitTime);
		HideWindow ();
	}
	void  AskForOk()
	{
		Ask.SetActive (true);
		AskOrNot.SetActive (false);
	}
	void  AskOkOrNot()
	{
		Ask.SetActive (false);
		AskOrNot.SetActive (true);
	}


	public void PressOK()
	{
		del ();
		HideWindow ();
	}

	public void PressNo()
	{
		HideWindow ();
	}

}
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程