public Model Load(string fileName)
{
var document = new XmlDocument();
if (fileName.EndsWith(".tcn"))
{
var file = new ZipFile(new FileStream(fileName, FileMode.Open, FileAccess.Read));
var enumerator = file.GetEnumerator();
while (enumerator.MoveNext())
{
if (((ZipEntry)enumerator.Current).Name.EndsWith(".xml"))
{
document.Load(file.GetInputStream((ZipEntry)enumerator.Current));
break;
}
}
}
else if (fileName.EndsWith(".xml"))
document.Load(fileName);
else
throw new FileLoadException();
var tcnModel = new TCNFile();
tcnModel.Parse(document.DocumentElement);
return tcnModel.Convert();
}
/// <summary>
/// Extracts the specified zip file stream.
/// </summary>
/// <param name="fileStream">The zip file stream.</param>
/// <returns></returns>
public void Extract(Stream fileStream)
{
_isValid = true;
ZipFile zipFile = null;
try
{
zipFile = new ZipFile(fileStream);
IEnumerator enumerator = zipFile.GetEnumerator();
while (enumerator.MoveNext())
{
ZipEntry entry = (ZipEntry)enumerator.Current;
ExtractZipEntry(zipFile, entry);
}
}
catch (Exception ex)
{
_isValid = false;
_exceptionMessage = ex.Message;
}
finally
{
fileStream.Close();
if (null != zipFile) zipFile.Close();
}
}
//jordenwu 精简
public int UnityExtractStreamZipInit(Stream inputStream, string targetDirectory)
{
continueRunning_ = true;
overwrite_ = Overwrite.Always;
confirmDelegate_ = null;
extractNameTransform_ = new WindowsNameTransform(targetDirectory);
restoreDateTimeOnExtract_ = false;
createEmptyDirectories_ = true;
//
zipFile_ = new ZipFile(inputStream);
zipFile_.IsStreamOwner = false;
#if !NETCF_1_0
if (password_ != null)
{
zipFile_.Password = password_;
}
#endif
//获取文件总数
System.Collections.IEnumerator enumerator = zipFile_.GetEnumerator();
int fileCnt = 0;
while (enumerator.MoveNext())
{
ZipEntry ze = enumerator.Current as ZipEntry;
if (ze != null)
{
if (ze.IsFile)
{
fileCnt++;
}
}
}
return(fileCnt);
}
/// <summary>
/// Extract the contents of a zip file.
/// </summary>
/// <param name="zipFileName">The zip file to extract from.</param>
/// <param name="targetDirectory">The directory to save extracted information in.</param>
/// <param name="overwrite">The style of <see cref="Overwrite">overwriting</see> to apply.</param>
/// <param name="confirmDelegate">A delegate to invoke when confirming overwriting.</param>
/// <param name="fileFilter">A filter to apply to files.</param>
/// <param name="directoryFilter">A filter to apply to directories.</param>
/// <param name="restoreDateTime">Flag indicating wether to restore the date and time for extracted files.</param>
public void ExtractZip(string zipFileName, string targetDirectory, string fileFilter, string directoryFilter)
{
continueRunning_ = true;
extractNameTransform_ = new WindowsNameTransform(targetDirectory);
fileFilter_ = new NameFilter(fileFilter);
directoryFilter_ = new NameFilter(directoryFilter);
using (zipFile_ = new ZipFile(zipFileName))
{
IEnumerator enumerator = zipFile_.GetEnumerator();
while (continueRunning_ && enumerator.MoveNext())
{
var entry = (ZipEntry)enumerator.Current;
if (entry.IsFile)
{
// TODO Path.GetDirectory can fail here on invalid characters.
if (directoryFilter_.IsMatch(Path.GetDirectoryName(entry.Name)) &&
fileFilter_.IsMatch(entry.Name))
{
ExtractEntry(entry);
}
}
}
}
}
public static bool unzipFile(Stream inputStream, string targetDirectory, bool overwrite, OnUnzipProgress callback)
{
bool ret = false;
callback(0, 0);
using (ZipFile zipFile_ = new ZipFile(inputStream))
{
int totalBytes = (int)zipFile_.unzipSize;
UnzipCach cach = new UnzipCach();
cach.start(totalBytes, callback, overwrite);
INameTransform extractNameTransform_ = new WindowsNameTransform(targetDirectory);
System.Collections.IEnumerator enumerator = zipFile_.GetEnumerator();
while (enumerator.MoveNext())
{
try
{
ZipEntry entry = (ZipEntry)enumerator.Current;
if (entry.IsFile)
{
string fileName = extractNameTransform_.TransformFile(entry.Name);
string dirName = Path.GetDirectoryName(Path.GetFullPath(fileName));
if (!Directory.Exists(dirName))
{
Directory.CreateDirectory(dirName);
}
Stream source = zipFile_.GetInputStream(entry);
cach.addFile(fileName, (int)entry.Size, source);
source.Close();
}
else
{
string dirName = extractNameTransform_.TransformDirectory(entry.Name);
if (!Directory.Exists(dirName))
{
Directory.CreateDirectory(dirName);
}
}
}
catch (Exception e)
{
cach.setState(UnzipCach.State.Error);
//LogManager.GetInstance().LogException(e.Message, e, LogManager.ModuleFilter.RES);
}
if (cach.isError())
{
break;
}
}
cach.setState(UnzipCach.State.Ok);
ret = cach.stop();
callback(1, ret?0:1);
return(ret);
}
}
/// <summary>
/// Extract the contents of a zip file held in a stream.
/// </summary>
/// <param name="inputStream">The seekable input stream containing the zip to extract from.</param>
/// <param name="targetDirectory">The directory to save extracted information in.</param>
/// <param name="overwrite">The style of <see cref="Overwrite">overwriting</see> to apply.</param>
/// <param name="confirmDelegate">A delegate to invoke when confirming overwriting.</param>
/// <param name="fileFilter">A filter to apply to files.</param>
/// <param name="directoryFilter">A filter to apply to directories.</param>
/// <param name="restoreDateTime">Flag indicating whether to restore the date and time for extracted files.</param>
/// <param name="isStreamOwner">Flag indicating whether the inputStream will be closed by this method.</param>
public void ExtractZip(Stream inputStream, string targetDirectory,
Overwrite overwrite, ConfirmOverwriteDelegate confirmDelegate,
string fileFilter, string directoryFilter, bool restoreDateTime,
bool isStreamOwner)
{
if ((overwrite == Overwrite.Prompt) && (confirmDelegate == null))
{
throw new ArgumentNullException("confirmDelegate");
}
continueRunning_ = true;
overwrite_ = overwrite;
confirmDelegate_ = confirmDelegate;
extractNameTransform_ = new WindowsNameTransform(targetDirectory);
fileFilter_ = new NameFilter(fileFilter);
directoryFilter_ = new NameFilter(directoryFilter);
restoreDateTimeOnExtract_ = restoreDateTime;
using (zipFile_ = new ZipFile(inputStream))
{
#if !NETCF_1_0
if (password_ != null)
{
zipFile_.Password = password_;
}
#endif
zipFile_.IsStreamOwner = isStreamOwner;
IEnumerator enumerator = zipFile_.GetEnumerator();
while (continueRunning_ && enumerator.MoveNext())
{
var entry = (ZipEntry)enumerator.Current;
if (entry.IsFile)
{
// TODO Path.GetDirectory can fail here on invalid characters.
if (directoryFilter_.IsMatch(Path.GetDirectoryName(entry.Name)) &&
fileFilter_.IsMatch(entry.Name))
{
ExtractEntry(entry);
}
}
else if (entry.IsDirectory)
{
if (directoryFilter_.IsMatch(entry.Name) && CreateEmptyDirectories)
{
ExtractEntry(entry);
}
}
else
{
// Do nothing for volume labels etc...
}
}
}
}
void ExtractZipThread()
{
continueRunning_ = true;
overwrite_ = Overwrite.Always;
confirmDelegate_ = null;
extractNameTransform_ = new WindowsNameTransform(mTmpDirectory);
fileFilter_ = new NameFilter(null);
directoryFilter_ = new NameFilter(null);
restoreDateTimeOnExtract_ = false;
using (zipFile_ = new ZipFile(mInputStream)) {
#if !NETCF_1_0
if (password_ != null)
{
zipFile_.Password = password_;
}
#endif
mUnzipSize = (int)zipFile_.unzipSize;
zipFile_.IsStreamOwner = true;
WaitForEndOfFrame w = new WaitForEndOfFrame();
System.Collections.IEnumerator enumerator = zipFile_.GetEnumerator();
while (continueRunning_ && enumerator.MoveNext())
{
ZipEntry entry = (ZipEntry)enumerator.Current;
if (entry.IsFile)
{
// TODO Path.GetDirectory can fail here on invalid characters.
if (directoryFilter_.IsMatch(Path.GetDirectoryName(entry.Name)) && fileFilter_.IsMatch(entry.Name))
{
ExtractEntry(entry);
}
}
else if (entry.IsDirectory)
{
if (directoryFilter_.IsMatch(entry.Name) && CreateEmptyDirectories)
{
ExtractEntry(entry);
}
}
else
{
// Do nothing for volume labels etc...
}
}
mInputStream.Close();
if (mUnzipSize == mUnzipBytes)
{
Directory.Move(mTmpDirectory, mOutDirectory);
mCallback(1f, 0);
}
}
}
public static Map contents(ZipFile zipFile)
{
Map c = new Map(Sys.UriType, Sys.FileType);
IEnumerator e = zipFile.GetEnumerator();
while (e.MoveNext())
{
ZipEntry entry = (ZipEntry)e.Current;
ZipEntryFile f = new ZipEntryFile(zipFile, entry);
c.set(f.m_uri, f);
}
return c;
}
/// <summary>
/// Extract the contents of a zip file.
/// </summary>
/// <param name="zipFileName">The zip file to extract from.</param>
/// <param name="targetDirectory">The directory to save extracted information in.</param>
/// <param name="overwrite">The style of <see cref="Overwrite">overwriting</see> to apply.</param>
/// <param name="confirmDelegate">A delegate to invoke when confirming overwriting.</param>
/// <param name="fileFilter">A filter to apply to files.</param>
/// <param name="directoryFilter">A filter to apply to directories.</param>
/// <param name="restoreDateTime">Flag indicating wether to restore the date and time for extracted files.</param>
public void ExtractZip(string zipFileName, string targetDirectory,
Overwrite overwrite, ConfirmOverwriteDelegate confirmDelegate,
string fileFilter, string directoryFilter, bool restoreDateTime)
{
if ((overwrite == Overwrite.Prompt) && (confirmDelegate == null))
{
throw new ArgumentNullException("confirmDelegate");
}
continueRunning_ = true;
overwrite_ = overwrite;
confirmDelegate_ = confirmDelegate;
targetDirectory_ = targetDirectory;
fileFilter_ = new NameFilter(fileFilter);
directoryFilter_ = new NameFilter(directoryFilter);
restoreDateTimeOnExtract_ = restoreDateTime;
using (zipFile_ = new ZipFile(zipFileName)) {
#if !NETCF_1_0
if (password_ != null)
{
zipFile_.Password = password_;
}
#endif
System.Collections.IEnumerator enumerator = zipFile_.GetEnumerator();
while (continueRunning_ && enumerator.MoveNext())
{
ZipEntry entry = (ZipEntry)enumerator.Current;
if (entry.IsFile)
{
if (directoryFilter_.IsMatch(Path.GetDirectoryName(entry.Name)) && fileFilter_.IsMatch(entry.Name))
{
ExtractEntry(entry);
}
}
else if (entry.IsDirectory)
{
if (directoryFilter_.IsMatch(entry.Name) && CreateEmptyDirectories)
{
ExtractEntry(entry);
}
}
else
{
// Do nothing for volume labels etc...
}
}
}
}
/// <summary>
/// Extract ZIP to memory
/// </summary>
/// <param name="inputStream"></param>
public List<ZipEntry> ExtractZip(Stream inputStream)
{
using (ZipFile zip_file = new ZipFile(inputStream)) {
System.Collections.IEnumerator enumerator = zip_file.GetEnumerator();
while ( enumerator.MoveNext()) {
ZipEntry entry = (ZipEntry)enumerator.Current;
if (entry.IsFile)
{
ExtractEntry(entry);
// ZipOutputStream zos = ((ZipFile)entry).GetOutputStream( entry );
}
else if (entry.IsDirectory) {
ExtractEntry(entry);
}
}
}
}
/// <summary>
/// Extract the contents of a zip file held in a stream.
/// </summary>
/// <param name="inputStream">The seekable input stream containing the zip to extract from.</param>
/// <param name="targetDirectory">The directory to save extracted information in.</param>
/// <param name="overwrite">The style of <see cref="Overwrite">overwriting</see> to apply.</param>
/// <param name="confirmDelegate">A delegate to invoke when confirming overwriting.</param>
/// <param name="fileFilter">A filter to apply to files.</param>
/// <param name="directoryFilter">A filter to apply to directories.</param>
/// <param name="restoreDateTime">Flag indicating whether to restore the date and time for extracted files.</param>
/// <param name="isStreamOwner">Flag indicating whether the inputStream will be closed by this method.</param>
public void ExtractZip(Stream inputStream, string targetDirectory,
Overwrite overwrite, ConfirmOverwriteDelegate confirmDelegate,
string fileFilter, string directoryFilter, bool restoreDateTime,
bool isStreamOwner)
{
if ((overwrite == Overwrite.Prompt) && (confirmDelegate == null))
{
throw new ArgumentNullException("confirmDelegate");
}
continueRunning_ = true;
overwrite_ = overwrite;
confirmDelegate_ = confirmDelegate;
extractNameTransform_ = new WindowsNameTransform(targetDirectory);
fileFilter_ = new NameFilter(fileFilter);
directoryFilter_ = new NameFilter(directoryFilter);
restoreDateTimeOnExtract_ = restoreDateTime;
using (zipFile_ = new ZipFile(inputStream))
{
#if !NETCF_1_0
if (password_ != null)
{
zipFile_.Password = password_;
}
#endif
zipFile_.IsStreamOwner = isStreamOwner;
extractEnum_ = zipFile_.GetEnumerator();
totalCount_ = 0;
while (continueRunning_ && extractEnum_.MoveNext())
{
ZipEntry entry = (ZipEntry)extractEnum_.Current;
totalCount_ += entry.Size;
}
extractEnum_.Reset();
doneCount_ = 0;
ExtractUpdate();
}
}
public void ExtractZip(Stream inputStream, string targetDirectory, Overwrite overwrite, ConfirmOverwriteDelegate confirmDelegate, string fileFilter, string directoryFilter, bool restoreDateTime, bool isStreamOwner)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
if (overwrite == Overwrite.Prompt && confirmDelegate == null)
{
throw new ArgumentNullException("confirmDelegate");
}
continueRunning_ = true;
overwrite_ = overwrite;
confirmDelegate_ = confirmDelegate;
extractNameTransform_ = new WindowsNameTransform(targetDirectory);
fileFilter_ = new NameFilter(fileFilter);
directoryFilter_ = new NameFilter(directoryFilter);
restoreDateTimeOnExtract_ = restoreDateTime;
using (zipFile_ = new ZipFile(inputStream))
{
if (password_ != null)
{
zipFile_.Password = password_;
}
zipFile_.IsStreamOwner = isStreamOwner;
global::System.Collections.IEnumerator enumerator = zipFile_.GetEnumerator();
while (continueRunning_ && enumerator.MoveNext())
{
ZipEntry zipEntry = (ZipEntry)enumerator.get_Current();
if (zipEntry.IsFile)
{
if (directoryFilter_.IsMatch(Path.GetDirectoryName(zipEntry.Name)) && fileFilter_.IsMatch(zipEntry.Name))
{
ExtractEntry(zipEntry);
}
}
else if (zipEntry.IsDirectory && directoryFilter_.IsMatch(zipEntry.Name) && CreateEmptyDirectories)
{
ExtractEntry(zipEntry);
}
}
}
}
public bool BeginExtractZipSelf(string orgPath, string tarPath, string filefilter)
{
bool res = true;
try
{
Stream inputStream = File.Open(orgPath, FileMode.Open, FileAccess.Read, FileShare.Read);
continueRunning_ = true;
overwrite_ = Overwrite.Always;
confirmDelegate_ = null;
extractNameTransform_ = new WindowsNameTransform(tarPath);
fileFilter_ = new NameFilter(filefilter);
directoryFilter_ = new NameFilter(null);
//restoreDateTimeOnExtract_ = restoreDateTimeOnExtract_;
zipFile_ = new ZipFile(inputStream);
{
#if !NETCF_1_0
if (password_ != null)
{
zipFile_.Password = password_;
}
#endif
zipFile_.IsStreamOwner = true;
enumerator_ = zipFile_.GetEnumerator();
}
}
catch
{
res = false;
}
return(res);
}
/// <summary>
/// Extract the contents of a zip file.
/// </summary>
/// <param name="zipFileName">The zip file to extract from.</param>
/// <param name="targetDirectory">The directory to save extracted information in.</param>
/// <param name="overwrite">The style of <see cref="Overwrite">overwriting</see> to apply.</param>
/// <param name="confirmDelegate">A delegate to invoke when confirming overwriting.</param>
/// <param name="fileFilter">A filter to apply to files.</param>
/// <param name="directoryFilter">A filter to apply to directories.</param>
/// <param name="restoreDateTime">Flag indicating wether to restore the date and time for extracted files.</param>
public void ExtractZip(string zipFileName, string targetDirectory,
Overwrite overwrite, ConfirmOverwriteDelegate confirmDelegate,
string fileFilter, string directoryFilter, bool restoreDateTime)
{
if ( (overwrite == Overwrite.Prompt) && (confirmDelegate == null) ) {
throw new ArgumentNullException("confirmDelegate");
}
continueRunning_ = true;
overwrite_ = overwrite;
confirmDelegate_ = confirmDelegate;
targetDirectory_ = targetDirectory;
fileFilter_ = new NameFilter(fileFilter);
directoryFilter_ = new NameFilter(directoryFilter);
restoreDateTimeOnExtract_ = restoreDateTime;
using ( zipFile_ = new ZipFile(zipFileName) ) {
#if !NETCF_1_0
if (password_ != null) {
zipFile_.Password = password_;
}
#endif
System.Collections.IEnumerator enumerator = zipFile_.GetEnumerator();
while ( continueRunning_ && enumerator.MoveNext()) {
ZipEntry entry = (ZipEntry) enumerator.Current;
if ( entry.IsFile )
{
if ( directoryFilter_.IsMatch(Path.GetDirectoryName(entry.Name)) && fileFilter_.IsMatch(entry.Name) ) {
ExtractEntry(entry);
}
}
else if ( entry.IsDirectory ) {
if ( directoryFilter_.IsMatch(entry.Name) && CreateEmptyDirectories ) {
ExtractEntry(entry);
}
}
else {
// Do nothing for volume labels etc...
}
}
}
}
/// <summary>
/// Extract the contents of a zip file held in a stream.
/// </summary>
/// <param name="inputStream">The seekable input stream containing the zip to extract from.</param>
/// <param name="targetDirectory">The directory to save extracted information in.</param>
/// <param name="overwrite">The style of <see cref="Overwrite">overwriting</see> to apply.</param>
/// <param name="confirmDelegate">A delegate to invoke when confirming overwriting.</param>
/// <param name="fileFilter">A filter to apply to files.</param>
/// <param name="directoryFilter">A filter to apply to directories.</param>
/// <param name="restoreDateTime">Flag indicating whether to restore the date and time for extracted files.</param>
/// <param name="isStreamOwner">Flag indicating whether the inputStream will be closed by this method.</param>
public void ExtractZip(Stream inputStream, string targetDirectory,
Overwrite overwrite, ConfirmOverwriteDelegate confirmDelegate,
string fileFilter, string directoryFilter, bool restoreDateTime,
bool isStreamOwner)
{
if ((overwrite == Overwrite.Prompt) && (confirmDelegate == null)) {
throw new ArgumentNullException("confirmDelegate");
}
continueRunning_ = true;
overwrite_ = overwrite;
confirmDelegate_ = confirmDelegate;
extractNameTransform_ = new WindowsNameTransform(targetDirectory);
fileFilter_ = new NameFilter(fileFilter);
directoryFilter_ = new NameFilter(directoryFilter);
restoreDateTimeOnExtract_ = restoreDateTime;
using (zipFile_ = new ZipFile(inputStream)) {
#if !NETCF_1_0
if (password_ != null) {
zipFile_.Password = password_;
}
#endif
zipFile_.IsStreamOwner = isStreamOwner;
IEnumerator enumerator = zipFile_.GetEnumerator();
while (continueRunning_ && enumerator.MoveNext()) {
ZipEntry entry = (ZipEntry)enumerator.Current;
if (entry.IsFile)
{
// TODO Path.GetDirectory can fail here on invalid characters.
if (directoryFilter_.IsMatch(Path.GetDirectoryName(entry.Name)) && fileFilter_.IsMatch(entry.Name)) {
ExtractEntry(entry);
}
}
else if (entry.IsDirectory) {
if (directoryFilter_.IsMatch(entry.Name) && CreateEmptyDirectories) {
ExtractEntry(entry);
}
}
else {
// Do nothing for volume labels etc...
}
}
}
}
public static long GetUnzipFileSize(string strZipFile)
{
long lngUnzipFileSize = 0;
try
{
ZipFile zf = new ZipFile(strZipFile);
System.Collections.IEnumerator ie = zf.GetEnumerator();
while (ie.MoveNext())
{
ZipEntry ze = (ZipEntry)ie.Current;
lngUnzipFileSize += ze.Size;
}
zf.Close();
return lngUnzipFileSize;
}
catch (Exception ex)
{
//LogClass.WriteLog("GetUnzipFileSize Exception: " + ex.Message);
lngUnzipFileSize = 0;
return lngUnzipFileSize;
}
}
/// <summary>
/// Extract the contents of a zip file.
/// </summary>
/// <param name="zipFileName">The zip file to extract from.</param>
/// <param name="targetDirectory">The directory to save extracted information in.</param>
/// <param name="overwrite">The style of <see cref="Overwrite">overwriting</see> to apply.</param>
/// <param name="confirmDelegate">A delegate to invoke when confirming overwriting.</param>
/// <param name="fileFilter">A filter to apply to files.</param>
/// <param name="directoryFilter">A filter to apply to directories.</param>
/// <param name="restoreDateTime">Flag indicating wether to restore the date and time for extracted files.</param>
public void ExtractZip(string zipFileName, string targetDirectory, string fileFilter, string directoryFilter)
{
continueRunning_ = true;
extractNameTransform_ = new WindowsNameTransform(targetDirectory);
fileFilter_ = new NameFilter(fileFilter);
directoryFilter_ = new NameFilter(directoryFilter);
using (zipFile_ = new ZipFile(zipFileName))
{
IEnumerator enumerator = zipFile_.GetEnumerator();
while (continueRunning_ && enumerator.MoveNext())
{
var entry = (ZipEntry) enumerator.Current;
if (entry.IsFile)
{
// TODO Path.GetDirectory can fail here on invalid characters.
if (directoryFilter_.IsMatch(Path.GetDirectoryName(entry.Name)) &&
fileFilter_.IsMatch(entry.Name))
{
ExtractEntry(entry);
}
}
}
}
}
/// <summary>
/// Extracts the specified zip file stream.
/// </summary>
/// <param name="fileStream">The zip file stream.</param>
/// <returns></returns>
public bool Extract(Stream fileStream)
{
if (null == fileStream) return false;
CleanFromTemp(false);
NewTempPath();
_isValid = true;
ZipFile zipFile = null;
try
{
zipFile = new ZipFile(fileStream);
IEnumerator enumerator = zipFile.GetEnumerator();
while (enumerator.MoveNext())
{
ZipEntry entry = (ZipEntry)enumerator.Current;
ExtractZipEntry(zipFile, entry);
}
}
catch (Exception ex)
{
_isValid = false;
_exceptionMessage = ex.Message;
CleanFromTemp(true); //true tells CleanFromTemp not to raise an IO Exception if this operation fails. If it did then the real error here would be masked
}
finally
{
fileStream.Close();
if (null != zipFile) zipFile.Close();
}
return _isValid ? CheckFolderTree() : false;
}
static void unzipFileThread()
{
//LogManager.GetInstance().LogMessage("unzip begin outpath="+_targetDirectory, LogManager.ModuleFilter.RES);
_callback(0, 0);
bool ret = false;
using (ZipFile zipFile_ = new ZipFile(_inputStream))
{
int totalBytes = (int)zipFile_.unzipSize;
UnzipCach cach = new UnzipCach();
cach.start(totalBytes, _callback);
INameTransform extractNameTransform_ = new WindowsNameTransform(_tmpDirectory);
System.Collections.IEnumerator enumerator = zipFile_.GetEnumerator();
while (enumerator.MoveNext())
{
try
{
ZipEntry entry = (ZipEntry)enumerator.Current;
if (entry.IsFile)
{
string fileName = extractNameTransform_.TransformFile(entry.Name);
string dirName = Path.GetDirectoryName(Path.GetFullPath(fileName));
if (!Directory.Exists(dirName))
{
Directory.CreateDirectory(dirName);
}
Stream source = zipFile_.GetInputStream(entry);
cach.addFile(fileName, (int)entry.Size, source);
source.Close();
}
else
{
string dirName = extractNameTransform_.TransformDirectory(entry.Name);
if (!Directory.Exists(dirName))
{
Directory.CreateDirectory(dirName);
}
}
}
catch (Exception e)
{
cach.setState(UnzipCach.State.Error);
//LogManager.GetInstance().LogException(e.Message, e, LogManager.ModuleFilter.RES);
}
if (cach.isError())
{
break;
}
}
cach.setState(UnzipCach.State.Ok);
if (cach.stop())
{
try
{
Directory.Move(_tmpDirectory, _targetDirectory);
ret = true;
}
catch (Exception e)
{
//LogManager.GetInstance().LogException("unzip rename dir error.", e);
}
}
_callback(1, ret?0:1);
//LogManager.GetInstance().LogMessage("unzip end", LogManager.ModuleFilter.RES);
_inputStream = null;
_callback = null;
}
}
public static List<DEngine> Load(string fileName, UndoRedoArea undoRedoArea, out DPoint pageSize, out BackgroundFigure bf, string[] extraEntryDirs, out Dictionary<string, byte[]> extraEntries)
{
System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
pageSize = null;
bf = null;
extraEntries = null;
List<DEngine> res = new List<DEngine>();
// load zipfile
using (ZipFile zf = new ZipFile(fileName))
{
// find pages ini file entry
byte[] data = Read(zf, PAGES_INI);
if (data != null)
{
// read general background figure
byte[] genBkgndFigureData = Read(zf, GENBKGNDFIGURE);
if (genBkgndFigureData != null)
{
List<Figure> figs = FigureSerialize.FromXml(encoding.GetString(genBkgndFigureData));
if (figs.Count == 1 && figs[0] is BackgroundFigure)
{
LoadImage(zf, figs[0]);
bf = (BackgroundFigure)figs[0];
// read page size from background figure
if (bf.Width > 0 && bf.Height > 0)
pageSize = new DPoint(bf.Width, bf.Height);
}
}
// create Nini config source from pages ini entry stream
IniConfigSource source = new IniConfigSource(new MemoryStream(data));
// load each page info mentioned in ini entry
foreach (IConfig config in source.Configs)
{
// create new DEngine for page
DEngine de = new DEngine(undoRedoArea);
// set page size
if (config.Contains(PAGESIZE))
de.PageSize = DPoint.FromString(config.Get(PAGESIZE));
if (config.Contains(PAGENAME))
de.PageName = config.Get(PAGENAME);
// set the figures
if (config.Contains(FIGURELIST))
{
string figureListEntryName = config.Get(FIGURELIST);
data = Read(zf, figureListEntryName);
if (data != null)
{
List<Figure> figs = FigureSerialize.FromXml(encoding.GetString(data));
foreach (Figure f in figs)
{
de.AddFigure(f);
LoadImage(zf, f);
}
}
}
// set the background figure
if (config.Contains(BACKGROUNDFIGURE))
{
string backgroundFigureEntryName = config.Get(BACKGROUNDFIGURE);
data = Read(zf, backgroundFigureEntryName);
if (data != null)
{
List<Figure> figs = FigureSerialize.FromXml(encoding.GetString(data));
if (figs.Count == 1 && figs[0] is BackgroundFigure)
{
LoadImage(zf, figs[0]);
de.SetBackgroundFigure((BackgroundFigure)figs[0], true);
}
}
}
else if (bf != null)
de.SetBackgroundFigure(bf, false);
// add to list of DEngines
res.Add(de);
}
// read extra entries
if (extraEntryDirs != null)
{
extraEntries = new Dictionary<string, byte[]>();
foreach (string dir in extraEntryDirs)
{
IEnumerator en = zf.GetEnumerator();
en.Reset();
while (en.MoveNext())
{
ZipEntry entry = (ZipEntry)en.Current;
if (entry.Name.IndexOf(dir) == 0)
extraEntries.Add(entry.Name, Read(zf, entry.Name));
}
}
}
}
}
return res;
}
/// <summary>
/// Extract the contents of a zip file.
/// </summary>
/// <param name="zipFileName">The zip file to extract from.</param>
/// <param name="targetDirectory">The directory to save extracted information in.</param>
/// <param name="overwrite">The style of <see cref="Overwrite">overwriting</see> to apply.</param>
/// <param name="confirmDelegate">A delegate to invoke when confirming overwriting.</param>
/// <param name="fileFilter">A method-filter to apply to files.</param>
/// <param name="directoryFilter">A method-filter to apply to directories.</param>
public void ExtractZip(
string zipFileName,
string targetDirectory,
Overwrite overwrite,
ConfirmOverwriteDelegate confirmDelegate,
Func<string, bool> fileFilter,
Func<string, bool> directoryFilter)
{
if ((overwrite == Overwrite.Prompt) && (confirmDelegate == null))
{
throw new ArgumentNullException("confirmDelegate");
}
continueRunning_ = true;
overwrite_ = overwrite;
confirmDelegate_ = confirmDelegate;
extractNameTransform_ = new WindowsNameTransform(targetDirectory);
restoreDateTimeOnExtract_ = true;
Stream inputStream = File.Open(zipFileName, FileMode.Open, FileAccess.Read, FileShare.Read);
using (zipFile_ = new ZipFile(inputStream))
{
#if !NETCF_1_0
if (password_ != null)
{
zipFile_.Password = password_;
}
#endif
zipFile_.IsStreamOwner = true;
System.Collections.IEnumerator enumerator = zipFile_.GetEnumerator();
while (continueRunning_ && enumerator.MoveNext())
{
ZipEntry entry = (ZipEntry)enumerator.Current;
if (entry.IsFile)
{
// TODO Path.GetDirectory can fail here on invalid characters.
if (directoryFilter(Path.GetDirectoryName(entry.Name)) && fileFilter(entry.Name))
{
ExtractEntry(entry);
}
}
else if (entry.IsDirectory)
{
if (directoryFilter(entry.Name) && CreateEmptyDirectories)
{
ExtractEntry(entry);
}
}
}
}
}
/// <summary>
/// Extracts the specified zip file stream.
/// </summary>
/// <param name="fileStream">The zip file stream.</param>
/// <returns></returns>
public bool Extract(Stream fileStream)
{
if (null == fileStream) return false;
CleanFromTemp();
NewTempPath();
_isValid = true;
ZipFile zipFile = null;
try
{
zipFile = new ZipFile(fileStream);
IEnumerator enumerator = zipFile.GetEnumerator();
while (enumerator.MoveNext())
{
ZipEntry entry = (ZipEntry)enumerator.Current;
ExtractZipEntry(zipFile, entry);
}
}
catch (Exception ex)
{
_isValid = false;
_exceptionMessage = ex.Message;
CleanFromTemp();
}
finally
{
fileStream.Close();
if (null != zipFile) zipFile.Close();
}
return _isValid ? CheckFolderTree() : false;
}
/// <summary>
/// Extracts the specified zip file stream.
/// </summary>
/// <param name="fileStream">The zip file stream.</param>
/// <returns></returns>
public bool Extract(Stream fileStream)
{
if (null == fileStream) return false;
CleanFromTemp();
NewTempPath();
_isValid = true;
ZipFile zipFile = null;
try
{
zipFile = new ZipFile(fileStream);
IEnumerator enumerator = zipFile.GetEnumerator();
//System.Diagnostics.Debug.WriteLine(string.Format("Enumerating {0} zipfiles", zipFile.Count.ToString()));
while (enumerator.MoveNext())
{
ZipEntry entry = (ZipEntry)enumerator.Current;
// System.Diagnostics.Debug.WriteLine(entry.ZipFileIndex.ToString() + " " + entry.Name);
ExtractZipEntry(zipFile, entry);
}
}
catch (Exception ex)
{
_isValid = false;
_exceptionMessage = ex.Message;
CleanFromTemp();
}
finally
{
fileStream.Close();
if (null != zipFile) zipFile.Close();
}
return _isValid ? CheckFolderTree() : false;
}
public ExcelDocument(string filename)
{
if (!filename.Contains("\\"))
{
filename = FileService.GetPath() + "\\" + filename;
}
WorkSheets = new ObservableCollection <WorkSheet>();
try
{
using (zip.ZipFile zf = new zip.ZipFile(filename))
{
IEnumerator ienum = zf.GetEnumerator();
int ifld = zf.FindEntry("xl/workbook.xml", true);
StreamReader srwb = new StreamReader(zf.GetInputStream(ifld));
XmlDocument xd = new XmlDocument();
xd.LoadXml(srwb.ReadToEnd());
foreach (XmlNode xn in xd.DocumentElement.GetElementsByTagName("sheet"))
{
string sheetId = xn.Attributes["sheetId"].Value;
string name = xn.Attributes["name"].Value;
int intsh = zf.FindEntry("xl/worksheets/sheet" + sheetId + ".xml", true);
if (intsh != -1)
{
StreamReader sr = new StreamReader(zf.GetInputStream(intsh));
WorkSheet ws = new WorkSheet()
{
SheetName = name, SheetXml = sr.ReadToEnd()
};
XmlDocument xdr = new XmlDocument();
xdr.LoadXml(ws.SheetXml);
string decsep = (1.5).ToString();
string repdecsep = decsep.Contains(",") ? "," : decsep.Contains(".") ? "." : "";
decsep = decsep.Contains(",") ? "." : decsep.Contains(".") ? "," : "";
foreach (XmlNode xnr in xdr.DocumentElement.GetElementsByTagName("row"))
{
try
{
ExcelRow row = new ExcelRow();
row.Row = int.Parse(xnr.Attributes["r"].Value.ToString());
row.Span = xnr.Attributes["spans"].Value;
foreach (XmlNode xnc in xnr.ChildNodes)
{
try
{
ExcelCell cell = new ExcelCell();
cell.Coord = xnc.Attributes["r"].Value;
cell.Formula = xnc.ChildNodes.Count > 0 && xnc.FirstChild != null && xnc.FirstChild.Name.Equals("f") ? xnc.FirstChild.InnerText : "";
cell.Value = xnc.ChildNodes.Count == 1 && xnc.FirstChild != null && xnc.FirstChild.Name.Equals("v") && !string.IsNullOrEmpty(xnc.FirstChild.InnerText) ? xnc.FirstChild.InnerText :
xnc.ChildNodes.Count > 1 && xnc.LastChild != null && xnc.LastChild.Name.Equals("v") && !string.IsNullOrEmpty(xnc.LastChild.InnerText) ? xnc.LastChild.InnerText : "0";
row.Cells.Add(cell);
row.setA2Z(cell.Coord);
}
catch (Exception ex) { string ss = ex.Message; }
}
ws.Rows.Add(row);
}
catch (Exception ex) { string ss = ex.Message; }
}
WorkSheets.Add(ws);
}
}
}
}
catch (Exception ex) { string ss = ex.Message; }
}
public ZipEntryWrapperEnumerator(ZipFile file)
{
enumerator = file.GetEnumerator();
}
