观察者模式

这次的内容有点类似设计模式里的观察者模式。但是和常规意义上的观察者模式也不是完全一致,所以各位就不要咬文嚼字啦!咦?设计模式?!不懂!没关系,说不定你以前就用过。


开场白


我们来想象一个场景。在加载一个模型时,你需要从网上下载,但是你并不知道下载需要花费多少时间。你所知道的是,当下载完成后,就可以把模型放在特定位置上,开始游戏。那么,我们怎样才能判断下载完成呢?
一个简单的方法是,在每一帧的时候都判断下载是否完成,完成后就可以继续后面的工作。因此,我们可以这样做,我们告诉一个管理器,嗨,你帮我盯着点,看下载完了没有,完了就叫我一声,好让我执行XXX函数。我们今天要做的,就是构造这样一个管理器。


实现

注意,下面的代码依赖于之前所讲到的单例模式

我们不防把上面这样一件工作成为一个计数器——Timer(这个名字可能不太恰当),把需要被通知者成为观察者——Oberver,而像下载管理器这样的对象成为一个主题——Subject。

首先,我们来定义观察者和主题对象 TimerObserverOrSubject.cs如下:
[csharp]  view plain copy
  1. using UnityEngine;  
  2. using System.Collections;  
  3.   
  4. public class TimerObserverOrSubject : MonoBehaviour {  
  5.       
  6.     virtual protected void OnDestroy ()  
  7.     {  
  8.         if(Singleton.IsCreatedInstance("TimerController"))  
  9.         {  
  10.             (Singleton.getInstance("TimerController"as TimerController).ClearTimer(this);  
  11.         }  
  12.     }  
  13. }  


TimerObserverOrSubject.cs的内容非常简单,它的工作就是在该脚本被析构时,及时地从计数器管理器里面删除涉及这个对象的所有Timer。

计数器管理器的脚本—— TimerController.cs如下:
[csharp]  view plain copy
  1. using UnityEngine;  
  2. using System.Collections;  
  3. using System.Collections.Generic;  
  4.    
  5. public class TimerController : MonoBehaviour {  
  6.       
  7.     public delegate void OnCallBack(object arg);  
  8.     public delegate bool OnIsCanDo(object arg);  
  9.       
  10.     public class Timer {  
  11.         public TimerObserverOrSubject m_Observer;  
  12.         public OnCallBack m_Callback = null;  
  13.         public object m_Arg = null;  
  14.           
  15.         public TimerObserverOrSubject m_Subject;  
  16.         public OnIsCanDo m_IsCanDoFunc = null;   
  17.         public object m_ArgForIsCanDoFunc = null;  
  18.           
  19.         public float m_PassTime = 0;  
  20.           
  21.         public Timer(TimerObserverOrSubject observer, OnCallBack callback, object arg,   
  22.             TimerObserverOrSubject subject, OnIsCanDo isCanDoFunc, object argForIsCanDo) {  
  23.             m_Observer = observer;  
  24.             m_Callback = callback;  
  25.             m_Arg = arg;  
  26.                
  27.             m_Subject = subject;  
  28.             m_IsCanDoFunc = isCanDoFunc;  
  29.             m_ArgForIsCanDoFunc = argForIsCanDo;  
  30.               
  31.             m_PassTime = 0;  
  32.                 }  
  33.           
  34.         public Timer(TimerObserverOrSubject observer, OnCallBack callback, object arg, float time) {  
  35.             m_Observer = observer;  
  36.             m_Callback = callback;  
  37.             m_Arg = arg;  
  38.               
  39.             m_Subject = null;  
  40.             m_IsCanDoFunc = null;  
  41.             m_ArgForIsCanDoFunc = null;  
  42.               
  43.             m_PassTime = time;  
  44.         }  
  45.         }  
  46.     private List<Timer> m_Timers = new List<Timer>();  
  47.     private List<Timer> m_NeedRemoveTimer = new List<Timer>();  
  48.     private List<Timer> m_CurRunTimer = new List<Timer>();  
  49.        
  50.     /// <summary>  
  51.     /// Sets the timer.  
  52.     /// </summary>  
  53.     /// <param name='observer'>  
  54.     /// The TimerObserverOrSubject you need to listen  
  55.     /// </param>  
  56.     /// <param name='callback'>  
  57.     /// The callback when condition is true.  
  58.     /// </param>  
  59.     /// <param name='arg'>  
  60.     /// Argument of the callback.  
  61.     /// </param>  
  62.     /// <param name='observer'>  
  63.     /// The TimerObserverOrSubject you need to observe  
  64.     /// </param>  
  65.     /// <param name='isCanDoFunc'>  
  66.     /// The condition function, must return a boolean.  
  67.     /// </param>  
  68.     /// <param name='argForIsCanDo'>  
  69.     /// Argument for condition function.  
  70.     /// </param>  
  71.     public void SetTimer(TimerObserverOrSubject observer, OnCallBack callback ,object arg,  
  72.         TimerObserverOrSubject subject, OnIsCanDo isCanDoFunc,object argForIsCanDo) {  
  73.         if (observer == null || subject == null || callback == null || isCanDoFunc == nullreturn;  
  74.           
  75.         if (isCanDoFunc(argForIsCanDo)) {  
  76.             callback(arg);  
  77.             return;  
  78.         }  
  79.           
  80.         Timer timer = new Timer(observer, callback, arg, subject, isCanDoFunc, argForIsCanDo);       
  81.         m_Timers.Add(timer);  
  82.     }  
  83.        
  84.     /// <summary>  
  85.     /// Sets the timer.  
  86.     /// </summary>  
  87.     /// <param name='observer'>  
  88.     /// The TimerObserverOrSubject you need to listen  
  89.     /// </param>  
  90.     /// <param name='callback'>  
  91.     /// The callback when time is up.  
  92.     /// </param>  
  93.     /// <param name='arg'>  
  94.     /// Argument of the callback.  
  95.     /// </param>  
  96.     /// <param name='timepass'>  
  97.     /// Timepass before calling the callback.  
  98.     /// </param>  
  99.     public void SetTimer(TimerObserverOrSubject observer, OnCallBack callback , object arg, float timepass) {  
  100.         if (observer != null && callback != null) {             
  101.             Timer timer = new Timer(observer, callback, arg, timepass);  
  102.             m_Timers.Add(timer);  
  103.         }  
  104.     }  
  105.        
  106.     /// <summary>  
  107.     /// Clears all Timers of the observer.  
  108.     /// </summary>  
  109.     /// <param name='observer'>  
  110.     /// The TimerObserverOrSubject you need to clear  
  111.     /// </param>  
  112.     public void ClearTimer(TimerObserverOrSubject observer) {  
  113.         List<Timer> needRemovedTimers = new List<Timer>();  
  114.           
  115.         foreach (Timer timer in m_Timers) {  
  116.             if (timer.m_Observer == observer || timer.m_Subject) {  
  117.                 needRemovedTimers.Add(timer);  
  118.             }  
  119.         }  
  120.           
  121.         foreach (Timer timer in needRemovedTimers) {  
  122.             m_Timers.Remove(timer);  
  123.         }  
  124.     }  
  125.        
  126.         // Update is called once per frame  
  127.         void Update ()   
  128.     {  
  129.         InitialCurTimerDict();  
  130.         RunTimer();  
  131.         RemoveTimer();  
  132.         }  
  133.       
  134.     private void InitialCurTimerDict() {  
  135.         m_CurRunTimer.Clear();  
  136.           
  137.         foreach (Timer timer in m_Timers) {  
  138.             m_CurRunTimer.Add(timer);  
  139.         }  
  140.     }  
  141.       
  142.     private void RunTimer() {  
  143.         m_NeedRemoveTimer.Clear();  
  144.           
  145.         foreach (Timer timer in m_CurRunTimer) {          
  146.             if (timer.m_IsCanDoFunc == null) {  
  147.                 timer.m_PassTime =  timer.m_PassTime - Time.deltaTime;  
  148.                 if (timer.m_PassTime < 0) {  
  149.                     timer.m_Callback(timer.m_Arg);  
  150.                     m_NeedRemoveTimer.Add(timer);  
  151.                 }  
  152.             } else {  
  153.                 if (timer.m_IsCanDoFunc(timer.m_ArgForIsCanDoFunc)) {  
  154.                     timer.m_Callback(timer.m_Arg);  
  155.                     m_NeedRemoveTimer.Add(timer);  
  156.                 }  
  157.             }     
  158.         }  
  159.     }  
  160.       
  161.     private void RemoveTimer() {  
  162.         foreach (Timer timer in m_NeedRemoveTimer) {  
  163.             if (m_Timers.Contains(timer)) {  
  164.                 m_Timers.Remove(timer);  
  165.             }  
  166.         }  
  167.     }  
  168.   
  169. }  

首先,它定义了回调函数的类型:
[csharp]  view plain copy
  1. public delegate void OnCallBack(object arg);  
  2. public delegate bool OnIsCanDo(object arg);  

关于C#的委托机制,如果有童鞋不了解,请详见 官方文档。简单来说,委托类似一个函数指针,常被用于回调函数。

然后,定义了一个数据类型Timer用于保存一个计数器的各个信息。

接下来,就是TimerController的两个重要的SetTimer函数。我们先看第一个SetTimer函数:
[csharp]  view plain copy
  1. /// <summary>  
  2. /// Sets the timer.  
  3. /// </summary>  
  4. /// <param name='observer'>  
  5. /// The observer to observe the subject  
  6. /// </param>  
  7. /// <param name='callback'>  
  8. /// The callback when condition is true.  
  9. /// </param>  
  10. /// <param name='arg'>  
  11. /// Argument of the callback.  
  12. /// </param>  
  13. /// <param name='subject'>  
  14. /// The subject you need to observe  
  15. /// </param>  
  16. /// <param name='isCanDoFunc'>  
  17. /// The condition function, must return a boolean.  
  18. /// </param>  
  19. /// <param name='argForIsCanDo'>  
  20. /// Argument for condition function.  
  21. /// </param>  
  22. public void SetTimer(TimerObserverOrSubject observer, OnCallBack callback ,object arg,  
  23.     TimerObserverOrSubject subject, OnIsCanDo isCanDoFunc,object argForIsCanDo) {  
  24.     if (observer == null || subject == null || callback == null || isCanDoFunc == nullreturn;  
  25.       
  26.     if (isCanDoFunc(argForIsCanDo)) {  
  27.         callback(arg);  
  28.         return;  
  29.        }  
  30.       
  31.     Timer timer = new Timer(observer, callback, arg, subject, isCanDoFunc, argForIsCanDo);       
  32.     m_Timers.Add(timer);  
  33. }  


根据函数说明可以看出,它负责建立一个计数器,当subject的 isCanDoFunc( argForIsCanDo)函数返回true时,通知 observer,执行 observer的 callback( arg)函数。

第二个SetTimer函数更简单:
[csharp]  view plain copy
  1. /// <summary>  
  2. /// Sets the timer.  
  3. /// </summary>  
  4. /// <param name='observer'>  
  5. /// The observer to observe the subject  
  6. /// </param>  
  7. /// <param name='callback'>  
  8. /// The callback when time is up.  
  9. /// </param>  
  10. /// <param name='arg'>  
  11. /// Argument of the callback.  
  12. /// </param>  
  13. /// <param name='timepass'>  
  14. /// Timepass before calling the callback.  
  15. /// </param>  
  16. public void SetTimer(TimerObserverOrSubject observer, OnCallBack callback , object arg, float timepass) {  
  17.     if (observer != null && callback != null) {             
  18.         Timer timer = new Timer(observer, callback, arg, timepass);  
  19.         m_Timers.Add(timer);  
  20.     }  
  21. }  

它负责建立一个计数器,在 timepass的时间后,通知observer,执行observer的callback(arg)函数。

Update()函数里面负责检查所有Timer是否可以触发以及是否需要删除。


例子



在这个例子里,我们需要在程序开始运行5秒后,打印一些信息。当然这个的实现有很多方法,这里我们使用今天实现的TimerController来实现。

TimerSample.cs的内容如下:
[csharp]  view plain copy
  1. using UnityEngine;  
  2. using System.Collections;  
  3.   
  4. public class TimerSample : TimerObserverOrSubject {  
  5.       
  6.     private TimerController m_TimerCtr = null;  
  7.       
  8.     private bool m_IsCanDisplay = false;  
  9.       
  10.     private string m_DisplayContent = "Hello, candycat!";  
  11.       
  12.     // Use this for initialization  
  13.     void Start () {  
  14.         m_TimerCtr = Singleton.getInstance("TimerController"as TimerController;  
  15.           
  16.         //m_TimerCtr.SetTimer(this, Display, m_DisplayContent, 5);  
  17.           
  18.         m_TimerCtr.SetTimer(this, Display, nullthis, IsCanDisplay, null);  
  19.           
  20.         StartCoroutine(DelayDisplay());  
  21.     }  
  22.       
  23.     void Display(object arg) {  
  24.         if (arg == null) {  
  25.             Debug.Log(m_DisplayContent);  
  26.         } else {  
  27.             string content = arg as string;  
  28.           
  29.             Debug.Log(content);  
  30.         }  
  31.     }  
  32.       
  33.     bool IsCanDisplay(object arg) {  
  34.         return m_IsCanDisplay;  
  35.     }  
  36.       
  37.     IEnumerator DelayDisplay() {  
  38.         yield return new WaitForSeconds(5.0f);  
  39.           
  40.         m_IsCanDisplay = true;  
  41.     }  
  42.       
  43.     // Update is called once per frame  
  44.     void Update () {  
  45.       
  46.     }  
  47. }  

首先,它向 TimerController请求注册了一个计时器。这里,它的条件是 IsCanDisplay函数,它返回bool值 m_IsCanDisplay。而这个值将会在5秒后,通过协同函数 DelayDisplay来由false置为true。当其为true时,TimerController就将通知TimerSample调用 Display函数。

我们将第16行代码注释解开,并将18-20行代码注释掉,则可以达到相同的效果。


结束语


C#的委托机制还是非常常用的,使用Unity的童鞋最好还是了解一下。关于TimerController的执行效率,由于它是每一帧都要去判断所有的condition函数,所以应当让condition函数中的逻辑尽可能简单。

好了,这次就到这里,如果有更好的想法,或者这里的代码有什么问题,都非常欢迎指正。谢谢阅读!
已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页