ZIP乱码

```
public abstract class ZipService
{
    private static readonly Lazy<Encoding[]> SupportedEncodings = new Lazy<Encoding[]>(() =>
    {
        // 注册编码提供程序（解决GBK等编码问题）
        Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);

var encodings = new List<Encoding> { Encoding.UTF8, Encoding.Default };

try
        {
            // 尝试添加中文编码
            var gb2312 = Encoding.GetEncoding("GB2312");
            if (!encodings.Contains(gb2312))
                encodings.Add(gb2312);
        }
        catch { }

try
        {
            var gb18030 = Encoding.GetEncoding("GB18030");
            if (!encodings.Contains(gb18030))
                encodings.Add(gb18030);
        }
        catch { }

try
        {
            // GBK 是常用的中文编码
            var gbk = Encoding.GetEncoding("GBK");
            if (!encodings.Contains(gbk))
                encodings.Add(gbk);
        }
        catch { }

return encodings.ToArray();
    });

static ZipService()
    {
        // 静态构造函数中预加载编码
        _ = SupportedEncodings.Value;
    }

/// <summary>
    /// 获取ZIP文件中的所有条目名称（解决中文乱码问题）
    /// </summary>
    public static List<string> GetZipEntries(string zipFilePath)
    {
        ValidateFilePath(zipFilePath);

var encodings = SupportedEncodings.Value;
        var attemptedEncodings = new List<string>();

foreach (var encoding in encodings)
        {
            try
            {
                attemptedEncodings.Add(encoding.WebName);
                using var archive = ZipFile.Open(zipFilePath, ZipArchiveMode.Read, encoding);
                var entries = archive.Entries;
                var result = new List<string>(entries.Count);

foreach (var entry in entries)
                {
                    if (!string.IsNullOrEmpty(entry.FullName))
                        result.Add(entry.FullName);
                }

// 检查是否有乱码
                if (!HasGarbledText(result))
                    return result;
            }
            catch (Exception ex) when (ex is ArgumentException || ex is NotSupportedException)
            {
                // 编码不支持，继续尝试下一个
                continue;
            }
        }

// 回退方案：使用默认编码
        try
        {
            using var fallbackArchive = ZipFile.OpenRead(zipFilePath);
            return fallbackArchive.Entries
                .Where(entry => !string.IsNullOrEmpty(entry.FullName))
                .Select(entry => entry.FullName)
                .ToList();
        }
        catch (Exception ex)
        {
            throw new InvalidOperationException(
                $"无法读取ZIP文件。尝试的编码: {string.Join(", ", attemptedEncodings)}. 错误: {ex.Message}", ex);
        }
    }

/// <summary>
    /// 从ZIP文件中提取特定文件（增强版）
    /// </summary>
    public static (bool Success, string Message) ExtractFileFromZip(string zipPath, string extractPath, string targetFile)
    {
        ValidateFilePath(zipPath);

if (string.IsNullOrWhiteSpace(extractPath))
            throw new ArgumentException("提取路径不能为空", nameof(extractPath));

if (string.IsNullOrWhiteSpace(targetFile))
            throw new ArgumentException("目标文件名不能为空", nameof(targetFile));

// 确保目标目录存在
        var directory = Path.GetDirectoryName(extractPath);
        if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
        {
            Directory.CreateDirectory(directory);
        }

var encodings = SupportedEncodings.Value;
        var attemptedEncodings = new List<string>();

foreach (var encoding in encodings)
        {
            try
            {
                attemptedEncodings.Add(encoding.WebName);
                using var archive = ZipFile.Open(zipPath, ZipArchiveMode.Read, encoding);
                var normalizedTargetFile = targetFile.TrimStart('/', '\\');

// 精确匹配
                var entry = archive.GetEntry(normalizedTargetFile);
                if (entry == null)
                {
                    // 模糊匹配（处理路径分隔符差异）
                    entry = archive.Entries.FirstOrDefault(e =>
                        !string.IsNullOrEmpty(e.FullName) &&
                        (e.FullName.Replace('\\', '/').EndsWith(normalizedTargetFile.Replace('\\', '/')) ||
                         e.Name?.Equals(normalizedTargetFile, StringComparison.OrdinalIgnoreCase) == true));
                }

if (entry != null && !string.IsNullOrEmpty(entry.Name))
                {
                    ExtractEntry(entry, extractPath);
                    return (true, $"文件提取成功，使用的编码: {encoding.WebName}");
                }
            }
            catch (Exception ex) when (ex is ArgumentException || ex is NotSupportedException)
            {
                continue;
            }
        }

// 回退方案
        try
        {
            using var fallbackArchive = ZipFile.OpenRead(zipPath);
            var normalizedTargetFile = targetFile.TrimStart('/', '\\');
            var entry = fallbackArchive.GetEntry(normalizedTargetFile);

if (entry != null && !string.IsNullOrEmpty(entry.Name))
            {
                ExtractEntry(entry, extractPath);
                return (true, "文件提取成功（使用默认编码）");
            }

return (false, $"未找到文件: {targetFile}");
        }
        catch (Exception ex)
        {
            return (false, $"提取失败: {ex.Message}");
        }
    }

/// <summary>
    /// 简化的ZIP条目获取方法（避免编码问题）
    /// </summary>
    public static List<string> GetZipEntriesSimple(string zipFilePath)
    {
        ValidateFilePath(zipFilePath);

try
        {
            using var archive = ZipFile.OpenRead(zipFilePath);
            return archive.Entries
                .Where(entry => !string.IsNullOrEmpty(entry.FullName))
                .Select(entry => entry.FullName)
                .ToList();
        }
        catch (Exception ex)
        {
            throw new InvalidOperationException($"读取ZIP文件失败: {ex.Message}", ex);
        }
    }

/// <summary>
    /// 手动修复乱码的ZIP条目名称
    /// </summary>
    public static List<string> GetZipEntriesWithFix(string zipFilePath)
    {
        ValidateFilePath(zipFilePath);

var entries = GetZipEntriesSimple(zipFilePath);
        var fixedEntries = new List<string>();

foreach (var entry in entries)
        {
            fixedEntries.Add(FixGarbledText(entry));
        }

return fixedEntries;
    }

/// <summary>
    /// 尝试修复乱码文本
    /// </summary>
    private static string FixGarbledText(string text)
    {
        if (string.IsNullOrEmpty(text))
            return text;

// 常见的乱码转换表（GBK误识别为UTF-8的情况）
        var commonFixes = new Dictionary<string, string>
        {
            { "Ã¥", "å" }, { "Ã¤", "ä" }, { "Ã¶", "ö" },
            { "Ã©", "é" }, { "Ã¨", "è" }, { "Ãª", "ê" },
            { "Ã±", "ñ" }, { "Ãº", "ú" }, { "Ã¼", "ü" }
        };

var result = text;
        foreach (var fix in commonFixes)
        {
            result = result.Replace(fix.Key, fix.Value);
        }

return result;
    }

/// <summary>
    /// 安全地提取ZIP条目到文件
    /// </summary>
    private static void ExtractEntry(ZipArchiveEntry entry, string extractPath, bool overwrite = true)
    {
        if (File.Exists(extractPath))
        {
            if (!overwrite)
                throw new InvalidOperationException($"文件已存在: {extractPath}");
            File.Delete(extractPath);
        }

// 安全检查：防止路径遍历攻击
        var fullExtractPath = Path.GetFullPath(extractPath);
        if (fullExtractPath != Path.GetFullPath(extractPath.Trim()))
        {
            throw new InvalidOperationException("无效的文件路径");
        }

using var entryStream = entry.Open();
        using var fileStream = new FileStream(extractPath, FileMode.Create, FileAccess.Write);
        entryStream.CopyTo(fileStream);
    }

/// <summary>
    /// 验证文件路径参数
    /// </summary>
    private static void ValidateFilePath(string filePath)
    {
        if (string.IsNullOrWhiteSpace(filePath))
            throw new ArgumentException("文件路径不能为空", nameof(filePath));

if (!File.Exists(filePath))
            throw new FileNotFoundException($"文件不存在: {filePath}");
    }

/// <summary>
    /// 检测文本是否包含乱码
    /// </summary>
    private static bool HasGarbledText(List<string> texts)
    {
        var garbledPatterns = new string[] { "ï»¿", "Ã", "Â", "â", "€", "™", "�" };

foreach (var text in texts)
        {
            if (string.IsNullOrEmpty(text)) continue;

foreach (var pattern in garbledPatterns)
            {
                if (text.Contains(pattern))
                    return true;
            }
        }

return false;
    }
}
```

活字格技术研发团队/HZG-ArsenalPluginSourceCode

内容风险标识

评论 (0)

活字格技术研发团队/HZG-ArsenalPluginSourceCode .gitee-modal { width: 500px !important; }

内容风险标识

ZIP乱码

评论 (0)

搜索帮助

活字格技术研发团队/HZG-ArsenalPluginSourceCode