/// <summary> /// Rewrite the directory within a zipfile. /// </summary> /// /// <remarks> /// /// <para> /// In cases of data error, the directory in a zip file can get out of /// synch with the entries in the zip file. This method attempts to fix /// the zip file if this has occurred. /// </para> /// /// <para> This can take a long time for large zip files. </para> /// /// <para> This won't work if the zip file uses a non-standard /// code page - neither IBM437 nor UTF-8. </para> /// /// <para> /// This method is not supported in the Reduced or Compact Framework /// versions of DotNetZip. /// </para> /// /// <para> /// Developers using COM can use the <see /// cref="ComHelper.FixZipDirectory(String)">ComHelper.FixZipDirectory(String)</see> /// method. /// </para> /// /// </remarks> /// /// <param name="zipFileName">The filename to of the zip file to fix.</param> /// /// <seealso cref="CheckZip(string)"/> /// <seealso cref="CheckZip(string,bool,System.IO.TextWriter)"/> internal static void FixZipDirectory(string zipFileName) { using (var zip = ZipFileExtensions.Read(zipFileName, new ReadOptions { FullScan = true })) { zip.Save(zipFileName); } }
/// <summary> /// Create a <c>ZipInputStream</c>, given the name of an existing zip file. /// </summary> /// /// <remarks> /// /// <para> /// This constructor opens a <c>FileStream</c> for the given zipfile, and /// wraps a <c>ZipInputStream</c> around that. See the documentation for the /// <see cref="ZipInputStream(Stream)"/> constructor for full details. /// </para> /// /// <para> /// While the <see cref="ZipFile"/> class is generally easier /// to use, this class provides an alternative to those /// applications that want to read from a zipfile directly, /// using a <see cref="System.IO.Stream"/>. /// </para> /// /// </remarks> /// /// <param name="fileName"> /// The name of the filesystem file to read. /// </param> /// /// <example> /// /// This example shows how to read a zip file, and extract entries, using the /// <c>ZipInputStream</c> class. /// /// <code lang="C#"> /// private void Unzip() /// { /// byte[] buffer= new byte[2048]; /// int n; /// using (var input= new ZipInputStream(inputFileName)) /// { /// ZipEntry e; /// while (( e = input.GetNextEntry()) != null) /// { /// if (e.IsDirectory) continue; /// string outputPath = Path.Combine(extractDir, e.FileName); /// using (var output = File.Open(outputPath, FileMode.Create, FileAccess.ReadWrite)) /// { /// while ((n= input.Read(buffer, 0, buffer.Length)) > 0) /// { /// output.Write(buffer,0,n); /// } /// } /// } /// } /// } /// </code> /// /// <code lang="VB"> /// Private Sub UnZip() /// Dim inputFileName As String = "MyArchive.zip" /// Dim extractDir As String = "extract" /// Dim buffer As Byte() = New Byte(2048) {} /// Using input As ZipInputStream = New ZipInputStream(inputFileName) /// Dim e As ZipEntry /// Do While (Not e = input.GetNextEntry Is Nothing) /// If Not e.IsDirectory Then /// Using output As FileStream = File.Open(Path.Combine(extractDir, e.FileName), _ /// FileMode.Create, FileAccess.ReadWrite) /// Dim n As Integer /// Do While (n = input.Read(buffer, 0, buffer.Length) > 0) /// output.Write(buffer, 0, n) /// Loop /// End Using /// End If /// Loop /// End Using /// End Sub /// </code> /// </example> internal static ZipInputStream Create(String fileName) { string fullPath = ZipFileExtensions.GetFullPath(fileName); var file = FileSystem.Current.GetFileFromPathAsync(fullPath).ExecuteSync(); if (file == null) { throw new FileNotFoundException(string.Format("That file ({0}) does not exist!", fileName)); } var stream = file.OpenAsync(FileAccess.Read).ExecuteSync(); return(new ZipInputStream(stream)); }
public FileSystemZipSegmentedStreamManager(string baseName) { _baseName = baseName; _fullBaseName = ZipFileExtensions.GetFullPath(_baseName); var baseDir = Path.GetDirectoryName(_fullBaseName); _baseFolder = FileSystem.Current.GetFolderFromPathAsync(baseDir).ExecuteSync(); if (_baseFolder == null) { var dir = Path.GetDirectoryName(_baseName); throw new ZipException("Bad Directory", new ArgumentException(string.Format("That folder ({0}) does not exist!", dir))); } }
/// <summary> /// Create a ZipOutputStream that writes to a filesystem file. /// </summary> /// /// <remarks> /// The <see cref="ZipFile"/> class is generally easier to use when creating /// zip files. The ZipOutputStream offers a different metaphor for creating a /// zip file, based on the <see cref="System.IO.Stream"/> class. /// </remarks> /// /// <param name="fileName"> /// The name of the zip file to create. /// </param> /// /// <example> /// /// This example shows how to create a zip file, using the /// ZipOutputStream class. /// /// <code lang="C#"> /// private void Zipup() /// { /// if (filesToZip.Count == 0) /// { /// System.Console.WriteLine("Nothing to do."); /// return; /// } /// /// using (var output= new ZipOutputStream(outputFileName)) /// { /// output.Password = "******"; /// output.Encryption = EncryptionAlgorithm.WinZipAes256; /// /// foreach (string inputFileName in filesToZip) /// { /// System.Console.WriteLine("file: {0}", inputFileName); /// /// output.PutNextEntry(inputFileName); /// using (var input = File.Open(inputFileName, FileMode.Open, FileAccess.Read, /// FileShare.Read | FileShare.Write )) /// { /// byte[] buffer= new byte[2048]; /// int n; /// while ((n= input.Read(buffer,0,buffer.Length)) > 0) /// { /// output.Write(buffer,0,n); /// } /// } /// } /// } /// } /// </code> /// /// <code lang="VB"> /// Private Sub Zipup() /// Dim outputFileName As String = "XmlData.zip" /// Dim filesToZip As String() = Directory.GetFiles(".", "*.xml") /// If (filesToZip.Length = 0) Then /// Console.WriteLine("Nothing to do.") /// Else /// Using output As ZipOutputStream = New ZipOutputStream(outputFileName) /// output.Password = "******" /// output.Encryption = EncryptionAlgorithm.WinZipAes256 /// Dim inputFileName As String /// For Each inputFileName In filesToZip /// Console.WriteLine("file: {0}", inputFileName) /// output.PutNextEntry(inputFileName) /// Using input As FileStream = File.Open(inputFileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite) /// Dim n As Integer /// Dim buffer As Byte() = New Byte(2048) {} /// Do While (n = input.Read(buffer, 0, buffer.Length) > 0) /// output.Write(buffer, 0, n) /// Loop /// End Using /// Next /// End Using /// End If /// End Sub /// </code> /// </example> internal static ZipOutputStream Create(String fileName) { string fullPath = ZipFileExtensions.GetFullPath(fileName); var file = FileSystem.Current.GetFileFromPathAsync(fullPath).ExecuteSync(); if (file == null) { var dirName = Path.GetDirectoryName(fullPath); var dir = ZipEntryExtensions.CreateDirectory(dirName, true); file = dir.CreateFileAsync(Path.GetFileName(fileName), CreationCollisionOption.ReplaceExisting).ExecuteSync(); } var stream = file.OpenAsync(FileAccess.ReadAndWrite).ExecuteSync(); return(new ZipOutputStream(stream)); }
/// <summary> /// Pass in either basedir or s, but not both. /// In other words, you can extract to a stream or to a directory (filesystem), but not both! /// The Password param is required for encrypted entries. /// </summary> private static void InternalExtractToBaseDir(this ZipEntry zipEntry, string baseDir, string password) { if (baseDir == null) { throw new ArgumentNullException("baseDir"); } var zipFile = zipEntry.GetZipFile(); // workitem 10355 if (zipFile == null) { throw new InvalidOperationException("Use Extract() only with ZipFile."); } // get the full filename var f = ZipEntryInternal.NameInArchive(zipEntry.FileName); var targetFileName = zipFile.FlattenFoldersOnExtract ? Path.Combine(baseDir, Path.GetFileName(f)) : Path.Combine(baseDir, f); // workitem 10639 targetFileName = targetFileName.Replace('/', PortablePath.DirectorySeparatorChar); var fullTargetPath = ZipFileExtensions.GetFullPath(targetFileName); var fileExistsBeforeExtraction = false; try { // check if it is a directory if (zipEntry.IsDirectory || zipEntry.FileName.EndsWith("/")) { CreateDirectory(fullTargetPath); goto ExitTry; // all done, caller will return } // it is a file, so start the extraction if (FileSystem.Current.GetFileFromPathAsync(fullTargetPath).ExecuteSync() != null) { fileExistsBeforeExtraction = true; int rc = zipEntry.CheckExtractExistingFile(baseDir, targetFileName); if (rc == 2) { goto ExitTry; // cancel } if (rc == 1) { return; // do not overwrite } } // set up the output stream var tmpName = Path.GetRandomFileName(); var tmpPath = Path.Combine(Path.GetDirectoryName(fullTargetPath), tmpName); var dirName = Path.GetDirectoryName(tmpPath); // ensure the target path exists var dir = CreateDirectory(dirName, true); // extract var file = dir.CreateFileAsync(tmpPath, CreationCollisionOption.ReplaceExisting).ExecuteSync(); using (var output = file.OpenAsync(FileAccess.ReadAndWrite).ExecuteSync()) { zipEntry.ExtractWithPassword(output, password); } MoveFileInPlace(fileExistsBeforeExtraction, fullTargetPath, tmpPath); ExitTry :; } catch (Exception) { zipEntry.SetIOOperationCanceled(true); throw; } finally { if (zipEntry.IsIOOperationCanceled() && targetFileName != null) { // An exception has occurred. If the file exists, check // to see if it existed before we tried extracting. If // it did not, attempt to remove the target file. There // is a small possibility that the existing file has // been extracted successfully, overwriting a previously // existing file, and an exception was thrown after that // but before final completion (setting times, etc). In // that case the file will remain, even though some // error occurred. Nothing to be done about it. var file = FileSystem.Current.GetFileFromPathAsync(fullTargetPath).ExecuteSync(); if (file != null && !fileExistsBeforeExtraction) { file.DeleteAsync(); } } } }
/// <summary> /// Rewrite the directory within a zipfile. /// </summary> /// /// <remarks> /// /// <para> /// In cases of data error, the directory in a zip file can get out of /// synch with the entries in the zip file. This method attempts to fix /// the zip file if this has occurred. /// </para> /// /// <para> This can take a long time for large zip files. </para> /// /// <para> This won't work if the zip file uses a non-standard /// code page - neither IBM437 nor UTF-8. </para> /// /// <para> /// This method is not supported in the Reduced or Compact Framework /// versions of DotNetZip. /// </para> /// /// <para> /// Developers using COM can use the <see /// cref="ComHelper.FixZipDirectory(String)">ComHelper.FixZipDirectory(String)</see> /// method. /// </para> /// /// </remarks> /// /// <param name="zipFileName">The filename to of the zip file to fix.</param> /// /// <seealso cref="CheckZip(string)"/> /// <seealso cref="CheckZip(string,bool,System.IO.TextWriter)"/> public static void FixZipDirectory(string zipFileName) { ZipFileExtensions.FixZipDirectory(zipFileName); }
/// <summary> /// Verify the password on a zip file. /// </summary> /// /// <remarks> /// <para> /// Keep in mind that passwords in zipfiles are applied to /// zip entries, not to the entire zip file. So testing a /// zipfile for a particular password doesn't work in the /// general case. On the other hand, it's often the case /// that a single password will be used on all entries in a /// zip file. This method works for that case. /// </para> /// <para> /// There is no way to check a password without doing the /// decryption. So this code decrypts and extracts the given /// zipfile into <see cref="System.IO.Stream.Null"/> /// </para> /// </remarks> /// /// <param name="zipFileName">The filename to of the zip file to fix.</param> /// /// <param name="password">The password to check.</param> /// /// <returns>a bool indicating whether the password matches.</returns> public static bool CheckZipPassword(string zipFileName, string password) { return(ZipFileExtensions.CheckZipPassword(zipFileName, password)); }
/// <summary> /// Checks a zip file to see if its directory is consistent. /// </summary> /// /// <remarks> /// /// <para> /// In cases of data error, the directory within a zip file can get out /// of synch with the entries in the zip file. This method checks the /// given zip file and returns true if this has occurred. /// </para> /// /// <para> This method may take a long time to run for large zip files. </para> /// /// <para> /// This method is not supported in the Reduced or Compact Framework /// versions of DotNetZip. /// </para> /// /// <para> /// Developers using COM can use the <see /// cref="ComHelper.CheckZip(String)">ComHelper.CheckZip(String)</see> /// method. /// </para> /// /// </remarks> /// /// <param name="zipFileName">The filename to of the zip file to check.</param> /// /// <returns>true if the named zip file checks OK. Otherwise, false. </returns> /// /// <seealso cref="FixZipDirectory(string)"/> /// <seealso cref="CheckZip(string,bool,System.IO.TextWriter)"/> public static bool CheckZip(string zipFileName) { return(ZipFileExtensions.CheckZip(zipFileName)); }
/// <summary> /// Checks a zip file to see if its directory is consistent, /// and optionally fixes the directory if necessary. /// </summary> /// /// <remarks> /// /// <para> /// In cases of data error, the directory within a zip file can get out of /// synch with the entries in the zip file. This method checks the given /// zip file, and returns true if this has occurred. It also optionally /// fixes the zipfile, saving the fixed copy in <em>Name</em>_Fixed.zip. /// </para> /// /// <para> /// This method may take a long time to run for large zip files. It /// will take even longer if the file actually needs to be fixed, and if /// <c>fixIfNecessary</c> is true. /// </para> /// /// <para> /// This method is not supported in the Reduced or Compact /// Framework versions of DotNetZip. /// </para> /// /// </remarks> /// /// <param name="zipFileName">The filename to of the zip file to check.</param> /// /// <param name="fixIfNecessary">If true, the method will fix the zip file if /// necessary.</param> /// /// <param name="writer"> /// a TextWriter in which messages generated while checking will be written. /// </param> /// /// <returns>true if the named zip is OK; false if the file needs to be fixed.</returns> /// /// <seealso cref="CheckZip(string)"/> /// <seealso cref="FixZipDirectory(string)"/> public static bool CheckZip(string zipFileName, bool fixIfNecessary, TextWriter writer) { return(ZipFileExtensions.CheckZip(zipFileName, fixIfNecessary, writer)); }
/// <summary> /// Checks the given file to see if it appears to be a valid zip file. /// </summary> /// <remarks> /// /// <para> /// Calling this method is equivalent to calling <see cref="IsZipFile(string, /// bool)"/> with the testExtract parameter set to false. /// </para> /// </remarks> /// /// <param name="zipFileName">The file to check.</param> /// <returns>true if the file appears to be a zip file.</returns> public static bool IsZipFile(string zipFileName) { return(ZipFileExtensions.IsZipFile(zipFileName)); }
/// <summary> /// Checks a file to see if it is a valid zip file. /// </summary> /// /// <remarks> /// <para> /// This method opens the specified zip file, reads in the zip archive, /// verifying the ZIP metadata as it reads. /// </para> /// /// <para> /// If everything succeeds, then the method returns true. If anything fails - /// for example if an incorrect signature or CRC is found, indicating a /// corrupt file, the the method returns false. This method also returns /// false for a file that does not exist. /// </para> /// /// <para> /// If <paramref name="testExtract"/> is true, as part of its check, this /// method reads in the content for each entry, expands it, and checks CRCs. /// This provides an additional check beyond verifying the zip header and /// directory data. /// </para> /// /// <para> /// If <paramref name="testExtract"/> is true, and if any of the zip entries /// are protected with a password, this method will return false. If you want /// to verify a <c>ZipFile</c> that has entries which are protected with a /// password, you will need to do that manually. /// </para> /// /// </remarks> /// /// <param name="zipFileName">The zip file to check.</param> /// <param name="testExtract">true if the caller wants to extract each entry.</param> /// <returns>true if the file contains a valid zip file.</returns> public static bool IsZipFile(string zipFileName, bool testExtract) { return(ZipFileExtensions.IsZipFile(zipFileName, testExtract)); }
/// <summary> /// Reads a zip file archive from the named filesystem file using the /// specified options. /// </summary> /// /// <remarks> /// <para> /// This version of the <c>Read()</c> method allows the caller to pass /// in a <c>TextWriter</c> an <c>Encoding</c>, via an instance of the /// <c>ReadOptions</c> class. The <c>ZipFile</c> is read in using the /// specified encoding for entries where UTF-8 encoding is not /// explicitly specified. /// </para> /// </remarks> /// /// <example> /// /// <para> /// This example shows how to read a zip file using the Big-5 Chinese /// code page (950), and extract each entry in the zip file, while /// sending status messages out to the Console. /// </para> /// /// <para> /// For this code to work as intended, the zipfile must have been /// created using the big5 code page (CP950). This is typical, for /// example, when using WinRar on a machine with CP950 set as the /// default code page. In that case, the names of entries within the /// Zip archive will be stored in that code page, and reading the zip /// archive must be done using that code page. If the application did /// not use the correct code page in ZipFile.Read(), then names of /// entries within the zip archive would not be correctly retrieved. /// </para> /// /// <code lang="C#"> /// string zipToExtract = "MyArchive.zip"; /// string extractDirectory = "extract"; /// var options = new ReadOptions /// { /// StatusMessageWriter = System.Console.Out, /// Encoding = System.Text.Encoding.GetEncoding(950) /// }; /// using (ZipFile zip = ZipFile.Read(zipToExtract, options)) /// { /// foreach (ZipEntry e in zip) /// { /// e.Extract(extractDirectory); /// } /// } /// </code> /// /// /// <code lang="VB"> /// Dim zipToExtract as String = "MyArchive.zip" /// Dim extractDirectory as String = "extract" /// Dim options as New ReadOptions /// options.Encoding = System.Text.Encoding.GetEncoding(950) /// options.StatusMessageWriter = System.Console.Out /// Using zip As ZipFile = ZipFile.Read(zipToExtract, options) /// Dim e As ZipEntry /// For Each e In zip /// e.Extract(extractDirectory) /// Next /// End Using /// </code> /// </example> /// /// /// <example> /// /// <para> /// This example shows how to read a zip file using the default /// code page, to remove entries that have a modified date before a given threshold, /// sending status messages out to a <c>StringWriter</c>. /// </para> /// /// <code lang="C#"> /// var options = new ReadOptions /// { /// StatusMessageWriter = new System.IO.StringWriter() /// }; /// using (ZipFile zip = ZipFile.Read("PackedDocuments.zip", options)) /// { /// var Threshold = new DateTime(2007,7,4); /// // We cannot remove the entry from the list, within the context of /// // an enumeration of said list. /// // So we add the doomed entry to a list to be removed later. /// // pass 1: mark the entries for removal /// var MarkedEntries = new System.Collections.Generic.List<ZipEntry>(); /// foreach (ZipEntry e in zip) /// { /// if (e.LastModified < Threshold) /// MarkedEntries.Add(e); /// } /// // pass 2: actually remove the entry. /// foreach (ZipEntry zombie in MarkedEntries) /// zip.RemoveEntry(zombie); /// zip.Comment = "This archive has been updated."; /// zip.Save(); /// } /// // can now use contents of sw, eg store in an audit log /// </code> /// /// <code lang="VB"> /// Dim options as New ReadOptions /// options.StatusMessageWriter = New System.IO.StringWriter /// Using zip As ZipFile = ZipFile.Read("PackedDocuments.zip", options) /// Dim Threshold As New DateTime(2007, 7, 4) /// ' We cannot remove the entry from the list, within the context of /// ' an enumeration of said list. /// ' So we add the doomed entry to a list to be removed later. /// ' pass 1: mark the entries for removal /// Dim MarkedEntries As New System.Collections.Generic.List(Of ZipEntry) /// Dim e As ZipEntry /// For Each e In zip /// If (e.LastModified < Threshold) Then /// MarkedEntries.Add(e) /// End If /// Next /// ' pass 2: actually remove the entry. /// Dim zombie As ZipEntry /// For Each zombie In MarkedEntries /// zip.RemoveEntry(zombie) /// Next /// zip.Comment = "This archive has been updated." /// zip.Save /// End Using /// ' can now use contents of sw, eg store in an audit log /// </code> /// </example> /// /// <exception cref="System.Exception"> /// Thrown if the zipfile cannot be read. The implementation of /// this method relies on <c>System.IO.File.OpenRead</c>, which /// can throw a variety of exceptions, including specific /// exceptions if a file is not found, an unauthorized access /// exception, exceptions for poorly formatted filenames, and so /// on. /// </exception> /// /// <param name="zipFileName"> /// The name of the zip archive to open. /// This can be a fully-qualified or relative pathname. /// </param> /// /// <param name="options"> /// The set of options to use when reading the zip file. /// </param> /// /// <returns>The ZipFile instance read from the zip archive.</returns> /// /// <seealso cref="ZipFile.Read(Stream, ReadOptions)"/> /// public static ZipFile Read(string zipFileName, ReadOptions options) { return(ZipFileExtensions.Read(zipFileName, options)); }
/// <summary> /// Creates a new <c>ZipFile</c> instance, using the specified name for the /// filename, the specified status message writer, and the specified Encoding. /// </summary> /// /// <remarks> /// <para> /// This constructor works like the <see cref="ZipFile(String)">ZipFile /// constructor that accepts a single string argument.</see> See that /// reference for detail on what this constructor does. /// </para> /// /// <para> /// This version of the constructor allows the caller to pass in a /// <c>TextWriter</c>, and an Encoding. The <c>TextWriter</c> will collect /// verbose messages that are generated by the library during extraction or /// creation of the zip archive. A console application may wish to pass /// <c>System.Console.Out</c> to get messages on the Console. A graphical or /// headless application may wish to capture the messages in a different /// <c>TextWriter</c>, for example, a <c>StringWriter</c>, and then display /// the messages in a <c>TextBox</c>, or generate an audit log of /// <c>ZipFile</c> operations. /// </para> /// /// <para> /// The <c>Encoding</c> is used as the default alternate encoding for entries /// with filenames or comments that cannot be encoded with the IBM437 code /// page. This is a equivalent to setting the <see /// cref="ProvisionalAlternateEncoding"/> property on the <c>ZipFile</c> /// instance after construction. /// </para> /// /// <para> /// To encrypt the data for the files added to the <c>ZipFile</c> instance, /// set the <c>Password</c> property after creating the <c>ZipFile</c> /// instance. /// </para> /// /// <para> /// Instances of the <c>ZipFile</c> class are not multi-thread safe. You may /// not party on a single instance with multiple threads. You may have /// multiple threads that each use a distinct <c>ZipFile</c> instance, or you /// can synchronize multi-thread access to a single instance. /// </para> /// /// </remarks> /// /// <exception cref="Ionic.Zip.ZipException"> /// Thrown if <c>fileName</c> refers to an existing file that is not a valid zip file. /// </exception> /// /// <param name="zipFileName">The filename to use for the new zip archive.</param> /// <param name="statusMessageWriter">A TextWriter to use for writing verbose /// status messages.</param> /// <param name="encoding"> /// The Encoding is used as the default alternate encoding for entries with /// filenames or comments that cannot be encoded with the IBM437 code page. /// </param> public static ZipFile Read(string zipFileName, TextWriter statusMessageWriter, System.Text.Encoding encoding) { return(ZipFileExtensions.Read(zipFileName, statusMessageWriter, encoding)); }
/// <summary> /// Reads a zip file archive using the specified the specified TextWriter for /// status messages and returns the instance. /// </summary> /// /// <param name="zipFileName"> /// The name of the zip archive to open. /// This can be a fully-qualified or relative pathname. /// </param> /// /// <param name="statusMessageWriter"> /// The <c>System.IO.TextWriter</c> to use for writing verbose status messages /// during operations on the zip archive. A console application may wish to /// pass <c>System.Console.Out</c> to get messages on the Console. A graphical /// or headless application may wish to capture the messages in a different /// <c>TextWriter</c>, such as a <c>System.IO.StringWriter</c>. /// </param> /// /// <returns>The instance read from the zip archive.</returns> /// public static ZipFile Read(string zipFileName, TextWriter statusMessageWriter) { return(ZipFileExtensions.Read(zipFileName, statusMessageWriter)); }
/// <summary> /// Reads a zip file archive using the specified text encoding and returns the /// instance. /// </summary> /// /// <param name="zipFileName"> /// The name of the zip archive to open. /// This can be a fully-qualified or relative pathname. /// </param> /// /// <param name="encoding"> /// The <c>System.Text.Encoding</c> to use when reading in the zip archive. Be /// careful specifying the encoding. If the value you use here is not the same /// as the Encoding used when the zip archive was created (possibly by a /// different archiver) you will get unexpected results and possibly exceptions. /// </param> /// /// <returns>The instance read from the zip archive.</returns> /// public static ZipFile Read(string zipFileName, System.Text.Encoding encoding) { return(ZipFileExtensions.Read(zipFileName, encoding)); }
/// <summary> /// Reads a zip file archive and returns the instance. /// </summary> /// /// <remarks> /// <para> /// The stream is read using the default <c>System.Text.Encoding</c>, which is the /// <c>IBM437</c> codepage. /// </para> /// </remarks> /// /// <exception cref="System.Exception"> /// Thrown if the <c>ZipFile</c> cannot be read. The implementation of this method /// relies on <c>System.IO.File.OpenRead</c>, which can throw a variety of exceptions, /// including specific exceptions if a file is not found, an unauthorized access /// exception, exceptions for poorly formatted filenames, and so on. /// </exception> /// /// <param name="zipFileName"> /// The name of the zip archive to open. This can be a fully-qualified or relative /// pathname. /// </param> /// /// <seealso cref="ZipFile.Read(String, ReadOptions)"/>. /// /// <returns>The instance read from the zip archive.</returns> /// public static ZipFile Read(string zipFileName) { return(ZipFileExtensions.Read(zipFileName)); }