C# SevenZip.SevenZipExtractor类代码示例

        public static String docxParser(String filename)
        {
            //path to the systems temporary folder
            String tempFolderPath = Path.GetTempPath();

            //set the path of the 7z.dll (it needs to be in the debug folder)
            SevenZipExtractor.SetLibraryPath("7z.dll");

            SevenZipExtractor extractor = new SevenZipExtractor(filename);

            //create a filestream for the file we are going to extract
            FileStream f = new FileStream(tempFolderPath + "document.xml", FileMode.Create);

            //extract the document.xml
            extractor.ExtractFile("word\\document.xml", f);

            //get rid of the object because it is unmanaged
            extractor.Dispose();

            //close the filestream
            f.Close();

            //send document.xml that we extracted from the .docx to the xml parser
            String result = XMLParser.Parser.ParseXMLtoString(tempFolderPath + "document.xml");

            //delete the extracted file from the temp folder
            File.Delete(tempFolderPath + "document.xml");

            return result;
        }

            public override void Execute()
            {
                var libraryPath = Path.Combine(Path.GetDirectoryName(GetType().Assembly.Location), Environment.Is64BitProcess ? "7z64.dll" : "7z.dll");
                SevenZipBase.SetLibraryPath(libraryPath);

                var targetPath = new FileInfo(Path.Combine(_cmdlet.SessionState.Path.CurrentFileSystemLocation.Path, _cmdlet.TargetPath)).FullName;
                var archiveFileName = new FileInfo(Path.Combine(_cmdlet.SessionState.Path.CurrentFileSystemLocation.Path, _cmdlet.ArchiveFileName)).FullName;

                var activity = String.Format("Extracting {0} to {1}", System.IO.Path.GetFileName(archiveFileName), targetPath);
                var statusDescription = "Extracting";

                Write(String.Format("Extracting archive {0}", archiveFileName));
                WriteProgress(new ProgressRecord(0, activity, statusDescription) { PercentComplete = 0 });

                using (var extractor = new SevenZipExtractor(archiveFileName)) {
                    extractor.Extracting += (sender, args) =>
                                            WriteProgress(new ProgressRecord(0, activity, statusDescription) { PercentComplete = args.PercentDone });
                    extractor.FileExtractionStarted += (sender, args) => {
                        statusDescription = String.Format("Extracting file {0}", args.FileInfo.FileName);
                        Write(statusDescription);
                    };
                    extractor.ExtractArchive(targetPath);
                }

                WriteProgress(new ProgressRecord(0, activity, "Finished") { RecordType = ProgressRecordType.Completed });
                Write("Extraction finished");
            }

        public FileReader(IFileStreamWrap stream)
        {
            if (stream == null) throw new ArgumentNullException(nameof(stream));

            //Asses file ext
            var ext = Path.GetExtension(stream.Name);
            if (ext == ".gz")
            {
                Compression = CompressionScheme.GZip;
            }

            //Assign stream
            Stream = stream;

            //If not testing assign actual stream
            if (stream.FileStreamInstance != null)
            {
                if (Compression == CompressionScheme.None)
                {
                    _reader = new StreamReaderWrap(stream.FileStreamInstance);
                }
                else if (Compression == CompressionScheme.GZip)
                {
                    // Toggle between the x86 and x64 bit dll
                   // var path = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),Environment.Is64BitProcess ? "x64" : "x86", "7z.dll");
                    SevenZipExtractor.SetLibraryPath("C:\\Program Files (x86)\\7-Zip\\7z.dll");

                    _gzipStream = new SevenZipExtractor(stream.FileStreamInstance);
                    //_memoryStream = new MemoryStream();
                    //_gzipStream.ExtractFile(0, _memoryStream);
                    _gzipStream.ExtractArchive("D:\\test.txt");
                    _reader = new StreamReaderWrap(_memoryStream);              
                }
            }
        }

        /// <summary>
        /// Decompresses an archive.
        /// </summary>
        /// <param name="archive">Path for the archive</param>
        /// <param name="destination">Archive content destination folder.</param>
        /// <returns>True if no errors</returns>
        public static bool Decompress(string archive, string destination)
        {
            try {
                string archive_name = Path.GetFileNameWithoutExtension(archive);
                if(main.full_path_output)
                    console.Write("Extracting " + archive + " to " + destination + " ->  0%", console.msgType.standard, false);
                else
                    console.Write("Extracting " + archive_name + " to " + destination + " ->  0%", console.msgType.standard, false);

                SevenZipExtractor zip = new SevenZipExtractor(archive);
                zip.Extracting += Zip_Extracting;
                if (!main.overwrite)
                    zip.FileExists += Zip_FileExists;
                if (main.create_dir)
                {
                    zip.ExtractArchive(destination + @"\" + archive_name);
                }
                else
                    zip.ExtractArchive(destination);
                Console.WriteLine("");
                return true;
            }
            catch (Exception e)
            {
                Console.WriteLine("");
                console.Write(e.Message +"("+archive+")", console.msgType.error);
                Log(e.ToString());
                return false;
            }
        }

        public void Update()
        {
            if (!IsUpdateAvailable())
            {
                throw new LauncherException("no update is available");
            }

            using (var mutex = new WurmAssistantMutex())
            {
                mutex.Enter(1000, "You must close Wurm Assistant before running update");
                var newFileZipped = WebApiClientSpellbook.GetFileFromWebApi(
                    AppContext.WebApiBasePath,
                    string.Format("{0}/{1}", AppContext.ProjectName, buildType),
                    TimeSpan.FromSeconds(15),
                    BasePath);

                using (var extractor = new SevenZipExtractor(newFileZipped.FullName))
                {
                    extractor.ExtractArchive(BasePath);
                }

                Thread.Sleep(1000);

                var cleaner = new DirCleaner(BasePath);
                cleaner.Cleanup();
            }
        }

 public ZipContainer(SevenZipExtractor zip, ArchiveFileInfo entry, ZipContainer parent)
 {
     _name = entry.FileName;
     _entry = entry;
     Zip = zip;
     _parent = parent;
 }

 public override void Execute(DirectoryInfo targetDirectory, PortableEnvironment portableEnvironment)
 {
     // Decompress the file.
     SevenZipBase.SetLibraryPath(SevenZipLibPath);
     using (var extractor = new SevenZipExtractor(Path.Combine(targetDirectory.FullName, FileName)))
         extractor.ExtractArchive(targetDirectory.FullName);
 }

        internal RarImporterHelper(SevenZipExtractor Sex)
        {
            string FileName = Sex.FileName;
            _DP = Path.GetFileName(FileName);

            StringAlbumParser sa = null;
            _RootDir = Sex.GetRootDir();

            if (_RootDir != null)
            {
                sa = StringAlbumParser.FromDirectoryHelper(_RootDir);
                _RootLength = _RootDir.Path.Length;
            }

            if ((sa == null) || (sa.FounSomething == false))
                sa = StringAlbumParser.FromRarZipName(FileName);

            _Album = sa.AlbumName;
            _Artist = sa.AlbumAuthor;
            _Year = sa.AlbumYear;

            _MaxLengthWithoutRoot = (from path in Sex.SafeArchiveFileNames() let npath = ConvertFileName(path) let len = (npath == null) ? 0 : npath.Length select len).Max();
            _MaxLengthFlat = (from path in Sex.ArchiveFileData let npath = Path.GetFileName(path.SafePath()) where (!path.IsDirectory) select npath.Length).Max();
            _MaxLengthBasic = (from path in Sex.SafeArchiveFileNames() select path.Length).Max();

            if (_MaxLengthFlat > _MaxLengthWithoutRoot)
                throw new Exception("Algo Error");

            if (_MaxLengthWithoutRoot > _MaxLengthBasic)
                throw new Exception("Algo Error");
        }

        public TickReader(FileInfo file)
        {
            Serializer = new PbTickSerializer();
            Codec = new QuantBox.Data.Serializer.V2.PbTickCodec();
            _stream = new MemoryStream();
            _originalLength = (int)file.Length;

            // 加载文件，支持7z解压
            var fileStream = file.Open(FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            {
                try
                {
                    using (var zip = new SevenZipExtractor(fileStream))
                    {
                        zip.ExtractFile(0, _stream);
                        _stream.Seek(0, SeekOrigin.Begin);
                    }
                }
                catch
                {
                    _stream = fileStream;
                    _stream.Seek(0, SeekOrigin.Begin);
                }
            }
        }

        public DirectoryInfo extractToTemp(bool force)
        {
            string modRoot;

            DirectoryInfo temp = new DirectoryInfo(TempPath);
            modRoot = Path.Combine(
                temp.FullName,
                Path.GetFileNameWithoutExtension(
                Path.GetFileNameWithoutExtension(
                FilePath)));
            DirectoryInfo modRootInfo = new DirectoryInfo(modRoot);
            if (Directory.Exists(modRoot) && !force)
            {

                m_extractedRoot = modRootInfo;
                return modRootInfo;
            }
            else
            {
                SevenZipExtractor extractor = new SevenZipExtractor(FilePath);
                modRootInfo.Create();
                extractor.ExtractArchive(modRoot);
                m_extractedRoot = modRootInfo;
                return modRootInfo;
            }
        }

        public static byte[] ExtractBytes(byte[] data)
        {
            Inits.EnsureBinaries();

            using (var inStream = new MemoryStream(data))
            {
                using (var outStream = new MemoryStream())
                {
                    try
                    {
                        using (var extract = new SevenZipExtractor(inStream))
                        {
                            extract.ExtractFile(0, outStream);
                            return outStream.ToArray();
                        }
                    }
                    catch
                    {
                        try
                        {
                            return SevenZipExtractor.ExtractBytes(inStream.ToArray());
                        }
                        catch { return null; }
                    }
                }
            }
        }

 public static void Extract(string file, string to)
 {
     using (var extractor = new SevenZipExtractor(file))
     {
         extractor.ExtractArchive(to);
     }
 }

        private void Decompress(string[] args)
        {
            //If no file name is specified, write usage text.

            if (args.Length == 0)
            {
                Console.WriteLine("error");
            }
            else
            {
                for (int i = 0; i < args.Length; i++)
                {
                    if (File.Exists(args[i]))
                    {
                        SevenZipExtractor.SetLibraryPath(@"C:\Users\thlacroi\AppData\Local\Apps\COMOS\COMOS Walkinside 6.2 (64 bit)\7z.dll");
                        using (var tmp = new SevenZipExtractor(args[i]))
                        {
                            for (int n = 0; n < tmp.ArchiveFileData.Count; n++)
                            {
                                if (tmp.ArchiveFileData[n].FileName.Contains(".xml"))
                                {
                                    tmp.ExtractFiles(Path.Combine(Resource.DirectoryTmp, i.ToString()), tmp.ArchiveFileData[n].Index);
                                }
                            }
                        }
                    }
                }
            }
        }

 public static void extract(string fileName, string directory)
 {
     SevenZipExtractor.SetLibraryPath("7z.dll");
     SevenZipExtractor extractor = new SevenZipExtractor(fileName);
     extractor.Extracting += new EventHandler<ProgressEventArgs>(extr_Extracting);
     extractor.FileExtractionStarted += new EventHandler<FileInfoEventArgs>(extr_FileExtractionStarted);
     extractor.ExtractionFinished += new EventHandler<EventArgs>(extr_ExtractionFinished);
     extractor.ExtractArchive(directory);
 }

 internal DirectoryHandle CreateByUnzippingFile(string zipFilePath)
 {
     var dir = CreateTempDirectory();
     zipFilePath = AbsolutizePath(zipFilePath);
     var extractor =
         new SevenZipExtractor(File.OpenRead(zipFilePath));
     extractor.ExtractArchive(dir.FullName);
     return new DirectoryHandle(this, dir);
 }