2. 程式人生 > >Unity 遊戲框架：資源管理神器 ResKit

Unity 遊戲框架：資源管理神器 ResKit

阿新 • • 發佈：2020-03-26

此篇文章準備了將近兩週的時間，寫了改，改了刪。之前有朋友反饋，上一個文章太冗長了，影響閱讀體驗，這一講就走個精簡路線。所以只要不是很重要的內容就都刪減掉了。

文章分兩個部分，第一部分是原理，第二部分是實戰。

原理部分，初學者儘量去理解就好，不用跟著敲，列出的程式碼都是示意程式碼。

實戰部分是留給初學者的，希望敲完程式碼，這樣有助於理解前邊的原理。

當然原理不是很難。

第一部分：原理

ResKit 中值得一說的 Feature 如下：

  • 引用計數器
  • 可以不傳 BundleName

當然也有很多不值得一提的 Feature。

  • 比如統一的載入 API，一個 ResLaoder.LoadSync API 可以載入 Resources/AssetBundle/PersistentDataPath/StreamingAssets，甚至是網路資源。這個很多開源方案都有實現。

  • Simulation Mode，這個功能最早源自於 Unity 官方推出的 AssetBundleManager，不過不維護了，被 AssetBundleBrowser 替代了。但是這個功能真的很方便就加入到 ResKit 裡了。

  • 物件池，是管理記憶體的一種手段，在 ResKit 中作用不是很大，但是是一個非常值得學習的優化工具，所以也列到本次 chat 裡了。

接下來就按著以上順序聊聊這些 Feature。

首先先看下 ResKit 示例程式碼。

// 在載入 AssetBundle 資源之前，要進行一次(只需一次) 初始化操作
ResMgr.Init();

// 申請一個載入器物件(從物件池中)
var loader = ResLoader.Allocate<ResLoader>();

// 載入 prefab
var smObjPrefab = loader.LoadSync<GameObject>("smObj");

// 載入 Bg
var bgTexture = loader.LoadSync<Texture2D>("Bg");

// 通過 AssetBundleName 載入 logo
var logoTexture = loader.LoadSync<Texture2D>("hometextures","logo");

// 當 GameOject Destroy 時候進行呼叫,這裡進行一個資源回收操作，會將每個引用計數器減一。
loader.Recycle2Cache();
loader = null;

最先登場的是 ResMgr。

ResMgr.Init() 進行了讀取配置操作。在遊戲啟動或者是熱更新完成之後可以呼叫一次。

第二登場的是 ResLoader。字如其意，就是資源載入器。使用者大部分時間都是和它打交道。

ResLoader.LoadSync 預設載入 AssetBundle 中的資源。

如果想載入 Resources 目錄下的資源，程式碼如下所示:

var someObjPrefab = loader.LoadSync<GameObject>("resources://someObj");

當然也可以擴充套件成支援載入網路資源等。

這裡關鍵的一點是 resources://

這個字首。和 https:// 或 http:// 類似，是一個路徑，和 www 的 file:// 的原理是一樣的。

實現比較簡單。核心程式碼如下：

        public static IRes Create(string assetName)
        {
            short assetType = 0;
            if (assetName.StartsWith("resources://"))
            {
                assetType = ResType.Internal;
            }
            else if (assetName.StartsWith("NetImage:"))
            {
                assetType = ResType.NetImageRes;
            }
            else if (assetName.StartsWith("LocalImage:"))
            {
                assetType = ResType.LocalImageRes;
            }
            else
            {
                var data = ResDatas.Instance.GetAssetData(assetName);
                if (data == null)
                {
                    Log.E("Failed to Create Res. Not Find AssetData:" + assetName);
                    return null;
                }

                assetType = data.AssetType;
            }

            return Create(assetName, assetType);
        }

這裡除了支援 resources:// 還支援網路圖片 NetImage: 和本地圖片 LocalImage: 的載入。

同樣也可以支援自定義格式，通過特殊的字首去決定資源如何載入、從哪裡載入、非同步還是同步等等，一個靈活的系提供應該如此。這裡不多說，文章的下半部分的實戰環節仔細講解。

接下來說一個比較重要的概念，引用計數。

雖然在以上的程式碼中看不出來引用計數的影子，但是他是整個 ResKit 的核心。

先進行一個簡單的入門。貼上筆者的專欄：Unity 遊戲框架搭建 (二十二) 簡易引用計數器。文章不長，足夠入門。

在講引用計數在 ResKit 中的應用之前，還要再重新介紹一次 ResMgr。

在開頭介紹了 ResMgr.Init 進行了讀取配置操作。配置檔案中則記錄的是 AssetBundle 和 Asset 資訊。

那 ResMgr 的職責是什麼呢?

字如其意就是管理資源。

以筆者的習慣，稱為 XXXMgr 或者 YYYManager 的都是一個容器，叫容器是因為裡邊維護了 List 或 Dictionary 等，用來對外提供查詢 API 和進行一些簡單的邏輯處理。

這裡的 ResMgr 就是 Res 的容器。Res 是一個類，它持有一個真正的資源物件（UnityEngine.Object）。有的 Res 是從 Resources 里加載進來的，在 ResKit 中叫做 InternalRes。有的 Res 從 AssetBundle 里加載進來的，這裡叫做 AssetRes/AssetBundleRes。它們都繼承一個共同的父類 Res，之間的區別只是載入的方式不同。

程式碼如下：InternalRes.cs

public class InternalRes : Res
{
    ...
    public void LoadSync()
    {
        mAsset = Resources.Load(AssetName);    
    }
    ...
}

AssetRes.cs

public class AssetRes : Res
{
    ...
    public void LoadSync()
    {
        mAsset = mAssetBundle.LoadAsset(AssetName);
    }
    ...
}

這裡每個 Res 都實現了引用計數器。那麼在什麼時候進行引用計數+1（Retain）操作呢?

ResMgr 對 ResLoader 提供一個 GetRes API，當 ResLoader 呼叫它的時候會對獲取的 Res 進行 Retain 操作。

這裡瞭解下 ResLoader 載入一個資源的步驟就知道了。

var smObjPrefab = loader.LoadSync<GameObject>("smObj");

以上這步操作做了一下事情:

  1. 判斷 loader 裡的 List<Res> 中有沒有載入過 Name 為 "smObj" 的 Res，如果載入過直接返回這個資源。
  2. 接著通過 GetRes 這個 API 從 ResMgr 獲取這個資源，獲取之後對這個 Res 進行 Retain 操作，之後將 Res 儲存到 loader 的 List<Res> 中，之後再返回給使用者。
  3. 在 ResMgr.GetRes 中，先判判斷容器中有沒有該 Res，如果沒有就建立一個出來加入到容器中，再返回給 ResLoader。

理解起來不難，程式碼如下：

ResLoader.cs

    public class ResLoader
    {       
        /// <summary>
        /// 持有的
        /// </summary>
        private List<Res> mResList = new List<Res>();

        public T Load<T>(string assetName, string assetBundleName = null) where T : Object
        {
            var loadedRes = mResList.Find(loadedAsset => loadedAsset.Name == assetName);

            if (loadedRes != null)
            {
                return loadedRes as T;
            }

            loadedRes = ResMgr.GetRes(assetName, assetBundleName);

            mResList.Add(loadedRes);

            return loadedRes.Asset as T;

        }
        ...
    }

ResMgr.cs

    public class ResMgr
    {
        /// <summary>
        /// 共享的 
        /// </summary>
        public static List<Res> SharedLoadedReses = new List<Res>();

        
        public static Res GetRes(string resName, string assetBundleName)
        {
            var retRes = SharedLoadedReses.Find(loadedAsset => loadedAsset.Name == resName);

            if (retRes != null)
            {
                retRes.Retain();

                return retRes;
            }

            if (resName.StartsWith("resources://"))
            {
                retRes = new ResourcesRes(resName);
            }
            else
            {
                retRes = new AssetRes(resName, assetBundleName);
            }

            retRes.Load();

            SharedLoadedReses.Add(retRes);

            retRes.Retain();

            return retRes;
        }
        ...
    }

到這裡，總結下:

  • ResLoader 中有個 ResList，用來快取從 ResMgr 中獲取的 Res。也就是使用者載入過的資源都會在 ResLoader 中快取一次，這裡快取的當然只是這個物件，並不是真正的資源。使用者可以同 Res 物件訪問真實的資源。
  • ResMgr 中有個 SharedLoadedReses，用來儲存共享的 Res。
  • 所以 ResMgr 中的 Res 會共享給，每個 ResLoader。
  • ResLoader 是 ResMgr 的一個分身，只不過每個分身從 ResMgr 獲取資源，都會對資源進行 Retain 操作。

什麼時候進行資源的 Release 操作呢?

就是當 ResLoader 呼叫 Recycle2Cache 時：

public class ResLoader
{
    ...
    public void Recycle2Cache()
    {
        foreach (var asset in mResList)
        {
            asset.Release();
        }
        
        mResList.Clear();
        mResList = null;
    }
}

程式碼比較簡單了。就是遍歷 List<Res>，對每個 Res 進行一個 Release 操作。當 每個資源引用計數 Release 到 0 的時候會呼叫對應的 Unload 操作。各個 Res 子類之間的 Unload 的區別 LoadSync 一樣。這裡不介紹了。

下面介紹下這種設計的優點。

ResKit 中提倡每個需要動態載入的 MonoBehaviour 或者單元都申請一個 ResLoader 物件。當該 MonoBehaviour 進行 OnDestroy 時，呼叫 Recycle2Cache。

比較理想的使用方式如下:

public class UIHomePanel : MonoBehaivour
{
    private ResLoader mResLoader = ResLoader.Allocate();
    
    void Start()
    {
        var someObjPrefab = mResLoader.LoadSync<GameOBject>("someObj")
        
        // 載入 Bg
        var bgTexture = mResLoader.LoadSync<Texture2D>("Bg");

        // 通過 AssetBundleName 載入 logo
        var logoTexture = mResLoader.LoadSync<Texture2D>("hometextures","logo");
    }
    
    void OnDestroy()
    {
        mResLoader.Recycle2Cache();
        mResLoader = null
    }
}

在該 Panel Destroy 時，進行資源的引用計數減一操作。這裡載入過的資源並不一定真正進行解除安裝，而是當引用計數減為 0 時才進行真正的解除安裝操作。這個好處非常明顯了，就是減少大腦負荷，不用記住某個資源在那裡載入過，需要在哪裡進行真正的解除安裝。主要保證每個 ResLoader 的申請，都對應一個 Recycle2Cache 就好。

這就是引用計數器的力量。引用計數的應用先說到這裡。

下面說說，不用傳入 AssetBundleName 就能載入資源這個功能。

目前市面上大部分開源資源管理模組都不支援這個功能，當然筆者不是原創。原創是筆者的前同事，給出原創 git 連結：Qarth

我們一般的方案， 每個從 AssetBundle 載入的資源，必須傳入 AssetBundleName。

例如：

ResourcesManager.LoadSync<Texture2D>("images","bg");
AssetBundleManager.LoadSync<Texture2D>("images","bg");

這是常見的解決方案。實現起來和原理也比較簡單。而且它已經足夠解決大部分問題了。

但是用的時候會有一點限制。

在一個專案的初期，美術的資源還沒有全部給出。專案中美術資源相關的目錄結構還不是最終版。這時候載入方式全部像上邊一樣寫。

在整個專案週期中，目錄結構發生了幾次變化。每次變化資源就會被打進不同的 AssetBundle 中，導致都要更改一次載入資源相關的程式碼，可能改成如下：

ResourcesManager.LoadSync<Texture2D>("homes","bg");
AssetBundleManager.LoadSync<Texture2D>("homes","bg");

而字串的更改往往比較麻煩，載入錯誤不會被編譯器識別，只有當專案執行之後才可能發現。這就會造成大量人力浪費。

而 ResKit 初期就處於這個階段。

當時的解決方案是程式碼生成。生成 Bundle 名字常量和各個資源常量。這樣當一發生目錄結構的改變，就會報出來很多編譯錯誤。這樣生成的編譯錯誤一個一個地改就好了。

生成程式碼如下：

namespace QAssetBundle
{
    
    public class Assetobj_prefab
    {
        public const string BundleName = "ASSETOBJ_PREFAB";
        public const string ASSETOBJ = "ASSETOBJ";
    }
    public class Gamelogic
    {
        public const string BundleName = "GAMELOGIC";
        public const string BGLAYER = "BGLAYER";
        public const string DEATHZONE = "DEATHZONE";
        public const string LANDEFFECT = "LANDEFFECT";
        public const string MAGNETITELAYER = "MAGNETITELAYER";
        public const string PLAYER = "PLAYER";
        public const string RAINPREFAB2D = "RAINPREFAB2D";
        public const string STAGELAYER = "STAGELAYER";
        public const string SUN = "SUN";
    }
    public class Gameplay_prefab
    {
        public const string BundleName = "GAMEPLAY_PREFAB";
        public const string GAMEPLAY = "GAMEPLAY";
    }
    ...
}

初期 ResKit 以這個方案減少了很多工作量，和專案風險。

關於只傳入 AssetName 不傳 AssetBundleName 支援的構想在很早就有了，只不過不敢確定到底可不可行，會不會造成效能上的瓶頸什麼的，直到後來發現了 Qarth，確定是可行的方案。

實現非常簡單，只要生成一個配置表就夠了。

配置檔案如下：

AssetTable.json

{
    "AssetBundleInfos": [
        {
            "AssetInfos": [
                {
                    "OwnerAssetBundleName": "images",
                    "AssetName": "Square"
                },
                {
                    "OwnerAssetBundleName": "images",
                    "AssetName": "SquareA"
                },
                {
                    "OwnerAssetBundleName": "images",
                    "AssetName": "SquareB"
                }
            ],
            "AssetBundleName": "images"
        }
    ]
}

有了這個檔案，就可以根據 AssetName 查詢對應的 AssetBundleName 就好了。

這樣直到專案優化階段會很少去進行程式碼的改動，畢竟專案開發的每一分鐘都很寶貴。

使用這種方式會有一些限制，就是資源不能同名。同名時就會載入第一個查詢到的資源和對應的 AssetBundle。

當發生不同 AssetBundle 之間有相同資源時，只要傳入 AssetBundleName 就可以解決。這種操作在日常開發中佔極少數。多語言包可能是一種常見的需求。

還有一種是不同型別的資源同名，比如 prefab 型別 和 TextureD 型別的資源使用了同一個名字，這裡筆者想了幾種解決方案：

1. 可傳入副檔名。根據副檔名決定載入哪個資源，比如：

AssetBundleManager.LoadSync<Texture2D>("bg.jpg");
AssetBundleManager.LoadSync<GameObject>("bg.prefab");

實現起來也是比較容易的事情。

2. 根據傳入泛型型別去判斷，比如：

mResLoader.LoadSync<Texture2D>("bg"); // 載入 紋理型別的，名為 bg 的資源。
mResLoader.LoadSync<GameObject>("bg"); // 載入 GameObject 型別的，名為 bg 的資源。

實現也是比較簡單。

以上兩種都需要在生成配置階段，對每個資源生成更多的資訊。

還有一種是 Qarth 的方案。

就是在對每個 AssetBundle，都加入了啟用和未啟用兩個狀態。

示意程式碼如下。

ResMgr.ActivateAssetBundle("images");
mResLoader.LoadSync<Texture2D>("bg"); 
ResMgr.DectivateAssetBundle("images");

ResMgr.ActivateAssetBundle("home");
mResLoader.LoadSync<GameObject>("bg"); 
ResMgr.ActivateAssetBundle("home");

這也是一個非常不錯的方案。

目前以上三種 ResKit 都沒有支援，筆者也在糾結當中，也許三種都支援，也許只支援 1 ~ 2 種方式。可能會有更好的，隨著 QFramework 發展慢慢來吧。

值得一說的 Features 都聊完了。

接下來開始實踐部分，如果對原理部分有問題歡迎在文章下邊留言探討，或者私聊我也行，聯絡方式在 QFramework 主頁上能找到。

第二部分：實踐

讓我們先一切歸零。下面筆者展示資源管理模組的演化過程。

v0.0.1 Resources API 入門

public class UIHomePanel: MonoBehaviour
{
    private Texture2D mBgTexture = null;
    
    void Start()
    {
        mBgTexture = Resources.Load<Texture2D>("bg");
        // do something
    }
    
    void OnDestroy()
    {
        Resources.UnloadAsset(mBgTexture);
        mBgTexture = null;
    }
}

程式碼很容易理解，就是開啟 UIHomePanel 時動態載入背景資源，當關閉時進行資源的解除安裝操作。

如果隨著需求增多，這個頁面可能需要動態載入的資源也會增多。

public class UIHomePanel: MonoBehaviour
{
    private Texture2D mBgTexture = null;
    private Texture2D mLogoTexture = null;
    private Texture2D mBgEnTexture = null;
    
    void Start()
    {
        mBgTexture = Resources.Load<Texture2D>("bg");
        // do something
        
        mLogoTexture = Resources.Load<Texture2D>("logo");
        // do something
        
        mBgEnTexture = Resources.Load<Texture2D>("bg_en");
        // do something
    }
    
    void OnDestroy()
    {
        Resources.UnloadAsset(mBgTexture);
        mBgTexture = null;
        Resources.UnloadAsset(mLogoTexture);
        mBgTexture = null;
        Resources.UnloadAsset(mBgEnTexture);
        mBgTexture = null;
    }
}

這樣程式碼量就增多了，成員變數的程式碼和需要解除安裝的程式碼隨著資源載入數量正比例增長。這裡要儘量避免這種型別的增長。因為宣告那麼多成員變數不是很好的事情。解決方案很簡單，引入一個 List，使用 List 來記錄本頁面載入過的資源。

v0.0.1 引入 List<UnityEngine.Object>

public class UIHomePanel: MonoBehaviour
{
    private List<UnityEngine.Object> mLoadedAssets = new List<UnityEngine.Object>();
    
    void Start()
    {
        var bgTexture = Resources.Load<Texture2D>("bg");
        mLoadedAssets.Add(bgTexture);
        // do something
        
        var logoTexture = Resources.Load<Texture2D>("logo");
        mLoadedAssets.Add(logoTexture);
        // do something
        
        var bgEnTexture = Resources.Load<Texture2D>("bg_en");
        mLoadedAssets.Add(bgEnTexture);
        // do something
    }
    
    void OnDestroy()
    {
        mLoadedAssets.ForEach(loadedAsset => {
            Resources.UnloadAsset(loadedAsset);
        });
        
        mLoadedAssets.Clear();
        mLoadedAssets = null;
    }
}

這樣載入和解除安裝相關的程式碼就固定了。

這時候又有一個問題，資源的重複載入和解除安裝。可能程式碼如下：

public class UIHomePanel: MonoBehaviour
{
    private List<UnityEngine.Object> mLoadedAssets = new List<UnityEngine.Object>();
    
    void Start()
    {
        var bgTexture = Resources.Load<Texture2D>("bg");
        mLoadedAssets.Add(bgTexture);
        // do something
        
        var logoTexture = Resources.Load<Texture2D>("logo");
        mLoadedAssets.Add(logoTexture);
        // do something
        
        var bgEnTexture = Resources.Load<Texture2D>("bg_en");
        mLoadedAssets.Add(bgEnTexture);
        // do something
        
        OtherFunction();
    }
    
    void OtherFunction()
    {
        // 重複載入了，也會導致重複解除安裝。
        var logoTexture = Resources.Load<Texture2D>("logo");
        mLoadedAssets.Add(logoTexture);
        // do something
    }
    
    void OnDestroy()
    {
        mLoadedAssets.ForEach(loadedAsset => {
            Resources.UnloadAsset(loadedAsset);
        });
        
        mLoadedAssets.Clear();
        mLoadedAssets = null;
    }
}

對於 Resources 這個 API 來說問題不大，但是 AssetBundle 就可能比較危險了，重複載入 AssetBundle 會導致閃退。所以比較危險了，還是要避免。

v0.0.2 新增重複載入判斷

public class UIHomePanel: MonoBehaviour
{
    private List<UnityEngine.Object> mLoadedAssets = new List<UnityEngine.Object>();
    
    void Start()
    {
        var bgTexture = LoadAsset<Texture2D>("bg");
        // do something
        
        var logoTexture = LoadAsset<Texture2D>("logo");
        // do something
        
        var bgEnTexture = LoadAsset<Texture2D>("bg_en");
        // do something
        
        OtherFunction();
    }
    
    void OtherFunction()
    {
        // 重複載入了，也會導致重複解除安裝。
        var logoTexture = LoadAsset<Texture2D>("logo");
        // do something
    }
    
    T LoadAsset<T>(string assetName) where T: UnityEngine.Object
    {
        var retAsset = mLoadedAssets.Find(loadedAsset=>loadedAsset.name == assetName);
        
        if (resAsset)
        {
            return resAsset as T;
        }
        
        retAsset = Resources.Load<T>(assetName);
        mLoadedAssets.Add(retAsset);
        
        return retAsset;
    }
    
    void OnDestroy()
    {
        mLoadedAssets.ForEach(loadedAsset => {
            Resources.UnloadAsset(loadedAsset);
        });
        
        mLoadedAssets.Clear();
        mLoadedAssets = null;
    }
}

新增 LoadAset 方法，帶來了一個意外的好處，就是載入資源部分的程式碼也變得精簡了。

這樣就可以避免重複載入和解除安裝了，當然重複載入和解除安裝僅限於在 UIHomePanel 內。還是沒法避免多個頁面之間的對統一個資源的重複載入和解除安裝的。要解決這個問題會相對麻煩，我們分幾個版本慢慢迭代。

第一個要做的就是，先把這套載入解除安裝策略封裝好，總不能讓每個載入資源的頁面或者指令碼都寫一遍這套策略。

v0.0.3 ResLoader

策略的複用有很多種，繼承、封裝成服務類物件等等。

封裝成一個服務類物件會好搞一些，就是 ResLoader。

public class ResLoader
{
    private List<UnityEngine.Object> mLoadedAssets = new List<UnityEngine.Object>();

    public T LoadAsset<T>(string assetName) where T: UnityEngine.Object
    {
        var retAsset = mLoadedAssets.Find(loadedAsset=>loadedAsset.name == assetName);
        
        if (resAsset)
        {
            return resAsset as T;
        }
        
        retAsset = Resources.Load<T>(assetName);
        mLoadedAssets.Add(retAsset);
        
        return retAsset;
    }
    
    public void UnloadAll()
    {
        mLoadedAssets.ForEach(loadedAsset => {
            Resources.UnloadAsset(loadedAsset);
        });
        
        mLoadedAssets.Clear();
        mLoadedAssets = null;
    }
}

而 UIHomePanel 則會變成如下:

public class UIHomePanel: MonoBehaviour
{
    ResLoader mResLoader = new ResLoader();
    
    void Start()
    {
        var bgTexture = mResLoader.LoadAsset<Texture2D>("bg");
        // do something
        
        var logoTexture = mResLoader.LoadAsset<Texture2D>("logo");
        // do something
        
        var bgEnTexture = mResLoader.LoadAsset<Texture2D>("bg_en");
        // do something
        
        OtherFunction();
    }
    
    void OtherFunction()
    {
        // 重複載入了，也會導致重複解除安裝。
        var logoTexture = mResLoader.LoadAsset<Texture2D>("logo");
        // do something
    }
    
    void OnDestroy()
    {
        mResLoader.UnloadAll();
        mResLoader = null;
    }
}

使用程式碼精簡了很多。

ResLoader 只是記錄下當前頁面或者指令碼載入過的資源，這樣不夠用，還需要一個記錄全域性載入過資源的容器。

v0.0.4 SharedLoadedAssets & Res

實現很簡單，給 ResLoader 建立一個靜態 List<UnityEngine.Object>。

ResLoader.cs

public class ResLoader
{
    private List<UnityEngine.Object> mLoadedAssets = new List<UnityEngine.Object>();
    
    private static List<UnityEngine.Object> mSharedLoadedAssets = new List<UnityEngine.Object>();

    public T LoadAsset<T>(string assetName) where T: UnityEngine.Object
    {
        var retAsset = mLoadedAssets.Find(loadedAsset=>loadedAsset.name == assetName);
        
        if (resAsset)
        {
            return resAsset as T;
        }
        
        retAsset = Resources.Load<T>(assetName);
        mLoadedAssets.Add(retAsset);
        
        return retAsset;
    }
    
    public void UnloadAll()
    {
        mLoadedAssets.ForEach(loadedAsset => {
            Resources.UnloadAsset(loadedAsset);
        });
        
        mLoadedAssets.Clear();
        mLoadedAssets = null;
    }
}

這個 mSharedLoadedAssets 有什麼作用呢 ？

它相當於一個全域性資源池，而 ResLoader 獲取資源，都要從資源池中獲取，何時進行載入和解除安裝取決於某個資源是否是第一次載入、某個資源解除安裝時是不是不被所有 ResLoader 引用。

所以資源的載入和解除安裝，應該取決於被引用的次數，第一次被引用就載入該資源，最後一次引用釋放則進行解除安裝。

但是 UnityEngine.Object 沒有提供引用計數功能。

所以需要在 UnityEngine.Object 基礎上抽象一個類 Res：

這個 Res，要實現一個引用計數的功能。

而且為了未來分出來不同型別的資源（例如 ResourcesRes 和 AssetBundleRes/AssetRes 等），Res 也要管理自己的載入解除安裝操作。

程式碼如下：

Res.cs

    public class Res
    {
        public string Name
        {
            get { return mAsset.name; }
        }
        
        public Res(Object asset)
        {
            mAsset = asset;
        }
        
        private Object mAsset;
        
        private int mReferenceCount = 0;

        public void Retain()
        {
            mReferenceCount++;
        }

        public void Release()
        {
            mReferenceCount--;

            if (mReferenceCount == 0)
            {
                Resources.UnloadAsset(mAsset);

                ResLoader.SharedLoadedReses.Remove(this);

                mAsset = null;
            }
        }
    }

對應的 ResLoader 變為如下：

    public class ResLoader
    {
        /// <summary>
        /// 共享的 
        /// </summary>
        public static List<Res> SharedLoadedReses = new List<Res>();
        
        
        /// <summary>
        /// 持有的
        /// </summary>
        private List<Res> mResList = new List<Res>();

        public T LoadAsset<T>(string assetName) where T : Object
        {
            var loadedRes = mResList.Find(loadedAsset=>loadedAsset.Name == assetName);
            
            if (loadedRes != null)
            {
                return loadedRes as T;
            }

            loadedRes = SharedLoadedReses.Find(loadedAsset => loadedAsset.Name == assetName);

            if (loadedRes != null)
            {
                loadedRes.Retain();
                
                mResList.Add(loadedRes);
                
                return loadedRes as T;
            }
            
            var asset = Resources.Load<T>(assetName);

            loadedRes = new Res(asset);

            SharedLoadedReses.Add(loadedRes);
            
            loadedRes.Retain();

            mResList.Add(loadedRes);

            return asset;
        }

        public void UnloadAll()
        {
            foreach (var asset in mResList)
            {
                asset.Release();
            }

            mResList.Clear();
            mResList = null;
        }
    }

ResLoader 的程式碼，希望大家仔細研讀下，尤其是 LoadAsset 方法。載入步驟在原理部分有簡單講過，這裡不多說了。而 UnloadAll，則是不是進行真正的解除安裝，而是對資源進行一次釋放。

使用程式碼 UIHomePanel.cs 不變：

public class UIHomePanel: MonoBehaviour
{
    ResLoader mResLoader = new ResLoader();
    
    void Start()
    {
        var bgTexture = mResLoader.LoadAsset<Texture2D>("bg");
        // do something
        
        var logoTexture = mResLoader.LoadAsset<Texture2D>("logo");
        // do something
        
        var bgEnTexture = mResLoader.LoadAsset<Texture2D>("bg_en");
        // do something
        
        OtherFunction();
    }
    
    void OtherFunction()
    {
        // 重複載入了，也會導致重複解除安裝。
        var logoTexture = mResLoader.LoadAsset<Texture2D>("logo");
        // do something
    }
    
    void OnDestroy()
    {
        mResLoader.UnloadAll();
        mResLoader = null;
    }
}

這裡在寫其他的示例程式碼，載入相同的資源：

public class UIOtherPanel: MonoBehaviour
{
    ResLoader mResLoader = new ResLoader();
    
    void Start()
    {
        var bgTexture = mResLoader.LoadAsset<Texture2D>("bg");
        // do something
        
        var logoTexture = mResLoader.LoadAsset<Texture2D>("logo");
        // do something
        
        var bgEnTexture = mResLoader.LoadAsset<Texture2D>("bg_en");
        // do something
        
        OtherFunction();
    }
    
    void OtherFunction()
    {
        // 重複載入了，也會導致重複解除安裝。
        var logoTexture = mResLoader.LoadAsset<Texture2D>("logo");
        // do something
    }
    
    void OnDestroy()
    {
        mResLoader.UnloadAll();
        mResLoader = null;
    }
}

這樣就算 UIHomePanel 和 UIOtherPanel 同時開啟，也不會發生資源的重複載入或解除安裝了。

到這裡一個基本的管理模型完成了，可以將版本號升級為 v0.1.1，算是一個最小可執行版本（MVP）。不管在使用還是結構上都是一個非常好的方案。而 ResKit 就是以這個管理模型為基礎，慢慢完善功能的，至今為止支援了非常多的專案。

本片的文章就到這裡

那麼剩下的不值得一提的功能歡迎研讀本 chat 的示例工程和 QFramework 中的 ResKit 模組。

轉載請註明地址：涼鞋的筆記：liangxiegame.com

更多內容

  • QFramework 地址：https://github.com/liangxiegame/QFramework
  • QQ 交流群：623597263
  • Unity 進階小班：
    • 主要訓練內容：
      • 框架搭建訓練（第一年）
      • 跟著案例學 Shader（第一年）
      • 副業的孵化（第二年、第三年）
    • 權益、授課形式等具體詳情請檢視《小班產品手冊》：https://liangxiegame.com/master/intro
  • 關注公眾號：liangxiegame 獲取第一時間更新通知及更多的免費內容。

相關推薦

Unity 遊戲框架：資源管理神器 ResKit

此篇文章準備了將近兩週的時間，寫了改，改了刪。之前有朋友反饋，上一個文章太冗長了，影響閱讀體驗，這一講就走個精簡路線。所以只要不是很重要的內容就都刪減掉了。 文章分兩個部分，第一部分是原理，第二部分是實戰。 原理部分，初學者儘量去理解就好，不用跟著敲，列出的程式碼都是示意程式碼。 實戰部分是留給初學者的，希望

Unity 遊戲框架：UI 管理神器 UI Kit

### UI Kit 快速入門 首先我們來進行 UI Kit 的快速入門 製作一個介面的，步驟如下: 1. 準備 2. 生成程式碼 3. 邏輯編寫 4. 執行 #### 1. 準備 * 先建立一個場景 TestUIHomePanel。 ![enter image description here

Unity 遊戲框架搭建：我所理解的框架

進入到遊戲行業後，大家多多少少聽到過 "框架、架構" 等聽起來很"高大上"的詞彙，那麼到底什麼叫做框架?架構又什麼?如何去搭建遊戲框架，又如何去做遊戲的架構呢？本場 Chat 從多個角度剖析“框架、架構”這兩個概念，然後收集遊戲開發中遇到與"框架、架構"相關的問題，並在這裡給

MapReduce再學習：資源管理框架YARN

在前面寫到的三篇部落格中，HDFS概述 和 MapReduce簡介寫的都是hadoop1.0的情況，針對1.0版本的各種不足，2.0都有相應的改動， HDFS再學習：HA和Federation機制寫的是儲存系統HDFS上的改動。針對我們的計算模型MapReduc

涼鞋：我所理解的框架 【Unity 遊戲框架搭建】

前言 架構和框架這些概念聽起來很遙遠，讓很多初學者不明覺厲。會產生“等自己技術牛逼了再去做架構或者搭建框架”這樣的想法。在這裡筆者可以很肯定地告訴大家，初學者是完全可以去做這些事情的。 初識架構和框架 架構和框架是非常接地氣的，離我們其實並不遙遠。 什麼是架構? 架構是一個約定，一個規則，一個大家都懂得遵守

SQL Server性能調優：資源管理之內存管理篇（上）

方式 hive 服務 ces inpu 都是 功能 一個 type http://www.cnblogs.com/caspnet/archive/2011/02/21/1959539.html 對SQL Server來說，最重要的資源是內存、Disk和CPU，其中內存又是

[UGUI]圖文混排(三)：資源管理

圖片 dal cti sharp ons set creat ces turn 1.圖文混排中的資源，主要是圖片。 2.所謂的資源管理，可以分為資源對象池和資源加載這兩部分。這裏是為圖文混排單獨做一套資源管理，當然也可以改為調用項目中的資源管理。 RichTextRes

資源管理神器Clover

開開心心地上班,這時你得開啟我的電腦,點進D盤,開啟某個專案;然後還得開啟XX文件,還有.... 最後的最後,你的桌面便成了這個樣子 每天你都得天開啟多個資料夾，切換時找檔案找的暈頭轉向而煩惱。 每天層層深入的找某個檔案而浪費時間。 今天為大家推薦一款資源管理神器“Colver”,Colver可快速

Java進階學習第二十四天（Spring框架：事務管理、Spring與Hibernate整合）

一、事務控制 1、引入 使用者訪問 > Action > Service > Dao 如何保證： 在service中呼叫2次dao，其中一個dao執行失敗，整個操作要回滾 2、事務控制概述 ① 程式設計式事務控制：自己手動控制事務 Jdbc程式

簡單總結Unity使用Resources類資源管理

最近參考了各位大神的資源，初步學習了Unity的資源管理模式，包括在編輯器管理（使用AssetDatabase）和在執行時管理（使用Resources和AssetBundle）。在此簡單總結執行時用Resources類資源管理的方法，方便自己回顧。

Unity 遊戲框架搭建 (七) 減少加班利器-QApp類

本來這周想介紹一些框架中自認為比較好用的小工具的,但是發現很多小工具都依賴一個類----App。 App類的職責:   1.接收的生命週期事件。   2.做為遊戲的入口。   3.一些框架級別的元件初始化。   本文只介紹App的職責

高階 Linux 命令精通指南，第 3 部分：資源管理

感謝原創Arup Nanda 在此部分中，瞭解用於監視物理元件的高階 Linux 命令 Linux 系統由若干主要物理元件組成，如 CPU、記憶體、網絡卡和儲存裝置。要有效地管理 Linux 環境，您應該能夠以合理的精度測量這些資源的各種指標 — 每個元件處理多少資源、是否存

Unity 遊戲框架搭建 (二十三) 重構小工具 Platform

在日常開發中，我們經常遇到或者寫出這樣的程式碼 var sTrAngeNamingVariable = "a variable"; #if UNITY_IOS || UNITY_ANDROID || UNITY_EDITOR sTrAng

Cocos Creator 通用框架設計 —— 資源管理

如果你想使用Cocos Creator製作一些規模稍大的遊戲，那麼資源管理是必須解決的問題，隨著遊戲的進行，你可能會發現遊戲的記憶體佔用只升不降，哪怕你當前只用到了極少的資源，並且有使用cc.loader.release來釋放之前載入的資源，但之前使用過的大部分資源都會留在記憶體中！為什麼會這樣呢？ coco

Unity 遊戲框架搭建 2019 (九~十二) 第一章小結&第二章簡介&第八個示例

第一章小結 為了強化教程的重點，會在合適的時候進行總結與快速複習。 第二章 簡介 在第一章我們做了知識庫的準備，從而讓我們更高效地收集示例。 在第二章，我們就用準備好的匯出工具試著收集幾個示例，這些示例中有的是我們後續庫的基礎工具，也有的是在專案中非常實用的小工具，還有一些示例是實踐了在框架搭建方向上非常

Unity 遊戲框架搭建 2019 (十三~十五) 接下來要學什麼？& 第九個示例

在之前的兩篇中，我們使用 public 靜態方法對之前的內容進行了一個抽取，有了 public 靜態方法這個工具，我們的學習行為也發生了一點變化。 在沒使用 public 關鍵字之前呢，每一個示例僅僅是一個知識的記錄作用。而我們用了 public 關鍵字之後，我們可以把知識作為一個可以複用的方法。但是呢，這

Unity 遊戲框架搭建 2019 (十六、十七) localPosition 簡化與Transform 重置

在上一篇我們收集了一個 螢幕解析度檢測的一個小工具。今天呢再往下接著探索。 ### 問題 我們今天在接著探索。不管是寫 UI 還是寫 GamePlay，多多少少都需要操作 Transform。 而在筆者剛接觸 Unity 的時候有一個非常不習慣的地方。就是對 transform 的位置、角度、縮放進行賦值。

Unity 遊戲框架搭建 2019 (十八~二十) 概率函式 & GameObject 顯示、隱藏簡化 & 第二章 小結與快速複習

在筆者剛做專案的時候，遇到了一個需求。第一個專案是一個跑酷遊戲，而跑酷遊戲是需要一條一條跑道拼接成的。每個跑道的長度是固定的，而怪物的出現位置也是在跑道上固定好的。那麼怪物出現的概率決定一部分關卡的難度。 以上有點繞，其實就是，到某一個時刻，怪物是否要出現。而是否要出現是根據概率來決定的。如果一個怪物出現的

Unity 遊戲框架搭建 2019 (二十一、二十二) 第三章簡介&整理前的準備

整理前的準備 到目前為止，我們積攢了很多示例了，並且每個示例也都貫徹了最的約定和規則。 在上一篇的小結也說了一個比較新的東西:程式設計體驗優化。 在之前我們還積攢了一個問題：程式碼重複問題。 我們可是忍住整理的衝動忍了好久了。 所以現在也是時候準備著手整理了。 知識點和問題總結 遺留問題 我們寫列出來之前

Unity 遊戲框架搭建 2019 (二十三、二十四) 備份與版本號&危險的操作

先列出上一篇的總結: 要做的事情: 備份:匯出檔案，並取一個合理的名字。 遺留問題: 第八個示例與之前的示例程式碼重複，功能重複。 約定和規則: 每個示例在 QFramework 目錄下建立一個資料夾，資料夾的格式是: 數字.示例的功能 每個示例寫一個指令碼，指令碼中包含可複用的靜態方法和 M