update new cache system

重新设计了资源缓存系统
This commit is contained in:
hevinci
2023-02-07 18:39:08 +08:00
parent 33a1b9d4bf
commit 8ce8e81792
38 changed files with 858 additions and 841 deletions
@@ -0,0 +1,12 @@
using System;
using System.IO;
namespace YooAsset
{
[Serializable]
internal class CacheFileInfo
{
public string FileCRC;
public long FileSize;
}
}
@@ -1,5 +1,5 @@
fileFormatVersion: 2
guid: a6296859f09655c4191594304ddf378f
guid: e4a97c06e069c1146a881fcb359f9b4b
MonoImporter:
externalObjects: {}
serializedVersion: 2
@@ -2,19 +2,19 @@
using System.IO;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
namespace YooAsset
{
internal static class CacheSystem
{
private readonly static Dictionary<string, PatchBundle> _cachedDic = new Dictionary<string, PatchBundle>(1000);
private readonly static Dictionary<string, PackageCache> _cachedDic = new Dictionary<string, PackageCache>(1000);
/// <summary>
/// 初始化时的验证级别
/// </summary>
public static EVerifyLevel InitVerifyLevel { set; get; } = EVerifyLevel.Low;
/// <summary>
/// 清空所有数据
/// </summary>
@@ -25,103 +25,119 @@ namespace YooAsset
/// <summary>
/// 查询是否为验证文件
/// 注意:被收录的文件完整性是绝对有效的
/// </summary>
public static bool IsCached(PatchBundle patchBundle)
public static bool IsCached(string packageName, string cacheGUID)
{
string cacheKey = patchBundle.CacheKey;
if (_cachedDic.ContainsKey(cacheKey))
var cache = GetOrCreateCache(packageName);
return cache.IsCached(cacheGUID);
}
/// <summary>
/// 录入验证的文件
/// </summary>
public static void RecordFile(string packageName, string cacheGUID, PackageCache.RecordWrapper wrapper)
{
var cache = GetOrCreateCache(packageName);
cache.Record(cacheGUID, wrapper);
}
/// <summary>
/// 丢弃验证的文件(同时删除文件)
/// </summary>
public static void DiscardFile(string packageName, string cacheGUID)
{
var cache = GetOrCreateCache(packageName);
var wrapper = cache.TryGetWrapper(cacheGUID);
if (wrapper == null)
return;
cache.Discard(cacheGUID);
try
{
string filePath = patchBundle.CachedFilePath;
if (File.Exists(filePath))
{
return true;
}
else
{
_cachedDic.Remove(cacheKey);
YooLogger.Error($"Cache file is missing : {filePath}");
return false;
}
string dataFilePath = wrapper.DataFilePath;
FileInfo fileInfo = new FileInfo(dataFilePath);
if (fileInfo.Exists)
fileInfo.Directory.Delete(true);
}
else
catch (Exception e)
{
return false;
YooLogger.Error($"Failed to delete cache file ! {e.Message}");
}
}
/// <summary>
/// 缓存补丁包文件
/// 验证缓存文件(子线程内操作)
/// </summary>
public static void CacheBundle(PatchBundle patchBundle)
public static EVerifyResult VerifyingCacheFile(VerifyElement element, EVerifyLevel verifyLevel)
{
string cacheKey = patchBundle.CacheKey;
if (_cachedDic.ContainsKey(cacheKey) == false)
try
{
string filePath = patchBundle.CachedFilePath;
YooLogger.Log($"Cache verify file : {filePath}");
_cachedDic.Add(cacheKey, patchBundle);
string infoFilePath = element.InfoFilePath;
if (File.Exists(infoFilePath) == false)
return EVerifyResult.InfoFileNotExisted;
// 解析信息文件获取验证数据
string jsonContent = FileUtility.ReadAllText(infoFilePath);
CacheFileInfo fileInfo = UnityEngine.JsonUtility.FromJson<CacheFileInfo>(jsonContent);
element.DataFileCRC = fileInfo.FileCRC;
element.DataFileSize = fileInfo.FileSize;
}
}
/// <summary>
/// 验证补丁包文件
/// </summary>
public static EVerifyResult VerifyBundle(PatchBundle patchBundle, EVerifyLevel verifyLevel)
{
return VerifyContentInternal(patchBundle.CachedFilePath, patchBundle.FileSize, patchBundle.FileCRC, verifyLevel);
}
/// <summary>
/// 验证并缓存本地文件
/// </summary>
public static EVerifyResult VerifyAndCacheLocalBundleFile(PatchBundle patchBundle, EVerifyLevel verifyLevel)
{
var verifyResult = VerifyContentInternal(patchBundle.CachedFilePath, patchBundle.FileSize, patchBundle.FileCRC, verifyLevel);
if (verifyResult == EVerifyResult.Succeed)
CacheBundle(patchBundle);
return verifyResult;
}
/// <summary>
/// 验证并缓存下载文件
/// </summary>
public static EVerifyResult VerifyAndCacheDownloadBundleFile(string tempFilePath, PatchBundle patchBundle, EVerifyLevel verifyLevel)
{
var verifyResult = VerifyContentInternal(tempFilePath, patchBundle.FileSize, patchBundle.FileCRC, verifyLevel);
if (verifyResult == EVerifyResult.Succeed)
catch (Exception)
{
try
{
string destFilePath = patchBundle.CachedFilePath;
if (File.Exists(destFilePath))
File.Delete(destFilePath);
return EVerifyResult.Exception;
}
FileInfo fileInfo = new FileInfo(tempFilePath);
fileInfo.MoveTo(destFilePath);
}
catch (Exception)
{
verifyResult = EVerifyResult.FileMoveFailed;
}
return VerifyingInternal(element.DataFilePath, element.DataFileSize, element.DataFileCRC, verifyLevel);
}
if (verifyResult == EVerifyResult.Succeed)
/// <summary>
/// 验证下载文件
/// </summary>
public static EVerifyResult VerifyingTempFile(PatchBundle patchBundle, EVerifyLevel verifyLevel)
{
return VerifyingInternal(patchBundle.TempDataFilePath, patchBundle.FileSize, patchBundle.FileCRC, verifyLevel);
}
/// <summary>
/// 验证记录文件
/// </summary>
public static EVerifyResult VerifyingRecordFile(string packageName, string cacheGUID)
{
var cache = GetOrCreateCache(packageName);
var wrapper = cache.TryGetWrapper(cacheGUID);
if (wrapper == null)
return EVerifyResult.CacheNotFound;
EVerifyResult result = VerifyingInternal(wrapper.DataFilePath, wrapper.DataFileSize, wrapper.DataFileCRC, EVerifyLevel.High);
return result;
}
/// <summary>
/// 获取未被使用的缓存文件
/// </summary>
public static List<string> GetUnusedCacheGUIDs(AssetsPackage package)
{
var cache = GetOrCreateCache(package.PackageName);
var keys = cache.GetAllKeys();
List<string> result = new List<string>(keys.Count);
foreach (var cacheGUID in keys)
{
if (package.IsIncludeBundleFile(cacheGUID) == false)
{
CacheBundle(patchBundle);
result.Add(cacheGUID);
}
}
return verifyResult;
return result;
}
/// <summary>
/// 验证文件完整性
/// </summary>
private static EVerifyResult VerifyContentInternal(string filePath, long fileSize, string fileCRC, EVerifyLevel verifyLevel)
private static EVerifyResult VerifyingInternal(string filePath, long fileSize, string fileCRC, EVerifyLevel verifyLevel)
{
try
{
if (File.Exists(filePath) == false)
return EVerifyResult.FileNotExisted;
return EVerifyResult.DataFileNotExisted;
// 先验证文件大小
long size = FileUtility.GetFileSize(filePath);
@@ -149,5 +165,14 @@ namespace YooAsset
return EVerifyResult.Exception;
}
}
private static PackageCache GetOrCreateCache(string packageName)
{
if (_cachedDic.TryGetValue(packageName, out PackageCache cache) == false)
{
cache = new PackageCache(packageName);
_cachedDic.Add(packageName, cache);
}
return cache;
}
}
}
@@ -7,14 +7,19 @@ namespace YooAsset
internal enum EVerifyResult
{
/// <summary>
/// 文件不存在
/// 未找到缓存信息
/// </summary>
FileNotExisted = -5,
CacheNotFound = -6,
/// <summary>
/// 文件移动失败(重命名失败)
/// 信息文件不存在
/// </summary>
FileMoveFailed = -4,
InfoFileNotExisted = -5,
/// <summary>
/// 数据文件不存在
/// </summary>
DataFileNotExisted = -4,
/// <summary>
/// 文件内容不足(小于正常大小)
@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: d29a9623b2b346e439b7a7e37fafa781
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,71 @@
using System.Collections;
using System.Collections.Generic;
using System.IO;
namespace YooAsset
{
/// <summary>
/// 清理本地包裹未使用的缓存文件
/// </summary>
public sealed class ClearUnusedCacheFilesOperation : AsyncOperationBase
{
private enum ESteps
{
None,
GetUnusedCacheFiles,
ClearUnusedCacheFiles,
Done,
}
private readonly AssetsPackage _package;
private List<string> _unusedCacheGUIDs;
private int _unusedFileTotalCount = 0;
private ESteps _steps = ESteps.None;
internal ClearUnusedCacheFilesOperation(AssetsPackage package)
{
_package = package;
}
internal override void Start()
{
_steps = ESteps.GetUnusedCacheFiles;
}
internal override void Update()
{
if (_steps == ESteps.None || _steps == ESteps.Done)
return;
if (_steps == ESteps.GetUnusedCacheFiles)
{
_unusedCacheGUIDs = CacheSystem.GetUnusedCacheGUIDs(_package);
_unusedFileTotalCount = _unusedCacheGUIDs.Count;
YooLogger.Log($"Found unused cache file count : {_unusedFileTotalCount}");
_steps = ESteps.ClearUnusedCacheFiles;
}
if (_steps == ESteps.ClearUnusedCacheFiles)
{
for (int i = _unusedCacheGUIDs.Count - 1; i >= 0; i--)
{
string cacheGUID = _unusedCacheGUIDs[i];
CacheSystem.DiscardFile(_package.PackageName, cacheGUID);
_unusedCacheGUIDs.RemoveAt(i);
if (OperationSystem.IsBusy)
break;
}
if (_unusedFileTotalCount == 0)
Progress = 1.0f;
else
Progress = 1.0f - (_unusedCacheGUIDs.Count / _unusedFileTotalCount);
if (_unusedCacheGUIDs.Count == 0)
{
_steps = ESteps.Done;
Status = EOperationStatus.Succeed;
}
}
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 5d188c50fd00bf941b2eeebb374dc0d1
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,80 @@
using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;
namespace YooAsset
{
internal class PackageCachingOperation : AsyncOperationBase
{
private enum ESteps
{
None,
GetCacheFiles,
VerifyCacheFiles,
Done,
}
private readonly string _packageName;
private PackageVerifyOperation _packageVerifyOp;
private ESteps _steps = ESteps.None;
public PackageCachingOperation(string packageName)
{
_packageName = packageName;
}
internal override void Start()
{
_steps = ESteps.GetCacheFiles;
}
internal override void Update()
{
if (_steps == ESteps.None || _steps == ESteps.Done)
return;
if (_steps == ESteps.GetCacheFiles)
{
var elements = GetVerifyElements();
_packageVerifyOp = PackageVerifyOperation.CreateOperation(elements);
OperationSystem.StartOperation(_packageVerifyOp);
_steps = ESteps.VerifyCacheFiles;
}
if (_steps == ESteps.VerifyCacheFiles)
{
Progress = _packageVerifyOp.Progress;
if (_packageVerifyOp.IsDone == false)
return;
// 注意:总是返回成功
_steps = ESteps.Done;
Status = EOperationStatus.Succeed;
}
}
private List<VerifyElement> GetVerifyElements()
{
string cacheFolderPath = PersistentHelper.GetCacheFolderPath(_packageName);
if (Directory.Exists(cacheFolderPath) == false)
return new List<VerifyElement>();
DirectoryInfo rootDirectory = new DirectoryInfo(cacheFolderPath);
DirectoryInfo[] fileFolders = rootDirectory.GetDirectories();
List<VerifyElement> result = new List<VerifyElement>(fileFolders.Length);
foreach (var fileFoder in fileFolders)
{
string cacheGUID = fileFoder.Name;
if (CacheSystem.IsCached(_packageName, cacheGUID))
continue;
string fileRootPath = fileFoder.FullName;
string dataFilePath = $"{fileRootPath}/{ YooAssetSettings.CacheBundleDataFileName}";
string infoFilePath = $"{fileRootPath}/{ YooAssetSettings.CacheBundleInfoFileName}";
VerifyElement element = new VerifyElement(_packageName, cacheGUID, fileRootPath, dataFilePath, infoFilePath);
result.Add(element);
}
return result;
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 4ff95e7516dbfa148b4fe16eaab783fb
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,258 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Threading;
namespace YooAsset
{
internal abstract class PackageVerifyOperation : AsyncOperationBase
{
public static PackageVerifyOperation CreateOperation(List<VerifyElement> elements)
{
#if UNITY_WEBGL
var operation = new PackageVerifyWithoutThreadOperation(elements);
#else
var operation = new PackageVerifyWithThreadOperation(elements);
#endif
return operation;
}
}
/// <summary>
/// 本地缓存文件验证(线程版)
/// </summary>
internal class PackageVerifyWithThreadOperation : PackageVerifyOperation
{
private enum ESteps
{
None,
InitVerify,
UpdateVerify,
Done,
}
private readonly ThreadSyncContext _syncContext = new ThreadSyncContext();
private List<VerifyElement> _waitingList;
private List<VerifyElement> _verifyingList;
private int _verifyMaxNum;
private int _verifyTotalCount;
private float _verifyStartTime;
private int _succeedCount;
private int _failedCount;
private ESteps _steps = ESteps.None;
public PackageVerifyWithThreadOperation(List<VerifyElement> elements)
{
_waitingList = elements;
}
internal override void Start()
{
_steps = ESteps.InitVerify;
_verifyStartTime = UnityEngine.Time.realtimeSinceStartup;
}
internal override void Update()
{
if (_steps == ESteps.None || _steps == ESteps.Done)
return;
if (_steps == ESteps.InitVerify)
{
int fileCount = _waitingList.Count;
// 设置同时验证的最大数
ThreadPool.GetMaxThreads(out int workerThreads, out int ioThreads);
YooLogger.Log($"Work threads : {workerThreads}, IO threads : {ioThreads}");
_verifyMaxNum = Math.Min(workerThreads, ioThreads);
_verifyTotalCount = fileCount;
if (_verifyMaxNum < 1)
_verifyMaxNum = 1;
_verifyingList = new List<VerifyElement>(_verifyMaxNum);
_steps = ESteps.UpdateVerify;
}
if (_steps == ESteps.UpdateVerify)
{
_syncContext.Update();
Progress = GetProgress();
if (_waitingList.Count == 0 && _verifyingList.Count == 0)
{
_steps = ESteps.Done;
Status = EOperationStatus.Succeed;
float costTime = UnityEngine.Time.realtimeSinceStartup - _verifyStartTime;
YooLogger.Log($"Package verify elapsed time {costTime:f1} seconds");
}
for (int i = _waitingList.Count - 1; i >= 0; i--)
{
if (OperationSystem.IsBusy)
break;
if (_verifyingList.Count >= _verifyMaxNum)
break;
var element = _waitingList[i];
if (BeginVerifyFileWithThread(element))
{
_waitingList.RemoveAt(i);
_verifyingList.Add(element);
}
else
{
YooLogger.Warning("The thread pool is failed queued.");
break;
}
}
}
}
private float GetProgress()
{
if (_verifyTotalCount == 0)
return 1f;
return (float)(_succeedCount + _failedCount) / _verifyTotalCount;
}
private bool BeginVerifyFileWithThread(VerifyElement element)
{
return ThreadPool.QueueUserWorkItem(new WaitCallback(VerifyInThread), element);
}
private void VerifyInThread(object obj)
{
VerifyElement element = (VerifyElement)obj;
element.Result = CacheSystem.VerifyingCacheFile(element, CacheSystem.InitVerifyLevel);
_syncContext.Post(VerifyCallback, element);
}
private void VerifyCallback(object obj)
{
VerifyElement element = (VerifyElement)obj;
_verifyingList.Remove(element);
if (element.Result == EVerifyResult.Succeed)
{
_succeedCount++;
var wrapper = new PackageCache.RecordWrapper(element.InfoFilePath, element.DataFilePath, element.DataFileCRC, element.DataFileSize);
CacheSystem.RecordFile(element.PackageName, element.CacheGUID, wrapper);
}
else
{
_failedCount++;
// 删除验证失败的缓存文件
if (Directory.Exists(element.FileRootPath))
{
YooLogger.Warning($"Failed verify file and delete files : {element.FileRootPath}");
Directory.Delete(element.FileRootPath, true);
}
}
}
}
/// <summary>
/// 本地缓存文件验证(非线程版)
/// </summary>
internal class PackageVerifyWithoutThreadOperation : PackageVerifyOperation
{
private enum ESteps
{
None,
InitVerify,
UpdateVerify,
Done,
}
private List<VerifyElement> _waitingList;
private List<VerifyElement> _verifyingList;
private int _verifyMaxNum;
private int _verifyTotalCount;
private float _verifyStartTime;
private int _succeedCount;
private int _failedCount;
private ESteps _steps = ESteps.None;
public PackageVerifyWithoutThreadOperation(List<VerifyElement> elements)
{
_waitingList = elements;
}
internal override void Start()
{
_steps = ESteps.InitVerify;
_verifyStartTime = UnityEngine.Time.realtimeSinceStartup;
}
internal override void Update()
{
if (_steps == ESteps.None || _steps == ESteps.Done)
return;
if (_steps == ESteps.InitVerify)
{
int fileCount = _waitingList.Count;
// 设置同时验证的最大数
_verifyMaxNum = fileCount;
_verifyTotalCount = fileCount;
_verifyingList = new List<VerifyElement>(_verifyMaxNum);
_steps = ESteps.UpdateVerify;
}
if (_steps == ESteps.UpdateVerify)
{
Progress = GetProgress();
if (_waitingList.Count == 0 && _verifyingList.Count == 0)
{
_steps = ESteps.Done;
Status = EOperationStatus.Succeed;
float costTime = UnityEngine.Time.realtimeSinceStartup - _verifyStartTime;
YooLogger.Log($"Package verify elapsed time {costTime:f1} seconds");
}
for (int i = _waitingList.Count - 1; i >= 0; i--)
{
if (OperationSystem.IsBusy)
break;
if (_verifyingList.Count >= _verifyMaxNum)
break;
var element = _waitingList[i];
BeginVerifyFileWithoutThread(element);
_waitingList.RemoveAt(i);
_verifyingList.Add(element);
}
// 主线程内验证,可以清空列表
_verifyingList.Clear();
}
}
private float GetProgress()
{
if (_verifyTotalCount == 0)
return 1f;
return (float)(_succeedCount + _failedCount) / _verifyTotalCount;
}
private void BeginVerifyFileWithoutThread(VerifyElement element)
{
element.Result = CacheSystem.VerifyingCacheFile(element, CacheSystem.InitVerifyLevel);
if (element.Result == EVerifyResult.Succeed)
{
_succeedCount++;
var wrapper = new PackageCache.RecordWrapper(element.InfoFilePath, element.DataFilePath, element.DataFileCRC, element.DataFileSize);
CacheSystem.RecordFile(element.PackageName, element.CacheGUID, wrapper);
}
else
{
_failedCount++;
// 删除验证失败的缓存文件
if (Directory.Exists(element.FileRootPath))
{
YooLogger.Warning($"Failed verify file and delete files : {element.FileRootPath}");
Directory.Delete(element.FileRootPath, true);
}
}
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 868188d19436b674b8c403d2d90afeaf
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,103 @@
using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;
namespace YooAsset
{
internal class PackageCache
{
internal class RecordWrapper
{
public string InfoFilePath { private set; get; }
public string DataFilePath { private set; get; }
public string DataFileCRC { private set; get; }
public long DataFileSize { private set; get; }
public RecordWrapper(string infoFilePath, string dataFilePath, string dataFileCRC, long dataFileSize)
{
InfoFilePath = infoFilePath;
DataFilePath = dataFilePath;
DataFileCRC = dataFileCRC;
DataFileSize = dataFileSize;
}
}
private readonly Dictionary<string, RecordWrapper> _wrappers = new Dictionary<string, RecordWrapper>();
/// <summary>
/// 包裹名称
/// </summary>
public string PackageName { private set; get; }
public PackageCache(string packageName)
{
PackageName = packageName;
}
/// <summary>
/// 清空所有数据
/// </summary>
public void ClearAll()
{
_wrappers.Clear();
}
/// <summary>
/// 查询缓存记录
/// </summary>
public bool IsCached(string cacheGUID)
{
return _wrappers.ContainsKey(cacheGUID);
}
/// <summary>
/// 记录验证结果
/// </summary>
public void Record(string cacheGUID, RecordWrapper wrapper)
{
if (_wrappers.ContainsKey(cacheGUID) == false)
{
_wrappers.Add(cacheGUID, wrapper);
}
else
{
throw new Exception("Should never get here !");
}
}
/// <summary>
/// 丢弃验证结果
/// </summary>
public void Discard(string cacheGUID)
{
if (_wrappers.ContainsKey(cacheGUID))
{
_wrappers.Remove(cacheGUID);
}
}
/// <summary>
/// 获取记录对象
/// </summary>
public RecordWrapper TryGetWrapper(string cacheGUID)
{
if (_wrappers.TryGetValue(cacheGUID, out RecordWrapper value))
return value;
else
return null;
}
internal List<string> GetAllKeys()
{
List<string> keys = new List<string>(_wrappers.Keys.Count);
var keyCollection = _wrappers.Keys;
foreach (var key in keyCollection)
{
keys.Add(key);
}
return keys;
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 08f3e92fdbd5d56459d8882be1f54f60
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,25 @@
namespace YooAsset
{
internal class VerifyElement
{
public string PackageName { private set; get; }
public string CacheGUID { private set; get; }
public string FileRootPath { private set; get; }
public string DataFilePath { private set; get; }
public string InfoFilePath { private set; get; }
public EVerifyResult Result;
public string DataFileCRC;
public long DataFileSize;
public VerifyElement(string packageName, string cacheGUID, string fileRootPath, string dataFilePath, string infoFilePath)
{
PackageName = packageName;
CacheGUID = cacheGUID;
FileRootPath = fileRootPath;
DataFilePath = dataFilePath;
InfoFilePath = infoFilePath;
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 5a4b96484bd701f4289b2f74c38abaa8
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -1,33 +0,0 @@
namespace YooAsset
{
internal class VerifyInfo
{
/// <summary>
/// 验证的资源文件是否为内置资源
/// </summary>
public bool IsBuildinFile { private set; get; }
/// <summary>
/// 验证的资源包实例
/// </summary>
public PatchBundle VerifyBundle { private set; get; }
/// <summary>
/// 验证的文件路径
/// </summary>
public string VerifyFilePath { private set; get; }
/// <summary>
/// 验证结果
/// </summary>
public EVerifyResult Result;
public VerifyInfo(bool isBuildinFile, PatchBundle verifyBundle)
{
IsBuildinFile = isBuildinFile;
VerifyBundle = verifyBundle;
VerifyFilePath = verifyBundle.CachedFilePath;
}
}
}