Unity5 AssetBundle资源管理架构设计

http://blog.csdn.net/qq_19399235/article/details/51702964

1：Unity5 资源管理架构设计（2017.4.22版本）

2：Android 热更新（不考虑IOS）根据C#反射实现的代码全更新方案（网上一大坨，我重新整理一下）。

一：Unity资源管理架构设计

注意：我配置的Bundle资源文件都放在Assets/ResourceABs文件夹下，并且此文件夹下每个文件夹都对应一个Bundle文件，最终这些文件都打包到StreamingAssets流文件夹下。

1：设计一个资源信息管理类，能够反映Assets/ResourceABs文件夹下的全部的资源信息。

生成工具放在Editor文件下， 代码如下：

[csharp] view
plain copy

using UnityEngine;

using System.Collections;

using System.IO;

using UnityEditor;

using xk_System.AssetPackage;

public class ExportAssetInfoEditor : MonoBehaviour

{

static string extention = AssetBundlePath.ABExtention;

static string BuildAssetPath = "Assets/ResourceABs";

static string CsOutPath = "Assets/Scripts/auto";

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~创建AB文件所有的信息~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

[MenuItem("UnityEditor/GenerationPackage/Generation AssetInfo Cs File")]

public static void GenericAssetCSInfo()

{

Debug.Log("Start Generation AssetInfo Cs Info");

CreateABCSFile();

Debug.Log("Finish Generation AssetInfo Cs Info");

}

private static void CreateABCSFile()

{

string m = "";

m += "namespace xk_System.AssetPackage\n{\n";

DirectoryInfo mDir = new DirectoryInfo(BuildAssetPath);

m += "\tpublic class " + mDir.Name + "Folder : Singleton<" + mDir.Name + "Folder>\n\t{\n";

string s = "";

foreach (var v in mDir.GetDirectories())

{

FileInfo[] mFileInfos1 = v.GetFiles();

int mFilesLength1 = 0;

foreach (var v1 in mFileInfos1)

{

if (v1.Extension != ".meta")

{

mFilesLength1++;

break;

}

}

if (mFilesLength1 > 0 || v.GetDirectories().Length > 0)

{

string fieldName = v.Name + "Folder";

m += "\t\t public " + fieldName + " " + v.Name + "=new " + fieldName + "();\n";

// s += CreateDirClass(v, v.Name.ToLower());

}

}

foreach (var v in mDir.GetDirectories())

{

m += CreateDirClass(v, v.Name.ToLower());

}

m += "\t}\n";

// m += s;

m += "}\n";

string fileName = CsOutPath + "/" + mDir.Name + ".cs";

StreamWriter mSw = new StreamWriter(fileName, false);

mSw.Write(m);

mSw.Close();

}

private static string CreateDirClass(DirectoryInfo mDir, string bundleName)

{

string tStr = GetTStr(mDir);

string m = "";

string s = "";

FileInfo[] mFileInfos = mDir.GetFiles();

int mFilesLength = 0;

foreach (var v in mFileInfos)

{

if (v.Extension != ".meta")

{

mFilesLength++;

break;

}

}

if (mFilesLength > 0)

{

string bundleName1 = bundleName+ extention;

m = tStr+"public class " + mDir.Name + "Folder\n"+tStr+"{\n";

foreach (var v in mFileInfos)

{

if (v.Extension != ".meta")

{

string assetPath = GetAssetPath(v.FullName);

string fileName = v.Name.Substring(0, v.Name.LastIndexOf(v.Extension));

m += tStr+"\t public AssetInfo m" + fileName + "=new AssetInfo(\""+assetPath+"\",\"" + bundleName1 + "\",\"" + v.Name + "\");\n";

}

}

m += tStr+"}\n";

}

else

{

if (mDir.GetDirectories().Length > 0)

{

m = tStr+"public class " + mDir.Name + "Folder\n"+tStr+"{\n";

foreach (var v in mDir.GetDirectories())

{

FileInfo[] mFileInfos1 = v.GetFiles();

int mFilesLength1 = 0;

foreach (var v1 in mFileInfos1)

{

if (v1.Extension != ".meta")

{

mFilesLength1++;

break;

}

}

if (mFilesLength1 > 0 || v.GetDirectories().Length > 0)

{

string fieldName = v.Name + "Folder";

m += tStr+"\t public " + fieldName + " " + v.Name + "=new " + fieldName + "();\n";

}

}

foreach (var v in mDir.GetDirectories())

{

m += CreateDirClass(v, bundleName + "_" + v.Name.ToLower());

}

m += tStr+"}\n";

// m += s;

}

}

return m;

}

public static string GetTStr(DirectoryInfo mDir)

{

int coutT = 0;

int index = mDir.FullName.IndexOf(@"ResourceABs\");

if (index >= 0)

{

for(int j=0;j<mDir.FullName.Length;j++)

{

if (j > index)

{

var v = mDir.FullName[j];

if (v.Equals('\\'))

{

coutT++;

}

}

}

}

coutT++;

string tStr = "";

int i = 0;

while(i<coutT)

{

tStr += "\t";

i++;

}

return tStr;

}

public static string GetAssetPath(string filePath)

{

string assetPath = "";

int index = filePath.IndexOf(@"Assets\");

if (index >= 0)

{

assetPath = filePath.Remove(0, index);

assetPath = assetPath.Replace(@"\","/");

}

return assetPath;

}

}

到这里，这个资源基本信息管理类就处理好了。

2：我们就正式开始写资源管理架构类了

我们首先写一个AssetBundleManager类，这个类的目的专门用来更新完毕后，充当资源加载管理器。代码如下

[csharp] view
plain copy

using UnityEngine;

using System.Collections;

using xk_System.Debug;

using System.Collections.Generic;

using System.Xml;

namespace xk_System.AssetPackage

{

/// <summary>

/// 此类的目的就是加载本地的Bundle进行资源读取操作的

/// </summary>

public class AssetBundleManager : SingleTonMonoBehaviour<AssetBundleManager>

{

private ResourcesABManager mResourcesABManager = new ResourcesABManager();

private Dictionary<string, AssetBundle> mBundleDic = new Dictionary<string, AssetBundle>();

private Dictionary<string, Dictionary<string, UnityEngine.Object>> mAssetDic = new Dictionary<string, Dictionary<string, UnityEngine.Object>>();

private List<string> mBundleLockList = new List<string>();

/// <summary>

/// 加载Assetbundle方案1：初始化时，全部加载

/// </summary>

/// <returns></returns>

public IEnumerator InitLoadAllBundleFromLocal()

{

yield return mResourcesABManager.InitLoadMainifestFile();

List<AssetBundleInfo> bundleList = mResourcesABManager.mNeedLoadBundleList;

List<AssetBundleInfo>.Enumerator mIter = bundleList.GetEnumerator();

while (mIter.MoveNext())

{

yield return AsyncLoadFromLoaclSingleBundle(mIter.Current);

}

}

public IEnumerator InitAssetBundleManager()

{

yield return mResourcesABManager.InitLoadMainifestFile();

}

private IEnumerator CheckBundleDependentBundle(AssetBundleInfo mBundle)

{

if (mBundle != null)

{

string[] mdependentBundles = mBundle.mDependentBundleList;

foreach (string s in mdependentBundles)

{

AssetBundleInfo mBundleInfo = mResourcesABManager.GetBundleInfo(s);

if (mBundleInfo != null)

{

AssetBundle mAB = null;

if (!mBundleDic.TryGetValue(mBundleInfo.bundleName, out mAB))

{

yield return AsyncLoadFromLoaclSingleBundle(mBundleInfo);

}

else

{

if (mAB == null)

{

yield return AsyncLoadFromLoaclSingleBundle(mBundleInfo);

}

}

}

}

}

}

/// <summary>

/// 从本地外部存储位置加载单个Bundle资源,全部加载

/// </summary>

/// <param name="BaseBundleInfo"></param>

/// <returns></returns>

private IEnumerator AsyncLoadFromLoaclSingleBundle1(AssetBundleInfo BaseBundleInfo)

{

if(mBundleLockList.Contains(BaseBundleInfo.bundleName))

{

while(mBundleLockList.Contains(BaseBundleInfo.bundleName))

{

yield return null;

}

yield break;

}

mBundleLockList.Add(BaseBundleInfo.bundleName);

yield return CheckBundleDependentBundle(BaseBundleInfo);

string path = AssetBundlePath.Instance.ExternalStorePathUrl;

string url = path + "/" + BaseBundleInfo.bundleName;

WWW www = new WWW(url);

yield return www;

if (www.isDone)

{

if (!string.IsNullOrEmpty(www.error))

{

DebugSystem.LogError("www Load Error:" + www.error);

www.Dispose();

mBundleLockList.Remove(BaseBundleInfo.bundleName);

yield break;

}

}

AssetBundle asset = www.assetBundle;

SaveBundleToDic(BaseBundleInfo.bundleName, asset);

mBundleLockList.Remove(BaseBundleInfo.bundleName);

www.Dispose();

}

/// <summary>

/// 从本地外部存储位置加载单个Bundle资源,全部加载

/// </summary>

/// <param name="BaseBundleInfo"></param>

/// <returns></returns>

private IEnumerator AsyncLoadFromLoaclSingleBundle(AssetBundleInfo BaseBundleInfo)

{

if (mBundleLockList.Contains(BaseBundleInfo.bundleName))

{

while (mBundleLockList.Contains(BaseBundleInfo.bundleName))

{

yield return null;

}

yield break;

}

mBundleLockList.Add(BaseBundleInfo.bundleName);

yield return CheckBundleDependentBundle(BaseBundleInfo);

string path = AssetBundlePath.Instance.ExternalStorePath+"/"+BaseBundleInfo.bundleName;

AssetBundleCreateRequest www= AssetBundle.LoadFromFileAsync(path);

www.allowSceneActivation = true;

yield return www;

AssetBundle asset = www.assetBundle;

SaveBundleToDic(BaseBundleInfo.bundleName, asset);

mBundleLockList.Remove(BaseBundleInfo.bundleName);

}

/// <summary>

/// 异步从本地外部存储加载单个Asset文件，只加载Bundle中的单个资源

/// </summary>

/// <param name="bundle"></param>

/// <returns></returns>

private IEnumerator AsyncLoadFromLocalSingleAsset(AssetBundleInfo bundle, string assetName)

{

if (bundle != null)

{

yield return AsyncLoadFromLoaclSingleBundle(bundle);

UnityEngine.Object Obj = mBundleDic[bundle.bundleName].LoadAsset(assetName);

if (Obj != null)

{

DebugSystem.Log("Async Load Asset Success:" + Obj.name);

SaveAssetToDic(bundle.bundleName, assetName, Obj);

}

}

}

/// <summary>

/// 同步从本地外部存储加载单个Bundle文件

/// </summary>

/// <param name="BaseBundleInfo"></param>

/// <param name="assetName"></param>

/// <returns></returns>

private void SyncLoadFromLocalSingleBundle(string bundleName)

{

if (!JudegeOrExistBundle(bundleName))

{

string path = AssetBundlePath.Instance.ExternalStorePath + "/" + bundleName;

AssetBundle asset = AssetBundle.LoadFromFile(path);

SaveBundleToDic(bundleName, asset);

}else

{

DebugSystem.LogError("Bundle 已存在："+bundleName);

}

}

/// <summary>

/// 同步从本地外部存储加载单个资源文件

/// </summary>

/// <param name="BaseBundleInfo"></param>

/// <param name="assetName"></param>

/// <returns></returns>

public UnityEngine.Object SyncLoadFromLocalSingleAsset(AssetInfo mAssetInfo)

{

if (!JudgeOrExistAsset(mAssetInfo.bundleName, mAssetInfo.assetName))

{

string path = AssetBundlePath.Instance.ExternalStorePath+"/"+mAssetInfo.bundleName;

AssetBundle asset = AssetBundle.LoadFromFile(path);

SaveBundleToDic(mAssetInfo.bundleName,asset);

}

return GetAssetFromDic(mAssetInfo.bundleName,mAssetInfo.assetName);

}

private void SaveBundleToDic(string bundleName, AssetBundle bundle)

{

if (bundle == null)

{

DebugSystem.LogError("未保存的Bundle为空:"+bundleName);

return;

}

if (!mBundleDic.ContainsKey(bundleName))

{

mBundleDic[bundleName] = bundle;

}else

{

DebugSystem.LogError("Bundle资源 重复:"+bundleName);

}

}

private void SaveAssetToDic(string bundleName, string assetName, UnityEngine.Object asset)

{

if (asset == null)

{

DebugSystem.LogError("未保存的资源为空:"+assetName);

return;

}

if(asset is GameObject)

{

GameObject obj = asset as GameObject;

obj.SetActive(false);

}

if (!mAssetDic.ContainsKey(bundleName))

{

Dictionary<string, UnityEngine.Object> mDic = new Dictionary<string, UnityEngine.Object>();

mAssetDic.Add(bundleName, mDic);

}

mAssetDic[bundleName][assetName] = asset;

}

private bool JudgeOrBundelIsLoading(string bundleName)

{

if (mBundleLockList.Contains(bundleName))

{

return true;

}else

{

return false;

}

}

private bool JudegeOrExistBundle(string bundleName)

{

if (mBundleDic.ContainsKey(bundleName) && mBundleDic[bundleName] != null)

{

return true;

}

else

{

return false;

}

}

private bool JudgeOrExistAsset(string bundleName, string asstName)

{

if (JudegeOrExistBundle(bundleName))

{

if (!mAssetDic.ContainsKey(bundleName) || mAssetDic[bundleName] == null || !mAssetDic[bundleName].ContainsKey(asstName) || mAssetDic[bundleName][asstName] == null)

{

UnityEngine.Object mm = mBundleDic[bundleName].LoadAsset(asstName);

if (mm != null)

{

SaveAssetToDic(bundleName, asstName, mm);

return true;

}

else

{

return false;

}

}

else

{

return true;

}

}

else

{

return false;

}

}

private UnityEngine.Object GetAssetFromDic(string bundleName, string asstName)

{

if (JudgeOrExistAsset(bundleName, asstName))

{

UnityEngine.Object mAsset1 = mAssetDic[bundleName][asstName];

if (mAsset1 is GameObject)

{

GameObject obj = Instantiate(mAsset1) as GameObject;

return obj;

}

else

{

return mAsset1;

}

}

else

{

DebugSystem.LogError("Asset is NUll:" + asstName);

}

return null;

}

#if UNITY_EDITOR

private Dictionary<string, UnityEngine.Object> mEditorAssetDic = new Dictionary<string, UnityEngine.Object>();

private UnityEngine.Object GetAssetFromEditorDic(string assetPath)

{

if (string.IsNullOrEmpty(assetPath))

{

DebugSystem.LogError("Editor AssetPath is Empty");

return null;

}

UnityEngine.Object asset = null;

if (!mEditorAssetDic.TryGetValue(assetPath, out asset))

{

asset = UnityEditor.AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(assetPath);

if (asset != null)

{

if (asset is GameObject)

{

GameObject obj = asset as GameObject;

obj.SetActive(false);

}

mEditorAssetDic.Add(assetPath, asset);

}

else

{

DebugSystem.LogError("找不到资源：" + assetPath);

}

}

if (asset is GameObject)

{

GameObject obj = Instantiate(asset) as GameObject;

return obj;

}

else

{

return asset;

}

}

#endif

public IEnumerator AsyncLoadBundle(string bundleName)

{

if (!JudegeOrExistBundle(bundleName))

{

string path = AssetBundlePath.Instance.ExternalStorePath + "/" + bundleName;

AssetBundle asset = AssetBundle.LoadFromFile(path);

SaveBundleToDic(bundleName, asset);

yield return null;

}

}

/// <summary>

/// 这个东西用来在顶层使用

/// </summary>

/// <param name="type"></param>

/// <param name="assetName"></param>

/// <returns></returns>

public UnityEngine.Object LoadAsset(AssetInfo mAssetInfo)

{

if (GameConfig.Instance.orUseAssetBundle)

{

return GetAssetFromDic(mAssetInfo.bundleName, mAssetInfo.assetName);

}

else

{

return GetAssetFromEditorDic(mAssetInfo.assetPath);

}

}

/// <summary>

/// 这个东西用来在专门的管理器中使用（底层封装一下），禁止在顶层使用

/// </summary>

/// <param name="type"></param>

/// <param name="assetName"></param>

/// <returns></returns>

public IEnumerator AsyncLoadAsset(AssetInfo mAssetInfo)

{

if (GameConfig.Instance.orUseAssetBundle)

{

string bundleName = mAssetInfo.bundleName;

string asstName = mAssetInfo.assetPath;

if (!JudgeOrExistAsset(bundleName, asstName))

{

yield return AsyncLoadFromLocalSingleAsset(mResourcesABManager.GetBundleInfo(bundleName), asstName);

}

}

}

}

public class ResourcesABManager

{

public int VersionId = -1;

public List<AssetBundleInfo> mNeedLoadBundleList = new List<AssetBundleInfo>();

public AssetBundleInfo GetBundleInfo(string bundleName)

{

AssetBundleInfo mBundleInfo = mNeedLoadBundleList.Find((x) =>

{

return x.bundleName == bundleName;

});

return mBundleInfo;

}

public IEnumerator InitLoadMainifestFile()

{

if (mNeedLoadBundleList.Count == 0)

{

string path = AssetBundlePath.Instance.ExternalStorePathUrl;

string url = path + "/" + AssetBundlePath.AssetDependentFileBundleName;

WWW www = new WWW(url);

yield return www;

if (www.isDone)

{

if (!string.IsNullOrEmpty(www.error))

{

DebugSystem.LogError("初始化 MainifestFile 失败：" + www.error);

www.Dispose();

yield break;

}

}

AssetBundle asset = www.assetBundle;

www.Dispose();

if (asset == null)

{

DebugSystem.LogError("MainifestFile Bundle is Null");

www.Dispose();

yield break;

}

AssetBundleManifest mAllBundleMainifest = asset.LoadAsset<AssetBundleManifest>(AssetBundlePath.AssetDependentFileAssetName);

if (mAllBundleMainifest == null)

{

DebugSystem.LogError("Mainifest is Null");

www.Dispose();

yield break;

}

string[] mAssetNames = mAllBundleMainifest.GetAllAssetBundles();

if (mAssetNames != null)

{

foreach (var v in mAssetNames)

{

string bundleName = v;

string[] bundleDependentList = mAllBundleMainifest.GetAllDependencies(v);

Hash128 mHash = mAllBundleMainifest.GetAssetBundleHash(v);

AssetBundleInfo mABInfo = new AssetBundleInfo(bundleName, mHash, bundleDependentList);

mNeedLoadBundleList.Add(mABInfo);

}

}

else

{

DebugSystem.Log("初始化资源依赖文件： Null");

}

asset.Unload(false);

DebugSystem.Log("初始化资源管理器全局Bundle信息成功");

www.Dispose();

yield return InitLoadExternalStoreVersionConfig();

}

}

private IEnumerator InitLoadExternalStoreVersionConfig()

{

string url = AssetBundlePath.Instance.ExternalStorePathUrl + "/" + AssetBundlePath.versionConfigBundleName;

WWW www = new WWW(url);

yield return www;

if (www.isDone)

{

if (!string.IsNullOrEmpty(www.error))

{

DebugSystem.LogError("www Load Error:" + www.error);

www.Dispose();

yield break;

}

}

AssetBundle mConfigBundle = www.assetBundle;

TextAsset mVersionConfig = mConfigBundle.LoadAsset<TextAsset>(AssetBundlePath.versionConfigAssetName);

VersionId = GetVersionIdByParseXML(mVersionConfig);

DebugSystem.Log("当前版本号："+VersionId);

mConfigBundle.Unload(false);

www.Dispose();

}

private int GetVersionIdByParseXML(TextAsset mTextAsset)

{

XmlDocument mdoc = new XmlDocument();

mdoc.LoadXml(mTextAsset.text);

foreach (XmlNode v in mdoc.ChildNodes)

{

if (v.Name == "root")

{

foreach (XmlNode x in v.ChildNodes)

{

if (x.Name.Contains("versionId"))

{

return int.Parse(x.InnerText);

}

}

}

}

return 0;

}

}

public class AssetBundleInfo

{

public string bundleName;

public Hash128 mHash;

public string[] mDependentBundleList;

public AssetBundleInfo(string bundleName, Hash128 mHash128, string[] mDependentBundleList)

{

this.bundleName = bundleName;

this.mHash = mHash128;

this.mDependentBundleList = mDependentBundleList;

}

}

public class AssetInfo

{

public string bundleName;

public string assetName;

public string assetPath;

public AssetInfo(string assetPath,string bundleName, string assetName)

{

this.assetPath = assetPath;

this.bundleName = bundleName;

this.assetName = assetName;

}

public AssetInfo(string bundleName, string assetName)

{

this.bundleName = bundleName;

this.assetName = assetName;

}

}

public class AssetBundlePath : Singleton<AssetBundlePath>

{

public const string versionConfigBundleName = "version.xk_unity3d";

public const string versionConfigAssetName = "version.xml";

public const string AssetDependentFileBundleName = "StreamingAssets";

public const string AssetDependentFileAssetName = "AssetBundleManifest";

public const string ABExtention = ".xk_unity3d";

public readonly string StreamingAssetPathUrl;

public readonly string ExternalStorePathUrl;

public readonly string WebServerPathUrl;

public readonly string ExternalStorePath;

public AssetBundlePath()

{

if (Application.platform == RuntimePlatform.WindowsEditor)

{

WebServerPathUrl = "file:///F:/WebServer";

StreamingAssetPathUrl = "file:///" + Application.streamingAssetsPath;

ExternalStorePathUrl = "file:///" + Application.persistentDataPath;

ExternalStorePath = Application.persistentDataPath;

} else if (Application.platform == RuntimePlatform.WindowsPlayer)

{

WebServerPathUrl = "file:///F:/WebServer";

StreamingAssetPathUrl = "file:///" + Application.streamingAssetsPath;

ExternalStorePathUrl = "file:///" + Application.persistentDataPath;

ExternalStorePath = Application.persistentDataPath;

}else if(Application.platform == RuntimePlatform.Android)

{

WebServerPathUrl = "file:///F:/WebServer";

StreamingAssetPathUrl = "jar:file://" + Application.dataPath + "!/assets";

ExternalStorePathUrl = "file://" + Application.persistentDataPath;

ExternalStorePath = Application.persistentDataPath;

}

DebugSystem.LogError("www server path: " + WebServerPathUrl);

DebugSystem.LogError("www local Stream Path: " + StreamingAssetPathUrl);

DebugSystem.LogError("www local external Path: " + ExternalStorePathUrl);

}

}

}

3：加载完本地的Bundle文件，那么现在我们开始下载Web服务器上的Bundle文件：

注意：本来我是自己定义一个md5配置文件专门用来比对资源，后来发现，Unity已经帮我们实现了这个功能。这个关键点就在于AssetBundleManifest类，具体请参考这篇文章末尾所讲的资源依赖配置文件：http://liweizhaolili.blog.163.com/blog/static/16230744201541410275298/

下载Web服务器资源代码如下：

[csharp] view
plain copy

using UnityEngine;

using System.Collections;

using xk_System.Debug;

using System.Collections.Generic;

using xk_System.AssetPackage;

using System.IO;

using System.Xml;

namespace xk_System.HotUpdate

{

public class AssetBundleHotUpdateManager : Singleton<AssetBundleHotUpdateManager>

{

private int mStreamFolderVersionId=-1;

private int mExternalStoreVersionId=-1;

private int mWebServerVersionId=-1;

private List<AssetBundleInfo> mExternalStoreABInfoList = new List<AssetBundleInfo>();

private List<AssetBundleInfo> mWebServerABInfoList = new List<AssetBundleInfo>();

private List<AssetBundleInfo> mStreamFolderABInfoList = new List<AssetBundleInfo>();

private DownLoadAssetInfo mDownLoadAssetInfo = new DownLoadAssetInfo();

public LoadProgressInfo mTask = new LoadProgressInfo();

public IEnumerator CheckUpdate()

{

mTask.progress = 0;

mTask.Des = "正在检查资源";

yield return CheckVersionConfig();

if (mDownLoadAssetInfo.mAssetNameList.Count > 0)

{

mTask.progress += 10;

mTask.Des = "正在下载资源";

yield return DownLoadAllNeedUpdateBundle();

}

else

{

mTask.progress = 100;

}

}

/// <summary>

/// 检查版本配置文件

/// </summary>

/// <returns></returns>

private IEnumerator CheckVersionConfig()

{

yield return InitLoadExternalStoreVersionConfig();

yield return InitLoadStreamFolderVersionConfig();

yield return InitLoadWebServerVersionConfig();

DebugSystem.Log("本地版本号：" + mExternalStoreVersionId);

DebugSystem.Log("WebServer版本号：" + mWebServerVersionId);

DebugSystem.Log("StreamFolder版本号：" + mStreamFolderVersionId);

if (mWebServerVersionId > mExternalStoreVersionId)

{

yield return InitLoadExternalStoreABConfig();

if (mWebServerVersionId > mStreamFolderVersionId)

{

yield return InitLoadWebServerABConfig();

CheckAssetInfo(AssetBundlePath.Instance.WebServerPathUrl, mWebServerABInfoList);

}

else

{

yield return InitLoadStreamFolderABConfig();

CheckAssetInfo(AssetBundlePath.Instance.StreamingAssetPathUrl, mStreamFolderABInfoList);

}

}

else if (mStreamFolderVersionId > mExternalStoreVersionId)

{

yield return InitLoadExternalStoreABConfig();

yield return InitLoadStreamFolderABConfig();

CheckAssetInfo(AssetBundlePath.Instance.StreamingAssetPathUrl, mStreamFolderABInfoList);

}

}

/// <summary>

/// 检查资源配置文件

/// </summary>

/// <returns></returns>

private void CheckAssetInfo(string url, List<AssetBundleInfo> mUpdateABInfoList)

{

mDownLoadAssetInfo.url = url;

foreach (AssetBundleInfo k in mUpdateABInfoList)

{

AssetBundleInfo mBundleInfo = mExternalStoreABInfoList.Find((x) =>

{

if (x.mHash.isValid && k.mHash.isValid)

{

return x.mHash.Equals(k.mHash);

}

else

{

DebugSystem.LogError("Hash is no Valid");

return false;

}

});

if (mBundleInfo == null)

{

mDownLoadAssetInfo.mAssetNameList.Add(k.bundleName);

}

}

if (mDownLoadAssetInfo.mAssetNameList.Count > 0)

{

mDownLoadAssetInfo.mAssetNameList.Add(AssetBundlePath.AssetDependentFileBundleName);

}

DebugSystem.Log("需要下载更新的个数：" + mDownLoadAssetInfo.mAssetNameList.Count);

}

private IEnumerator InitLoadWebServerVersionConfig()

{

string url = AssetBundlePath.Instance.WebServerPathUrl + "/" + AssetBundlePath.versionConfigBundleName;

WWW www = new WWW(url);

yield return www;

if (www.isDone)

{

if (!string.IsNullOrEmpty(www.error))

{

DebugSystem.LogError("www Load Error:" + www.error);

www.Dispose();

yield break;

}

}

AssetBundle mConfigBundle = www.assetBundle;

TextAsset mVersionConfig = mConfigBundle.LoadAsset<TextAsset>(AssetBundlePath.versionConfigAssetName);

mWebServerVersionId = ParseXML(mVersionConfig);

mConfigBundle.Unload(false);

www.Dispose();

}

private IEnumerator InitLoadExternalStoreVersionConfig()

{

string url = AssetBundlePath.Instance.ExternalStorePathUrl + "/" + AssetBundlePath.versionConfigBundleName;

WWW www = new WWW(url);

yield return www;

if (www.isDone)

{

if (!string.IsNullOrEmpty(www.error))

{

DebugSystem.LogError("www Load Error:" + www.error);

www.Dispose();

yield break;

}

}

AssetBundle mConfigBundle = www.assetBundle;

TextAsset mVersionConfig = mConfigBundle.LoadAsset<TextAsset>(AssetBundlePath.versionConfigAssetName);

mExternalStoreVersionId = ParseXML(mVersionConfig);

mConfigBundle.Unload(false);

www.Dispose();

}

private IEnumerator InitLoadStreamFolderVersionConfig()

{

string url = AssetBundlePath.Instance.StreamingAssetPathUrl + "/" + AssetBundlePath.versionConfigBundleName;

WWW www = new WWW(url);

yield return www;

if (www.isDone)

{

if (!string.IsNullOrEmpty(www.error))

{

DebugSystem.LogError("www Load Error:" + www.error);

www.Dispose();

yield break;

}

}

AssetBundle mConfigBundle = www.assetBundle;

TextAsset mVersionConfig = mConfigBundle.LoadAsset<TextAsset>(AssetBundlePath.versionConfigAssetName);

mStreamFolderVersionId = ParseXML(mVersionConfig);

mConfigBundle.Unload(false);

www.Dispose();

}

private IEnumerator InitLoadWebServerABConfig()

{

string url = AssetBundlePath.Instance.WebServerPathUrl + "/" + AssetBundlePath.AssetDependentFileBundleName;

WWW www = new WWW(url);

yield return www;

if (www.isDone)

{

if (!string.IsNullOrEmpty(www.error))

{

DebugSystem.LogError("www Load Error:" + www.error);

www.Dispose();

yield break;

}

}

AssetBundle mConfigBundle = www.assetBundle;

AssetBundleManifest mAllBundleMainifest = mConfigBundle.LoadAsset<AssetBundleManifest>("AssetBundleManifest");

if (mAllBundleMainifest == null)

{

DebugSystem.LogError("Mainifest is Null");

www.Dispose();

yield break;

}

string[] mAssetNames = mAllBundleMainifest.GetAllAssetBundles();

if (mAssetNames != null)

{

foreach (var v in mAssetNames)

{

string bundleName = v;

string[] bundleDependentList = mAllBundleMainifest.GetAllDependencies(v);

Hash128 mHash = mAllBundleMainifest.GetAssetBundleHash(v);

AssetBundleInfo mABInfo = new AssetBundleInfo(bundleName, mHash, bundleDependentList);

mWebServerABInfoList.Add(mABInfo);

}

}

else

{

DebugSystem.Log("初始化资源依赖文件： Null");

}

mConfigBundle.Unload(false);

www.Dispose();

}

private IEnumerator InitLoadExternalStoreABConfig()

{

string url = AssetBundlePath.Instance.ExternalStorePathUrl + "/" + AssetBundlePath.AssetDependentFileBundleName;

WWW www = new WWW(url);

yield return www;

if (www.isDone)

{

if (!string.IsNullOrEmpty(www.error))

{

DebugSystem.LogError("www Load Error:" + www.error);

www.Dispose();

yield break;

}

}

AssetBundle mConfigBundle = www.assetBundle;

AssetBundleManifest mAllBundleMainifest = mConfigBundle.LoadAsset<AssetBundleManifest>("AssetBundleManifest");

if (mAllBundleMainifest == null)

{

DebugSystem.LogError("Mainifest is Null");

www.Dispose();

yield break;

}

string[] mAssetNames = mAllBundleMainifest.GetAllAssetBundles();

if (mAssetNames != null)

{

foreach (var v in mAssetNames)

{

string bundleName = v;

string[] bundleDependentList = mAllBundleMainifest.GetAllDependencies(v);

Hash128 mHash = mAllBundleMainifest.GetAssetBundleHash(v);

AssetBundleInfo mABInfo = new AssetBundleInfo(bundleName, mHash, bundleDependentList);

mExternalStoreABInfoList.Add(mABInfo);

}

}

else

{

DebugSystem.Log("初始化资源依赖文件： Null");

}

mConfigBundle.Unload(false);

www.Dispose();

}

private IEnumerator InitLoadStreamFolderABConfig()

{

string url = AssetBundlePath.Instance.StreamingAssetPathUrl + "/" + AssetBundlePath.AssetDependentFileBundleName;

WWW www = new WWW(url);

yield return www;

if (www.isDone)

{

if (!string.IsNullOrEmpty(www.error))

{

DebugSystem.LogError("www Load Error:" + www.error);

www.Dispose();

yield break;

}

}

AssetBundle mConfigBundle = www.assetBundle;

AssetBundleManifest mAllBundleMainifest = mConfigBundle.LoadAsset<AssetBundleManifest>("AssetBundleManifest");

if (mAllBundleMainifest == null)

{

DebugSystem.LogError("Mainifest is Null");

www.Dispose();

yield break;

}

string[] mAssetNames = mAllBundleMainifest.GetAllAssetBundles();

if (mAssetNames != null)

{

foreach (var v in mAssetNames)

{

string bundleName = v;

string[] bundleDependentList = mAllBundleMainifest.GetAllDependencies(v);

Hash128 mHash = mAllBundleMainifest.GetAssetBundleHash(v);

AssetBundleInfo mABInfo = new AssetBundleInfo(bundleName, mHash, bundleDependentList);

mStreamFolderABInfoList.Add(mABInfo);

}

}

else

{

DebugSystem.Log("初始化资源依赖文件： Null");

}

mConfigBundle.Unload(false);

www.Dispose();

}

/// <summary>

/// 得到版本号

/// </summary>

/// <param name="mbytes"></param>

/// <returns></returns>

public int ParseXML(TextAsset mTextAsset)

{

XmlDocument mdoc = new XmlDocument();

mdoc.LoadXml(mTextAsset.text);

foreach (XmlNode v in mdoc.ChildNodes)

{

if (v.Name == "root")

{

foreach (XmlNode x in v.ChildNodes)

{

if (x.Name.Contains("versionId"))

{

return int.Parse(x.InnerText);

}

}

}

}

return 0;

}

private IEnumerator DownLoadAllNeedUpdateBundle()

{

List<string> bundleList = mDownLoadAssetInfo.mAssetNameList;

List<string>.Enumerator mIter = bundleList.GetEnumerator();

uint addPro = (uint)Mathf.CeilToInt((LoadProgressInfo.MaxProgress - mTask.progress)/(float)bundleList.Count);

while (mIter.MoveNext())

{

DebugSystem.LogError("下载的文件：" + mDownLoadAssetInfo.url + " | " + mIter.Current);

yield return DownLoadSingleBundle(mDownLoadAssetInfo.url, mIter.Current);

mTask.progress+=addPro;

}

}

private IEnumerator DownLoadSingleBundle(string path, string bundleName)

{

string url = path + "/" + bundleName;

WWW www = new WWW(url);

yield return www;

if (www.isDone)

{

if (!string.IsNullOrEmpty(www.error))

{

DebugSystem.LogError("www Load Error:" + www.error);

www.Dispose();

yield break;

}

}

string savePath = AssetBundlePath.Instance.ExternalStorePath + "/" + bundleName;

SaveDownLoadedFile(savePath, www.bytes);

www.Dispose();

}

private void SaveDownLoadedFile(string path, byte[] mdata)

{

if (File.Exists(path))

{

File.Delete(path);

}

FileInfo mFileInfo = new FileInfo(path);

FileStream mFileStream = mFileInfo.OpenWrite();

mFileStream.Write(mdata, 0, mdata.Length);

mFileStream.Flush();

mFileStream.Close();

}

private class DownLoadAssetInfo

{

public string url;

public List<string> mAssetNameList = new List<string>();

}

}

}

现在 资源管理架构设计就完了。

二： C#反射热更新（网上热更新的传说，多数资料都是简单一笔带过）

1：如何编译Unity代码，生成程序集：

Unity工程本身编译的程序集会放在Project\Library\ScriptAssemblies文件夹下，所以刚开始我是直接拿这个去加载程序集的，后来发现不行。

因为加载的程序集，与本地程序集重名，Unity会认为加载的程序集，还是本地程序集。（测过结果就是这样）

所以后来，通过VS2015编译Unity工程，但遇到一个问题：build的时候报了一大堆错误，错误的原因在于，Proto 生成的cs文件 所用的.net版本过高导致的。

你可以重新新build Protobuf 源码，然后生成.net低版本的程序集，这样做是可以的。

2：加载程序集，代码如下

[csharp] view
plain copy

using UnityEngine;

using System.Collections;

using System.Reflection;

using xk_System.Debug;

using System;

namespace xk_System.AssetPackage

{

public class AssemblyManager : Singleton<AssemblyManager>

{

private Assembly mHotUpdateAssembly;

private Assembly mCurrentAssembly;

/// <summary>

/// 加载程序集

/// </summary>

/// <returns></returns>

public IEnumerator LoadAssembly()

{

AssetInfo mAssetInfo = ResourceABsFolder.Instance.scripts.mtest;

string path = AssetBundlePath.Instance.ExternalStorePathUrl;

string bundleName1 = mAssetInfo.bundleName;

string url = path + "/" + bundleName1;

WWW www = new WWW(url);

yield return www;

if (www.isDone)

{

if (!string.IsNullOrEmpty(www.error))

{

DebugSystem.LogError("www Load Error:" + www.error);

yield break;

}

}

AssetBundle mConfigBundle = www.assetBundle;

TextAsset mAsset = mConfigBundle.LoadAsset<TextAsset>(mAssetInfo.assetName);

mHotUpdateAssembly = Assembly.Load(mAsset.bytes);

if (mHotUpdateAssembly != null)

{

DebugSystem.Log("加载程序集：" + mHotUpdateAssembly.FullName);

}

else

{

DebugSystem.Log("加载程序集： null");

}

mCurrentAssembly = this.GetType().Assembly;

DebugSystem.Log("当前程序集：" + mCurrentAssembly.FullName);

if (mCurrentAssembly.FullName.Equals(mHotUpdateAssembly.FullName))

{

DebugSystem.LogError("加载程序集名字有误");

}

mConfigBundle.Unload(false);

}

public object CreateInstance(string typeFullName)

{

if (mHotUpdateAssembly != null)

{

return mHotUpdateAssembly.CreateInstance(typeFullName);

}

else

{

return mCurrentAssembly.CreateInstance(typeFullName);

}

}

/// <summary>

/// 仅仅写入口时，调用。（否则，会使程序变得混乱，反正我是搞乱了）

/// </summary>

/// <param name="obj"></param>

/// <param name="typeFullName"></param>

/// <returns></returns>

public Component AddComponent(GameObject obj, string typeFullName)

{

DebugSystem.Log("Type: " + typeFullName);

if (mHotUpdateAssembly != null)

{

Type mType = mHotUpdateAssembly.GetType(typeFullName);

return obj.AddComponent(mType);

}

else

{

Type mType = typeFullName.GetType();

return obj.AddComponent(mType);

}

}

}

}

3：加载完程序集后该如何使用这个程序集就是重点了。

刚开始想这个问题的时候感觉无非反射了这么简单的问题，后来越想感觉越复杂，幸好，崩溃完了之后，发现其实，你只要遵守2点即可实现游戏代码全部更新。（1）：我们前面已经做完了，加载资源和加载程序集的工作，那么我们现在要做的工作，就是实现这个新加载的程序集的入口。切记，这个入口要通过动态添加组件的方式出现。如：

Type mType = mHotUpdateAssembly.GetType(typeFullName);obj.AddComponent(mType);

（2）:要注意所有的预制件上要动态添加脚本，否则，预制件会去寻找【本地程序集】的脚本添加上去，并且还会导致【本地程序集】与【热更新程序集】相互访问的问题。

在这里要注意一点：因为我们已经提供了【热更新程序集】的入口，所以，接下来程序动态添加脚本就会使用【热更新程序集】里脚本。千万不要再去反射程序集里某某个脚本了，加载脚本，还和以前一样写就好了。如：

obj.AddComponent<T>(); 这里与入口动态添加的方式可不一样啊。（没有反射的）。