/// <summary>
/// This function creates a zip
/// </summary>
/// <param name="filepaths">List of absolute system filepaths</param>
/// <param name="zipFileName">Absolute desired systeme final zip filepath</param>
/// <param name="compressionLevel">Compression level from 0 (no comp.) to 9 (best comp.)</param>
/// <returns></returns>
public StdResult<NoType> CreateZip(List<string> filepaths, string zipFileName, int compressionLevel)
{
try
{
using (ZipOutputStream s = new ZipOutputStream(File.Create(zipFileName)))
{
s.SetLevel(9); // 0 - store only to 9 - means best compression
byte[] buffer = new byte[4096];
foreach (string file in filepaths)
{
// Using GetFileName makes the result compatible with XP
// as the resulting path is not absolute.
ZipEntry entry = new ZipEntry(Path.GetFileName(file));
// Setup the entry data as required.
// Crc and size are handled by the library for seakable streams
// so no need to do them here.
// Could also use the last write time or similar for the file.
entry.DateTime = DateTime.Now;
s.PutNextEntry(entry);
using (FileStream fs = File.OpenRead(file))
{
// Using a fixed size buffer here makes no noticeable difference for output
// but keeps a lid on memory usage.
int sourceBytes;
do
{
sourceBytes = fs.Read(buffer, 0, buffer.Length);
s.Write(buffer, 0, sourceBytes);
} while (sourceBytes > 0);
}
}
// Finish/Close arent needed strictly as the using statement does this automatically
// Finish is important to ensure trailing information for a Zip file is appended. Without this
// the created file would be invalid.
s.Finish();
// Close is important to wrap things up and unlock the file.
s.Close();
return StdResult<NoType>.OkResult;
}
}
catch (Exception ex)
{
return StdResult<NoType>.BadResult(ex.Message);
// No need to rethrow the exception as for our purposes its handled.
}
}
/// <summary>
/// Zip all the specified files into the specified ZipFileName.
/// </summary>
public static string ZipFiles(IEnumerable<string> FilesToZip, string ZipFileName, string Password)
{
if (!File.Exists(ZipFileName))
File.Delete(ZipFileName);
ZipOutputStream Zip = new ZipOutputStream(File.Create(ZipFileName));
if (Password != "")
Zip.Password = Password;
try
{
Zip.SetLevel(5); // 0 - store only to 9 - means best compression
foreach (string FileName in FilesToZip)
{
FileStream fs = File.OpenRead(FileName);
byte[] Buffer = new byte[fs.Length];
fs.Read(Buffer, 0, Buffer.Length);
fs.Close();
ZipEntry Entry = new ZipEntry(Path.GetFileName(FileName));
Zip.PutNextEntry(Entry);
Zip.Write(Buffer, 0, Buffer.Length);
}
Zip.Finish();
Zip.Close();
return ZipFileName;
}
catch (System.Exception)
{
Zip.Finish();
Zip.Close();
File.Delete(ZipFileName);
throw;
}
}
public void zip(string to, string[] files)
{
using (ZipOutputStream s = new ZipOutputStream(File.Create(to)))
{
s.SetLevel(9);
byte[] buffer = new byte[4096];
foreach (string file in files)
{
ZipEntry entry = new ZipEntry(Path.GetFileName(file)) { 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();
}
}
private void saveFileDialog_FileOk(object sender, CancelEventArgs e)
{
ReportText = ReportTextBox.Text;
ZipEntry ze;
ZipOutputStream zip_out = new ZipOutputStream(File.Create((sender as SaveFileDialog).FileName));
string SourceText;
byte[] data=null;
foreach (string FileName in FileNames)
{
SourceText = VEC.StandartCompiler.GetSourceFileText(FileName);
if (SourceText != null)
{
data = System.Text.Encoding.GetEncoding(1251).GetBytes(SourceText);
ze = new ZipEntry(System.IO.Path.GetFileName(FileName));
zip_out.PutNextEntry(ze);
zip_out.Write(data, 0, data.Length);
}
}
ze = new ZipEntry("Report.txt");
zip_out.PutNextEntry(ze);
data = System.Text.Encoding.GetEncoding(1251).GetBytes(ReportText);
zip_out.Write(data, 0, data.Length);
zip_out.Finish();
zip_out.Close();
}
public static void ZipFile(IEnumerable<string> InputFilePath, string outputPathAndFile, string password)
{
string outPath = outputPathAndFile;
ZipOutputStream oZipStream = new ZipOutputStream(File.Create(outPath));
foreach (string FilePath in InputFilePath)
{
int TrimLength = 0;
if (Path.GetDirectoryName(FilePath) != null)
{
TrimLength = (Path.GetDirectoryName(FilePath)).Length;
TrimLength += 1; //remove '\'
}
if (!string.IsNullOrEmpty(password))
oZipStream.Password = password;
oZipStream.SetLevel(9); // maximum compression
ZipFile(TrimLength, oZipStream, FilePath);
}
oZipStream.Finish();
oZipStream.Close();
}
public void ZipFile(string FileToZip, string ZipedFile, int CompressionLevel, int BlockSize)
{
if (!File.Exists(FileToZip))
{
throw new FileNotFoundException("The specified file " + FileToZip + " could not be found. Zipping aborderd");
}
FileStream fileStream = new FileStream(FileToZip, FileMode.Open, FileAccess.Read);
FileStream baseOutputStream = File.Create(ZipedFile);
ZipOutputStream zipOutputStream = new ZipOutputStream(baseOutputStream);
ZipEntry entry = new ZipEntry("ZippedFile");
zipOutputStream.PutNextEntry(entry);
zipOutputStream.SetLevel(CompressionLevel);
byte[] array = new byte[BlockSize];
int num = fileStream.Read(array, 0, array.Length);
zipOutputStream.Write(array, 0, num);
try
{
while ((long)num < fileStream.Length)
{
int num2 = fileStream.Read(array, 0, array.Length);
zipOutputStream.Write(array, 0, num2);
num += num2;
}
}
catch (Exception ex)
{
throw ex;
}
zipOutputStream.Finish();
zipOutputStream.Close();
fileStream.Close();
}
//public static void ZipFile(string path, string file2Zip, string zipFileName, string zip, string bldgType)
public static void ZipFile(string path, string file2Zip, string zipFileName)
{
//MemoryStream ms = InitializeGbxml(path + file2Zip, zip, bldgType) as MemoryStream;
MemoryStream ms = InitializeGbxml(Path.Combine(path , file2Zip)) as MemoryStream;
string compressedFile =Path.Combine(path, zipFileName);
if (File.Exists(compressedFile))
{
File.Delete(compressedFile);
}
Crc32 objCrc32 = new Crc32();
ZipOutputStream strmZipOutputStream = new ZipOutputStream(File.Create(compressedFile));
strmZipOutputStream.SetLevel(9);
byte[] gbXmlBuffer = new byte[ms.Length];
ms.Read(gbXmlBuffer, 0, gbXmlBuffer.Length);
ZipEntry objZipEntry = new ZipEntry(file2Zip);
objZipEntry.DateTime = DateTime.Now;
objZipEntry.Size = ms.Length;
ms.Close();
objCrc32.Reset();
objCrc32.Update(gbXmlBuffer);
objZipEntry.Crc = objCrc32.Value;
strmZipOutputStream.PutNextEntry(objZipEntry);
strmZipOutputStream.Write(gbXmlBuffer, 0, gbXmlBuffer.Length);
strmZipOutputStream.Finish();
strmZipOutputStream.Close();
strmZipOutputStream.Dispose();
}
public byte[] diskLess()
{
MemoryStream ms = new MemoryStream();
StreamWriter sw = new StreamWriter(ms);
sw.WriteLine("HELLO!");
sw.WriteLine("I WANT TO SAVE THIS FILE AS A .TXT FILE WITHIN TWO FOLDERS");
sw.Flush(); //This is required or you get a blank text file :)
ms.Position = 0;
// create the ZipEntry archive from the txt file in memory stream ms
MemoryStream outputMS = new System.IO.MemoryStream();
ZipOutputStream zipOutput = new ZipOutputStream(outputMS);
ZipEntry ze = new ZipEntry(@"dir1/dir2/whatever.txt");
zipOutput.PutNextEntry(ze);
zipOutput.Write(ms.ToArray(), 0, Convert.ToInt32(ms.Length));
zipOutput.Finish();
zipOutput.Close();
byte[] byteArrayOut = outputMS.ToArray();
outputMS.Close();
ms.Close();
return byteArrayOut;
}
public override void ExecuteResult(ControllerContext context)
{
string fileName = Path.GetTempFileName();
var response = context.HttpContext.Response;
using (var zipOutputStream = new ZipOutputStream(new FileStream(fileName, FileMode.OpenOrCreate)))
{
zipOutputStream.SetLevel(0);
foreach (var photo in Photos)
{
//FileInfo fileInfo = new FileInfo(photo.MediaFilePath);
ZipEntry entry = new ZipEntry(Tag.Name + @"\" + photo.Id + ".jpg");
zipOutputStream.PutNextEntry(entry);
using (FileStream fs = System.IO.File.OpenRead(photo.MediaFilePath))
{
byte[] buff = new byte[1024];
int n = 0;
while ((n = fs.Read(buff, 0, buff.Length)) > 0)
zipOutputStream.Write(buff, 0, n);
}
}
zipOutputStream.Finish();
}
System.IO.FileInfo file = new System.IO.FileInfo(fileName);
response.Clear();
response.AddHeader("Content-Disposition", "attachment; filename=" + "Photos.zip");
response.AddHeader("Content-Length", file.Length.ToString());
response.ContentType = "application/octet-stream";
response.WriteFile(file.FullName);
response.End();
System.IO.File.Delete(fileName);
}
public static string PackToBase64(byte[] data)
{
byte[] buffer;
MemoryStream ms = new MemoryStream();
using (ICSharpCode.SharpZipLib.Zip.ZipOutputStream zipOutputStream = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(ms))
{
zipOutputStream.SetLevel(9);
ICSharpCode.SharpZipLib.Zip.ZipEntry zipEntry = new ICSharpCode.SharpZipLib.Zip.ZipEntry("Boliglag.Admin");
zipOutputStream.PutNextEntry(zipEntry);
zipOutputStream.Write(data, 0, data.Length);
zipOutputStream.Flush();
zipOutputStream.Finish();
buffer = new byte[ms.Length];
ms.Position = 0;
ms.Read(buffer, 0, Convert.ToInt32(ms.Length));
}//using ( ICSharpCode.SharpZipLib.Zip.ZipOutputStream zipOutputStream = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream( fileStreamOut ) ) ...
return(ToBase64(buffer));
}
public static string PackToBase64(string text)
{
byte[] buffer;
MemoryStream ms = new MemoryStream();
using (ICSharpCode.SharpZipLib.Zip.ZipOutputStream zipOutputStream = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(ms))
{
zipOutputStream.SetLevel(9);
ICSharpCode.SharpZipLib.Zip.ZipEntry zipEntry = new ICSharpCode.SharpZipLib.Zip.ZipEntry("Boliglag.Admin");
zipOutputStream.PutNextEntry(zipEntry);
byte[] bytes = System.Text.Encoding.Unicode.GetBytes(text.ToCharArray());
zipOutputStream.Write(bytes, 0, bytes.Length);
zipOutputStream.Flush();
zipOutputStream.Finish();
buffer = new byte[ms.Length];
ms.Position = 0;
ms.Read(buffer, 0, Convert.ToInt32(ms.Length));
}//using ( ICSharpCode.SharpZipLib.Zip.ZipOutputStream zipOutputStream = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream( fileStreamOut ) ) ...
return(ToBase64(buffer));
}
public static string GetZipFileName(string filename)
{
string zipfile = filename.Replace (".db", ".zip");
try {
using (ZipOutputStream s = new ZipOutputStream (File.Create (zipfile))) {
s.SetLevel (9); // 0 - store only to 9 - means best compression
byte[] buffer = new byte[4096];
ZipEntry entry = new ZipEntry (filename);
entry.DateTime = DateTime.Now;
s.PutNextEntry (entry);
using (FileStream fs = File.OpenRead (filename)) {
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) {
zipfile = filename;
}
return zipfile;
}
private void CompressFiles(IEnumerable<string> filePaths, ZipOutputStream zipStream)
{
foreach (var fullFileName in filePaths)
{
var fi = new FileInfo(fullFileName);
var fileName = Path.GetFileName(fullFileName);
var newEntry = new ZipEntry(fileName) {DateTime = fi.LastWriteTime, Size = fi.Length};
// Note the zip format stores 2 second granularity
// Specifying the AESKeySize triggers AES encryption. Allowable values are 0 (off), 128 or 256.
// A password on the ZipOutputStream is required if using AES.
// newEntry.AESKeySize = 256;
// To permit the zip to be unpacked by built-in extractor in WinXP and Server2003, WinZip 8, Java, and other older code,
// you need to do one of the following: Specify UseZip64.Off, or set the Size.
// If the file may be bigger than 4GB, or you do not need WinXP built-in compatibility, you do not need either,
// but the zip will be in Zip64 format which not all utilities can understand.
// zipStream.UseZip64 = UseZip64.Off;
zipStream.UseZip64 = UseZip64.Off;
zipStream.PutNextEntry(newEntry);
// Zip the file in buffered chunks
// the "using" will close the stream even if an exception occurs
var buffer = new byte[4096];
using (var streamReader = File.OpenRead(fullFileName))
{
StreamUtils.Copy(streamReader, zipStream, buffer);
}
zipStream.CloseEntry();
}
zipStream.Finish();
}
static public void CompressFolder(string aFolderName, string aFullFileOuputName, string[] ExcludedFolderNames, string[] ExcludedFileNames){
// Perform some simple parameter checking. More could be done
// like checking the target file name is ok, disk space, and lots
// of other things, but for a demo this covers some obvious traps.
if (!Directory.Exists(aFolderName)) {
Debug.Log("Cannot find directory : " + aFolderName);
return;
}
try
{
string[] exFileNames = new string[0];
string[] exFolderNames = new string[0];
if(ExcludedFileNames != null) exFileNames = ExcludedFileNames;
if(ExcludedFolderNames != null) exFolderNames = ExcludedFolderNames;
// Depending on the directory this could be very large and would require more attention
// in a commercial package.
List<string> filenames = GenerateFolderFileList(aFolderName, null);
//foreach(string filename in filenames) Debug.Log(filename);
// 'using' statements guarantee the stream is closed properly which is a big source
// of problems otherwise. Its exception safe as well which is great.
using (ZipOutputStream zipOut = new ZipOutputStream(File.Create(aFullFileOuputName))){
zipOut.Finish();
zipOut.Close();
}
using(ZipFile s = new ZipFile(aFullFileOuputName)){
s.BeginUpdate();
int counter = 0;
//add the file to the zip file
foreach(string filename in filenames){
bool include = true;
string entryName = filename.Replace(aFolderName, "");
//Debug.Log(entryName);
foreach(string fn in exFolderNames){
Regex regEx = new Regex(@"^" + fn.Replace(".",@"\."));
if(regEx.IsMatch(entryName)) include = false;
}
foreach(string fn in exFileNames){
Regex regEx = new Regex(@"^" + fn.Replace(".",@"\."));
if(regEx.IsMatch(entryName)) include = false;
}
if(include){
s.Add(filename, entryName);
}
counter++;
}
//commit the update once we are done
s.CommitUpdate();
//close the file
s.Close();
}
}
catch(Exception ex)
{
Debug.Log("Exception during processing" + ex.Message);
// No need to rethrow the exception as for our purposes its handled.
}
}
public void CreateFxz()
{
using (var zipStream =
new ZipOutputStream(File.Create(GetTemporaryDirectory() +
"foo.fxz"))) {
_zipStream = zipStream;
zipStream.SetLevel(9);
string filename = "content.fxd";
string fullpath = GetFullPath(filename);
var ms = File.Create(fullpath);
_streamWriter = new StreamWriter(ms);
WriteContent();
ms.Close();
AddFileToZip(fullpath);
RemoveTemporaryFile(fullpath);
_streamWriter.Flush();
zipStream.Finish();
zipStream.Close();
}
}
/// <summary>
/// Compresses an array of bytes and stores the result in a new array of bytes.
/// </summary>
/// <param name="uncompressed">The uncompressed buffer.</param>
/// <param name="compressed">An array of bytes where the compressed input will be stored.</param>
/// <remarks>
/// The compressed input is passed back to the calling method as an <b>out</b>
/// parameter. That means that the calling method doesn't need to initialize the
/// compressed buffer.
/// </remarks>
/// <exception cref="ArgumentNullException">
/// Thrown if the uncompressed input buffer is empty or null.
/// </exception>
/// <exception cref="CWZipException">
/// Thrown if a problem is encountered during the compression process.
/// </exception>
public static void CompressBuffer(byte[] uncompressed, out byte[] compressed)
{
if ((uncompressed == null) || (uncompressed.Length == 0))
{
throw new ArgumentNullException("uncompressed", "The uncompressed input buffer cannot be null or empty.");
}
MemoryStream ms = null;
compressed = null;
try
{
ms = new MemoryStream();
ZipOutputStream zip = new ZipOutputStream(ms);
zip.SetLevel(compressionLevel);
ZipEntry entry = new ZipEntry("1");
zip.PutNextEntry(entry);
zip.Write(uncompressed, 0, uncompressed.Length);
zip.Finish();
ms.Position = 0;
compressed = ms.ToArray();
ms.Close();
}
catch (Exception e)
{
if (ms != null)
{
ms.Close();
}
throw new CWZipException(e.Message);
}
finally
{
ms = null;
GC.Collect();
}
}
/// <summary>
/// Método que faz o zip de arquivos encontrados no diretório <strPathDirectory>
/// </summary>
/// <param name="strPath"></param>
public static void ZipFiles(String strPathDirectory, String strZipName)
{
try
{
using (ZipOutputStream ZipOut = new ZipOutputStream(File.Create(strPathDirectory + "\\" + strZipName + ".zip")))
{
string[] OLfiles = Directory.GetFiles(strPathDirectory);
Console.WriteLine(OLfiles.Length);
ZipOut.SetLevel(9);
byte[] buffer = new byte[4096];
foreach (string filename in OLfiles)
{
ZipEntry entry = new ZipEntry(Path.GetFileName(filename));
ZipOut.PutNextEntry(entry);
using (FileStream fs = File.OpenRead(filename))
{
int sourceBytes;
do
{
sourceBytes = fs.Read(buffer, 0, buffer.Length);
ZipOut.Write(buffer, 0, sourceBytes);
} while (sourceBytes > 0);
}
}
ZipOut.Finish();
ZipOut.Close();
}
}
catch (System.Exception ex)
{
System.Console.Error.WriteLine("exception: " + ex);
//TODO colocar log
}
}
/// <summary>
/// Creates a bundle containing version list delta and all data of files.
/// </summary>
/// <returns>The binary bundle.</returns>
/// <param name="list">List needed to transferred.</param>
public static byte[] CreateFileBundle(List<FileEvent> list)
{
using (MemoryStream ms = new MemoryStream())
using (ZipOutputStream zip = new ZipOutputStream(ms))
{
ZipEntry block = new ZipEntry("vs");
zip.PutNextEntry(block);
zip.WriteAllBytes(list.SerializeAsBytes());
zip.CloseEntry();
foreach (var sha1 in list.Where(x => x.SHA1 != null).Select(x => x.SHA1).Distinct())
{
block = new ZipEntry(sha1);
zip.PutNextEntry(block);
zip.WriteAllBytes(File.ReadAllBytes(Config.MetaFolderData.File(sha1)));
zip.CloseEntry();
}
zip.Finish();
ms.Flush();
ms.Position = 0;
return ms.ToArray();
}
}
/// <summary>
/// 压缩文件
/// </summary>
/// <param name="sourcePath">待压缩的目录</param>
/// <param name="zipFilePath">待生成的压缩文件</param>
public static void CreateZipFile(string sourcePath, string zipFilePath)
{
if (!Directory.Exists(sourcePath) && !File.Exists(sourcePath))
throw new IOException("找不到目录或文件sourcePath");
if (!zipFilePath.ToLower().EndsWith(".zip"))
{
zipFilePath += ".zip";
}
using (ZipOutputStream s = new ZipOutputStream(File.Create(zipFilePath)))
{
s.SetLevel(9); // 压缩级别 0-9
//s.Password = "******"; //Zip压缩文件密码
if (Directory.Exists(sourcePath))
AppendZipDirectory(s, null, sourcePath);
else if (File.Exists(sourcePath))
AppendZipFile(s, null, sourcePath);
s.Finish();
s.Close();
}
}
/// <summary>
/// Compress an string using ZIP
/// </summary>
/// <param name="xml"></param>
/// <returns></returns>
public static byte[] CompressContent(string contentToZip)
{
System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding();
byte[] buff = encoding.GetBytes(contentToZip);
try
{
using (MemoryStream stream = new MemoryStream())
{
using (ZipOutputStream zipout = new ZipOutputStream(stream))
{
zipout.SetLevel(9);
ZipEntry entry = new ZipEntry("zipfile.zip");
entry.DateTime = DateTime.Now;
zipout.PutNextEntry(entry);
zipout.Write(buff, 0, buff.Length);
zipout.Finish();
byte[] outputbyte = new byte[(int)stream.Length];
stream.Position = 0;
stream.Read(outputbyte, 0, (int)stream.Length);
return outputbyte;
}
}
}
catch (Exception ex)
{
ex.Message.ToString();
return null;
}
}
/// <summary>
/// 压缩文件
/// </summary>
/// <param name="sourceFilePath">待压缩的文件或文件夹路径</param>
/// <param name="destinationZipFilePath">保存压缩文件的文件名</param>
/// <param name="level">压缩文件等级</param>
/// <returns>返回-2说明被压缩文件已经存在，返回1说明压缩成功</returns>
public static int CreateFileZip(string sourceFilePath, string destinationZipFilePath, int level)
{
if (!Directory.Exists(destinationZipFilePath.Substring(0, destinationZipFilePath.LastIndexOf("\\"))))
{
Directory.CreateDirectory(destinationZipFilePath.Substring(0, destinationZipFilePath.LastIndexOf("\\")));
}
if (File.Exists(destinationZipFilePath))
{
return -2;
}
else
{
ZipOutputStream zipStream = new ZipOutputStream(File.Create(destinationZipFilePath));
zipStream.SetLevel(level); // 压缩级别 0-9
Crc32 crc = new Crc32();
FileStream fileStream = File.OpenRead(sourceFilePath);
byte[] buffer = new byte[fileStream.Length];
fileStream.Read(buffer, 0, buffer.Length);
string tempFile = sourceFilePath.Substring(sourceFilePath.LastIndexOf("\\") + 1);
ZipEntry entry = new ZipEntry(tempFile);
entry.DateTime = DateTime.Now;
entry.Size = fileStream.Length;
fileStream.Close();
crc.Reset();
crc.Update(buffer);
entry.Crc = crc.Value;
zipStream.PutNextEntry(entry);
zipStream.Write(buffer, 0, buffer.Length);
zipStream.Finish();
zipStream.Close();
return 1;
}
}
/// <summary>
/// Zips the files in the specifed directory and outputs the zip file to the specified location.
/// </summary>
/// <param name="zipFilePath">The full path to the output zip file.</param>
/// <returns>The total number of files added to the zip file.</returns>
public int ZipToFile(string zipFilePath)
{
int total = 0;
if (Directory.Exists(DirectoryPath))
{
if (!Directory.Exists(Path.GetDirectoryName(zipFilePath)))
{
Directory.CreateDirectory(Path.GetDirectoryName(zipFilePath));
}
// Create the zip file
//Crc32 crc = new Crc32();
ZipOutputStream zipFile = new ZipOutputStream(File.Create(zipFilePath));
zipFile.UseZip64 = UseZip64.Off;
zipFile.SetLevel(9);
total += ZipFromPath(zipFile, DirectoryPath);
// Close the writer
zipFile.Finish();
zipFile.Close();
}
return total;
}
public FileResult DownloadAllFiles()
{
var context = System.Web.HttpContext.Current;
var folderPath = context.Server.MapPath("~/UploadedFiles/");
var baseOutputStream = new MemoryStream();
ZipOutputStream zipOutput = new ZipOutputStream(baseOutputStream) {IsStreamOwner = false};
/*
* Higher compression level will cause higher usage of reources
* If not necessary do not use highest level 9
*/
zipOutput.SetLevel(4);
SharpZipLibHelper.ZipFolder(folderPath, zipOutput);
zipOutput.Finish();
zipOutput.Close();
/* Set position to 0 so that cient start reading of the stream from the begining */
baseOutputStream.Position = 0;
/* Set custom headers to force browser to download the file instad of trying to open it */
return new FileStreamResult(baseOutputStream, "application/x-zip-compressed")
{
FileDownloadName = "eResult.zip"
};
}
public static void CreateZipFile(string[] filenames, string outputFile)
{
// Zip up the files - From SharpZipLib Demo Code
using (ZipOutputStream s = new ZipOutputStream(File.Create(outputFile)))
{
s.SetLevel(9); // 0-9, 9 being the highest level of compression
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();
}
}
private void Page_Load(object sender, System.EventArgs e)
{
System.DateTime dateTime = System.DateTime.Now;
string s1 = "Message_Backup_\uFFFD" + dateTime.ToString("ddMMyy_HHmmss\uFFFD") + ".zip\uFFFD";
System.IO.MemoryStream memoryStream = new System.IO.MemoryStream();
ICSharpCode.SharpZipLib.Zip.ZipOutputStream zipOutputStream = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(memoryStream);
ActiveUp.Net.Mail.Mailbox mailbox = ((ActiveUp.Net.Mail.Imap4Client)Session["imapobject\uFFFD"]).SelectMailbox(Request.QueryString["b\uFFFD"]);
char[] chArr = new char[] { ',' };
string[] sArr = Request.QueryString["m\uFFFD"].Split(chArr);
for (int i = 0; i < sArr.Length; i++)
{
string s2 = sArr[i];
byte[] bArr = mailbox.Fetch.Message(System.Convert.ToInt32(s2));
ActiveUp.Net.Mail.Header header = ActiveUp.Net.Mail.Parser.ParseHeader(bArr);
ICSharpCode.SharpZipLib.Zip.ZipEntry zipEntry = new ICSharpCode.SharpZipLib.Zip.ZipEntry(header.Subject + ".eml\uFFFD");
zipOutputStream.PutNextEntry(zipEntry);
zipOutputStream.SetLevel(9);
zipOutputStream.Write(bArr, 0, bArr.Length);
zipOutputStream.CloseEntry();
}
zipOutputStream.Finish();
Response.AddHeader("Content-Disposition\uFFFD", "attachment; filename=\uFFFD" + s1);
Response.ContentType = "application/zip\uFFFD";
Response.BinaryWrite(memoryStream.GetBuffer());
zipOutputStream.Close();
}
public static void CompressFiles(IEnumerable<ISong> files, string destinationPath)
{
if (log.IsDebugEnabled)
{
log.Debug("Starting creation of zip file : " + destinationPath);
}
using (ZipOutputStream zipOutputStream = new ZipOutputStream(new FileStream(destinationPath, FileMode.OpenOrCreate)))
{
zipOutputStream.SetLevel(0);
foreach (ISong song in files)
{
FileInfo fileInfo = new FileInfo(song.MediaFilePath);
ZipEntry entry = new ZipEntry(song.Artist.Name + "\\" + song.Album.Name + "\\" + song.Title + fileInfo.Extension);
zipOutputStream.PutNextEntry(entry);
FileStream fs = File.OpenRead(song.MediaFilePath);
byte[] buff = new byte[1024];
int n = 0;
while ((n = fs.Read(buff, 0, buff.Length)) > 0)
{
zipOutputStream.Write(buff, 0, n);
}
fs.Close();
}
zipOutputStream.Finish();
}
if (log.IsDebugEnabled)
{
log.Debug("Zip file created : " + destinationPath);
}
}
public void CreateZipFile(string[] straFilenames, string strOutputFilename)
{
Crc32 crc = new Crc32();
ZipOutputStream zos = new ZipOutputStream(File.Create(strOutputFilename));
zos.SetLevel(m_nCompressionLevel);
foreach (string strFileName in straFilenames)
{
FileStream fs = File.OpenRead(strFileName);
byte[] buffer = new byte[fs.Length];
fs.Read(buffer, 0, buffer.Length);
ZipEntry entry = new ZipEntry(GetFileNameWithoutDrive(strFileName));
entry.DateTime = DateTime.Now;
entry.Size = fs.Length;
fs.Close();
crc.Reset();
crc.Update(buffer);
entry.Crc = crc.Value;
zos.PutNextEntry(entry);
zos.Write(buffer, 0, buffer.Length);
}
zos.Finish();
zos.Close();
}
public static void CreateFromDirectory(string[] sourceFileNames, string destinationArchiveFileName)
{
using (ZipOutputStream zipStream = new ZipOutputStream(File.Create(destinationArchiveFileName)))
{
byte[] buffer = new byte[BufferSize];
zipStream.SetLevel(9);
foreach (string file in sourceFileNames)
{
var entryName = Path.GetFileName(file);
var fileInfo = new FileInfo(file);
ZipEntry entry = new ZipEntry(entryName);
entry.DateTime = fileInfo.LastWriteTime;
zipStream.PutNextEntry(entry);
using (FileStream fileStream = File.OpenRead(file))
{
while (true)
{
int size = fileStream.Read(buffer, 0, buffer.Length);
if (size <= 0)
break;
zipStream.Write(buffer, 0, size);
}
}
}
zipStream.Finish();
zipStream.Close();
}
}
public void AddEntryAfterFinish()
{
MemoryStream ms = new MemoryStream();
ZipOutputStream s = new ZipOutputStream(ms);
s.Finish();
s.PutNextEntry(new ZipEntry("dummyfile.tst"));
}
public void ZipFile(string FileToZip, string ZipedFile, int CompressionLevel, int BlockSize)
{
//如果文件没有找到，则报错
if (!System.IO.File.Exists(FileToZip))
{
throw new System.IO.FileNotFoundException("The specified file " + FileToZip + " could not be found. Zipping aborderd");
}
System.IO.FileStream StreamToZip = new System.IO.FileStream(FileToZip, System.IO.FileMode.Open, System.IO.FileAccess.Read);
System.IO.FileStream ZipFile = System.IO.File.Create(ZipedFile);
ZipOutputStream ZipStream = new ZipOutputStream(ZipFile);
ZipEntry ZipEntry = new ZipEntry("ZippedFile");
ZipStream.PutNextEntry(ZipEntry);
ZipStream.SetLevel(CompressionLevel);
byte[] buffer = new byte[BlockSize];
System.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;
}
}
catch (System.Exception ex)
{
throw ex;
}
ZipStream.Finish();
ZipStream.Close();
StreamToZip.Close();
}
public void CompressFile(string sourcePath, string destinationPath)
{
using (ICSharpCode.SharpZipLib.Zip.ZipOutputStream zipStream = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(File.Create(destinationPath)))
{
zipStream.SetLevel(9);
byte[] buffer = new byte[4096];
ICSharpCode.SharpZipLib.Zip.ZipEntry entry = new ICSharpCode.SharpZipLib.Zip.ZipEntry(System.IO.Path.GetFileName(sourcePath));
entry.DateTime = DateTime.Now;
zipStream.PutNextEntry(entry);
using (FileStream fs = File.OpenRead(sourcePath))
{
int sourceBytes = 0;
do
{
sourceBytes = fs.Read(buffer, 0, buffer.Length);
zipStream.Write(buffer, 0, sourceBytes);
} while (sourceBytes > 0);
}
zipStream.Finish();
zipStream.Close();
zipStream.Dispose();
}
}
public static void ZipFiles(string inputFolderPath, string outputPathAndFile, string password)
{
ArrayList ar = GenerateFileList(inputFolderPath); // generate file list
int TrimLength = (Directory.GetParent(inputFolderPath)).ToString().Length;
// find number of chars to remove // from orginal file path
TrimLength += 1; //remove '\'
FileStream ostream;
byte[] obuffer;
string outPath = outputPathAndFile;
ZipOutputStream oZipStream = new ZipOutputStream(File.Create(outPath)); // create zip stream
if (password != null && password != String.Empty)
oZipStream.Password = password;
oZipStream.SetLevel(9); // maximum compression
ZipEntry oZipEntry;
foreach (string Fil in ar) // for each file, generate a zipentry
{
oZipEntry = new ZipEntry(Fil.Remove(0, TrimLength));
oZipStream.PutNextEntry(oZipEntry);
if (!Fil.EndsWith(@"/")) // if a file ends with '/' its a directory
{
ostream = File.OpenRead(Fil);
obuffer = new byte[ostream.Length];
ostream.Read(obuffer, 0, obuffer.Length);
oZipStream.Write(obuffer, 0, obuffer.Length);
}
}
oZipStream.Finish();
oZipStream.Close();
oZipStream.Dispose();
}
/// <summary>
/// 压缩文件
/// </summary>
/// <param name="strFile">压缩源路径</param>
/// <param name="strZip">压缩文件保存路径</param>
/// <param name = "rootDir">压缩文件根目录</param>
/// <param name = "isEndExtent">是否压缩包含扩展名的文件</param>
/// <param name = "extents">用于筛选的扩展名</param>
public static void ZipFile (string strFile, string strZip, string rootDir = "", bool isEndExtent = false, params string[] extents)
{
var s = new ZipOutputStream (File.Create (strZip));
s.SetLevel (9); // 0 - store only to 9 - means best compression
zip (strFile, s, rootDir, isEndExtent, extents);
s.Finish ();
s.Close ();
}
public static string CreateZIPFile(string path, int M, string strsuff)
{
try
{
Crc32 crc = new Crc32();//未压缩的
ICSharpCode.SharpZipLib.Zip.ZipOutputStream zipout = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(System.IO.File.Create(path + ".zip"));
//ICSharpCode.SharpZipLib.GZip.GZipOutputStream zipout = new GZipOutputStream(System.IO.File.Create(path+ ".zip"));
System.IO.FileStream fs = System.IO.File.OpenRead(path + strsuff);
long pai = 1024 * 1024 * M;//每M兆写一次
long forint = fs.Length / pai + 1;
byte[] buffer = null;
zipout.SetLevel(7);
ZipEntry entry = new ZipEntry(System.IO.Path.GetFileName(path + strsuff));
entry.Size = fs.Length;
entry.DateTime = DateTime.Now;
zipout.PutNextEntry(entry);
//zipout.
for (long i = 1; i <= forint; i++)
{
if (pai * i < fs.Length)
{
buffer = new byte[pai];
fs.Seek(pai * (i - 1), System.IO.SeekOrigin.Begin);
}
else
{
if (fs.Length < pai)
{
buffer = new byte[fs.Length];
}
else
{
buffer = new byte[fs.Length - pai * (i - 1)];
fs.Seek(pai * (i - 1), System.IO.SeekOrigin.Begin);
}
}
fs.Read(buffer, 0, buffer.Length);
crc.Reset();
crc.Update(buffer);
zipout.Write(buffer, 0, buffer.Length);
zipout.Flush();
}
fs.Close();
zipout.Finish();
zipout.Close();
System.IO.File.Delete(path + strsuff);
// File.Create(path.Replace(".doc","") + ".zip",buffer.Length);
return(path + ".zip");
}
catch (Exception ex)
{
string str = ex.Message;
return(path);
}
}
/// <summary>
/// 压缩文件(Zip)
/// </summary>
/// <param name="filesPath">待压缩文件目录</param>
/// <param name="zipFilePath">压缩文件输出目录</param>
/// <returns></returns>
public static ZipInfo CreateZipFile(string filesPath, string zipFilePath)
{
if (!System.IO.Directory.Exists(filesPath))
{
return(new ZipInfo
{
Success = false,
InfoMessage = "没有找到文件"
});
}
try
{
string[] filenames = System.IO.Directory.GetFiles(filesPath);
using (ICSharpCode.SharpZipLib.Zip.ZipOutputStream s = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(File.Create(zipFilePath)))
{
s.SetLevel(9); // 压缩级别 0-9
//s.Password = "******"; //Zip压缩文件密码
byte[] buffer = new byte[4096]; //缓冲区大小
foreach (string file in filenames)
{
ICSharpCode.SharpZipLib.Zip.ZipEntry entry = new ICSharpCode.SharpZipLib.Zip.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();
}
return(new ZipInfo
{
Success = true,
InfoMessage = "压缩成功"
});
}
catch (Exception ex)
{
return(new ZipInfo
{
Success = false,
InfoMessage = ex.Message
});
}
}
public static Boolean ZipFile(String filePath, String zipFile)
{
if (!File.Exists(filePath))
{
Debug.WriteLine("Cannot find file '{0}'", filePath);
return(false);
}
try
{
using (ICSharpCode.SharpZipLib.Zip.ZipOutputStream zipStream = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(File.Create(zipFile)))
{
zipStream.SetLevel(9); //0~9
byte[] buffer = new byte[4096];
ICSharpCode.SharpZipLib.Zip.ZipEntry entry = new ICSharpCode.SharpZipLib.Zip.ZipEntry(System.IO.Path.GetFileName(filePath));
entry.DateTime = DateTime.Now;
zipStream.PutNextEntry(entry);
using (FileStream fs = File.OpenRead(filePath))
{
int sourceBytes = 0;
do
{
sourceBytes = fs.Read(buffer, 0, buffer.Length);
zipStream.Write(buffer, 0, sourceBytes);
} while (sourceBytes > 0);
}
zipStream.Finish();
zipStream.Close();
zipStream.Dispose();
}
if (File.Exists(zipFile))
{
return(true);
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception during processing {0}", ex);
}
return(false);
}
private String CompressionDossier(String pFichier)
{
try
{
if (Directory.Exists(pFichier) == true)
{
//System.IO.Compression.GZipStream gzip = new System.IO.Compression.GZipStream();
using (var s = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(File.Create(String.Format("{0}.zip", pFichier))))
{
s.SetLevel(9);
var buffer = new byte[4096];
var entry = new ICSharpCode.SharpZipLib.Zip.ZipEntry(pFichier)
{
DateTime = DateTime.Now
};
s.PutNextEntry(entry);
using (StreamReader fs = new StreamReader(pFichier))
{
int sourceBytes;
do
{
sourceBytes = fs.Read();
s.Write(buffer, 0, sourceBytes);
} while (sourceBytes > 0);
}
s.Finish();
s.Close();
s.Dispose();
pFichier = string.Format("{0}.zip", pFichier);
}
//}
}
return(pFichier);
}
catch (Exception ex)
{
throw ex;
}
}
} // Unpack
/// <summary>
/// Zip a file.
/// </summary>
/// <param name="filename"></param>
/// <param name="appendZipExtension"></param>
public static void PackFile(string filename, bool appendZipExtension)
{
if (filename == null)
{
throw new ArgumentNullException("filename");
}
if (!File.Exists(filename))
{
throw new ArgumentException(string.Format("File does not exist: {0}.", filename), "filename");
}
string newFilename = filename + ".zip";
if (!appendZipExtension)
{
newFilename = Path.GetDirectoryName(filename) + Path.DirectorySeparatorChar + Path.GetFileNameWithoutExtension(filename) + ".zip";
}
if (File.Exists(newFilename))
{
File.Delete(newFilename);
}
FileStream fileStreamOut = File.Create(newFilename);
ICSharpCode.SharpZipLib.Zip.ZipOutputStream zipOutputStream = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(fileStreamOut);
zipOutputStream.SetLevel(9);
ICSharpCode.SharpZipLib.Zip.ZipEntry zipEntry = new ICSharpCode.SharpZipLib.Zip.ZipEntry(Path.GetFileName(filename));
zipOutputStream.PutNextEntry(zipEntry);
FileStream fileStreamIn = File.OpenRead(filename);
const long BUFFER_SIZE = 8192;
long currentIndex = 0;
byte[] buffer = new byte[BUFFER_SIZE];
if (fileStreamIn.Length <= BUFFER_SIZE)
{
fileStreamIn.Read(buffer, 0, Convert.ToInt32(fileStreamIn.Length));
zipOutputStream.Write(buffer, 0, Convert.ToInt32(fileStreamIn.Length));
}
else
{
do
{
long remaining = BUFFER_SIZE;
if (currentIndex + BUFFER_SIZE >= fileStreamIn.Length)
{
remaining = fileStreamIn.Length - currentIndex;
}
fileStreamIn.Read(buffer, 0, Convert.ToInt32(remaining));
currentIndex += remaining;
zipOutputStream.Write(buffer, 0, Convert.ToInt32(remaining));
} while (currentIndex < fileStreamIn.Length);
}
fileStreamIn.Close();
zipOutputStream.Flush();
zipOutputStream.Finish();
zipOutputStream.Close();
fileStreamOut.Close();
}// ZipFile
}// ZipFile
/// <summary>
/// Zip multiple files(fileNames) in directory(directory) to (flowName).zip.
/// </summary>
/// <param name="directory"></param>
/// <param name="fileNames"></param>
/// <param name="reportName"></param>
public static void PackFilesIntoOne(string directory, string[] fileNames, string outputFilename)
{
if (directory == null)
{
throw new ArgumentNullException("directory");
}
if (fileNames == null)
{
throw new ArgumentNullException("fileNames");
}
if (outputFilename == null)
{
throw new ArgumentNullException("outputFilename");
}
if (fileNames.Length == 0)
{
throw new ArgumentException("Length cannot be 0.", "fileNames");
}
string newFilename = Path.Combine(directory, outputFilename);
if (File.Exists(newFilename))
{
File.Delete(newFilename);
}
using (FileStream fileStreamOut = File.Create(newFilename))
{
using (ICSharpCode.SharpZipLib.Zip.ZipOutputStream zipOutputStream = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(fileStreamOut))
{
zipOutputStream.SetLevel(9);
foreach (string filename in fileNames)
{
ICSharpCode.SharpZipLib.Zip.ZipEntry zipEntry = new ICSharpCode.SharpZipLib.Zip.ZipEntry(filename);
zipOutputStream.PutNextEntry(zipEntry);
using (FileStream fileStreamIn = File.OpenRead(Path.Combine(directory, filename)))
{
const long BUFFER_SIZE = 8192;
long currentIndex = 0;
byte[] buffer = new byte[BUFFER_SIZE];
if (fileStreamIn.Length <= BUFFER_SIZE)
{
fileStreamIn.Read(buffer, 0, Convert.ToInt32(fileStreamIn.Length));
zipOutputStream.Write(buffer, 0, Convert.ToInt32(fileStreamIn.Length));
}
else
{
do
{
long remaining = BUFFER_SIZE;
if (currentIndex + BUFFER_SIZE >= fileStreamIn.Length)
{
remaining = fileStreamIn.Length - currentIndex;
}
fileStreamIn.Read(buffer, 0, Convert.ToInt32(remaining));
currentIndex += remaining;
zipOutputStream.Write(buffer, 0, Convert.ToInt32(remaining));
} while (currentIndex < fileStreamIn.Length);
}
} // using ( FileStream fileStreamIn = File.OpenRead( Path.Combine( directory, filename ) ...
} // foreach
zipOutputStream.Flush();
zipOutputStream.Finish();
} //using ( ICSharpCode.SharpZipLib.Zip.ZipOutputStream zipOutputStream = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream( fileStreamOut ) ) ...
} // using ( FileStream fileStreamOut = File.Create( newFilename ) ...
}
