IEnumerator _LoadAssets(Action loadComplete, Action loadError)
    {
        if (Debug.isDebugBuild)
            _loader = new WWW(Main.HOST + _versionBundle.url);
        else
            _loader = WWW.LoadFromCacheOrDownload(Main.HOST + _versionBundle.url, _versionBundle.versionValue);
        yield return _loader;

        if (string.IsNullOrEmpty(_loader.error))
        {
            if (_versionBundle.isEncrypted)
            {
                TextAsset encryped = _loader.assetBundle.Load(BundleLoader.ENCRYPTED_DATA, typeof(TextAsset)) as TextAsset;
                byte[] encryptedData = encryped.bytes;
                byte[] decryptedData = _Decrypt(encryptedData);
                _bundle = AssetBundle.CreateFromMemory(decryptedData).assetBundle;
            }
            else
            {
                _bundle = _loader.assetBundle;
            }

            _isLoadComplete = true;

            if (loadComplete != null) loadComplete();
        }
        else
        {
            Debug.LogError("Error: Load asset error with url: " + Main.HOST + _versionBundle.url + " - " + _loader.error);
            if (loadError != null) loadError();
        }
    }

 /// <summary>
 /// 创建
 /// </summary>
 /// <param name="decryptedData"></param>
 /// <returns></returns>
 IEnumerator LoadBundle(byte[] decryptedData)
 {
     AssetBundleCreateRequest acr = AssetBundle.CreateFromMemory(decryptedData);
     yield return acr;
     assetBundel = acr.assetBundle;
     Instantiate(assetBundel.Load("Cube"));
 }

    static void AddLoadedBundleToManager(AssetBundle bundle, string name)
    {
        if (!isBundleLoaded(bundle, name))
            return;

        AssetBundleManager.AddBundle(name, 0, bundle);
    }

    void Start()
    {
        m_cube = AssetBundle.LoadFromFile("C:\\Users\\yunsubaek_df\\Documents\\AssetBundleTest1\\AssetBundles\\Windows\\cube-bundle");

        cube_obj = (GameObject)m_cube.LoadAsset<GameObject>("Cube");
        GameObject.Instantiate(cube_obj,new Vector3(1,1,1),Quaternion.identity);
    }

    private AssetBundleRequest m_cRequest; //The load request

    #endregion Fields

    #region Methods

    /// <summary>
    /// Start async load the assetbundle
    /// </summary>
    /// <param name="asset"></param>
    /// <param name="resName"></param>
    /// <param name="callback"></param>
    public static AsyncLoader StartLoad(AssetBundle asset, string resName)
    {
        GameObject obj = new GameObject("AsyncLoader");
        AsyncLoader loader = obj.AddComponent<AsyncLoader>();
        loader.StartCoroutine(loader.GoLoader(asset, resName));
        return loader;
    }

    void OnAssetBundleLoaded(string url, AssetBundle assetBundle, params object[] args)
    {
        Object asset = null;
        System.DateTime beginTime = System.DateTime.Now;
        if (AssetInBundleName == null)
        {
            // 经过AddWatch调试，.mainAsset这个getter第一次执行时特别久，要做序列化
            try
            {
                asset = assetBundle.mainAsset;
            }
            catch
            {
                CBase.LogError("[OnAssetBundleLoaded:mainAsset]{0}", url);
            }
        }
        else
        {
            AssetBundleRequest request = assetBundle.LoadAsync(AssetInBundleName, typeof(Object));
            asset = request.asset;
        }

        CResourceManager.LogLoadTime("AssetFileBridge", url, beginTime);

        if (asset == null)
        {
            CBase.LogError("Asset is NULL: {0}", url);
        }

        AssetFileLoadedCallback(asset, CallbackArgs);
    }

    private void BundleLoadedHandler(WWW request)
    {
        Debug.Log("Bundle loaded: " + request.url);
        _bundle = request.assetBundle;

        AssetBundleRequest assetBundleRequest = _bundle.LoadAsync(AssetName, typeof(GameObject));
        _assetBundleQueue.Send(assetBundleRequest, AssetLoadedHandler);
    }

 IEnumerator DownloadAB()
 {
     Debug.Log("downloading...");
         yield return StartCoroutine(AssetBundleManager.downloadAssetBundle (url, version));
         bundle = AssetBundleManager.getAssetBundle (url, version);
         Debug.Log("complete");
         Debug.Log(bundle);
 }

 void OnGUI()
 {
     if (GUILayout.Button ("Download bundle")){
         bundle = AssetBundleManager.getAssetBundle (url, version);
         if(!bundle)
             StartCoroutine (DownloadAB());
     }
 }

 public IEnumerator LoadBundleFromFileUncompressed(string path)
 {
     CheckFileExists(path);
     bundle = AssetBundle.CreateFromFile(path);
     CheckBundle(bundle);
     Debug.Log("loaded bundle: " + path);
     yield return null;
 }

    /// <summary>
    /// Begin load
    /// </summary>
    /// <param name="asset"></param>
    /// <param name="resName"></param>
    /// <returns></returns>
    public IEnumerator GoLoader(AssetBundle asset, string resName)
    {
        this.m_cRequest = asset.LoadAsync(resName, typeof(UnityEngine.Object));

        for (; !this.m_cRequest.isDone; )
            yield return this.m_cRequest;

        GameObject.Destroy(this.gameObject);
    }

 public AssetBundleRequest Load(string name, Type type)
 {
     Debug.Log("Loading " + name);
     if (null == bundle)
     {
         bundle = www.assetBundle;
         www.Dispose();
     }
     return bundle.LoadAsync(name, type);
 }

    /// <summary>
    /// 初始化
    /// </summary>
    void initialize() {
        string uri = string.Empty;
        //------------------------------------Shared--------------------------------------
        uri = Util.DataPath + "shared.assetbundle";
        Debug.LogWarning("LoadFile::>> " + uri);

        shared = AssetBundle.CreateFromFile(uri);
        shared.Load("Dialog", typeof(GameObject));
        ioo.gameManager.OnResourceInited();    //回调游戏管理器，执行后续操作 
    }

 public IEnumerator LoadBundleFromMemory(byte[] buffer)
 {
     AssetBundleCreateRequest bundleRequest = AssetBundle.CreateFromMemory(buffer);
     yield return bundleRequest;
     if (bundleRequest.isDone)
     {
         bundle = bundleRequest.assetBundle;
         CheckBundle(bundle);
     }
 }

    public MapHandler(IMapLoader mapLoader, AssetBundle mapAsset, MapSettings mapSettings, int mapLayer)
    {
        this.mapLoader = mapLoader;
        this.bundle = mapAsset;
        this.mapSettings = mapSettings;
        this.mapLayer = mapLayer;

        this.mapOffset = new Vector3(mapSettings.length / 2, HUDConstants.MAP_HEIGHT, mapSettings.width / 2);
        this.mapBounds = new Rect();
    }

 private GameObject loadSprite(string spriteName)
 {
     #if USE_ASSETBUNDLE
     if(assetbundle == null)
         assetbundle = AssetBundle.CreateFromFile(Application.streamingAssetsPath +"/Main.assetbundle");
             return assetbundle.Load(spriteName) as Sprite;
     #else
     return Instantiate(Resources.Load<GameObject>("Prefab/Atlas/Public/" + spriteName)) as GameObject;
     #endif
 }

    public IEnumerator LoadAssetsFromBundle(AssetBundle bundle, string[] names)
    {
        objects = new List<Object>();

        foreach (var name in names)
        {
            Object obj = bundle.Load(name);
            TryAddAsset(name, obj, objects);
        }
        yield return null;
    }

    static bool isBundleLoaded(AssetBundle bundle, string name)
    {
        if (bundle == null)
        {
            Debug.LogWarning(string.Format("Bundle {0} is not loaded", name));
            return false;
        }

        Debug.Log(string.Format("Bundle {0} is loaded", name));
        return true;
    }

	public static void addAssetBundle(string url, int version, AssetBundle assetbundle )
	{
		Debug.Log("addAssetBundle url = "+ url);
		if( getAssetBundle(url, version ) == null )
		{
			Debug.Log("addAssetBundle Success");
			string keyName = url + version.ToString();
			AssetBundleRef abRef = new AssetBundleRef (url, version);
			abRef.assetBundle = assetbundle;
			dictAssetBundleRefs.Add (keyName, abRef);
		}
	}

 public bool Insert(AssetBundle assetBundle)
 {
     try
     {
         _ctx.AssetBundles.Add(assetBundle);
         return true;
     }
     catch
     {
         return false;
     }
 }