public class ZipHelper
{
#region 压缩
/// <summary>
/// 将文件压缩到文件流中
/// </summary>
/// <param name="files">文件的路径</param>
/// <param name="zipStream">文件流</param>
/// <returns></returns>
public static bool ZipDirectory(List<string> files, ZipOutputStream zipStream)
{
bool result = true;
ZipEntry ent = null;
FileStream fs = null;
Crc32 crc = new Crc32();
try
{
foreach (string file in files)
{
fs = File.OpenRead(file);
byte[] buffer = new byte[fs.Length];
fs.Read(buffer, 0, buffer.Length);
ent = new ZipEntry(file);
ent.DateTime = DateTime.Now;
ent.Size = fs.Length;
fs.Close();
crc.Reset();
crc.Update(buffer);
ent.Crc = crc.Value;
zipStream.PutNextEntry(ent);
zipStream.Write(buffer, 0, buffer.Length);
}
}
catch
{
result = false;
}
finally
{
if (fs != null)
{
fs.Close();
fs.Dispose();
}
if (ent != null)
{
ent = null;
}
GC.Collect();
GC.Collect(1);
}
return result;
}
/// <summary>
/// 递归压缩文件夹的内部方法
/// </summary>
/// <param name="folderToZip">要压缩的文件夹路径</param>
/// <param name="zipStream">压缩输出流</param>
/// <param name="parentFolderName">此文件夹的上级文件夹</param>
/// <returns></returns>
private static bool ZipDirectory(string folderToZip, ZipOutputStream zipStream, string parentFolderName)
{
bool result = true;
string[] folders, files;
ZipEntry ent = null;
FileStream fs = null;
Crc32 crc = new Crc32();
try
{
ent = new ZipEntry(Path.Combine(Path.GetFileName(parentFolderName), Path.GetFileName(folderToZip) + "\\"));
zipStream.PutNextEntry(ent);
zipStream.Flush();
files = Directory.GetFiles(folderToZip);
foreach (string file in files)
{
fs = File.OpenRead(file);
byte[] buffer = new byte[fs.Length];
fs.Read(buffer, 0, buffer.Length);
ent = new ZipEntry(Path.Combine(Path.GetFileName(parentFolderName), Path.GetFileName(folderToZip) + "\\" + Path.GetFileName(file)));
ent.DateTime = DateTime.Now;
ent.Size = fs.Length;
fs.Close();
crc.Reset();
crc.Update(buffer);
ent.Crc = crc.Value;
zipStream.PutNextEntry(ent);
zipStream.Write(buffer, 0, buffer.Length);
}
}
catch
{
result = false;
}
finally
{
if (fs != null)
{
fs.Close();
fs.Dispose();
}
if (ent != null)
{
ent = null;
}
GC.Collect();
GC.Collect(1);
}
folders = Directory.GetDirectories(folderToZip);
foreach (string folder in folders)
if (!ZipDirectory(folder, zipStream, folderToZip))
return false;
return result;
}
/// <summary>
/// 压缩文件夹
/// </summary>
/// <param name="folderToZip">要压缩的文件夹路径</param>
/// <param name="zipedFile">压缩文件完整路径</param>
/// <param name="password">密码</param>
/// <returns>是否压缩成功</returns>
public static bool ZipDirectory(string folderToZip, string zipedFile, string password)
{
bool result = false;
if (!Directory.Exists(folderToZip))
return result;
ZipOutputStream zipStream = new ZipOutputStream(File.Create(zipedFile));
zipStream.SetLevel(9);
if (!string.IsNullOrEmpty(password)) zipStream.Password = password;
result = ZipDirectory(folderToZip, zipStream, "");
zipStream.Finish();
zipStream.Close();
return result;
}
/// <summary>
/// 压缩文件夹
/// </summary>
/// <param name="folderToZip">要压缩的文件夹路径</param>
/// <param name="zipedFile">压缩文件完整路径</param>
/// <returns>是否压缩成功</returns>
public static bool ZipDirectory(string folderToZip, string zipedFile)
{
bool result = ZipDirectory(folderToZip, zipedFile, null);
return result;
}
/// <summary>
/// 压缩文件
/// </summary>
/// <param name="fileToZip">要压缩的文件全名</param>
/// <param name="zipedFile">压缩后的文件名</param>
/// <param name="password">密码</param>
/// <returns>压缩结果</returns>
public static bool ZipFile(string fileToZip, string zipedFile, string password)
{
bool result = true;
ZipOutputStream zipStream = null;
FileStream fs = null;
ZipEntry ent = null;
if (!File.Exists(fileToZip))
return false;
try
{
fs = File.OpenRead(fileToZip);
byte[] buffer = new byte[fs.Length];
fs.Read(buffer, 0, buffer.Length);
fs.Close();
fs = File.Create(zipedFile);
zipStream = new ZipOutputStream(fs);
if (!string.IsNullOrEmpty(password)) zipStream.Password = password;
ent = new ZipEntry(Path.GetFileName(fileToZip));
zipStream.PutNextEntry(ent);
zipStream.SetLevel(6);
zipStream.Write(buffer, 0, buffer.Length);
}
catch
{
result = false;
}
finally
{
if (zipStream != null)
{
zipStream.Finish();
zipStream.Close();
}
if (ent != null)
{
ent = null;
}
if (fs != null)
{
fs.Close();
fs.Dispose();
}
}
GC.Collect();
GC.Collect(1);
return result;
}
/// <summary>
/// 压缩文件
/// </summary>
/// <param name="fileToZip">要压缩的文件全名</param>
/// <param name="zipedFile">压缩后的文件名</param>
/// <returns>压缩结果</returns>
public static bool ZipFile(string fileToZip, string zipedFile)
{
bool result = ZipFile(fileToZip, zipedFile, null);
return result;
}
/// <summary>
/// 压缩文件或文件夹
/// </summary>
/// <param name="fileToZip">要压缩的路径</param>
/// <param name="zipedFile">压缩后的文件名</param>
/// <param name="password">密码</param>
/// <returns>压缩结果</returns>
public static bool Zip(string fileToZip, string zipedFile, string password)
{
bool result = false;
if (Directory.Exists(fileToZip))
result = ZipDirectory(fileToZip, zipedFile, password);
else if (File.Exists(fileToZip))
result = ZipFile(fileToZip, zipedFile, password);
return result;
}
/// <summary>
/// 压缩文件或文件夹
/// </summary>
/// <param name="fileToZip">要压缩的路径</param>
/// <param name="zipedFile">压缩后的文件名</param>
/// <returns>压缩结果</returns>
public static bool Zip(string fileToZip, string zipedFile)
{
bool result = Zip(fileToZip, zipedFile, null);
return result;
}
/// <summary>
///
/// </summary>
/// <param name="files">要压缩的路径</param>
/// <param name="zipedFile">压缩后的文件名</param>
/// <returns></returns>
public static MemoryStream Zip(List<string> files, string basedir, string password)
{
ZipEntry ent = null;
FileStream fs = null;
Crc32 crc = new Crc32();
MemoryStream ms = new MemoryStream();//支持存储区为内存的流
var zipMs = new MemoryStream();
using (ZipOutputStream zipStream = new ZipOutputStream(zipMs))
{
if (!string.IsNullOrEmpty(password))
{
zipStream.Password = password;
}
zipStream.SetLevel(9);
foreach (string file in files)
{
string fileName = file.Replace(basedir, "");
using (fs = File.OpenRead(file))
{
zipStream.PutNextEntry(new ZipEntry(fileName));
byte[] buffer = new byte[fs.Length];
fs.Read(buffer, 0, buffer.Length);
zipStream.Write(buffer, 0, buffer.Length);
zipStream.Flush();
}
}
zipStream.Finish();
zipMs.Position = 0;
zipMs.WriteTo(ms);
}
ms.Position = 0;
return ms;
}
public static MemoryStream Zip(List<string> files, string basedir)
{
return Zip(files, basedir, string.Empty);
}
/// <summary>
/// 多个ZIP合并
/// </summary>
/// <param name="files"></param>
/// <returns></returns>
public static MemoryStream Zip(Dictionary<string, MemoryStream> files)
{
Crc32 crc = new Crc32();
MemoryStream ms = new MemoryStream();//支持存储区为内存的流
var zipMs = new MemoryStream();
using (ZipOutputStream zipStream = new ZipOutputStream(zipMs))
{
zipStream.SetLevel(9);
foreach (KeyValuePair<string, MemoryStream> file in files)
{
zipStream.PutNextEntry(new ZipEntry(file.Key));
zipStream.Write(file.Value.ToArray(), 0, (int)file.Value.Length);
zipStream.Flush();
}
zipStream.Finish();
zipMs.Position = 0;
zipMs.WriteTo(ms);
}
ms.Position = 0;
return ms;
}
#endregion
#region 解压
/// <summary>
/// 解压功能(解压压缩文件到指定目录)
/// </summary>
/// <param name="fileToUnZip">待解压的文件</param>
/// <param name="zipedFolder">指定解压目标目录</param>
/// <param name="password">密码</param>
/// <returns>解压结果</returns>
public static bool UnZip(string fileToUnZip, string zipedFolder, string password)
{
bool result = true;
FileStream fs = null;
ZipInputStream zipStream = null;
ZipEntry ent = null;
string fileName;
if (!File.Exists(fileToUnZip))
return false;
if (!Directory.Exists(zipedFolder))
Directory.CreateDirectory(zipedFolder);
try
{
zipStream = new ZipInputStream(File.OpenRead(fileToUnZip));
if (!string.IsNullOrEmpty(password)) zipStream.Password = password;
while ((ent = zipStream.GetNextEntry()) != null)
{
if (!string.IsNullOrEmpty(ent.Name))
{
fileName = Path.Combine(zipedFolder, ent.Name);
fileName = fileName.Replace('/', '\\');//change by Mr.HopeGi
if (fileName.EndsWith("\\"))
{
Directory.CreateDirectory(fileName);
continue;
}
fs = File.Create(fileName);
int size = 2048;
byte[] data = new byte[size];
while (true)
{
size = zipStream.Read(data, 0, data.Length);
if (size > 0)
fs.Write(data, 0, data.Length);
else
break;
}
}
}
}
catch
{
result = false;
}
finally
{
if (fs != null)
{
fs.Close();
fs.Dispose();
}
if (zipStream != null)
{
zipStream.Close();
zipStream.Dispose();
}
if (ent != null)
{
ent = null;
}
GC.Collect();
GC.Collect(1);
}
return result;
}
/// <summary>
/// 解压功能(解压压缩文件到指定目录)
/// </summary>
/// <param name="fileToUnZip">待解压的文件</param>
/// <param name="zipedFolder">指定解压目标目录</param>
/// <returns>解压结果</returns>
public static bool UnZip(string fileToUnZip, string zipedFolder)
{
bool result = UnZip(fileToUnZip, zipedFolder, null);
return result;
}
#endregion
public static List<string> GetDirectory(string filePath)
{
List<string> list = new List<string>();
int index = 0;
using (ZipInputStream zip = new ZipInputStream(File.OpenRead(filePath)))
{
ZipEntry theEntry;
while ((theEntry = zip.GetNextEntry()) != null)
{
index = theEntry.Name.Length - (theEntry.Name.Replace("/", "")).Length;
if (theEntry.IsDirectory && index == 1)
{
list.Add(AppDomain.CurrentDomain.BaseDirectory + theEntry.Name.Replace("/", "\\"));
}
}
}
return list;
}
/// <summary>
/// 压缩文件夹
/// </summary>
/// <param name="folderToZip">要压缩的文件夹路径</param>
/// <param name="zipedFile">压缩文件完整路径</param>
/// <param name="packagename">包名</param>
/// <returns>是否压缩成功</returns>
public static bool ZipDirectorys(List<string> folderToZips, string zipedFile, string packagename)
{
bool result = false;
using (ZipFile zip = ICSharpCode.SharpZipLib.Zip.ZipFile.Create(zipedFile))
{
zip.BeginUpdate();
zip.AddDirectory(packagename);
foreach (var folderToZip in folderToZips)
{
if (!Directory.Exists(folderToZip)
|| folderToZip.ToString().EndsWith("BackUP")
|| folderToZip.ToString().EndsWith("Resource")
)
continue;
var files = Director(folderToZip);
string entrypath = Path.Combine(Path.GetFileName(packagename), Path.GetFileName(folderToZip) + "\\");
zip.AddDirectory(entrypath);
foreach (var f in files)
{
zip.Add(f, entrypath + Path.GetFileName(f));
//zip.Add(f);
}
}
zip.CommitUpdate();
return true;
}
}
private static List<string> Director(string dir)
{
List<string> list = new List<string>();
DirectoryInfo d = new DirectoryInfo(dir);
FileSystemInfo[] fsinfos = d.GetFileSystemInfos();
foreach (FileSystemInfo fsinfo in fsinfos)
{
if (fsinfo is DirectoryInfo) //判断是否为文件夹
{
if (fsinfo.FullName.EndsWith("BackUP")
|| fsinfo.FullName.EndsWith("Resource")
)
continue;
list.AddRange(Director(fsinfo.FullName));//递归调用
}
else
{
list.Add(fsinfo.FullName);//输出文件的全部路径
}
}
return list;
}
/// <summary>
/// 获取ZIP包中的所有文件名称
/// </summary>
/// <param name="zipfile"></param>
/// <returns></returns>
public static List<string> PageFiles(string zipfile)
{
List<string> list = new List<string>();
using (ZipFile zip = new ZipFile(zipfile))
{
foreach (ZipEntry e in zip)
{
if (e.IsFile)
{
list.Add(e.Name);
}
}
}
return list;
}
/// <summary>
/// 获取ZIP包中的所有文件名称
/// </summary>
/// <param name="zipfile"></param>
/// <returns></returns>
public static List<string> PageFiles(FileStream zipfile)
{
List<string> list = new List<string>();
byte[] zipBytes = StreamToBytes(zipfile);
Stream stream = new MemoryStream(zipBytes);
using (ZipFile zip = new ZipFile(stream))
{
foreach (ZipEntry e in zip)
{
if (e.IsFile)
{
list.Add(e.Name);
}
}
}
return list;
}
/// <summary>
/// 获取ZIP包中的所有文件名称
/// </summary>
/// <param name="zipfile"></param>
/// <returns></returns>
public static List<string> PageFiles(Stream zipfile)
{
List<string> list = new List<string>();
byte[] zipBytes = StreamToBytes(zipfile);
Stream stream = new MemoryStream(zipBytes);
using (ZipFile zip = new ZipFile(stream))
{
foreach (ZipEntry e in zip)
{
if (e.IsFile)
{
list.Add(e.Name);
}
}
}
return list;
}
public static byte[] StreamToBytes(Stream stream)
{
byte[] bytes = new byte[stream.Length];
stream.Read(bytes, 0, bytes.Length);
// 设置当前流的位置为流的开始
stream.Seek(0, SeekOrigin.Begin);
return bytes;
}
/// <summary>
/// 获取ZIP包中的所有目录名称
/// </summary>
/// <param name="zipfile"></param>
/// <returns></returns>
public static List<string> ZipDirectorys(Stream zipfile)
{
List<string> list = new List<string>();
byte[] zipBytes = StreamToBytes(zipfile);
Stream stream = new MemoryStream(zipBytes);
using (ZipFile zip = new ZipFile(stream))
{
foreach (ZipEntry e in zip)
{
if (e.IsDirectory && !list.Contains(e.Name))
{
list.Add(e.Name);
}
}
}
return list;
}
/// <summary>
/// 获取ZIP包中的所有目录名称
/// </summary>
/// <param name="zipfile"></param>
/// <returns></returns>
public static List<string> ZipDirectorys(string zipfile)
{
List<string> list = new List<string>();
using (ZipFile zip = new ZipFile(zipfile))
{
foreach (ZipEntry e in zip)
{
if (e.IsDirectory && !list.Contains(e.Name))
{
list.Add(e.Name);
}
}
}
return list;
}
}
Dictionary<string, MemoryStream> dic = new Dictionary<string, MemoryStream>();
//循环
MemoryStream fsm = ZipHelper.Zip(files, Server.MapPath(vpath));//files 文件列表 List<string> files,Server.MapPath(vpath)//目录
dic.Add("XXX.zip", fsm);
//循环
MemoryStream fs = ZipHelper.Zip(dic);//合并
//输出
if (fs != null)
{
Response.ContentType = "application/octet-stream";
Response.AddHeader("Content-Disposition", "attachment;filename=download.zip");
byte[] bt = fs.ToArray();
Response.OutputStream.Write(bt, 0, bt.Length);
fs.Close();
}
Dictionary<string, MemoryStream> dic = new Dictionary<string, MemoryStream>();
//循环
MemoryStream fsm = ZipHelper.Zip(files, Server.MapPath(vpath));//files 文件列表 List<string> files,Server.MapPath(vpath)//目录
dic.Add("XXX.zip", fsm);
//循环
MemoryStream fs = ZipHelper.Zip(dic);//合并
//输出
if (fs != null)
{
Response.ContentType = "application/octet-stream";
Response.AddHeader("Content-Disposition", "attachment;filename=download.zip");
byte[] bt = fs.ToArray();
Response.OutputStream.Write(bt, 0, bt.Length);
fs.Close();
}