C# Compression.ZipArchiveEntry類代碼示例

        private static void AddUpdateDeleteInventories(ZipArchiveEntry inventoriesEntry)
        {
            Console.WriteLine("inventories.csv is {0} bytes", inventoriesEntry.Length);
            IEnumerable<Inventory> inventories = null;

            using (var entryStream = inventoriesEntry.Open())
            {
                Console.WriteLine("Starting inventories at {0:hh:mm:ss.fff}", DateTime.Now);
                var stopwatch = new Stopwatch();
                stopwatch.Start();

                var reader = new StreamReader(entryStream);
                var csv = new CsvReader(reader);
                csv.Configuration.RegisterClassMap(new InventoryMap());
                StringBuilder invForImport = new StringBuilder();
                inventories = csv.GetRecords<Inventory>().Where(i => !i.IsDead);

                var inventoryCollection = new InventoryCollection();
                inventoryCollection.SetItems(inventories);
                var importer = new NpgsqlBulkImporter(ConfigurationManager.ConnectionStrings["spurious"].ConnectionString, stopwatch);
                importer.BulkImport("inventories", inventoryCollection);

                stopwatch.Stop();
                Console.WriteLine("Finished inventories at {0:hh:mm:ss.fff}, taking {1}", DateTime.Now, stopwatch.Elapsed);
            }
        }

 private static bool AreHashEqual(FileInfo existing, ZipArchiveEntry duplicate)
 {
     byte[] originalHash;
     byte[] otherHash;
     try
     {
         using (FileStream original = File.Open(existing.FullName, FileMode.Open, FileAccess.Read))
         {
             if (null == (originalHash = HashFile(original))) { return false; }
         }
         using (Stream other = duplicate.Open())
         {
             if (null == (otherHash = HashFile(other))) { return false; }
         }
         if (originalHash.Length == otherHash.Length)
         {
             for (int index = 0; index < originalHash.Length; index++)
             {
                 if (originalHash[index] != otherHash[index])
                 {
                     WriteError("Hashes don't match.");
                     return false;
                 }
             }
             return true;
         }
         return false;
     }
     catch (Exception e)
     {
         WriteError("Error while trying to compare hash. Error {0}",
             e.Message);
         return false;
     }
 }

 internal static string Process(ZipArchiveEntry packageFile, IMSBuildNuGetProjectSystem msBuildNuGetProjectSystem)
 {
     using (var stream = packageFile.Open())
     {
         return Process(stream, msBuildNuGetProjectSystem, throwIfNotFound: false);
     }
 }

 static void WriteZipArchiveEntry(ZipArchiveEntry entry, string toWrite)
 {
     using (StreamWriter writer = new StreamWriter(entry.Open()))
     {
         writer.Write(toWrite);
     }
 }

        /// <summary>
        /// Builds the zip file.
        /// </summary>
        /// <param name="updatesDirectory">The updates directory.</param>
        /// <param name="folderName">Name of the folder.</param>
        /// <param name="zipArchive">The zip archive.</param>
        /// <param name="zipArchiveEntry">The zip archive entry.</param>
        public void BuildZipFile(
            string updatesDirectory, 
            string folderName, 
            ZipArchive zipArchive, 
            ZipArchiveEntry zipArchiveEntry)
        {
            ////TraceService.WriteLine("ZipperService::BuildZipFile");

            string fullName = zipArchiveEntry.FullName;

            ////TraceService.WriteLine("Processing " + fullName);

            if (fullName.ToLower().StartsWith(folderName.ToLower()) &&
                fullName.ToLower().EndsWith(".dll"))
            {
                //// we have found one of the assemblies
                TraceService.WriteLine("Found assembley " + fullName);

                //// first look to see if we have a replacement
                string newFilePath = updatesDirectory + @"\" + zipArchiveEntry.Name;

                bool exists = this.fileSystem.File.Exists(newFilePath);

                if (exists)
                {
                    this.UpdateFile(zipArchive, zipArchiveEntry, fullName, newFilePath);
                }
                else
                {
                    TraceService.WriteLine(newFilePath + " does not exist");
                }
            }
        }

 public PackageEntry(ZipArchiveEntry zipArchiveEntry)
 {
     FullName = zipArchiveEntry.FullName;
     Name = zipArchiveEntry.Name;
     Length = zipArchiveEntry.Length;
     CompressedLength = zipArchiveEntry.CompressedLength;
 }

        /// <summary>
        /// Reads a ZipArchive entry as the routes CSV and extracts the route colors.
        /// </summary>
        private static List<GoogleRoute> ParseRouteCSV(ZipArchiveEntry entry)
        {
            var routes = new List<GoogleRoute>();

            using (var reader = new StreamReader(entry.Open()))
            {
                // Ignore the format line
                reader.ReadLine();

                while (!reader.EndOfStream)
                {
                    var parts = reader.ReadLine().Split(',');

                    // Ignore all routes which aren't part of CTS and thus don't have any real-time data.
                    if (parts[0].Contains("ATS") || parts[0].Contains("PC") || parts[0].Contains("LBL"))
                    {
                        continue;
                    }

                    routes.Add(new GoogleRoute(parts));
                }
            }

            return routes;
        }

        private static void AddUpdateDeleteStores(ZipArchiveEntry entry)
        {
            IEnumerable<Store> stores = null;

            using (var entryStream = entry.Open())
            {
                Console.WriteLine("stores.csv is {0} bytes", entry.Length);
                Console.WriteLine("Starting stores at {0:hh:mm:ss.fff}", DateTime.Now);
                var storeTimer = new Stopwatch();
                storeTimer.Start();
                var reader = new StreamReader(entryStream);
                var csv = new CsvReader(reader);
                csv.Configuration.RegisterClassMap(new StoreMap());
                stores = csv.GetRecords<Store>().Where(s => !s.IsDead);

                var storesCollection = new StoreCollection();
                storesCollection.SetItems(stores);
                var importer = new NpgsqlBulkImporter(ConfigurationManager.ConnectionStrings["spurious"].ConnectionString, storeTimer);
                importer.BulkImport("stores", storesCollection);

                using (var wrapper = new NpgsqlConnectionWrapper(ConfigurationManager.ConnectionStrings["spurious"].ConnectionString))
                {
                    wrapper.Connection.Open();
                    var rowsGeoUpdated = wrapper.ExecuteNonQuery("update stores s set (location) = ((select ST_SetSRID(ST_MakePoint(longitude, latitude), 4326) from stores ss where s.id = ss.id))");
                    Console.WriteLine($"Updated {rowsGeoUpdated} rows geo data from lat/long data");
                }

                storeTimer.Stop();
                Console.WriteLine("Finished stores at {0:hh:mm:ss.fff}, taking {1}", DateTime.Now, storeTimer.Elapsed);
            }
        }

        /// <summary>
        /// Unzips ZipArchiveEntry asynchronously.
        /// </summary>
        /// <param name="entry">The entry which needs to be unzipped</param>
        /// <param name="filePath">The entry's full name</param>
        /// <param name="unzipFolder">The unzip folder</param>
        /// <returns></returns>
        private static async Task UnzipZipArchiveEntryAsync(ZipArchiveEntry entry, string filePath, StorageFolder unzipFolder)
        {
            if (IfPathContainDirectory(filePath))
            {
                // Create sub folder
                string subFolderName = Path.GetDirectoryName(filePath);

                bool isSubFolderExist = await IfFolderExistsAsync(unzipFolder, subFolderName);

                StorageFolder subFolder;

                if (!isSubFolderExist)
                {
                    // Create the sub folder.
                    subFolder =
                        await unzipFolder.CreateFolderAsync(subFolderName, CreationCollisionOption.ReplaceExisting);
                }
                else
                {
                    // Just get the folder.
                    subFolder =
                        await unzipFolder.GetFolderAsync(subFolderName);
                }

                // All sub folders have been created yet. Just pass the file name to the Unzip function.
                string newFilePath = Path.GetFileName(filePath);

                if (!string.IsNullOrEmpty(newFilePath))
                {
                    // Unzip file iteratively.
                    await UnzipZipArchiveEntryAsync(entry, newFilePath, subFolder);
                }
            }
            else
            {

                // Read uncompressed contents
                using (Stream entryStream = entry.Open())
                {
                    byte[] buffer = new byte[entry.Length];
                    entryStream.Read(buffer, 0, buffer.Length);

                    // Create a file to store the contents
                    StorageFile uncompressedFile = await unzipFolder.CreateFileAsync
                    (entry.Name, CreationCollisionOption.ReplaceExisting);

                    // Store the contents
                    using (IRandomAccessStream uncompressedFileStream =
                    await uncompressedFile.OpenAsync(FileAccessMode.ReadWrite))
                    {
                        using (Stream outstream = uncompressedFileStream.AsStreamForWrite())
                        {
                            outstream.Write(buffer, 0, buffer.Length);
                            outstream.Flush();
                        }
                    }
                }
            }
        }

 private WrappedStream(Stream baseStream, Boolean closeBaseStream, ZipArchiveEntry entry, Action<ZipArchiveEntry> onClosed)
 {
     _baseStream = baseStream;
     _closeBaseStream = closeBaseStream;
     _onClosed = onClosed;
     _zipArchiveEntry = entry;
     _isDisposed = false;
 }

 private async Task Extract(ZipArchiveEntry entry, string basePath)
 {
     var fn = Path.Combine(basePath, entry.FullName);
     using (var fstream = File.Create(fn))
     {
         await entry.Open().CopyToAsync(fstream);
     }
 }

        /// <summary>
        /// Constructor.
        /// </summary>
        public CompressedArchiveFile(ZipArchiveEntry entry, int stripInitialFolders)
        {
            if (!entry.IsFile())
                throw new InvalidOperationException("Not a file.");

            _entry = entry;
            _stripInitialFolders = stripInitialFolders;
        }

        // A specific constructor to allow decompression of Deflate64
        internal DeflateManagedStream(Stream stream, ZipArchiveEntry.CompressionMethodValues method)
        {
            if (stream == null)
                throw new ArgumentNullException(nameof(stream));
            if (!stream.CanRead)
                throw new ArgumentException(SR.NotSupported_UnreadableStream, nameof(stream));

            InitializeInflater(stream, false, null, method);
        }

 private void OnDoubleClick(object sender, MouseButtonEventArgs e)
 {
     var listBox = sender as ListBox;
     if (listBox.SelectedItem != null)
     {
         Result = listBox.SelectedItem as ZipArchiveEntry;
         Close();
     }
 }

 public ZipWrappingStream(ZipArchiveEntry zipArchiveEntry, Stream stream, FileMode packageFileMode, FileAccess packageFileAccess, bool canRead, bool canWrite)
 {
     _zipArchiveEntry = zipArchiveEntry;
     _baseStream = stream;
     _packageFileMode = packageFileMode;
     _packageFileAccess = packageFileAccess;
     _canRead = canRead;
     _canWrite = canWrite;
 }