Caching

描述

Caching 类用于管理使用 UnityWebRequestAssetBundle.GetAssetBundle() 下载的缓存 AssetBundle。

另请参阅：DownloadHandlerAssetBundle。

using System.Collections;
using UnityEngine;
using System.IO;
using System;
using UnityEngine.Networking;
using System.Collections.Generic;

public class Example : MonoBehaviour
{
    IEnumerator DownloadAndCacheAssetBundle(string uri, string manifestBundlePath)
    {
        //Load the manifest
        AssetBundle manifestBundle = AssetBundle.LoadFromFile(manifestBundlePath);
        AssetBundleManifest manifest = manifestBundle.LoadAsset<AssetBundleManifest>("AssetBundleManifest");

        //Create new cache
        string today = DateTime.Today.ToLongDateString();
        Directory.CreateDirectory(today);
        Cache newCache = Caching.AddCache(today);

        //Set current cache for writing to the new cache if the cache is valid
        if (newCache.valid)
            Caching.currentCacheForWriting = newCache;

        //Download the bundle
        Hash128 hash = manifest.GetAssetBundleHash("bundleName");
        UnityWebRequest request = UnityWebRequestAssetBundle.GetAssetBundle(uri, hash, 0);
        yield return request.SendWebRequest();
        AssetBundle bundle = DownloadHandlerAssetBundle.GetContent(request);

        //Get all the cached versions
        List<Hash128> listOfCachedVersions = new List<Hash128>();
        Caching.GetCachedVersions(bundle.name, listOfCachedVersions);

        if (!AssetBundleContainsAssetIWantToLoad(bundle))     //Or any conditions you want to check on your new asset bundle
        {
            //If our criteria wasn't met, we can remove the new cache and revert back to the most recent one
            Caching.currentCacheForWriting = Caching.GetCacheAt(Caching.cacheCount);
            Caching.RemoveCache(newCache);

            for (int i = listOfCachedVersions.Count - 1; i > 0; i--)
            {
                //Load a different bundle from a different cache
                request = UnityWebRequestAssetBundle.GetAssetBundle(uri, listOfCachedVersions[i], 0);
                yield return request.SendWebRequest();
                bundle = DownloadHandlerAssetBundle.GetContent(request);

                //Check and see if the newly loaded bundle from the cache meets your criteria
                if (AssetBundleContainsAssetIWantToLoad(bundle))
                    break;
            }
        }
        else
        {
            //This is if we only want to keep 5 local caches at any time
            if (Caching.cacheCount > 5)
                Caching.RemoveCache(Caching.GetCacheAt(1));     //Removes the oldest user created cache
        }
    }

    bool AssetBundleContainsAssetIWantToLoad(AssetBundle bundle)
    {
        return (bundle.LoadAsset<GameObject>("MyAsset") != null);     //this could be any conditional
    }
}

如果您想存储一个捆绑包的最多 5 个缓存版本，并且在最近的缓存变为无效状态或下载的资源捆绑包出现问题时使用以前的缓存，可以像下面这样设置。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Networking;
using System.IO;

public class Example2 : MonoBehaviour
{
    public static class CacheWithPriority
    {
        public enum ResolutionType
        {
            High,
            Medium,
            Low,
        }
        static readonly Dictionary<ResolutionType, Cache> ResolutionCaches = new Dictionary<ResolutionType, Cache>();

        public static void InitResolutionCaches()
        {
            string highResPath = "HighRes";
            string medResPath = "MedRes";
            string lowResPath = Application.streamingAssetsPath;

            //Create cache paths
            Directory.CreateDirectory(highResPath);
            Directory.CreateDirectory(medResPath);

            //Create the caches and add them to a Dictionary
            ResolutionCaches.Add(ResolutionType.High, Caching.AddCache(highResPath));
            ResolutionCaches.Add(ResolutionType.Medium, Caching.AddCache(medResPath));
            ResolutionCaches.Add(ResolutionType.Low, Caching.AddCache(lowResPath));
        }

        public static void PrioritizeCacheForLoading(ResolutionType resolutionToPrioritize)
        {
            //Move cache to the start of the queue
            Caching.MoveCacheBefore(ResolutionCaches[resolutionToPrioritize], Caching.GetCacheAt(0));
        }

        public static void SetResolutionCacheForWriting(ResolutionType resolutionToWriteTo)
        {
            Caching.currentCacheForWriting = ResolutionCaches[resolutionToWriteTo];
        }
    }

    AssetBundle currentTextureAssetBundle;
    IEnumerator RearrangeCacheOrderExample(string manifestBundlePath)
    {
        CacheWithPriority.InitResolutionCaches();

        //Load the manifest
        AssetBundle manifestBundle = AssetBundle.LoadFromFile(manifestBundlePath);
        AssetBundleManifest manifest = manifestBundle.LoadAsset<AssetBundleManifest>("AssetBundleManifest");

        //We know we want to start loading from the Low Resolution Cache
        CacheWithPriority.PrioritizeCacheForLoading(CacheWithPriority.ResolutionType.Low);

        //Load the low res bundle from StreamingAssets
        UnityWebRequest lowRequest = UnityWebRequestAssetBundle.GetAssetBundle("lowResBundlePath",
            manifest.GetAssetBundleHash("lowResBundle"), 0);
        yield return lowRequest;
        currentTextureAssetBundle = DownloadHandlerAssetBundle.GetContent(lowRequest);

        //In the background we can start downloading our higher resolution bundles
        StartCoroutine(StartDownloadHigherResolutionBundles(manifest));

        //Do work with low res bundle while the higher resolutions download...
    }

    IEnumerator StartDownloadHigherResolutionBundles(AssetBundleManifest manifest)
    {
        CacheWithPriority.SetResolutionCacheForWriting(CacheWithPriority.ResolutionType.Medium);
        UnityWebRequest medRequest = UnityWebRequestAssetBundle.GetAssetBundle("medResBundleUrl", manifest.GetAssetBundleHash("medResBundle"), 0);
        medRequest.SendWebRequest();

        while (!medRequest.isDone)
            yield return null;
        SwitchTextureBundleTo(CacheWithPriority.ResolutionType.Medium, medRequest);

        //Now you'll be using the medium resolution bundle

        CacheWithPriority.SetResolutionCacheForWriting(CacheWithPriority.ResolutionType.High);
        UnityWebRequest highRequest = UnityWebRequestAssetBundle.GetAssetBundle("highResBundleUrl", manifest.GetAssetBundleHash("highResBundle"), 0);
        highRequest.SendWebRequest();

        while (!highRequest.isDone)
            yield return null;
        SwitchTextureBundleTo(CacheWithPriority.ResolutionType.High, highRequest);

        //Do work with the high resolution bundle now...
    }

    void SwitchTextureBundleTo(CacheWithPriority.ResolutionType typeToSwitchTo, UnityWebRequest request)
    {
        //For performance, we tell the Caching system what cache we want it to search first
        CacheWithPriority.PrioritizeCacheForLoading(typeToSwitchTo);
        //Unload our current texture bundle
        currentTextureAssetBundle.Unload(true);
        //Load the new one from the passed in UnityWebRequest
        currentTextureAssetBundle = DownloadHandlerAssetBundle.GetContent(request);
    }
}

拥有多个缓存的功能让您能够保留特定资源捆绑包的多个缓存版本。您可以将它们用于备份和回退等操作。

本示例演示如何在启动后下载中分辨率和高分辨率纹理，并将它们缓存到各自的专用缓存中。

静态变量

静态函数