C\#에서 ZipHelper 압축 및 압축 해제 도움말 클래스
이 문 서 는 ICSharpCode.SharpZipLib.dll 의 패 키 징 을 바탕 으로 자주 사용 하 는 압축 해제 와 압축 방법 이 모두 포함 되 어 있 으 며 프로젝트 실전 을 통 해 축 적 된 것 입 니 다.
공유 전 파 를 환영 합 니 다.원작 자의 정 보 를 유지 해 야 하지만 이 문 서 를 상업 이윤 에 직접 사용 하 는 것 은 금지 되 어 있 습 니 다.
저 는 몇 년 전에 프로 그래 밍 의 길 을 걷 게 되 었 습 니 다.좋 은 프레임 워 크 와 유 니 버 설 라 이브 러 리 를 수집 하고 정리 하 는 데 주력 해 왔 습 니 다.마이크로소프트 자신 이 든 제3자 가 든 실제 프로젝트 에서 좋 고 실제 문 제 를 해결 할 수 있다 면 모두 수집 하고 글 을 잘 써 서 다른 사람과 공유 하 는 것 을 배 웠 습 니 다.그러면 다른 사람 도 지식 을 배 울 수 있 습 니 다.오늘날 사 회 는 지식의 짐꾼 이 매우 필요 하 다.
1.기본 소개
프로젝트 에서 각종 압축 을 사용 하여 파일 을 압축 다운로드 하고 네트워크 의 대역 폭 을 줄 여야 하기 때문에 압축 은 매우 흔히 볼 수 있 는 기능 으로 마이크로소프트 자신 을 압축 하 는 데 도 라 이브 러 리 를 제공 합 니 다.
마이크로소프트 자체 압축 류 ZipArchive 류,NET FrameWork 4.5 에 적합 해 야 사용 할 수 있 습 니 다.
압축 소프트웨어 명령 을 호출 하여 압축 동작 을 실행 하려 면 컴퓨터 자체 에 압축 소프트웨어 를 설치 해 야 한다.
제3자 의 압축 dll 파일 을 사용 합 니 다.일반적으로 가장 많이 사용 하 는 것 은(ICSharpCode.SharpZipLib.dll)이 고 dllICSharpCode.SharpZipLib.zip을 다운로드 합 니 다.
2.실제 항목
단일 파일 을 압축 하려 면 압축 등급 을 지정 해 야 합 니 다.
단일 폴 더 를 압축 하려 면 압축 등급 을 지정 해 야 합 니 다.
여러 파일 이나 여러 폴 더 압축
압축 패 키 지 를 암호 화 합 니 다[사용 하 는 것 이 적 고 실제 상황 도 있 습 니 다]
2.1 단일 파일 압축
두 가지 방법 을 써 서 압축 등급 을 지정 할 수 있 습 니 다.그러면 압축 가방 의 크기 가 다 릅 니 다.
2.2 단일 폴 더 압축
public void ZipDir(string dirToZip, string zipedFileName, int compressionLevel = 9)
public bool ZipManyFilesOrDictorys(IEnumerable<string> folderOrFileList, string zipedFile, string password)
public bool ZipManyFilesOrDictorys(IEnumerable<string> folderOrFileList, string zipedFile, string password)
public void UnZip(string zipFilePath, string unZipDir)
3.ZipHelper 소스 코드
//-------------------------------------------------------------------------------------
// All Rights Reserved , Copyright (C) 2016 , ZTO , Ltd .
//-------------------------------------------------------------------------------------
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
namespace ZTO.PicTest.Utilities
{
using ICSharpCode.SharpZipLib.Checksums;
using ICSharpCode.SharpZipLib.Zip;
/// <summary>
/// Zip
///
///
///
/// 2015-09-16 ：1.0 YangHengLian ， 。
/// 2016-5-7 YangHengLian zip
///
/// ：1.0
///
/// <author>
/// <name>YangHengLian</name>
/// <date>2015-09-16</date>
/// </author>
/// </summary>
public class ZipHelper
{
/// <summary>
///
/// </summary>
/// <param name="dirToZip"></param>
/// <param name="zipedFileName"></param>
/// <param name="compressionLevel"> 0（ ）9（ ）</param>
public void ZipDir(string dirToZip, string zipedFileName, int compressionLevel = 9)
{
if (Path.GetExtension(zipedFileName) != ".zip")
{
zipedFileName = zipedFileName + ".zip";
}
using (var zipoutputstream = new ZipOutputStream(File.Create(zipedFileName)))
{
zipoutputstream.SetLevel(compressionLevel);
Crc32 crc = new Crc32();
Hashtable fileList = GetAllFies(dirToZip);
foreach (DictionaryEntry item in fileList)
{
FileStream fs = new FileStream(item.Key.ToString(), FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
byte[] buffer = new byte[fs.Length];
fs.Read(buffer, 0, buffer.Length);
// ZipEntry entry = new ZipEntry(item.Key.ToString().Substring(dirToZip.Length + 1));
ZipEntry entry = new ZipEntry(Path.GetFileName(item.Key.ToString()))
{
DateTime = (DateTime) item.Value,
Size = fs.Length
};
fs.Close();
crc.Reset();
crc.Update(buffer);
entry.Crc = crc.Value;
zipoutputstream.PutNextEntry(entry);
zipoutputstream.Write(buffer, 0, buffer.Length);
}
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public Hashtable GetAllFies(string dir)
{
Hashtable filesList = new Hashtable();
DirectoryInfo fileDire = new DirectoryInfo(dir);
if (!fileDire.Exists)
{
throw new FileNotFoundException(" :" + fileDire.FullName + " !");
}
GetAllDirFiles(fileDire, filesList);
GetAllDirsFiles(fileDire.GetDirectories(), filesList);
return filesList;
}
/// <summary>
///
/// </summary>
/// <param name="dirs"></param>
/// <param name="filesList"></param>
public void GetAllDirsFiles(IEnumerable<DirectoryInfo> dirs, Hashtable filesList)
{
foreach (DirectoryInfo dir in dirs)
{
foreach (FileInfo file in dir.GetFiles("*.*"))
{
filesList.Add(file.FullName, file.LastWriteTime);
}
GetAllDirsFiles(dir.GetDirectories(), filesList);
}
}
/// <summary>
///
/// </summary>
/// <param name="dir"> </param>
/// <param name="filesList"> HastTable</param>
public static void GetAllDirFiles(DirectoryInfo dir, Hashtable filesList)
{
foreach (FileInfo file in dir.GetFiles("*.*"))
{
filesList.Add(file.FullName, file.LastWriteTime);
}
}
/// <summary>
/// ： zip 。
/// </summary>
/// <param name="zipFilePath"> </param>
/// <param name="unZipDir"> , ， </param>
/// <returns> </returns>
public void UnZip(string zipFilePath, string unZipDir)
{
if (zipFilePath == string.Empty)
{
throw new Exception(" ！");
}
if (!File.Exists(zipFilePath))
{
throw new FileNotFoundException(" ！");
}
// ，
if (unZipDir == string.Empty)
unZipDir = zipFilePath.Replace(Path.GetFileName(zipFilePath), Path.GetFileNameWithoutExtension(zipFilePath));
if (!unZipDir.EndsWith("/"))
unZipDir += "/";
if (!Directory.Exists(unZipDir))
Directory.CreateDirectory(unZipDir);
using (var s = new ZipInputStream(File.OpenRead(zipFilePath)))
{
ZipEntry theEntry;
while ((theEntry = s.GetNextEntry()) != null)
{
string directoryName = Path.GetDirectoryName(theEntry.Name);
string fileName = Path.GetFileName(theEntry.Name);
if (!string.IsNullOrEmpty(directoryName))
{
Directory.CreateDirectory(unZipDir + directoryName);
}
if (directoryName != null && !directoryName.EndsWith("/"))
{
}
if (fileName != String.Empty)
{
using (FileStream streamWriter = File.Create(unZipDir + theEntry.Name))
{
int size;
byte[] data = new byte[2048];
while (true)
{
size = s.Read(data, 0, data.Length);
if (size > 0)
{
streamWriter.Write(data, 0, size);
}
else
{
break;
}
}
}
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="filePath"> ( )， </param>
/// <param name="zipedFileName"> ( )， </param>
/// <param name="compressionLevel"> 0（ ） 9（ ）</param>
public void ZipFile(string filePath, string zipedFileName, int compressionLevel = 9)
{
// ，
if (!File.Exists(filePath))
{
throw new FileNotFoundException(" ：" + filePath + " ！");
}
//
if (string.IsNullOrEmpty(zipedFileName))
{
string oldValue = Path.GetFileName(filePath);
if (oldValue != null)
{
zipedFileName = filePath.Replace(oldValue, "") + Path.GetFileNameWithoutExtension(filePath) + ".zip";
}
}
// zip， zip，
if (Path.GetExtension(zipedFileName) != ".zip")
{
zipedFileName = zipedFileName + ".zip";
}
// ， C:\Users\yhl\Desktop\
string zipedDir = zipedFileName.Substring(0, zipedFileName.LastIndexOf("\\", StringComparison.Ordinal));
if (!Directory.Exists(zipedDir))
{
Directory.CreateDirectory(zipedDir);
}
//
string filename = filePath.Substring(filePath.LastIndexOf("\\", StringComparison.Ordinal) + 1);
var streamToZip = new FileStream(filePath, FileMode.Open, FileAccess.Read);
var zipFile = File.Create(zipedFileName);
var zipStream = new ZipOutputStream(zipFile);
var zipEntry = new ZipEntry(filename);
zipStream.PutNextEntry(zipEntry);
zipStream.SetLevel(compressionLevel);
var buffer = new byte[2048];
Int32 size = streamToZip.Read(buffer, 0, buffer.Length);
zipStream.Write(buffer, 0, size);
try
{
while (size < streamToZip.Length)
{
int sizeRead = streamToZip.Read(buffer, 0, buffer.Length);
zipStream.Write(buffer, 0, sizeRead);
size += sizeRead;
}
}
finally
{
zipStream.Finish();
zipStream.Close();
streamToZip.Close();
}
}
/// <summary>
///
/// </summary>
/// <param name="fileToZip"> ， </param>
/// <param name="zipedFile"> , </param>
public void ZipFile(string fileToZip, string zipedFile)
{
// ，
if (!File.Exists(fileToZip))
{
throw new FileNotFoundException(" : " + fileToZip + " !");
}
using (FileStream fileStream = File.OpenRead(fileToZip))
{
byte[] buffer = new byte[fileStream.Length];
fileStream.Read(buffer, 0, buffer.Length);
fileStream.Close();
using (FileStream zipFile = File.Create(zipedFile))
{
using (ZipOutputStream zipOutputStream = new ZipOutputStream(zipFile))
{
// string fileName = fileToZip.Substring(fileToZip.LastIndexOf("\\") + 1);
string fileName = Path.GetFileName(fileToZip);
var zipEntry = new ZipEntry(fileName)
{
DateTime = DateTime.Now,
IsUnicodeText = true
};
zipOutputStream.PutNextEntry(zipEntry);
zipOutputStream.SetLevel(5);
zipOutputStream.Write(buffer, 0, buffer.Length);
zipOutputStream.Finish();
zipOutputStream.Close();
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="folderOrFileList"> ， , </param>
/// <param name="zipedFile"> ， </param>
/// <param name="password"> </param>
/// <returns></returns>
public bool ZipManyFilesOrDictorys(IEnumerable<string> folderOrFileList, string zipedFile, string password)
{
bool res = true;
using (var s = new ZipOutputStream(File.Create(zipedFile)))
{
s.SetLevel(6);
if (!string.IsNullOrEmpty(password))
{
s.Password = password;
}
foreach (string fileOrDir in folderOrFileList)
{
//
if (Directory.Exists(fileOrDir))
{
res = ZipFileDictory(fileOrDir, s, "");
}
else
{
//
res = ZipFileWithStream(fileOrDir, s);
}
}
s.Finish();
s.Close();
return res;
}
}
/// <summary>
///
/// </summary>
/// <param name="fileToZip"> </param>
/// <param name="zipStream"></param>
/// <returns></returns>
private bool ZipFileWithStream(string fileToZip, ZipOutputStream zipStream)
{
// ，
if (!File.Exists(fileToZip))
{
throw new FileNotFoundException(" : " + fileToZip + " !");
}
//FileStream fs = null;
FileStream zipFile = null;
ZipEntry zipEntry = null;
bool res = true;
try
{
zipFile = File.OpenRead(fileToZip);
byte[] buffer = new byte[zipFile.Length];
zipFile.Read(buffer, 0, buffer.Length);
zipFile.Close();
zipEntry = new ZipEntry(Path.GetFileName(fileToZip));
zipStream.PutNextEntry(zipEntry);
zipStream.Write(buffer, 0, buffer.Length);
}
catch
{
res = false;
}
finally
{
if (zipEntry != null)
{
}
if (zipFile != null)
{
zipFile.Close();
}
GC.Collect();
GC.Collect(1);
}
return res;
}
/// <summary>
///
/// </summary>
/// <param name="folderToZip"></param>
/// <param name="s"></param>
/// <param name="parentFolderName"></param>
private bool ZipFileDictory(string folderToZip, ZipOutputStream s, string parentFolderName)
{
bool res = true;
ZipEntry entry = null;
FileStream fs = null;
Crc32 crc = new Crc32();
try
{
//
entry = new ZipEntry(Path.Combine(parentFolderName, Path.GetFileName(folderToZip) + "/")); // “/”
s.PutNextEntry(entry);
s.Flush();
// ，
var filenames = Directory.GetFiles(folderToZip);
foreach (string file in filenames)
{
//
fs = File.OpenRead(file);
byte[] buffer = new byte[fs.Length];
fs.Read(buffer, 0, buffer.Length);
entry = new ZipEntry(Path.Combine(parentFolderName, Path.GetFileName(folderToZip) + "/" + Path.GetFileName(file)));
entry.DateTime = DateTime.Now;
entry.Size = fs.Length;
fs.Close();
crc.Reset();
crc.Update(buffer);
entry.Crc = crc.Value;
s.PutNextEntry(entry);
s.Write(buffer, 0, buffer.Length);
}
}
catch
{
res = false;
}
finally
{
if (fs != null)
{
fs.Close();
}
if (entry != null)
{
}
GC.Collect();
GC.Collect(1);
}
var folders = Directory.GetDirectories(folderToZip);
foreach (string folder in folders)
{
if (!ZipFileDictory(folder, s, Path.Combine(parentFolderName, Path.GetFileName(folderToZip))))
{
return false;
}
}
return res;
}
}
}
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
WebView2를 Visual Studio 2017 Express에서 사용할 수 있을 때까지Evergreen .Net Framework SDK 4.8 VisualStudio2017에서 NuGet을 사용하기 때문에 패키지 관리 방법을 packages.config 대신 PackageReference를 사용해야...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.
좋은 웹페이지 즐겨찾기
