// File : Create new, Append to existing, Raz existing
// ArchiveType : Rar = 0, Zip = 1, Tar = 2, SevenZip = 3, GZip = 4
// CompressionType : None = 0, GZip = 1, BZip2 = 2, PPMd = 3, Deflate = 4, Rar = 5, LZMA = 6, BCJ = 7, BCJ2 = 8, Unknown = 9,
// Zip compression type : BZip2
// GZip compression type : GZip
// example from https://github.com/adamhathcock/sharpcompress/wiki/API-Examples
// this example dont work to add file to an existing zip
public static void Test_Compress(string compressFile, IEnumerable<string> files, string baseDirectory = null, ArchiveType archiveType = ArchiveType.Zip,
CompressionType compressionType = CompressionType.BZip2, CompressionLevel compressionLevel = CompressionLevel.Default)
{
//FileOption
if (baseDirectory != null && !baseDirectory.EndsWith("\\"))
baseDirectory = baseDirectory + "\\";
CompressionInfo compressionInfo = new CompressionInfo();
compressionInfo.DeflateCompressionLevel = compressionLevel;
compressionInfo.Type = compressionType;
//Trace.WriteLine("SharpCompressManager : DeflateCompressionLevel {0}", compressionInfo.DeflateCompressionLevel);
//Trace.WriteLine("SharpCompressManager : CompressionType {0}", compressionInfo.Type);
Trace.WriteLine($"open compressed file \"{compressFile}\"");
// File.OpenWrite ==> OpenOrCreate
using (FileStream stream = File.OpenWrite(compressFile))
using (IWriter writer = WriterFactory.Open(stream, archiveType, compressionInfo))
//using (IWriter writer = WriterFactory.Open(stream, archiveType, CompressionType.BZip2))
{
foreach (string file in files)
{
string entryPath;
if (baseDirectory != null && file.StartsWith(baseDirectory))
entryPath = file.Substring(baseDirectory.Length);
else
entryPath = zPath.GetFileName(file);
Trace.WriteLine($"add file \"{entryPath}\" \"{file}\"");
writer.Write(entryPath, file);
}
}
}
public static IWriter Open(Stream stream, ArchiveType archiveType, CompressionInfo compressionInfo)
{
switch (archiveType)
{
case ArchiveType.GZip:
{
if (compressionInfo.Type != CompressionType.GZip)
{
throw new InvalidFormatException("GZip archives only support GZip compression type.");
}
return new GZipWriter(stream);
}
case ArchiveType.Zip:
{
return new ZipWriter(stream, compressionInfo, null);
}
case ArchiveType.Tar:
{
return new TarWriter(stream, compressionInfo);
}
default:
{
throw new NotSupportedException("Archive Type does not have a Writer: " + archiveType);
}
}
}
public ZipCompressionInfo(CompressionInfo compressionInfo)
{
switch (compressionInfo.Type)
{
case CompressionType.None:
this.Compression = ZipCompressionMethod.None;
return;
case CompressionType.BZip2:
this.Compression = ZipCompressionMethod.BZip2;
return;
case CompressionType.PPMd:
this.Compression = ZipCompressionMethod.PPMd;
return;
case CompressionType.Deflate:
this.DeflateCompressionLevel = compressionInfo.DeflateCompressionLevel;
this.Compression = ZipCompressionMethod.Deflate;
return;
case CompressionType.LZMA:
this.Compression = ZipCompressionMethod.LZMA;
return;
}
throw new InvalidFormatException("Invalid compression method: " + compressionInfo.Type);
}
public void Write(string entryPath, Stream source, DateTime? modificationTime, string comment, CompressionInfo compressionInfo = null)
{
using (Stream output = WriteToStream(entryPath, modificationTime, comment, compressionInfo))
{
source.TransferTo(output);
}
}
/// <summary>
/// Create an archive from a directory. It will iterate through all directories recursively.
/// </summary>
/// <param name="folderPath">Folder/directory to archive</param>
/// <param name="outputFile">Ouput path, including file name, of the resulting archive</param>
/// <param name="useZip">true for zip format; false for tar.gz format</param>
public static void CreateArchive(string folderPath, string outputFile, bool useZip)
{
using (var outputStream = File.OpenWrite(outputFile))
{
ArchiveType atype;
var cinfo = new CompressionInfo();
if (useZip)
{
atype = ArchiveType.Zip;
cinfo.Type = CompressionType.Deflate;
cinfo.DeflateCompressionLevel = SharpCompress.Compressor.Deflate.CompressionLevel.Default;
}
else
{
atype = ArchiveType.Tar;
cinfo.Type = CompressionType.GZip;
cinfo.DeflateCompressionLevel = SharpCompress.Compressor.Deflate.CompressionLevel.Default;
}
using (var awriter = WriterFactory.Open(outputStream, atype, cinfo))
{
awriter.WriteAll(folderPath, "*", SearchOption.AllDirectories);
}
}
}
public ZipCompressionInfo(CompressionInfo compressionInfo)
{
switch (compressionInfo.Type)
{
case CompressionType.None:
{
this.Compression = ZipCompressionMethod.None;
}
break;
case CompressionType.Deflate:
{
this.DeflateCompressionLevel = compressionInfo.DeflateCompressionLevel;
this.Compression = ZipCompressionMethod.Deflate;
}
break;
case CompressionType.BZip2:
{
this.Compression = ZipCompressionMethod.BZip2;
}
break;
case CompressionType.LZMA:
{
this.Compression = ZipCompressionMethod.LZMA;
}
break;
case CompressionType.PPMd:
{
this.Compression = ZipCompressionMethod.PPMd;
}
break;
default:
throw new InvalidFormatException("Invalid compression method: " + compressionInfo.Type);
}
}
public TarWriter(Stream destination, CompressionInfo compressionInfo)
: base(ArchiveType.Tar)
{
if (!destination.CanWrite)
{
throw new ArgumentException("Tars require writable streams.");
}
switch (compressionInfo.Type)
{
case CompressionType.None:
break;
case CompressionType.BZip2:
{
destination = new BZip2Stream(destination, CompressionMode.Compress, false);
}
break;
case CompressionType.GZip:
{
destination = new GZipStream(destination, CompressionMode.Compress, false);
}
break;
default:
{
throw new InvalidFormatException("Tar does not support compression: " + compressionInfo.Type);
}
}
InitalizeStream(destination, false);
}
public void Write(string entryPath, Stream source, DateTime? modificationTime, string comment, CompressionInfo compressionInfo)
{
using (Stream stream = this.WriteToStream(entryPath, modificationTime, comment, compressionInfo))
{
Utility.TransferTo(source, stream);
}
}
public static void CreateZip(string path, string sourceFileFolder, string comment)
{
if (!string.IsNullOrEmpty(path) && !string.IsNullOrEmpty(sourceFileFolder))
{
SharpCompress.Common.CompressionInfo ci = new SharpCompress.Common.CompressionInfo();
ci.DeflateCompressionLevel = SharpCompress.Compressor.Deflate.CompressionLevel.BestCompression;
using (FileStream sw = new FileStream(path, FileMode.Create, FileAccess.Write))
{
SharpCompress.Writer.Zip.ZipWriter zw = new SharpCompress.Writer.Zip.ZipWriter(sw,
ci, comment);
DirectoryInfo dir = new DirectoryInfo(sourceFileFolder);
foreach (FileInfo f in dir.GetFiles("*.*", SearchOption.AllDirectories))
{
using (FileStream fs = f.OpenRead())
{
string relativePath = string.Empty;
if (f.FullName.Length > sourceFileFolder.Length)
{
relativePath = f.FullName.Substring(sourceFileFolder.Length + 1);
}
zw.Write(relativePath, fs, f.LastWriteTime);
}
}
}
}
}
public static void SaveTo(this IWritableArchive writableArchive,
FileInfo fileInfo, CompressionInfo compressionInfo)
{
using (var stream = fileInfo.Open(FileMode.Create, FileAccess.Write))
{
writableArchive.SaveTo(stream, compressionInfo);
}
}
public ZipWriter(Stream destination, CompressionInfo compressionInfo, string zipComment)
: base(ArchiveType.Zip)
{
this.zipComment = zipComment ?? string.Empty;
this.zipCompressionInfo = new ZipCompressionInfo(compressionInfo);
InitalizeStream(destination, false);
}
public ZipWriter(Stream destination, CompressionInfo compressionInfo, string zipComment)
: base(ArchiveType.Zip)
{
this.ppmdProperties = new PpmdProperties();
this.entries = new List<ZipCentralDirectoryEntry>();
this.zipComment = zipComment ?? string.Empty;
this.zipCompressionInfo = new ZipCompressionInfo(compressionInfo);
base.InitalizeStream(destination, false);
}
public Stream WriteToStream(string entryPath, DateTime? modificationTime, string comment, CompressionInfo compressionInfo)
{
entryPath = this.NormalizeFilename(entryPath);
DateTime? nullable = modificationTime;
modificationTime = new DateTime?(nullable.HasValue ? nullable.GetValueOrDefault() : DateTime.Now);
comment = comment ?? "";
ZipCentralDirectoryEntry entry2 = new ZipCentralDirectoryEntry();
entry2.Comment = comment;
entry2.FileName = entryPath;
entry2.ModificationTime = modificationTime;
entry2.HeaderOffset = (uint) this.streamPosition;
ZipCentralDirectoryEntry entry = entry2;
uint num = (uint) this.WriteHeader(entryPath, modificationTime, compressionInfo);
this.streamPosition += num;
return new ZipWritingStream(this, base.OutputStream, entry);
}
public Stream WriteToStream(string entryPath, DateTime? modificationTime, string comment, CompressionInfo compressionInfo = null)
{
entryPath = NormalizeFilename(entryPath);
modificationTime = modificationTime ?? DateTime.Now;
comment = comment ?? "";
var entry = new ZipCentralDirectoryEntry
{
Comment = comment,
FileName = entryPath,
ModificationTime = modificationTime,
HeaderOffset = (uint) streamPosition,
};
var headersize = (uint)WriteHeader(entryPath, modificationTime, compressionInfo);
streamPosition += headersize;
return new ZipWritingStream(this, OutputStream, entry, compressionInfo);
}
private readonly PpmdProperties ppmdProperties; // Caching properties to speed up PPMd.
#endif
public ZipWriter(Stream destination, CompressionInfo compressionInfo, string zipComment, Encoding encoding = null)
: base(ArchiveType.Zip)
{
this.zipComment = zipComment ?? string.Empty;
this.encoding = encoding ?? ArchiveEncoding.Default;
switch (compressionInfo.Type)
{
case CompressionType.None:
{
compression = ZipCompressionMethod.None;
}
break;
case CompressionType.Deflate:
{
compression = ZipCompressionMethod.Deflate;
deflateCompressionLevel = compressionInfo.DeflateCompressionLevel;
}
break;
case CompressionType.BZip2:
{
compression = ZipCompressionMethod.BZip2;
}
break;
#if LZMA
case CompressionType.LZMA:
{
compression = ZipCompressionMethod.LZMA;
}
break;
#endif
#if PPMd
case CompressionType.PPMd:
{
ppmdProperties = new PpmdProperties();
compression = ZipCompressionMethod.PPMd;
}
break;
#endif
default:
throw new InvalidFormatException("Invalid compression method: " + compressionInfo.Type);
}
InitalizeStream(destination, false);
}
/// <summary>
///
/// </summary>
/// <param name="strBasePath">要压缩文件所在文件夹</param>
/// <param name="strSourceFolderName">生成TAR包存放路径</param>
/// <param name="sTarName">TAR包名</param>
/// <returns></returns>
public bool CreatTar(string strBasePath, string strSourceFolderName, string sTarName)
{
if (!System.IO.Directory.Exists(strSourceFolderName))
{
System.IO.Directory.CreateDirectory(strSourceFolderName);//不存在生成Tar文件目录就创建
}
if (string.IsNullOrEmpty(strBasePath) ||
string.IsNullOrEmpty(strSourceFolderName) ||
!System.IO.Directory.Exists(strBasePath)) //Path.Combine(strBasePath, strSourceFolderName)
{
return(false);
}
string strOupFileAllPath = strSourceFolderName + "\\EBDT_" + sTarName + ".tar";//压缩文件名及路径
Stream outStream = new FileStream(strOupFileAllPath, FileMode.OpenOrCreate);
SharpCompress.Archive.Tar.TarArchive archive = SharpCompress.Archive.Tar.TarArchive.Create();
try
{
DirectoryInfo theFolder = new DirectoryInfo(strBasePath);
FileInfo[] xmlfiles = theFolder.GetFiles("*.xml");
if (xmlfiles.Length > 0)
{
for (int i = 0; i < xmlfiles.Length; i++)
{
archive.AddEntry(xmlfiles[i].Name, xmlfiles[i]);
}
SharpCompress.Common.CompressionInfo infs = new SharpCompress.Common.CompressionInfo();
archive.SaveTo(outStream, infs);
outStream.Close();
archive.Dispose();
}
else
{
return(false);
}
}
catch
{
//outStream.Close();
return(false);
}
return(true);
}
private async void OnlineBackupExecute(string path)
{
await Task.Factory.StartNew(() =>
{
var zipFilePath = string.Empty;
try
{
IsEnable = false;
IsIndeterminate = true;
path = DatabaseBackup();
zipFilePath = path.Replace("bak", "zip");
var info = new CompressionInfo {Type = CompressionType.Deflate};
using (FileStream zip = File.OpenWrite(zipFilePath))
using (IWriter zipwriter = WriterFactory.Open(zip, ArchiveType.Zip, info))
{
zipwriter.Write(Path.GetFileName(path), path);
}
GetDropBoxAccess();
IsIndeterminate = false;
ICloudDirectoryEntry uploadFolder = _dropBoxStorage.GetFolder("/DatabaseTransfar");
_dropBoxStorage.UploadFile(zipFilePath, uploadFolder, UploadProgressChange);
MessageBox.Show("Online Database Backup Successfully", SoftwareName, MessageBoxButton.OK,
MessageBoxImage.Information);
}
catch (Exception)
{
MessageBox.Show("Online Database Backup is canceled", SoftwareName, MessageBoxButton.OK, MessageBoxImage.Exclamation);
ResetData();
}
finally
{
IsIndeterminate = true;
if (_dropBoxStorage.IsOpened)
_dropBoxStorage.Close();
if (File.Exists(path))
File.Delete(path);
if(!String.IsNullOrEmpty(zipFilePath) && File.Exists(zipFilePath))
File.Delete(zipFilePath);
IsEnable = true;
IsIndeterminate = false;
}
});
}
/// <summary>
/// Constructs a new zip instance.
/// If the file exists and has a non-zero length we read it,
/// otherwise we create a new archive.
/// </summary>
/// <param name="filename">The name of the file to read or write</param>
/// <param name="options">The options passed on the commandline</param>
public FileArchiveZip(string filename, Dictionary<string, string> options)
{
if (string.IsNullOrEmpty(filename) && filename.Trim().Length == 0)
throw new ArgumentException("filename");
if (File.Exists(filename) && new FileInfo(filename).Length > 0)
{
m_isWriting = false;
m_filename = filename;
}
else
{
m_compressionInfo = new CompressionInfo();
m_compressionInfo.Type = DEFAULT_COMPRESSION_METHOD;
m_compressionInfo.DeflateCompressionLevel = DEFAULT_COMPRESSION_LEVEL;
string cpmethod;
CompressionType tmptype;
if (options.TryGetValue(COMPRESSION_METHOD_OPTION, out cpmethod) && Enum.TryParse<SharpCompress.Common.CompressionType>(cpmethod, true, out tmptype))
m_compressionInfo.Type = tmptype;
string cplvl;
int tmplvl;
if (options.TryGetValue(COMPRESSION_LEVEL_OPTION, out cplvl) && int.TryParse(cplvl, out tmplvl))
m_compressionInfo.DeflateCompressionLevel = (SharpCompress.Compressor.Deflate.CompressionLevel)Math.Max(Math.Min(9, tmplvl), 0);
else if (options.TryGetValue(COMPRESSION_LEVEL_OPTION_ALIAS, out cplvl) && int.TryParse(cplvl, out tmplvl))
m_compressionInfo.DeflateCompressionLevel = (SharpCompress.Compressor.Deflate.CompressionLevel)Math.Max(Math.Min(9, tmplvl), 0);
m_defaultCompressionLevel = m_compressionInfo.DeflateCompressionLevel;
m_isWriting = true;
m_stream = new System.IO.FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.Read);
m_writer = WriterFactory.Open(m_stream, ArchiveType.Zip, m_compressionInfo);
//Size of endheader, taken from SharpCompress ZipWriter
m_flushBufferSize = 8 + 2 + 2 + 4 + 4 + 2 + 0;
}
}
public static IWriter Open(Stream stream, ArchiveType archiveType, CompressionType compressionType)
{
CompressionInfo compressionInfo = new CompressionInfo();
compressionInfo.Type = compressionType;
return Open(stream, archiveType, compressionInfo);
}
public static void SaveTo(this IWritableArchive writableArchive,
string filePath, CompressionInfo compressionInfo)
{
writableArchive.SaveTo(new FileInfo(filePath), compressionInfo);
}
public static void SaveTo(IWritableArchive writableArchive, Stream stream, CompressionType compressionType)
{
CompressionInfo info = new CompressionInfo();
info.Type = compressionType;
writableArchive.SaveTo(stream, info);
}
private int WriteHeader(string filename, DateTime? modificationTime, CompressionInfo compressionInfo)
{
ZipCompressionInfo info = (compressionInfo != null) ? new ZipCompressionInfo(compressionInfo) : this.zipCompressionInfo;
byte[] bytes = ArchiveEncoding.Default.GetBytes(filename);
base.OutputStream.Write(BitConverter.GetBytes((uint) 0x4034b50), 0, 4);
byte[] buffer = new byte[2];
buffer[0] = 0x3f;
base.OutputStream.Write(buffer, 0, 2);
HeaderFlags flags = (ArchiveEncoding.Default == Encoding.UTF8) ? HeaderFlags.UTF8 : ((HeaderFlags) 0);
if (!base.OutputStream.CanSeek)
{
flags = (HeaderFlags) ((ushort) (flags | HeaderFlags.UsePostDataDescriptor));
if (info.Compression == ZipCompressionMethod.LZMA)
{
flags = (HeaderFlags) ((ushort) (flags | HeaderFlags.Bit1));
}
}
base.OutputStream.Write(BitConverter.GetBytes((ushort) flags), 0, 2);
base.OutputStream.Write(BitConverter.GetBytes((ushort) info.Compression), 0, 2);
base.OutputStream.Write(BitConverter.GetBytes(Utility.DateTimeToDosTime(modificationTime)), 0, 4);
buffer = new byte[12];
base.OutputStream.Write(buffer, 0, 12);
base.OutputStream.Write(BitConverter.GetBytes((ushort) bytes.Length), 0, 2);
base.OutputStream.Write(BitConverter.GetBytes((ushort) 0), 0, 2);
base.OutputStream.Write(bytes, 0, bytes.Length);
return (30 + bytes.Length);
}
private int WriteHeader(string filename, DateTime? modificationTime, CompressionInfo compressionInfo = null)
{
var explicitZipCompressionInfo = compressionInfo != null ? new ZipCompressionInfo(compressionInfo) : this.zipCompressionInfo;
byte[] encodedFilename = ArchiveEncoding.Default.GetBytes(filename);
OutputStream.Write(DataConverter.LittleEndian.GetBytes(ZipHeaderFactory.ENTRY_HEADER_BYTES), 0, 4);
if (explicitZipCompressionInfo.Compression == ZipCompressionMethod.Deflate)
{
OutputStream.Write(new byte[] {20, 0}, 0, 2); //older version which is more compatible
}
else
{
OutputStream.Write(new byte[] {63, 0}, 0, 2); //version says we used PPMd or LZMA
}
HeaderFlags flags = ArchiveEncoding.Default == Encoding.UTF8 ? HeaderFlags.UTF8 : (HeaderFlags)0;
if (!OutputStream.CanSeek)
{
flags |= HeaderFlags.UsePostDataDescriptor;
if (explicitZipCompressionInfo.Compression == ZipCompressionMethod.LZMA)
{
flags |= HeaderFlags.Bit1; // eos marker
}
}
OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort) flags), 0, 2);
OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)explicitZipCompressionInfo.Compression), 0, 2); // zipping method
OutputStream.Write(DataConverter.LittleEndian.GetBytes(modificationTime.DateTimeToDosTime()), 0, 4);
// zipping date and time
OutputStream.Write(new byte[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0, 12);
// unused CRC, un/compressed size, updated later
OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort) encodedFilename.Length), 0, 2); // filename length
OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort) 0), 0, 2); // extra length
OutputStream.Write(encodedFilename, 0, encodedFilename.Length);
return 6 + 2 + 2 + 4 + 12 + 2 + 2 + encodedFilename.Length;
}
internal ZipWritingStream(ZipWriter writer, Stream originalStream, ZipCentralDirectoryEntry entry, CompressionInfo compressionInfo)
{
this.writer = writer;
this.originalStream = originalStream;
this.writer = writer;
this.entry = entry;
this.compressionInfo = compressionInfo == null ? writer.zipCompressionInfo : new ZipCompressionInfo(compressionInfo);
writeStream = GetWriteStream(originalStream);
}
