ASP.NET实现紧缩多个文件为.zip文件，实现批量下载功能

作者：袖梨 2022-06-25

址 http://www.ic*sharpco**de.net/OpenSource/SharpZipLib/Download.aspx

下面是对＃ZipLib进行.net下的解紧缩的办法的介绍。


1.BZip2
参加ICSharpCode.SharpZipLib.dll的引用，在＃Develop的安装目次下的SharpDevelopbin目次下。然后在法度中应用using语句把BZip2

类库包含进来。
紧缩：应用BZip2的静态办法Compress。
它的第一个参数是所要紧缩的文件所代表的输入流，可以应用System.IO.File的静态办法OpenRead。
第二个参数是要建树的紧缩文件所代表的输出流，可以应用System.IO.File的静态办法Create创建，紧缩文件名是所要紧缩文件的文件名

加上紧缩后缀.bz（同样你也可以取其他的文件名）。
第三个参数是要紧缩的块大小（一般为2048的整数）。

解压:应用BZip2的静态办法Decompress。
它的第一个参数是所要解压的紧缩文件所代表的输入流，可以应用System.IO.File的静态办法OpenRead。
第二个参数是要建树的解压文件所代表的输出流，可以应用System.IO.File的静态办法Create创建，因为解压文件的文件名是去掉了紧缩

文件扩大名的紧缩文件名（你也可以做成解压文件与紧缩文件不合名的）。
编译你的法度，然后在号令行体式格式下输入bzip2 文件名（假设建树的C＃文件是bzip2，就可以生成紧缩文件；输入bzip2 -d 文件名，就会解压
出文件来（-d是用来默示解压，你也可以应用其他的符号）。
呵呵，本来做紧缩可以这么简单的，紧缩结果也可以啊。

代码如下 复制代码
using System;
using System.IO;
using ICSharpCode.SharpZipLib.BZip2;

class MainClass
{
public static void Main（string[] args）
{
if （args[0] == "-d"） { // 解压
BZip2.Decompress（File.OpenRead（args[1]）， File.Create（Path.GetFileNameWithoutExtension（args[1]）））;
} else { //紧缩
BZip2.Compress（File.OpenRead（args[0]）， File.Create（args[0] + ".bz"）， 4096）;
}
}
}

2.GZip
参加ICSharpCode.SharpZipLib.dll的引用，在＃Develop的安装目次下的SharpDevelopbin目次下。然后在法度中应用using语句把GZip类

库包含进来。
因为GZip没有BZip2的简单解紧缩办法，是以只能应用流办法来进行解紧缩。具体的办法见法度的申明。
编译法度，然后在号令行体式格式下输入GZip 文件名（假设建树的C＃文件是GZip，就可以生成紧缩文件；输入GZip -d 文件名，就会解压出文

件来（-d是用来默示解压，你也可以应用其他的符号）。

代码如下 复制代码
using System;
using System.IO;

using ICSharpCode.SharpZipLib.GZip;

class MainClass
{
public static void Main（string[] args）
{
if （args[0] == "-d"） { // 解压
Stream s = new GZipInputStream（File.OpenRead（args[1]））;
//生成一个GZipInputStream流，用来打开紧缩文件。
//因为GZipInputStream由Stream派生，所以它可以赋给Stream。
//它的机关函数的参数是一个默示要解压的紧缩文件所代表的文件流
FileStream fs = File.Create（Path.GetFileNameWithoutExtension（args[1]））;
//生成一个文件流，它用来生成解压文件
//可以应用System.IO.File的静态函数Create来生成文件流
int size = 2048;//指定紧缩块的大小，一般为2048的倍数
byte[] writeData = new byte[size];//指定缓冲区的大小
while （true） {
size = s.Read（writeData， 0， size）;//读入一个紧缩块
if （size > 0） {
fs.Write（writeData， 0， size）;//写入解压文件代表的文件流
} else {
break;//若读到紧缩文件尾，则停止
}
}
s.Close（）;
} else { // 紧缩
Stream s = new GZipOutputStream（File.Create（args[0] + ".gz"））;
//生成一个GZipOutputStream流，用来生成紧缩文件。
//因为GZipOutputStream由Stream派生，所以它可以赋给Stream。
FileStream fs = File.OpenRead（args[0]）;
/生成一个文件流，它用来打开要紧缩的文件
//可以应用System.IO.File的静态函数OpenRead来生成文件流
byte[] writeData = new byte[fs.Length];
//指定缓冲区的大小
fs.Read（writeData， 0， （int）fs.Length）;
//读入文件
s.Write（writeData， 0， writeData.Length）;
//写入紧缩文件
s.Close（）;
//封闭文件
}
}
}

应用这个类库固然好，然则也有些缺点，它只能紧缩文件夹第一级子目次中的&＃8220;文件&＃8221;（不包含文件夹和子目次）的景象，这也不克不及满足我的请求，我想要的是可以紧缩随便率性路径的多个文件。
没办法，只好再想此外办法。愁闷了好久之后在别人的一篇文章中终于找到了灵感，别人的一篇文章是写在java中实现紧缩zip文件，我看了后发明在java中实现紧缩为zip文件很轻易。灵机一动我想到了.net中的J＃，J＃中应当有java中的如许类，若是有的话，那么我在我的C＃法度中就可以引用了（哄骗.net特有的说话互操纵性）。于是我就上彀搜这方面的内容，终于在MSDN中找到了如许的例子

（http://msdn.m**i*crosoft.com/en-gb/library/aa686114（zh-cn）.aspx＃EHAA得来全不费工夫啊），贴出来找到的代码，大师共同窗习。

代码如下 复制代码

using System;
using System.Collections;
using java.util;
using java.util.zip;

namespace CsZip
{
public delegate Enumeration EnumerationMethod（）;

///


/// Wraps java enumerators
///
public class EnumerationAdapter : IEnumerable
{
private class EnumerationWrapper : IEnumerator
{
private EnumerationMethod m_Method;
private Enumeration m_Wrapped;
private object m_Current;

public EnumerationWrapper（EnumerationMethod method）
{
m_Method = method;
}

// IEnumerator
public object Current
{
get { return m_Current; }
}

public void Reset（）
{
m_Wrapped = m_Method（）;
if （m_Wrapped == null）
throw new InvalidOperationException（）;
}

public bool MoveNext（）
{
if （m_Wrapped == null）
Reset（）;
bool Result = m_Wrapped.hasMoreElements（）;
if （Result）
m_Current = m_Wrapped.nextElement（）;
return Result;
}
}

private EnumerationMethod m_Method;

public EnumerationAdapter（EnumerationMethod method）
{
if （method == null）
throw new ArgumentException（）;
m_Method = method;
}

// IEnumerable
public IEnumerator GetEnumerator（）
{
return new EnumerationWrapper（m_Method）;
}
}

public delegate bool FilterEntryMethod（ZipEntry e）;

///


/// Zip stream utils
///
public class ZipUtility
{
public static void CopyStream（java.io.InputStream ， java.io.OutputStream to）
{
sbyte[] buffer = new sbyte[8192];
int got;
while （（got = .read（buffer， 0， buffer.Length）） > 0）
to.write（buffer， 0， got）;
}

public static void ExtractZipFile（ZipFile file， string path， FilterEntryMethod filter）
{
foreach （ZipEntry entry in new EnumerationAdapter（new EnumerationMethod（file.entries）））
{
if （!entry.isDirectory（））
{
if （（filter == null || filter（entry）））
{
java.io.InputStream s = file.getInputStream（entry）;
try
{
string fname = System.IO.Path.GetFileName（entry.getName（））;
string newpath = System.IO.Path.Combine（path， System.IO.Path.GetDirectoryName（entry.getName（）））;

System.IO.Directory.CreateDirectory（newpath）;

java.io.FileOutputStream dest = new java.io.FileOutputStream（System.IO.Path.Combine（newpath， fname））;
try
{
CopyStream（s， dest）;
}
finally
{
dest.close（）;
}
}
finally
{
s.close（）;
}
}
}
}
}

///


/// 创建新的Zip文件
///
/// Zip文件的路径
/// Zip文件的路径
public static ZipFile CreateEmptyZipFile（string fileName）
{
new ZipOutputStream（new java.io.FileOutputStream（fileName））.close（）;
return new ZipFile（fileName）;
}

///


/// 向存在的Zip文件中添加待紧缩的文件
///
/// Zip文件
///
/// 待紧缩的文件的路径
///
public static ZipFile UpdateZipFile（ZipFile file， FilterEntryMethod filter， string[] newFiles）
{
string prev = file.getName（）;
string tmp = System.IO.Path.GetTempFileName（）;
ZipOutputStream to = new ZipOutputStream（new java.io.FileOutputStream（tmp））;
try
{
CopyEntries（file， to， filter）;
// add entries here
if （newFiles != null）
{
foreach （string f in newFiles）
{
ZipEntry z = new ZipEntry（f.Remove（0， System.IO.Path.GetPathRoot（f）.Length））;
z.setMethod（ZipEntry.DEFLATED）;
to.putNextEntry（z）;
try
{
java.io.FileInputStream s = new java.io.FileInputStream（f）;
try
{
CopyStream（s， to）;
}
finally
{
s.close（）;
}
}
finally
{
to.closeEntry（）;
}
}
}
}
finally
{
to.close（）;
}
file.close（）;

// now replace the old file with the new one
System.IO.File.Copy（tmp， prev， true）;
System.IO.File.Delete（tmp）;

return new ZipFile（prev）;
}

public static void CopyEntries（ZipFile ， ZipOutputStream to）
{
CopyEntries（， to， null）;
}

public static void CopyEntries（ZipFile ， ZipOutputStream to， FilterEntryMethod filter）
{
foreach （ZipEntry entry in new EnumerationAdapter（new EnumerationMethod（.entries）））
{
if （filter == null || filter（entry））
{
java.io.InputStream s = .getInputStream（entry）;
try
{
to.putNextEntry（entry）;
try
{
CopyStream（s， to）;
}
finally
{
to.closeEntry（）;
}
}
finally
{
s.close（）;
}
}
}
}
}
}

应用国外开源加压解压库ICSharpCode.SharpZipLib实现加压，该库的官方网站为

http://www.ic*sharpco**de.net/OpenSource/SharpZipLib/Download.aspx

应用体验：可以照着例子实现简单的加压解压，可以加压一个文件夹中的所有文件，但没有供给加压子文件夹的申明。
今朝网上的一些代码有的无法加压空文件夹，有的加压了用rar解不开，这是一点须要改进的。
但若是只须要加压文件夹第一级子目次中的&＃8220;文件&＃8221;（不包含文件夹和子目次）的景象，应用这个库是很便利的。并且是正常zip格局。
比.Net供给的GZipStream类强在它可以遵守标准zip格局加压多个文件，而GZipStream没有供给加压多个文件的办法，须要本身定义，
如许解压也只有应用本身的法度才可以，通用性方面不如SharpZipLib。

代码如下 复制代码

＃region 加压解压办法
///


/// 功能：紧缩文件（临时只紧缩文件夹下一级目次中的文件，文件夹及其子级被忽视）
///
/// 被紧缩的文件夹夹路径
/// 生成紧缩文件的路径，为空则默认与被紧缩文件夹同一级目次，名称为：文件夹名+.zip
/// 失足信息
/// 是否紧缩成功
public bool ZipFile（string dirPath， string zipFilePath， out string err）
{
err = "";
if （dirPath == string.Empty）
{
err = "要紧缩的文件夹不克不及为空！";
return false;
}
if （!Directory.Exists（dirPath））
{
err = "要紧缩的文件夹不存在！";
return false;
}
//紧缩文件名为空时应用文件夹名＋.zip
if （zipFilePath == string.Empty）
{
if （dirPath.EndsWith（""））
{
dirPath = dirPath.Substring（0， dirPath.Length - 1）;
}
zipFilePath = dirPath + ".zip";
}

try
{
string[] filenames = Directory.GetFiles（dirPath）;
using （ZipOutputStream s = new ZipOutputStream（File.Create（zipFilePath）））
{
s.SetLevel（9）;
byte[] buffer = new byte[4096];
foreach （string file in filenames）
{
ZipEntry entry = new ZipEntry（Path.GetFileName（file））;
entry.DateTime = DateTime.Now;
s.PutNextEntry（entry）;
using （FileStream fs = File.OpenRead（file））
{
int sourceBytes;
do
{
sourceBytes = fs.Read（buffer， 0， buffer.Length）;
s.Write（buffer， 0， sourceBytes）;
} while （sourceBytes > 0）;
}
}
s.Finish（）;
s.Close（）;
}
}
catch （Exception ex）
{
err = ex.Message;
return false;
}
return true;
}

///


/// 功能：解压zip格局的文件。
///
/// 紧缩文件路径
/// 解压文件存放路径，为空时默认与紧缩文件同一级目次下，跟紧缩文件同名的文件夹
/// 失足信息
/// 解压是否成功
public bool UnZipFile（string zipFilePath， string unZipDir， out string err）
{
err = "";
if （zipFilePath == string.Empty）
{
err = "紧缩文件不克不及为空！";
return false;
}
if （!File.Exists（zipFilePath））
{
err = "紧缩文件不存在！";
return false;
}
//解压文件夹为空时默认与紧缩文件同一级目次下，跟紧缩文件同名的文件夹
if （unZipDir == string.Empty）
unZipDir = zipFilePath.Replace（Path.GetFileName（zipFilePath）， Path.GetFileNameWithoutExtension（zipFilePath））;
if （!unZipDir.EndsWith（""））
unZipDir += "";
if （!Directory.Exists（unZipDir））
Directory.CreateDirectory（unZipDir）;

try
{
using （ZipInputStream 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 （directoryName.Length > 0）
{
Directory.CreateDirectory（unZipDir + directoryName）;
}
if （!directoryName.EndsWith（""））
directoryName += "";
if （fileName != String.Empty）
{
using （FileStream streamWriter = File.Create（unZipDir + theEntry.Name））
{

int size = 2048;
byte[] data = new byte[2048];
while （true）
{
size = s.Read（data， 0， data.Length）;
if （size > 0）
{
streamWriter.Write（data， 0， size）;
}
else
{
break;
}
}
}
}
}//while
}
}
catch （Exception ex）
{
err = ex.Message;
return false;
}
return true;
}//解压停止
＃endregion

须要添加对SharpZipLib的引用：

代码如下 复制代码

using ICSharpCode.SharpZipLib.Zip;

相关文章

精彩推荐