C# FastZip.ExtractZip方法代码示例

        private static bool ExtractZipArchive(string archive, string destination, FastZip fz)
        {

            DirectoryInfo newdirFI;

            if (!Directory.Exists(destination))
            {
                newdirFI = Directory.CreateDirectory(destination);

                if (!Directory.Exists(newdirFI.FullName))
                {
                    //MessageBox.Show("Directory " + destination + " could not be created.");
                    return false;
                }
            }
            else newdirFI = new DirectoryInfo(destination);


            try
            {
                Thread.Sleep(500);
                fz.ExtractZip(archive, newdirFI.FullName, "");
            }
            catch (Exception e)
            {
                Debugger.LogMessageToFile("The archive " + archive + " could not be extracted to destination " + destination +
                                          ". The following error ocurred: " + e);
            }



            return true;
        }

        public ReleasePackage CreateDeltaPackage(ReleasePackage basePackage, ReleasePackage newPackage, string outputFile)
        {
            Contract.Requires(basePackage != null);
            Contract.Requires(!String.IsNullOrEmpty(outputFile) && !File.Exists(outputFile));

            if (basePackage.Version > newPackage.Version) {
                var message = String.Format(
                    "You cannot create a delta package based on version {0} as it is a later version than {1}",
                    basePackage.Version,
                    newPackage.Version);
                throw new InvalidOperationException(message);
            }

            if (basePackage.ReleasePackageFile == null) {
                throw new ArgumentException("The base package's release file is null", "basePackage");
            }

            if (!File.Exists(basePackage.ReleasePackageFile)) {
                throw new FileNotFoundException("The base package release does not exist", basePackage.ReleasePackageFile);
            }

            if (!File.Exists(newPackage.ReleasePackageFile)) {
                throw new FileNotFoundException("The new package release does not exist", newPackage.ReleasePackageFile);
            }

            string baseTempPath = null;
            string tempPath = null;

            using (Utility.WithTempDirectory(out baseTempPath, null))
            using (Utility.WithTempDirectory(out tempPath, null)) {
                var baseTempInfo = new DirectoryInfo(baseTempPath);
                var tempInfo = new DirectoryInfo(tempPath);

                this.Log().Info("Extracting {0} and {1} into {2}", 
                    basePackage.ReleasePackageFile, newPackage.ReleasePackageFile, tempPath);

                var fz = new FastZip();
                fz.ExtractZip(basePackage.ReleasePackageFile, baseTempInfo.FullName, null);
                fz.ExtractZip(newPackage.ReleasePackageFile, tempInfo.FullName, null);

                // Collect a list of relative paths under 'lib' and map them
                // to their full name. We'll use this later to determine in
                // the new version of the package whether the file exists or
                // not.
                var baseLibFiles = baseTempInfo.GetAllFilesRecursively()
                    .Where(x => x.FullName.ToLowerInvariant().Contains("lib" + Path.DirectorySeparatorChar))
                    .ToDictionary(k => k.FullName.Replace(baseTempInfo.FullName, ""), v => v.FullName);

                var newLibDir = tempInfo.GetDirectories().First(x => x.Name.ToLowerInvariant() == "lib");

                foreach (var libFile in newLibDir.GetAllFilesRecursively()) {
                    createDeltaForSingleFile(libFile, tempInfo, baseLibFiles);
                }

                ReleasePackage.addDeltaFilesToContentTypes(tempInfo.FullName);
                fz.CreateZip(outputFile, tempInfo.FullName, true, null);
            }

            return new ReleasePackage(outputFile);
        }

        private static void Main(string[] args)
        {
            if (args.Length != 3)
            {
                Console.Error.WriteLine("Error: not enough arguments");
                Console.Error.WriteLine("Usage: MetroIdeUpdateManager <update zip> <metroide exe> <parent pid>");
                return;
            }
            string zipPath = args[0];
            string exePath = args[1];
            int pid = Convert.ToInt32(args[2]);

            try
            {
                // Wait for Assembly to close
                try
                {
                    Process process = Process.GetProcessById(pid);
                    process.WaitForExit();
                    process.Close();
                }
                catch
                {
                }

                // Extract the update zip
                var fz = new FastZip {CreateEmptyDirectories = true};
                for (int i = 0; i < 5; i++)
                {
                    try
                    {
                        fz.ExtractZip(zipPath, Directory.GetCurrentDirectory(), null);
                        break;
                    }
                    catch (IOException)
                    {
                        Thread.Sleep(1000);
                        if (i == 4)
                        {
                            throw;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString(), "Assembly Update Manager", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }

            try
            {
                File.Delete(zipPath);
            }
            catch
            {
            }

            // Launch "The New iPa... Assembly"
            Process.Start("Assembly://post-update");
        }

 private void GetFile()
 {
     var exctractfolder = _localFile.DirectoryName.ToString() + @"\exctract\";
     DownloadFile(_localFile.FullName);
     var zip = new FastZip();
     zip.ExtractZip(_localFile.FullName, exctractfolder, "");
 }

 private void UnzipNewAgentVersion()
 {
     _logger.Log("Unzipping files");
     var fz = new FastZip();
     fz.ExtractZip(Constants.AgentServiceReleasePackage, Constants.AgentServiceUnzipPath, "");
     _logger.Log("Unzipping files complete");
 }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="filename"></param>
        /// <returns>temporary project file name.</returns>
        public string UnzipProject(string filename)
        {
            output = null;
            // Check File
            if (!File.Exists(filename))
                throw new EcellException(string.Format(MessageResources.ErrLoadPrj, filename));

            // Extract zip
            string dir = Path.Combine(Util.GetTmpDir(), Path.GetRandomFileName());
            FastZip fz = new FastZip();
            fz.ExtractZip(filename, dir, null);

            // Check Project File.
            string project = Path.Combine(dir,Constants.fileProjectXML);
            string info = Path.Combine(dir,Constants.fileProjectInfo);
            if(File.Exists(project))
                output = project;
            else if(File.Exists(info))
                output = info;

            if (output == null)
            {
                Directory.Delete(dir);
                throw new EcellException(string.Format(MessageResources.ErrLoadPrj, filename));
            }

            // Return project path.
            return output;
        }

        private static void DownloadAndUpdateSnakeBite(string URL)
        {
            // Download update archive
            using (WebClient w = new WebClient()) w.DownloadFile(URL, "update.dat");

            // Extract archive
            FastZip z = new FastZip();
            z.ExtractZip("update.dat", "_update", "(.*?)");

            // Move update file
            File.Delete("SnakeBite.exe");
            File.Delete("MakeBite.exe");
            File.Delete("GzsTool.Core.dll");
            File.Delete("fpk_dictionary.txt");
            File.Delete("qar_dictionary.txt");
            File.Move("_update/SnakeBite.exe", "SnakeBite.exe");
            File.Move("_update/MakeBite.exe", "MakeBite.exe");
            File.Move("_update/GzsTool.Core.dll", "GzsTool.Core.dll");
            File.Move("_update/fpk_dictionary.txt", "fpk_dictionary.txt");
            File.Move("_update/qar_dictionary.txt", "qar_dictionary.txt");

            // Restart updater
            Process updater = new Process();
            updater.StartInfo.Arguments = "-u";
            updater.StartInfo.UseShellExecute = false;
            updater.StartInfo.FileName = "sbupdater.exe";
            updater.Start();

            Environment.Exit(0);
        }

 /// <summary>
 /// 解压zip文件
 /// </summary>
 /// <param name="_zipFile">需要解压的zip路径+名字</param>
 /// <param name="_outForlder">解压路径</param>
 public void UnZipFile(string _zipFile, string _outForlder)
 {
     if (Directory.Exists(_outForlder))
         Directory.Delete(_outForlder, true);
     Directory.CreateDirectory(_outForlder);
     progress = progressOverall = 0;
     Thread thread = new Thread(delegate ()
     {
         int fileCount = (int)new ZipFile(_zipFile).Count;
         int fileCompleted = 0;
         FastZipEvents events = new FastZipEvents();
         events.Progress = new ProgressHandler((object sender, ProgressEventArgs e) =>
         {
             progress = e.PercentComplete;
             if (progress == 100) { fileCompleted++; progressOverall = 100 * fileCompleted / fileCount; }
         });
         events.ProgressInterval = TimeSpan.FromSeconds(progressUpdateTime);
         events.ProcessFile = new ProcessFileHandler(
             (object sender, ScanEventArgs e) => { });
         FastZip fastZip = new FastZip(events);
         fastZip.ExtractZip(_zipFile, _outForlder, "");
     });
     thread.IsBackground = true;
     thread.Start();
 }

        public static void unZIP(string srcZip, string detDir)
        {
            string filename = Path.GetFileNameWithoutExtension(srcZip);
            if (detDir == string.Empty)
            {
                detDir = srcZip.Substring(0,srcZip.LastIndexOf("\\"));
            }

            detDir = detDir + "\\" + filename;

            if (!Directory.Exists(detDir))
            {
                 Directory.CreateDirectory(detDir);
            }
            FastZip fastzip = new FastZip();
            //// Create Empty Directory
            fastzip.CreateEmptyDirectories = true;

            try
            {
                fastzip.ExtractZip(srcZip, detDir, string.Empty);
                //MessageBox.Show("ok");
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString());
            }
        }

		private void setDbfInfoFromZip(string dbfPath)
		{	
			try
			{	
				//Navigate the Zip to find the files and update their index
				ZipFile zFile = new ZipFile(dbfPath);				
				foreach (ZipEntry ze in zFile) 
				{
					if(ze.Name.ToLower().EndsWith(".dbf"))
					{
						//Extracts the file in temp
						FastZip fz = new FastZip();
						fz.ExtractZip(dbfPath, Path.GetTempPath(),
							ICSharpCode.SharpZipLib.Zip.FastZip.Overwrite.Always,null,"","");
						setDbfInfo(Path.Combine(Path.GetTempPath(),ze.Name));						
					}
				}						
			}
			catch { return; }			


			

            
			
			//TODO: read the sbf data into the datagrid

			//DataTable dt=getInfoFromDBF(dbfPath);			
			//dataGrid1.DataSource=dt;
			//dataGrid1.CaptionText=dbfPath;			
		}

 public static void ExtractZipFile(string zipFile, string outputFolder) {
     FastZip fastZip = new FastZip();
     try {
         fastZip.ExtractZip(zipFile, outputFolder, null); // Will always overwrite if target filenames already exist
     } catch (Exception ex) {
         Logger.Error("Extracting Zip failed.", ex);
     }
 }

 public static bool ExtractZip(string filename, string directory)
 {
     FastZip fz = new FastZip();
     fz.CreateEmptyDirectories = true;
     fz.ExtractZip(filename, directory, "");
     fz = null;
     return true;
 }

        public void UnZip()
        {
            string zipPath = "D:/Test.zip";
            string zipDir = "D:/Test2/";

            FastZip fastZip = new FastZip();
            fastZip.ExtractZip(zipPath, zipDir, null);
        }

        public static void Unzip(string directory, string zip)
        {
            var package = new FastZip
                              {
                                  CreateEmptyDirectories = true
                              };

            package.ExtractZip(zip, directory, String.Empty);
        }

        public void unZip()
        {
            string zipFileName = @"..\..\..\Sample-Sales-Reports.zip"; // change
            var targetDir = @"..\..\..\Excel";
            FastZip fastZip = new FastZip();
            string fileFilter = null;

            // Will always overwrite if target filenames already exist
            fastZip.ExtractZip(zipFileName, targetDir, fileFilter);
        }