Unity 工具之（SharpZipLib）实现带有中文文件Zip的压缩和解压（避免压缩中文内容乱码）

我就是我 2022-10-24 13:10 272阅读 0赞

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70][]

# Unity 工具 之 （SharpZipLib） 实现带有中文文件Zip的压缩和解压（避免压缩中文内容乱码） #

**目录**

Unity 工具 之 （SharpZipLib） 实现带有中文文件Zip的压缩和解压（避免压缩中文内容乱码）

一、简单介绍

二、实现原理

三、注意事项

四、效果预览

五、实现步骤

六、关键代码

--------------------

## 一、简单介绍 ##

Unity 工具类，自己整理的一些游戏开发可能用到的模块，单独独立使用，方便游戏开发。

Unity 进行文件的压缩和解压，这里介绍使用 SharpZipLib 库进行带有中文的内容文件的压缩和解压，并且避免中文乱码现象，这里做个整理，方便游戏数据的打包下载，更新一些资源等等，方法不唯一，感谢提供参考学习的朋友们，大牛们哈（借用下你们优秀代码，学习）。

这里zip dll 下载导入和简单使用，就不赘述了，可参考下面博文：

[Unity 工具 之 （SharpZipLib） 实现文件Zip的压缩和解压（（可代密码）可一次压缩多个文件/文件夹）][Unity _ _ _SharpZipLib_ _Zip]

## 二、实现原理 ##

1、很简单，一段代码，设置 Unicode 为 true 即可支持中文问价解压缩：

zipEntry.IsUnicodeText = true;    // 支持中文

## 三、注意事项 ##

1、如果你的不行，请下载较新的 dll

2、压缩文件，目前下面必须有，但是解压不带这个也可以解压中文文件（可能插件内部已经支持了），可以自行尝试

zipEntry.IsUnicodeText = true;    // 支持中文

## 四、效果预览 ##

![20210129165433857.gif][]

## 五、实现步骤 ##

这里zip dll 下载导入和简单使用，就不赘述了，可参考下面博文：

[Unity 工具 之 （SharpZipLib） 实现文件Zip的压缩和解压（（可代密码）可一次压缩多个文件/文件夹）][Unity _ _ _SharpZipLib_ _Zip]

1、打开Unity，新建空工程

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 1][]

2、导入，并实现 zip 加压解压功能

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 2][]

3、添加带有中文的文件文件夹，作为测试

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 3][]

4、编写脚本，测试带有中文文件的压缩和解压功能，并把脚本挂载到场景中

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 4][]

5、运行结果如上，中文解压缩基本OK

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 5][]

## 六、关键代码 ##

1、TestzipWrapper

using ICSharpCode.SharpZipLib.Zip;
    using System.Collections;
    using System.Collections.Generic;
    using UnityEditor;
    using UnityEngine;
    
    namespace ZipWrapper
    {
        public class TestzipWrapper : MonoBehaviour
        {
            //  压缩和解压缩的输出路径
            string zipOutputPath ;
            string unzipOutputPath ;
    
    
            // Start is called before the first frame update
            void Start()
            {
                zipOutputPath = Application.dataPath + "/ZipTestWithChineseFilesOrDirs中文.zip";
                unzipOutputPath = Application.dataPath + "/UnzipTestWithChineseFilesOrDirs中文";
    
                // 压缩和解压缩
                ZipWithChineseFilesOrDirs();
                UnzipWithChineseFilesOrDirs();
    
                // 刷新资源文件夹
                AssetDatabase.Refresh();
            }
    
            #region 中文压缩   
            void ZipWithChineseFilesOrDirs() {
                // 要打包zip的路径数组
                string[] zipPaths = new string[] {
                    Application.dataPath+ "/TestWithChineseFilesOrDirs中文"
                };
                Debug.Log("zipOutputPath : " + zipOutputPath);
                ZipWrapper.Zip(zipPaths, zipOutputPath,null, new MyChineseZipCallback());
            }
    
            public class MyChineseZipCallback : ZipWrapper.ZipCallback
            {
    
                public override bool OnPreZip(ZipEntry _entry)
                {
                    _entry.IsUnicodeText = true;    // 支持中文
                    return base.OnPreZip(_entry);
                }
    
                public override void OnFinished(bool _result)
                {
                    Debug.Log(GetType()+ "/OnFinished()/ Zip Finished……");
                    base.OnFinished(_result);
                }
            }
    
            #endregion
    
            #region 中文解压
            void UnzipWithChineseFilesOrDirs()
            {
                Debug.Log("zipOutputPath : " + zipOutputPath);
                ZipWrapper.UnzipFile(zipOutputPath, unzipOutputPath, null, new MyChineseUnzipCallback());
               
            }
    
            public class MyChineseUnzipCallback : ZipWrapper.UnzipCallback
            {
    
                public override bool OnPreUnzip(ZipEntry _entry)
                {
                    _entry.IsUnicodeText = true;    // 支持中文（后面测试，不带这个也可以解压中文文件（可能插件内部已经支持了））
                    return base.OnPreUnzip(_entry);
                }
    
                public override void OnFinished(bool _result)
                {
                    Debug.Log(GetType() + "/OnFinished()/ Unzip Finished……");
                    base.OnFinished(_result);
                }
            }
    
            #endregion
        }
    }

2、ZipWrapper

using ICSharpCode.SharpZipLib.Zip;
    using System.IO;
    using UnityEngine;
    
    namespace ZipWrapper
    {
        public class ZipWrapper : MonoBehaviour
        {
            #region ZipCallback
            public abstract class ZipCallback
            {
                /// <summary>
                /// 压缩单个文件或文件夹前执行的回调
                /// </summary>
                /// <param name="_entry"></param>
                /// <returns>如果返回true，则压缩文件或文件夹，反之则不压缩文件或文件夹</returns>
                public virtual bool OnPreZip(ZipEntry _entry)
                {
                    return true;
                }
    
                /// <summary>
                /// 压缩单个文件或文件夹后执行的回调
                /// </summary>
                /// <param name="_entry"></param>
                public virtual void OnPostZip(ZipEntry _entry) { }
    
                /// <summary>
                /// 压缩执行完毕后的回调
                /// </summary>
                /// <param name="_result">true表示压缩成功，false表示压缩失败</param>
                public virtual void OnFinished(bool _result) { }
            }
            #endregion
    
            #region UnzipCallback
            public abstract class UnzipCallback
            {
                /// <summary>
                /// 解压单个文件或文件夹前执行的回调
                /// </summary>
                /// <param name="_entry"></param>
                /// <returns>如果返回true，则压缩文件或文件夹，反之则不压缩文件或文件夹</returns>
                public virtual bool OnPreUnzip(ZipEntry _entry)
                {
                    return true;
                }
    
                /// <summary>
                /// 解压单个文件或文件夹后执行的回调
                /// </summary>
                /// <param name="_entry"></param>
                public virtual void OnPostUnzip(ZipEntry _entry) { }
    
                /// <summary>
                /// 解压执行完毕后的回调
                /// </summary>
                /// <param name="_result">true表示解压成功，false表示解压失败</param>
                public virtual void OnFinished(bool _result) { }
            }
            #endregion
    
            /// <summary>
            /// 压缩文件和文件夹
            /// </summary>
            /// <param name="_fileOrDirectoryArray">文件夹路径和文件名</param>
            /// <param name="_outputPathName">压缩后的输出路径文件名</param>
            /// <param name="_password">压缩密码</param>
            /// <param name="_zipCallback">ZipCallback对象，负责回调</param>
            /// <returns></returns>
            public static bool Zip(string[] _fileOrDirectoryArray, string _outputPathName, string _password = null, ZipCallback _zipCallback = null)
            {
                if ((null == _fileOrDirectoryArray) || string.IsNullOrEmpty(_outputPathName))
                {
                    if (null != _zipCallback)
                        _zipCallback.OnFinished(false);
    
                    return false;
                }
    
                ZipOutputStream zipOutputStream = new ZipOutputStream(File.Create(_outputPathName));
                zipOutputStream.SetLevel(6);    // 压缩质量和压缩速度的平衡点
                if (!string.IsNullOrEmpty(_password))
                    zipOutputStream.Password = _password;
    
                for (int index = 0; index < _fileOrDirectoryArray.Length; ++index)
                {
                    bool result = false;
                    string fileOrDirectory = _fileOrDirectoryArray[index];
                    if (Directory.Exists(fileOrDirectory))
                        result = ZipDirectory(fileOrDirectory, string.Empty, zipOutputStream, _zipCallback);
                    else if (File.Exists(fileOrDirectory))
                        result = ZipFile(fileOrDirectory, string.Empty, zipOutputStream, _zipCallback);
    
                    if (!result)
                    {
                        if (null != _zipCallback)
                            _zipCallback.OnFinished(false);
    
                        return false;
                    }
                }
    
                zipOutputStream.Finish();
                zipOutputStream.Close();
    
                if (null != _zipCallback)
                    _zipCallback.OnFinished(true);
    
                return true;
            }
    
            /// <summary>
            /// 解压Zip包
            /// </summary>
            /// <param name="_filePathName">Zip包的文件路径名</param>
            /// <param name="_outputPath">解压输出路径</param>
            /// <param name="_password">解压密码</param>
            /// <param name="_unzipCallback">UnzipCallback对象，负责回调</param>
            /// <returns></returns>
            public static bool UnzipFile(string _filePathName, string _outputPath, string _password = null, UnzipCallback _unzipCallback = null)
            {
                if (string.IsNullOrEmpty(_filePathName) || string.IsNullOrEmpty(_outputPath))
                {
                    if (null != _unzipCallback)
                        _unzipCallback.OnFinished(false);
    
                    return false;
                }
    
                try
                {
                    return UnzipFile(File.OpenRead(_filePathName), _outputPath, _password, _unzipCallback);
                }
                catch (System.Exception _e)
                {
                    Debug.LogError("[ZipUtility.UnzipFile]: " + _e.ToString());
    
                    if (null != _unzipCallback)
                        _unzipCallback.OnFinished(false);
    
                    return false;
                }
            }
    
            /// <summary>
            /// 解压Zip包
            /// </summary>
            /// <param name="_fileBytes">Zip包字节数组</param>
            /// <param name="_outputPath">解压输出路径</param>
            /// <param name="_password">解压密码</param>
            /// <param name="_unzipCallback">UnzipCallback对象，负责回调</param>
            /// <returns></returns>
            public static bool UnzipFile(byte[] _fileBytes, string _outputPath, string _password = null, UnzipCallback _unzipCallback = null)
            {
                if ((null == _fileBytes) || string.IsNullOrEmpty(_outputPath))
                {
                    if (null != _unzipCallback)
                        _unzipCallback.OnFinished(false);
    
                    return false;
                }
    
                bool result = UnzipFile(new MemoryStream(_fileBytes), _outputPath, _password, _unzipCallback);
                if (!result)
                {
                    if (null != _unzipCallback)
                        _unzipCallback.OnFinished(false);
                }
    
                return result;
            }
    
            /// <summary>
            /// 解压Zip包
            /// </summary>
            /// <param name="_inputStream">Zip包输入流</param>
            /// <param name="_outputPath">解压输出路径</param>
            /// <param name="_password">解压密码</param>
            /// <param name="_unzipCallback">UnzipCallback对象，负责回调</param>
            /// <returns></returns>
            public static bool UnzipFile(Stream _inputStream, string _outputPath, string _password = null, UnzipCallback _unzipCallback = null)
            {
                if ((null == _inputStream) || string.IsNullOrEmpty(_outputPath))
                {
                    if (null != _unzipCallback)
                        _unzipCallback.OnFinished(false);
    
                    return false;
                }
    
                // 创建文件目录
                if (!Directory.Exists(_outputPath))
                    Directory.CreateDirectory(_outputPath);
    
                // 解压Zip包
                ZipEntry entry = null;
                using (ZipInputStream zipInputStream = new ZipInputStream(_inputStream))
                {
                    if (!string.IsNullOrEmpty(_password))
                        zipInputStream.Password = _password;
    
                    while (null != (entry = zipInputStream.GetNextEntry()))
                    {
                        if (string.IsNullOrEmpty(entry.Name))
                            continue;
    
                        if ((null != _unzipCallback) && !_unzipCallback.OnPreUnzip(entry))
                            continue;   // 过滤
    
                        string filePathName = Path.Combine(_outputPath, entry.Name);
    
                        // 创建文件目录
                        if (entry.IsDirectory)
                        {
                            Directory.CreateDirectory(filePathName);
                            continue;
                        }
    
                        // 写入文件
                        try
                        {
                            using (FileStream fileStream = File.Create(filePathName))
                            {
                                byte[] bytes = new byte[1024];
                                while (true)
                                {
                                    int count = zipInputStream.Read(bytes, 0, bytes.Length);
                                    if (count > 0)
                                        fileStream.Write(bytes, 0, count);
                                    else
                                    {
                                        if (null != _unzipCallback)
                                            _unzipCallback.OnPostUnzip(entry);
    
                                        break;
                                    }
                                }
                            }
                        }
                        catch (System.Exception _e)
                        {
                            Debug.LogError("[ZipUtility.UnzipFile]: " + _e.ToString());
    
                            if (null != _unzipCallback)
                                _unzipCallback.OnFinished(false);
    
                            return false;
                        }
                    }
                }
    
                if (null != _unzipCallback)
                    _unzipCallback.OnFinished(true);
    
                return true;
            }
    
            /// <summary>
            /// 压缩文件
            /// </summary>
            /// <param name="_filePathName">文件路径名</param>
            /// <param name="_parentRelPath">要压缩的文件的父相对文件夹</param>
            /// <param name="_zipOutputStream">压缩输出流</param>
            /// <param name="_zipCallback">ZipCallback对象，负责回调</param>
            /// <returns></returns>
            private static bool ZipFile(string _filePathName, string _parentRelPath, ZipOutputStream _zipOutputStream, ZipCallback _zipCallback = null)
            {
    
                //Crc32 crc32 = new Crc32();
                ZipEntry entry = null;
                FileStream fileStream = null;
                try
                {
                    string entryName = _parentRelPath + '/' + Path.GetFileName(_filePathName);
                    entry = new ZipEntry(entryName);
                    entry.DateTime = System.DateTime.Now;
    
                    if ((null != _zipCallback) && !_zipCallback.OnPreZip(entry))
                        return true;    // 过滤
    
                    fileStream = File.OpenRead(_filePathName);
                    byte[] buffer = new byte[fileStream.Length];
                    fileStream.Read(buffer, 0, buffer.Length);
                    fileStream.Close();
    
                    entry.Size = buffer.Length;
    
                    //crc32.Reset();
                    //crc32.Update(buffer);
                    //entry.Crc = crc32.Value;
    
                    _zipOutputStream.PutNextEntry(entry);
                    _zipOutputStream.Write(buffer, 0, buffer.Length);
                }
                catch (System.Exception _e)
                {
                    Debug.LogError("[ZipUtility.ZipFile]: " + _e.ToString());
                    return false;
                }
                finally
                {
                    if (null != fileStream)
                    {
                        fileStream.Close();
                        fileStream.Dispose();
                    }
                }
    
                if (null != _zipCallback)
                    _zipCallback.OnPostZip(entry);
    
                return true;
            }
    
            /// <summary>
            /// 压缩文件夹
            /// </summary>
            /// <param name="_path">要压缩的文件夹</param>
            /// <param name="_parentRelPath">要压缩的文件夹的父相对文件夹</param>
            /// <param name="_zipOutputStream">压缩输出流</param>
            /// <param name="_zipCallback">ZipCallback对象，负责回调</param>
            /// <returns></returns>
            private static bool ZipDirectory(string _path, string _parentRelPath, ZipOutputStream _zipOutputStream, ZipCallback _zipCallback = null)
            {
                ZipEntry entry = null;
                try
                {
                    string entryName = Path.Combine(_parentRelPath, Path.GetFileName(_path) + '/');
                    entry = new ZipEntry(entryName);
                    entry.DateTime = System.DateTime.Now;
                    entry.Size = 0;
    
                    if ((null != _zipCallback) && !_zipCallback.OnPreZip(entry))
                        return true;    // 过滤
    
                    _zipOutputStream.PutNextEntry(entry);
                    _zipOutputStream.Flush();
    
                    string[] files = Directory.GetFiles(_path);
                    for (int index = 0; index < files.Length; ++index)
                    {
                        // 排除Unity中可能的 .meta 文件
                        if (files[index].EndsWith(".meta") == true)
                        {
                            Debug.LogWarning(files[index] + " not to zip");
                            continue;
                        }
    
                        ZipFile(files[index], Path.Combine(_parentRelPath, Path.GetFileName(_path)), _zipOutputStream, _zipCallback);
                    }
                }
                catch (System.Exception _e)
                {
                    Debug.LogError("[ZipUtility.ZipDirectory]: " + _e.ToString());
                    return false;
                }
    
                string[] directories = Directory.GetDirectories(_path);
                for (int index = 0; index < directories.Length; ++index)
                {
                    if (!ZipDirectory(directories[index], Path.Combine(_parentRelPath, Path.GetFileName(_path)), _zipOutputStream, _zipCallback))
                    {
                        return false;
                    }
                }
    
                if (null != _zipCallback)
                    _zipCallback.OnPostZip(entry);
    
                return true;
            }
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 6][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70]: /images/20221024/d45d5f92d94342ab998426864682cd06.png
[Unity _ _ _SharpZipLib_ _Zip]: https://blog.csdn.net/u014361280/article/details/109677502
[20210129165433857.gif]: /images/20221024/1c90e098924141918e8501313bb5c6ef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 1]: /images/20221024/9ae10da98d3644b4b93a6f4349ee6d81.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 2]: /images/20221024/92c0cfb0fa9047b590409b12abe73db2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 3]: /images/20221024/452e806caafc43748320b2cfcea2a965.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 4]: /images/20221024/2184fd3ad4dc4e66a5bb9e6bfd0b4f0c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 5]: /images/20221024/328ba887a69d4f22be1bc94a8b104be7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 6]: /images/20221024/d6c57e1a8561405bb4650973b9aa50d3.png