path = this._name +"." + Path.GetRandomFileName ();
if (File.Exists (path))
{
this.DeleteFileWithRetry (path);
}
File.Move (this._name, path);
}
this.OnSaveEvent (ZipProgressEventType.Saving_BeforeRenameTempArchive);
File.Move ((writeStream! = Null)? WriteStream.CurrentTempName: this._temporaryFileName, this._name);
this.OnSaveEvent (ZipProgressEventType.Saving_AfterRenameTempArchive);
if (path! = null)
{
try
{
if (File.Exists (path))
{
File.Delete (path);
}
}
catch
{
}
}
this._fileAlreadyExists = true;
}
NotifyEntriesSaveComplete (entries);
this.OnSaveCompleted ();
this._JustSaved = true;
}
}
}
finally
{
this.CleanupAfterSaveOperation ();
}
}
public static bool IsZipFile (Stream stream, bool testExtract)
{
if (stream == null)
{
throw new ArgumentNullException ("stream");
}
bool flag = false;
try
{
if (! stream.CanRead)
{
return false;
}
Stream @null = Stream.Null;
using (ZipFile file = Read (stream, null, null, null))
{
if (testExtract)
{
foreach (ZipEntry entry in file)
{
if (! entry.IsDirectory)
{
entry.Extract (@null);
}
}
}
}
flag = true;
}
catch (IOException)
{
}
catch (ZipException)
{
}
return flag;
}
2.Read () reads the data stream:
private static ZipFile Read (Stream zipStream, TextWriter statusMessageWriter, Encoding encoding, EventHandler <ReadProgressEventArgs> readProgress)
{
if (zipStream == null)
{
throw new ArgumentNullException ("zipStream");
}
ZipFile zf = new ZipFile {
_StatusMessageTextWriter = statusMessageWriter,
_alternateEncoding = encoding ?? DefaultEncoding,
_alternateEncodingUsage = ZipOption.Always
};
if (readProgress! = null)
{
zf.ReadProgress + = readProgress;
}
zf._readstream = (zipStream.Position == 0L)? zipStream: new OffsetStream (zipStream);
zf._ReadStreamIsOurs = false;
if (zf.Verbose)
{
zf._StatusMessageTextWriter.WriteLine ("reading from stream ...");
}
ReadIntoInstance (zf);
return zf;
}
The above is the analysis of some methods of the ZipFile class, and provides the source code of some methods of this component. As for the interpretation of the source code, it is not very difficult. As for the API of this component, you can directly view the corresponding methods after downloading the DLL file And attributes are not described in detail here.
Three. DotNetZip component usage examples:
The above is some analysis of the component, let's look at the example:
1. Compress ZIP file:
/// <summary>
/// Compress ZIP file
/// Support multiple files and directories, or multiple files and directories compressed together
/// </ summary>
/// <param name = "list"> File or directory collection to be compressed </ param>
/// <param name = "strZipName"> compressed file name </ param>
/// <param name = "isDirStruct"> Whether to compress by directory structure </ param>
/// <returns> success: true / failure: false </ returns>
public static bool CompressMulti (List <string> list, string strZipName, bool isDirStruct)
{
if (list == null)
{
throw new ArgumentNullException ("list");
}
if (string.IsNullOrEmpty (strZipName))
{
throw new ArgumentNullException (strZipName);
}
try
{
// Set encoding to solve Chinese garbled characters when compressing files
using (var zip = new ZipFile (Encoding.Default))
{
foreach (var path in list)
{
// take directory name
var fileName = Path.GetFileName (path);
// if it is a directory
if (Directory.Exists (path))
{
// compress by directory structure
if (isDirStruct)
{
zip.AddDirectory (path, fileName);
}
else
{
// The files in the directory are compressed to the root directory of Zip
zip.AddDirectory (path);
}
}
if (File.Exists (path))
{
zip.AddFile (path);
}
}
//compression
zip.Save (strZipName);
return true;
}
}
catch (Exception ex)
{
throw new Exception (ex.Message);
}
}
2. Unzip the ZIP file:
/// <summary>
/// Unzip the ZIP file
/// </ summary>
/// <param name = "strZipPath"> ZIP file to be extracted </ param>
/// <param name = "strUnZipPath"> Uncompressed directory </ param>
/// <param name = "overWrite"> Whether to override </ param>
/// <returns> success: true / failure: false </ returns>
public static bool Decompression (string strZipPath, string strUnZipPath, bool overWrite)
{
if (string.IsNullOrEmpty (strZipPath))
{
throw new ArgumentNullException (strZipPath);
}
if (string.IsNullOrEmpty (strUnZipPath))
{
throw new ArgumentNullException (strUnZipPath);
}
try
{
var options = new ReadOptions
{
Encoding = Encoding.Default
};
// Set encoding to solve Chinese garbled characters when decompressing files
using (var zip = ZipFile.Read (strZipPath, options))
{
foreach (var entry in zip)
{
if (string.IsNullOrEmpty (strUnZipPath))
{
strUnZipPath = strZipPath.Split ('.'). First ();
}
entry.Extract (strUnZipPath, overWrite
? ExtractExistingFileAction.OverwriteSilently
: ExtractExistingFileAction.DoNotOverwrite);
}
return true;
}
}
catch (Exception ex)
{
throw new Exception (ex.Message);
}
}
3. Get the ZIP compressed stream object of the specified input stream:
/// <summary>
/// get the ZIP compressed stream object for the specified input stream
/// </ summary>
/// <param name = "sourceStream"> source data stream </ param>
/// <param name = "entryName"> entity name </ param>
/// <returns> </ returns>
public static Stream ZipCompress (Stream sourceStream, string entryName = "zip")
{
if (sourceStream == null)
{
throw new ArgumentNullException ("sourceStream");
}
var compressedStream = new MemoryStream ();
long sourceOldPosition = 0;
try
{
sourceOldPosition = sourceStream.Position;
sourceStream.Position = 0;
using (var zip = new ZipFile ())
{
zip.AddEntry (entryName, sourceStream);
zip.Save (compressedStream);
compressedStream.Position = 0;
}
}
catch (Exception ex)
{
throw new Exception (ex.Message);
}
finally
{
try
{
sourceStream.Position = sourceOldPosition;
}
catch (Exception ex)
{
throw new Exception (ex.Message);
}
}
return compressedStream;
}
4. Get the ZIP decompressed stream object of the specified byte array:
/// <summary>
/// get the ZIP decompression stream object of the specified byte array
/// The current method is only applicable to a compressed package with only one compressed file, that is, only the first compressed file in the compressed package is taken in the method
/// </ summary>
/// <param name = "data"> </ param>
/// <returns> </ returns>
public static Stream ZipDecompress (byte [] data)
{
Stream decompressedStream = new MemoryStream ();
if (data == null) return decompressedStream;
try
{
var dataStream = new MemoryStream (data);
using (var zip = ZipFile.Read (dataStream))
{
if (zip.Entries.Count> 0)
{
zip.Entries.First (). Extract (decompressedStream);
// ms will be operated in the Extract method, and the Stream position must be reset to zero during subsequent use, otherwise no data will be read
// Perform a position zeroing action before returning this Stream object
decompressedStream.Position = 0;
}
}
}
catch (Exception ex)
{
throw new Exception (ex.Message);
}
return decompressedStream;
}
4. Summary:
The above are some examples of analysis and methods for DotNetZip components. As for whether this component is the best .NET compression component, this will not be evaluated. When selecting components, individuals first consider open source, followed by free, and finally consider efficiency and practicability. After all, some situations in China are clear to all developers (not to mention abroad because I do n’t know the situation abroad ). Customers need to reduce costs and components can be customized. However, I think that charging should be a trend. After all, all products require maintenance and development by personnel. There are deficiencies in the above blog posts, and I hope to correct them.
Start building with 50+ products and up to 12 months usage for Elastic Compute Service
1 on 1 presale consultation
24/7 Technical Support 6 Free Tickets per Quarter Faster Response
Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.
A comprehensive suite of global cloud computing services to power your business
Payment Methods We Support
