2. 程式人生 > 其它 >Unity-自定義事件派發器的兩次嘗試

Unity-自定義事件派發器的兩次嘗試

阿新 • • 發佈：2022-05-28

一、前言：

在遊戲開發的很多時候，需要引用其他類的方法，但是一旦類多起來了，相互引用會導致引用關係混亂，極其難以閱讀。

以前初次做抖音小遊戲時，和一位經驗老道的cocos程式設計師合作，看到我寫的程式碼他不禁皺起眉頭，說我的引用關係太亂了，看不懂，但是他又不知道unity的事件派發器怎麼寫，就去網上找了一個。簡直驚豔到我了。後來在現在公司做，又見到了一種事件派發器，於是心生感慨，模仿寫了一個，並寫部落格記錄一下。

二、現在做的事件派發器

1.宣告對應的委託，此委託主要為事件用的。委託的所有返回型別都為Void，簡化派發器的複雜程度；明確委託的方法引數型別，有幾種型別就定義幾種委託。

public
 
 delegate void VoidDelegate();
public delegate void BoolDelegate(params bool[] parameters);
public delegate void NumberDelegate(params float[] parameters);
public delegate void GameObjectDelegate(params GameObject[] parameters);

2.儲存容器，用於儲存事件

private static List<VoidDelegate> GameStart_List;

3.監聽者，暴露給外部呼叫者的介面，對監聽者的+=或-=對應容器裡的Add和Remove

public static event VoidDelegate GameStart_Listener
    {
        add
        {
            if(value != null)
            {
                if(GameStart_List == null)
                {
                    GameStart_List = new List<VoidDelegate>(1
 
);
                }
                GameStart_List.Add(value);
            }
        }
        remove
        {
            if(value != null)
            {
                for(int i = 0;i<GameStart_List.Count;i++)
                {
                    if(GameStart_List[i] != null && GameStart_List[i].Equals(value))
                    {
                        GameStart_List.RemoveAt(i);
                        break;
                    }
                }
            }
        }
    }

4.派發者，因為event只能在宣告類內部Invoke，所以需要暴露給外部呼叫者介面

public static void GameStart_Dispatch()
    {
        if(GameStart_List == null || GameStart_List.Count <= 0)
        {
            return;
        }
        for(int i = 0;i < GameStart_List.Count;i++)
        {
            GameStart_List[i]?.Invoke();
        }
    }

5.上文可看見我的事件叫GameStart,那麼我想新增一個GameEnd的事件，豈不是又要寫一遍？而且假如我的方法引數是float呢？是bool呢？是GameObject呢？豈不是改動很大？所以我在Unity做了一個自動生成事件的工具

5.1 定義ScriptObject作為配置檔案，可隨時修改以新增或者刪除事件

[CreateAssetMenu]
public class EventHandlerSetting:ScriptableObject
{
    public List<EventType> types;
    public List<EventItem> items;
}

[System.Serializable]
public class EventItem
{
    public string eventName;
    public string typeName;
}

[System.Serializable]
public class EventType
{
    public string typeName;
    public string typeDelegate;
}

 5.2 自動生成指令碼工具

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;

public class CodeGen
{
    private static string SettingPath = @"EventHandleSetting";
    private static EventHandlerSetting SettingObj;
    private static string CodePath = @"Assets\EventHandler\";
    private static string CodeName = "EventHandler.cs";
    private static string LineFeed = "\r\n";
    private static string LineTable = "\t";


    [MenuItem("Tools/EventCodeGen")]
    public static void CreateEventCode()
    {
        if (File.Exists(CodePath+CodeName))
        {
            File.Delete(CodePath + CodeName);
        }
        File.Create(CodePath + CodeName).Dispose();
        LoadSetting();

        File.AppendAllText(CodePath + CodeName, CreateNamespace());
        File.AppendAllText(CodePath + CodeName, CreateDelegate());
        File.AppendAllText(CodePath + CodeName, CreateClass());

        AssetDatabase.Refresh();
    }

    /// <summary>
    /// 載入配置檔案
    /// </summary>
    static void LoadSetting()
    {
        SettingObj = Resources.Load<EventHandlerSetting>(SettingPath);
    }

    static string CreateNamespace()
    {
        StringBuilder result = new StringBuilder();
        result.Append("using System;" + LineFeed);
        result.Append("using System.Collections;" + LineFeed);
        result.Append("using System.Collections.Generic;" + LineFeed);
        result.Append("using UnityEngine;" + LineFeed+LineFeed);
        return result.ToString();
    }

    /// <summary>
    /// 建立委託型別
    /// </summary>
    /// <returns></returns>
    static string CreateDelegate()
    {
        StringBuilder result = new StringBuilder();
        string commnPrefix = "public delegate void ";
        using (var e = SettingObj.types.GetEnumerator())
        {
            while (e.MoveNext())
            {
                result.Append(commnPrefix + e.Current.typeDelegate + ";" + LineFeed);
            }
        }
        result.Append(LineFeed);
        return result.ToString();
    }

    /// <summary>
    /// 建立EventHandler類
    /// </summary>
    /// <returns></returns>
    static string CreateClass()
    {
        StringBuilder result = new StringBuilder();
        result.Append("public class EventHandler"+LineFeed);
        result.Append("{"+LineFeed);
        List<EventItem> ls = SettingObj.items;
        for (int i = 0; i < ls.Count; i++)
        {
            string eventName = ls[i].eventName;
            string eventType = ls[i].typeName;
            result.Append(CreateEvent(eventName, eventType));
        }
        result.Append("}");
        return result.ToString();
    }

    /// <summary>
    /// 建立事件派發器
    /// </summary>
    /// <param name="eventName"></param>
    /// <param name="eventType"></param>
    /// <returns></returns>
    static string CreateEvent(string eventName,string eventType)
    {
        StringBuilder result = new StringBuilder();
        result.Append(LineFeed + "#region " + eventName + LineFeed);
        result.Append(MutiLineTable(1) + string.Format("private static List<{0}> {1}_List;", eventType + "Delegate", eventName) + LineFeed);//建立List
        result.Append(CreateListener(eventName, eventType));
        result.Append(CreateDispatch(eventName, eventType));
        result.Append("#endregion"+LineFeed);
        return result.ToString();
    }

    /// <summary>
    /// 建立Listener
    /// </summary>
    /// <param name="eventName"></param>
    /// <param name="eventType"></param>
    /// <returns></returns>
    static string CreateListener(string eventName,string eventType)
    {
        StringBuilder result = new StringBuilder();
        result.Append(MutiLineTable(1) + string.Format("public static event {0} {1}_Listener", eventType + "Delegate", eventName) + LineFeed);
        result.Append(MutiLineTable(1) + "{" + LineFeed);
        #region add
        result.Append(MutiLineTable(2) + "add" + LineFeed);
        result.Append(MutiLineTable(2) + "{" + LineFeed);
        result.Append(MutiLineTable(3) + "if(value != null)" + LineFeed);
        result.Append(MutiLineTable(3) + "{" + LineFeed);
        result.Append(MutiLineTable(4) + string.Format("if({0}_List == null)", eventName) + LineFeed);
        result.Append(MutiLineTable(4) + "{" + LineFeed);
        result.Append(MutiLineTable(5) + string.Format("{0}_List = new List<{1}>(1);", eventName, eventType + "Delegate")+LineFeed);
        result.Append(MutiLineTable(4) + "}" + LineFeed);
        result.Append(MutiLineTable(4) + string.Format("{0}_List.Add(value);", eventName) + LineFeed);
        result.Append(MutiLineTable(3) + "}" + LineFeed);
        result.Append(MutiLineTable(2) + "}" + LineFeed);
        #endregion
        #region remove
        result.Append(MutiLineTable(2) + "remove" + LineFeed);
        result.Append(MutiLineTable(2) + "{" + LineFeed);
        result.Append(MutiLineTable(3) + "if(value != null)" + LineFeed);
        result.Append(MutiLineTable(3) + "{" + LineFeed);
        result.Append(MutiLineTable(4) + string.Format("for(int i = 0;i<{0}_List.Count;i++)", eventName) + LineFeed);
        result.Append(MutiLineTable(4) + "{" + LineFeed);
        result.Append(MutiLineTable(5) + string.Format("if({0}_List[i] != null && {1}_List[i].Equals(value))",eventName,eventName) + LineFeed);
        result.Append(MutiLineTable(5) + "{" + LineFeed);
        result.Append(MutiLineTable(6) + string.Format("{0}_List.RemoveAt(i);" ,eventName) + LineFeed);
        result.Append(MutiLineTable(6) + "break;" + LineFeed);
        result.Append(MutiLineTable(5) + "}" + LineFeed);
        result.Append(MutiLineTable(4) + "}" + LineFeed);
        result.Append(MutiLineTable(3) + "}" + LineFeed);
        result.Append(MutiLineTable(2) + "}" + LineFeed);
        #endregion
        result.Append(MutiLineTable(1) + "}" + LineFeed);
        return result.ToString();
    }

    /// <summary>
    /// 建立Dispatch
    /// </summary>
    /// <param name="eventName"></param>
    /// <param name="eventType"></param>
    /// <returns></returns>
    static string CreateDispatch(string eventName,string eventType)
    {
        StringBuilder result = new StringBuilder();
        result.Append(MutiLineTable(1) + string.Format("public static void {0}_Dispatch({1})", eventName, GetTypeParameter(eventType)) + LineFeed);
        result.Append(MutiLineTable(1) + "{" + LineFeed);
        result.Append(MutiLineTable(2) + string.Format("if({0}_List == null || {1}_List.Count <= 0)", eventName, eventName) + LineFeed);
        result.Append(MutiLineTable(2) + "{" + LineFeed);
        result.Append(MutiLineTable(3) + "return;" + LineFeed);
        result.Append(MutiLineTable(2) + "}" + LineFeed);
        result.Append(MutiLineTable(2) + string.Format("for(int i = 0;i < {0}_List.Count;i++)", eventName) + LineFeed);
        result.Append(MutiLineTable(2) + "{" + LineFeed);
        if (!string.IsNullOrEmpty(GetTypeParameter(eventType)))
        {
            result.Append(MutiLineTable(3) + string.Format("{0}_List[i]?.Invoke(parameters[i]);", eventName) + LineFeed);
        }
        else
        {
            result.Append(MutiLineTable(3) + string.Format("{0}_List[i]?.Invoke();", eventName) + LineFeed);
        }
        result.Append(MutiLineTable(2) + "}" + LineFeed);
        result.Append(MutiLineTable(1) + "}" + LineFeed);
        return result.ToString();
    }

    /// <summary>
    /// 獲取字串中括號中的內容
    /// </summary>
    /// <param name="typeName"></param>
    /// <returns></returns>
    static string GetTypeParameter(string typeName)
    {
        if (string.IsNullOrEmpty(typeName))
        {
            return string.Empty;
        }
        using (var e=SettingObj.types.GetEnumerator())
        {
            while (e.MoveNext())
            {
                if (e.Current.typeName==typeName)
                {
                    string @delegate = e.Current.typeDelegate;
                    string result = @delegate.Substring(@delegate.IndexOf("(") + 1, @delegate.IndexOf(")") - (@delegate.IndexOf("(") + 1));
                    Debug.Log(result);
                    return result;
                }
            }
        }
        return string.Empty;
    }

    /// <summary>
    /// 多個table
    /// </summary>
    /// <param name="count"></param>
    /// <returns></returns>
    static string MutiLineTable(int count)
    {
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < count; i++)
        {
            result.Append(LineTable);
        }
        return result.ToString() ;
    }
}
View Code

6.總結

當然，我的這一套事件系統肯定還是有問題的。如果方法引數不止一個float呢？第二個引數是bool？組合起來呢？還有一個問題是，配置檔案不夠人性化，全部都是字串，假如多大一個空格或者標點就廢了。還有一個非常嚴重的問題，如果生成的指令碼，在語法上有錯，不能通過編譯器，Unity就會報錯，再次點選生成就不會生效。我認識的一個主程讓我在Unity外部生成，不要依賴Unity，且使用類似Lua、Python這種指令碼語言，目前還不會哈哈哈哈。

三、以前做的事件派發器

1.需要一個通用的引數型別，叫EventArgs,基礎型別為Systen.Object

public class EventArgs
{
    private List<System.Object> parameters;
    public int Count
    {
        get
        {
            if (parameters!=null)
            {
                return parameters.Count;
            }
            else
            {
                Debug.Log("parameters is not init");
                return 0;
            }
        }
    }
    public EventArgs(params System.Object[] parameters)
    {
        if (this.parameters==null)
        {
            this.parameters = new List<object>();
        }
        for (int i = 0; i < parameters.Length; i++)
        {
            this.parameters.Add(parameters[i]);
        }
    }
    public System.Object this[int index]
    {
        get
        {
            if (index>=0||index<parameters.Count)
            {
                return parameters[index];
            }
            else
            {
                Debug.LogError("index must be in range of parameters");
                return null;
            }
        }
    }
}

2.還是那句老話，事件派發器需要容器、監聽、派發三部分。

public class EventDispatcher
{
    public delegate void Listener(EventArgs args);
    private static Dictionary<string, Listener> cacheEvents = new Dictionary<string, Listener>();

    public static void Attach(string tag,Listener listen)
    {
        if (cacheEvents==null)
        {
            cacheEvents = new Dictionary<string, Listener>();
        }
        if (cacheEvents.ContainsKey(tag))
        {
            Debug.LogWarning("this tag already exsit in cache,please check agin,tag name:" + tag);
            return;
        }
        if (listen==null)
        {
            Debug.LogWarning("listen is null,cache failed");
            return;
        }
        cacheEvents.Add(tag, listen);
    }

    public static void Detach(string tag)
    {
        if (!cacheEvents.ContainsKey(tag))
        {
            Debug.LogWarning("tag is not exsit in cache,tag name:"+tag);
            return;
        }
        cacheEvents.Remove(tag);
    }

    public static void Dispatch(string tag,EventArgs args)
    {
        if (!cacheEvents.ContainsKey(tag))
        {
            Debug.LogWarning("this tag does not exsit in cache,please check agin,tag name:" + tag);
            return;
        }
        if (cacheEvents[tag]==null)
        {
            Debug.LogWarning("this listen is null,invoke failed");
            return;
        }
        cacheEvents[tag].Invoke(args);
    }
}

3.總結：

此事件派發器也存在缺陷，任何方法的引數型別都會被轉換成System.Object型別，有多餘的封裝箱操作。且不能重複新增一個方法，至少他的tag不能一樣。程式碼可讀性差，報錯了都不知道在哪兒。

四、關於事件派發器自己的看法

我相信沒有完美的派發器這一說，好的派發器與壞的派發器區別在於，呼叫是否方便？會不會存在隱藏的危險bug？效能上如何？不同專案有不同的事件派發器，適合自己的才是最好的。如果強行將事件派發器做成那種萬金油工具，且不論他是否真的是萬金油，程式碼開發成本之大，耗費時間之長，也不是一般小遊戲公司能夠耗得起的。上文所述兩個派發器，實際上都可以用，而且經歷過實戰的，並沒有什麼大問題。

相關推薦

Unity-自定義事件派發器的兩次嘗試

一、前言： 在遊戲開發的很多時候，需要引用其他類的方法，但是一旦類多起來了，相互引用會導致引用關係混亂，極其難以閱讀。

Unity自定義事件系統

不記得之前寫沒寫過這個 網上有好多種寫法 但是這種比較簡潔 也沒啥內容，就定義一個程式碼裡面定義一個委託，指令碼繼承EventTrigger搞就完了，直接程式碼：

Unity Mirror 自定義序列化器傳輸資料

Mirror支援許多內建型別的傳輸，具體可參考Mirror的NetworkWriter類的定義。 而一些自定義的型別，比如下面這個：

Spring Boot專案中使用事件派發器模式

在專案開發中，會遇到如下情形：我們自己的服務訂閱、接收來自訊息佇列或者客戶端的事件和請求，基於不同的事件採取對應的行動，這種情況下適合應用派發器模式。

SpringBoot系列教程web篇之如何自定義引數解析器

SpringMVC提供了各種姿勢的http引數解析支援，從前面的GET/POST引數解析篇也可以看到，加一個@RequsetParam註解就可以將方法引數與http引數繫結，看到這時自然就會好奇這是怎麼做到的,我們能不能自己定義一種引數解析

SpringMVC自定義型別轉換器實現解析

這篇文章主要介紹了SpringMVC自定義型別轉換器實現解析,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

Spring自定義引數解析器程式碼例項

這篇文章主要介紹了Spring自定義引數解析器程式碼例項,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

unity自定義彈出框功能

本文例項為大家分享了unity自定義彈出框的具體方法，供大家參考，具體內容如下

Django 自定義分頁器的實現程式碼

為什麼要實現分頁？ 在大部分網站中分頁的功能都是必要的，尤其是在後臺管理中分頁更是不可或缺

Django中自定義模型管理器(Manager)及方法

1.自定義管理器(Manager) 在語句Book.objects.all()中,objects 是一個特殊的屬性,通過它來查詢資料庫,它就是模型的一個Manager.

Hibernate validator使用以及自定義校驗器註解

JSR-303 是 JAVA EE 6 中的一項子規範，叫做 Bean Validation，用於對 Java Bean 中的欄位的值進行驗證。Hibernate Validator則是Hibdernate提供的一種對該規範的實現。

flask框架自定義url轉換器操作詳解

本文例項講述了flask框架自定義url轉換器。分享給大家供大家參考，具體如下：

iOS自定義日期選擇器

前言 封裝了一個日期選擇器，解決兩個問題： 1、點選textField，鍵盤彈出和日期選擇器彈出的邏輯處理；

使用Vue 自定義檔案選擇器元件的例項程式碼

本文 GitHub https://github.com/qq44924588... 上已經收錄，更多往期高贊文章的分類，也整理了很多我的文件，和教程資料。歡迎Star和完善，大家面試可以參照考點複習，希望我們一起有點東西。

Java基於自定義類載入器實現熱部署過程解析

熱部署： 熱部署就是在不重啟應用的情況下，當類的定義即位元組碼檔案修改後，能夠替換該Class建立的物件。一般情況下，類的載入都是由系統自帶的類載入器完成，且對於同一個全限定名的java類，只能被載入一次，而且

SpringBoot Shiro配置自定義密碼加密器程式碼例項

shiro主要有三大功能模組： 1. Subject：主體，一般指使用者。 2. SecurityManager：安全管理器，管理所有Subject，可以配合內部安全元件。(類似於SpringMVC中的DispatcherServlet)

C#自定義格式提供器

將數字轉化為單詞 public class WordFormatProvider : IFormatProvider,ICustomFormatter { static readonly string[] _numberWords= new string[] { \"zero\",\"one\",\"two\",\"three\",\"four\",\"five\",\"six\

vue使用自定義事件的表單輸入元件用法詳解【日期元件與貨幣元件】

本文例項講述了vue使用自定義事件的表單輸入元件用法。分享給大家供大家參考，具體如下：

Netty原始碼分析之自定義編解碼器

在日常的網路開發當中，協議解析都是必須的工作內容，Netty中雖然內建了基於長度、分隔符的編解碼器，但在大部分場景中我們使用的都是自定義協議，所以Netty提供了 MessageToByteEncoder<I> 與 ByteToMessageD

從Node.js事件觸發器到Vue自定義事件的深入講解

Node.js中的事件觸發器所引發的思考 今天在看 Node.js 文件的時候講到事件觸發器，其中的 emit 方法讓我想到了 Vue 中的自定義事件，藉此我對 Vue 又有了新的理解，所以將我的理解記錄下來，留作學習筆記。