C# Class Ionic.Zip.ZipFile

Datei anzeigen Open project: haf/DotNetZip.Semverd Class Usage Examples

Public Methods

Method	Description
AddDirectory ( string directoryName ) : ZipEntry	Adds the contents of a filesystem directory to a Zip file archive. The name of the directory may be a relative path or a fully-qualified path. Any files within the named directory are added to the archive. Any subdirectories within the named directory are also added to the archive, recursively. Top-level entries in the named directory will appear as top-level entries in the zip archive. Entries in subdirectories in the named directory will result in entries in subdirectories in the zip archive. If you want the entries to appear in a containing directory in the zip archive itself, then you should call the AddDirectory() overload that allows you to explicitly specify a directory path for use in the archive. For `ZipFile` properties including Encryption, , SetCompression, , ExtractExistingFile, ZipErrorAction, and CompressionLevel, their respective values at the time of this call will be applied to each ZipEntry added.
AddDirectory ( string directoryName, string directoryPathInArchive ) : ZipEntry	Adds the contents of a filesystem directory to a Zip file archive, overriding the path to be used for entries in the archive. The name of the directory may be a relative path or a fully-qualified path. The add operation is recursive, so that any files or subdirectories within the name directory are also added to the archive. Top-level entries in the named directory will appear as top-level entries in the zip archive. Entries in subdirectories in the named directory will result in entries in subdirectories in the zip archive. For `ZipFile` properties including Encryption, , SetCompression, , ExtractExistingFile, ZipErrorAction, and CompressionLevel, their respective values at the time of this call will be applied to each ZipEntry added.
AddDirectoryByName ( string directoryNameInArchive ) : ZipEntry	Creates a directory in the zip archive. Use this when you want to create a directory in the archive but there is no corresponding filesystem representation for that directory. You will probably not need to do this in your code. One of the only times you will want to do this is if you want an empty directory in the zip archive. The reason: if you add a file to a zip archive that is stored within a multi-level directory, all of the directory tree is implicitly created in the zip archive.
AddEntry ( string entryName, OpenDelegate opener, CloseDelegate closer ) : ZipEntry	Add an entry, for which the application will provide a stream containing the entry data, on a just-in-time basis. In cases where the application wishes to open the stream that holds the content for the ZipEntry, on a just-in-time basis, the application can use this method. The application provides an opener delegate that will be called by the DotNetZip library to obtain a readable stream that can be read to get the bytes for the given entry. Typically, this delegate opens a stream. Optionally, the application can provide a closer delegate as well, which will be called by DotNetZip when all bytes have been read from the entry. These delegates are called from within the scope of the call to ZipFile.Save(). For `ZipFile` properties including Encryption, , SetCompression, , ExtractExistingFile, ZipErrorAction, and CompressionLevel, their respective values at the time of this call will be applied to the `ZipEntry` added.
AddEntry ( string entryName, Stream stream ) : ZipEntry	Create an entry in the `ZipFile` using the given `Stream` as input. The entry will have the given filename. The application should provide an open, readable stream; in this case it will be read during the call to ZipFile.Save() or one of its overloads. The passed stream will be read from its current position. If necessary, callers should set the position in the stream before calling AddEntry(). This might be appropriate when using this method with a MemoryStream, for example. In cases where a large number of streams will be added to the `ZipFile`, the application may wish to avoid maintaining all of the streams open simultaneously. To handle this situation, the application should use the AddEntry(string, OpenDelegate, CloseDelegate) overload. For `ZipFile` properties including Encryption, , SetCompression, , ExtractExistingFile, ZipErrorAction, and CompressionLevel, their respective values at the time of this call will be applied to the `ZipEntry` added.
AddEntry ( string entryName, WriteDelegate writer ) : ZipEntry	Add a ZipEntry for which content is written directly by the application. When the application needs to write the zip entry data, use this method to add the ZipEntry. For example, in the case that the application wishes to write the XML representation of a DataSet into a ZipEntry, the application can use this method to do so. For `ZipFile` properties including Encryption, , SetCompression, , ExtractExistingFile, ZipErrorAction, and CompressionLevel, their respective values at the time of this call will be applied to the `ZipEntry` added. About progress events: When using the WriteDelegate, DotNetZip does not issue any SaveProgress events with `EventType` = Saving_EntryBytesRead. (This is because it is the application's code that runs in WriteDelegate - there's no way for DotNetZip to know when to issue a EntryBytesRead event.) Applications that want to update a progress bar or similar status indicator should do so from within the WriteDelegate itself. DotNetZip will issue the other SaveProgress events, including Saving_Started, Saving_BeforeWriteEntry, and Saving_AfterWriteEntry. Note: When you use PKZip encryption, it's normally necessary to compute the CRC of the content to be encrypted, before compressing or encrypting it. Therefore, when using PKZip encryption with a WriteDelegate, the WriteDelegate CAN BE called twice: once to compute the CRC, and the second time to potentially compress and encrypt. Surprising, but true. This is because PKWARE specified that the encryption initialization data depends on the CRC. If this happens, for each call of the delegate, your application must stream the same entry data in its entirety. If your application writes different data during the second call, it will result in a corrupt zip file. The double-read behavior happens with all types of entries, not only those that use WriteDelegate. It happens if you add an entry from a filesystem file, or using a string, or a stream, or an opener/closer pair. But in those cases, DotNetZip takes care of reading twice; in the case of the WriteDelegate, the application code gets invoked twice. Be aware. As you can imagine, this can cause performance problems for large streams, and it can lead to correctness problems when you use a `WriteDelegate`. This is a pretty big pitfall. There are two ways to avoid it. First, and most preferred: don't use PKZIP encryption. If you use the WinZip AES encryption, this problem doesn't occur, because the encryption protocol doesn't require the CRC up front. Second: if you do choose to use PKZIP encryption, write out to a non-seekable stream (like standard output, or the Response.OutputStream in an ASP.NET application). In this case, DotNetZip will use an alternative encryption protocol that does not rely on the CRC of the content. This also implies setting bit 3 in the zip entry, which still presents problems for some zip tools. In the future I may modify DotNetZip to always use bit 3 when PKZIP encryption is in use. This seems like a win overall, but there will be some work involved. If you feel strongly about it, visit the DotNetZip forums and vote up the Workitem tracking this issue.
AddEntry ( string entryName, byte byteContent ) : ZipEntry	Add an entry into the zip archive using the given filename and directory path within the archive, and the given content for the file. No file is created in the filesystem.
AddEntry ( string entryName, string content ) : ZipEntry	Adds a named entry into the zip archive, taking content for the entry from a string. Calling this method creates an entry using the given fileName and directory path within the archive. There is no need for a file by the given name to exist in the filesystem; the name is used within the zip archive only. The content for the entry is encoded using the default text encoding for the machine, or on Silverlight, using UTF-8.
AddEntry ( string entryName, string content, System encoding ) : ZipEntry	Adds a named entry into the zip archive, taking content for the entry from a string, and using the specified text encoding. Calling this method creates an entry using the given fileName and directory path within the archive. There is no need for a file by the given name to exist in the filesystem; the name is used within the zip archive only. The content for the entry, a string value, is encoded using the given text encoding. A BOM (byte-order-mark) is emitted into the file, if the Encoding parameter is set for that. Most Encoding classes support a constructor that accepts a boolean, indicating whether to emit a BOM or not. For example see .
AddFile ( string fileName ) : ZipEntry	Adds a File to a Zip file archive. This call collects metadata for the named file in the filesystem, including the file attributes and the timestamp, and inserts that metadata into the resulting ZipEntry. Only when the application calls Save() on the `ZipFile`, does DotNetZip read the file from the filesystem and then write the content to the zip file archive. This method will throw an exception if an entry with the same name already exists in the `ZipFile`. For `ZipFile` properties including Encryption, , SetCompression, , ExtractExistingFile, ZipErrorAction, and CompressionLevel, their respective values at the time of this call will be applied to the `ZipEntry` added.
AddFile ( string fileName, String directoryPathInArchive ) : ZipEntry	Adds a File to a Zip file archive, potentially overriding the path to be used within the zip archive. The file added by this call to the `ZipFile` is not written to the zip file archive until the application calls Save() on the `ZipFile`. This method will throw an exception if an entry with the same name already exists in the `ZipFile`. This version of the method allows the caller to explicitly specify the directory path to be used in the archive. For `ZipFile` properties including Encryption, , SetCompression, , ExtractExistingFile, ZipErrorAction, and CompressionLevel, their respective values at the time of this call will be applied to the `ZipEntry` added.
AddFiles ( System fileNames ) : void	This method adds a set of files to the `ZipFile`. Use this method to add a set of files to the zip archive, in one call. For example, a list of files received from `System.IO.Directory.GetFiles()` can be added to a zip archive in one call. For `ZipFile` properties including Encryption, , SetCompression, , ExtractExistingFile, ZipErrorAction, and CompressionLevel, their respective values at the time of this call will be applied to each ZipEntry added.
AddFiles ( System fileNames, String directoryPathInArchive ) : void	Adds a set of files to the `ZipFile`, using the specified directory path in the archive. Any directory structure that may be present in the filenames contained in the list is "flattened" in the archive. Each file in the list is added to the archive in the specified top-level directory. For `ZipFile` properties including , Password, , , , , and , their respective values at the time of this call will be applied to each ZipEntry added.
AddFiles ( System fileNames, bool preserveDirHierarchy, String directoryPathInArchive ) : void	Adds a set of files to the `ZipFile`, using the specified directory path in the archive, and preserving the full directory structure in the filenames. Think of the directoryPathInArchive as a "root" or base directory used in the archive for the files that get added. when preserveDirHierarchy is true, the hierarchy of files found in the filesystem will be placed, with the hierarchy intact, starting at that root in the archive. When `preserveDirHierarchy` is false, the path hierarchy of files is flattned, and the flattened set of files gets placed in the root within the archive as specified in `directoryPathInArchive`. For `ZipFile` properties including Encryption, , SetCompression, , ExtractExistingFile, ZipErrorAction, and CompressionLevel, their respective values at the time of this call will be applied to each ZipEntry added.
AddItem ( String fileOrDirectoryName, String directoryPathInArchive ) : ZipEntry	Adds an item, either a file or a directory, to a zip file archive, explicitly specifying the directory path to be used in the archive. If adding a directory, the add is recursive on all files and subdirectories contained within it. The name of the item may be a relative path or a fully-qualified path. The item added by this call to the `ZipFile` is not read from the disk nor written to the zip file archive until the application calls Save() on the `ZipFile`. This version of the method allows the caller to explicitly specify the directory path to be used in the archive, which would override the "natural" path of the filesystem file. Encryption will be used on the file data if the `Password` has been set on the `ZipFile` object, prior to calling this method. For `ZipFile` properties including Encryption, , SetCompression, , ExtractExistingFile, ZipErrorAction, and CompressionLevel, their respective values at the time of this call will be applied to the `ZipEntry` added.
AddItem ( string fileOrDirectoryName ) : ZipEntry	Adds an item, either a file or a directory, to a zip file archive. This method is handy if you are adding things to zip archive and don't want to bother distinguishing between directories or files. Any files are added as single entries. A directory added through this method is added recursively: all files and subdirectories contained within the directory are added to the `ZipFile`. The name of the item may be a relative path or a fully-qualified path. Remember, the items contained in `ZipFile` instance get written to the disk only when you call ZipFile.Save() or a similar save method. The directory name used for the file within the archive is the same as the directory name (potentially a relative path) specified in the fileOrDirectoryName. For `ZipFile` properties including Encryption, , SetCompression, , ExtractExistingFile, ZipErrorAction, and CompressionLevel, their respective values at the time of this call will be applied to the `ZipEntry` added.
RemoveEntries ( System entriesToRemove ) : void	This method removes a collection of entries from the `ZipFile`, by name.
RemoveEntries ( System entriesToRemove ) : void	This method removes a collection of entries from the `ZipFile`.
Save ( ) : void	Saves the Zip archive to a file, specified by the Name property of the `ZipFile`. The `ZipFile` instance is written to storage, typically a zip file in a filesystem, only when the caller calls `Save`. In the typical case, the Save operation writes the zip content to a temporary file, and then renames the temporary file to the desired name. If necessary, this method will delete a pre-existing file before the rename. The ZipFile.Name property is specified either explicitly, or implicitly using one of the parameterized ZipFile constructors. For COM Automation clients, the `Name` property must be set explicitly, because COM Automation clients cannot call parameterized constructors. When using a filesystem file for the Zip output, it is possible to call `Save` multiple times on the `ZipFile` instance. With each call the zip content is re-written to the same output file. Data for entries that have been added to the `ZipFile` instance is written to the output when the `Save` method is called. This means that the input streams for those entries must be available at the time the application calls `Save`. If, for example, the application adds entries with `AddEntry` using a dynamically-allocated `MemoryStream`, the memory stream must not have been disposed before the call to `Save`. See the property for more discussion of the availability requirements of the input stream for an entry, and an approach for providing just-in-time stream lifecycle management.
Save ( Stream outputStream ) : void	Save the zip archive to the specified stream. The `ZipFile` instance is written to storage - typically a zip file in a filesystem, but using this overload, the storage can be anything accessible via a writable stream - only when the caller calls `Save`. Use this method to save the zip content to a stream directly. A common scenario is an ASP.NET application that dynamically generates a zip file and allows the browser to download it. The application can call `Save(Response.OutputStream)` to write a zipfile directly to the output stream, without creating a zip file on the disk on the ASP.NET server. Be careful when saving a file to a non-seekable stream, including `Response.OutputStream`. When DotNetZip writes to a non-seekable stream, the zip archive is formatted in such a way that may not be compatible with all zip tools on all platforms. It's a perfectly legal and compliant zip file, but some people have reported problems opening files produced this way using the Mac OS archive utility.
Save ( String fileName ) : void	Save the file to a new zipfile, with the given name. This method allows the application to explicitly specify the name of the zip file when saving. Use this when creating a new zip file, or when updating a zip archive. An application can also save a zip archive in several places by calling this method multiple times in succession, with different filenames. The `ZipFile` instance is written to storage, typically a zip file in a filesystem, only when the caller calls `Save`. The Save operation writes the zip content to a temporary file, and then renames the temporary file to the desired name. If necessary, this method will delete a pre-existing file before the rename.
UpdateDirectory ( string directoryName ) : ZipEntry	Add or update a directory in a zip archive. If the specified directory does not exist in the archive, then this method is equivalent to calling `AddDirectory()`. If the specified directory already exists in the archive, then this method updates any existing entries, and adds any new entries. Any entries that are in the zip archive but not in the specified directory, are left alone. In other words, the contents of the zip file will be a union of the previous contents and the new files.
UpdateDirectory ( string directoryName, String directoryPathInArchive ) : ZipEntry	Add or update a directory in the zip archive at the specified root directory in the archive. If the specified directory does not exist in the archive, then this method is equivalent to calling `AddDirectory()`. If the specified directory already exists in the archive, then this method updates any existing entries, and adds any new entries. Any entries that are in the zip archive but not in the specified directory, are left alone. In other words, the contents of the zip file will be a union of the previous contents and the new files.
UpdateEntry ( string entryName, OpenDelegate opener, CloseDelegate closer ) : ZipEntry	Updates the given entry in the `ZipFile`, using the given delegates to open and close the stream that provides the content for the `ZipEntry`. Calling this method is equivalent to removing the `ZipEntry` for the given file name and directory path, if it exists, and then calling . See the documentation for that method for further explanation.
UpdateEntry ( string entryName, Stream stream ) : ZipEntry	Updates the given entry in the `ZipFile`, using the given stream as input, and the given filename and given directory Path. Calling the method is equivalent to calling `RemoveEntry()` if an entry by the same name already exists, and then calling `AddEntry()` with the given `fileName` and stream. The stream must be open and readable during the call to `ZipFile.Save`. You can dispense the stream on a just-in-time basis using the ZipEntry.InputStream property. Check the documentation of that property for more information. For `ZipFile` properties including Encryption, , SetCompression, , ExtractExistingFile, ZipErrorAction, and CompressionLevel, their respective values at the time of this call will be applied to the `ZipEntry` added.
UpdateEntry ( string entryName, WriteDelegate writer ) : ZipEntry	Updates the given entry in the `ZipFile`, using the given delegate as the source for content for the `ZipEntry`. Calling this method is equivalent to removing the `ZipEntry` for the given file name and directory path, if it exists, and then calling . See the documentation for that method for further explanation.
UpdateEntry ( string entryName, byte byteContent ) : ZipEntry	Updates the given entry in the `ZipFile`, using the given byte array as content for the entry. Calling this method is equivalent to removing the `ZipEntry` for the given filename and directory path, if it exists, and then calling AddEntry(String,byte[]). See the documentation for that method for further explanation.
UpdateEntry ( string entryName, string content ) : ZipEntry	Updates the given entry in the `ZipFile`, using the given string as content for the `ZipEntry`. Calling this method is equivalent to removing the `ZipEntry` for the given file name and directory path, if it exists, and then calling AddEntry(String,String). See the documentation for that method for further explanation. The string content is encoded using the default encoding for the machine, or on Silverlight, using UTF-8. This encoding is distinct from the encoding used for the filename itself. See AlternateEncoding.
UpdateEntry ( string entryName, string content, System encoding ) : ZipEntry	Updates the given entry in the `ZipFile`, using the given string as content for the `ZipEntry`. Calling this method is equivalent to removing the `ZipEntry` for the given file name and directory path, if it exists, and then calling . See the documentation for that method for further explanation.
UpdateFile ( string fileName ) : ZipEntry	Adds or Updates a File in a Zip file archive. This method adds a file to a zip archive, or, if the file already exists in the zip archive, this method Updates the content of that given filename in the zip archive. The `UpdateFile` method might more accurately be called "AddOrUpdateFile". Upon success, there is no way for the application to learn whether the file was added versus updated. For `ZipFile` properties including Encryption, , SetCompression, , ExtractExistingFile, ZipErrorAction, and CompressionLevel, their respective values at the time of this call will be applied to the `ZipEntry` added.
UpdateFile ( string fileName, String directoryPathInArchive ) : ZipEntry	Adds or Updates a File in a Zip file archive. This method adds a file to a zip archive, or, if the file already exists in the zip archive, this method Updates the content of that given filename in the zip archive. This version of the method allows the caller to explicitly specify the directory path to be used in the archive. The entry to be added or updated is found by using the specified directory path, combined with the basename of the specified filename. Upon success, there is no way for the application to learn if the file was added versus updated. For `ZipFile` properties including Encryption, , SetCompression, , ExtractExistingFile, ZipErrorAction, and CompressionLevel, their respective values at the time of this call will be applied to the `ZipEntry` added.
UpdateFiles ( System fileNames ) : void	Adds or updates a set of files in the `ZipFile`. Any files that already exist in the archive are updated. Any files that don't yet exist in the archive are added. For `ZipFile` properties including Encryption, , SetCompression, , ExtractExistingFile, ZipErrorAction, and CompressionLevel, their respective values at the time of this call will be applied to each ZipEntry added.
UpdateFiles ( System fileNames, String directoryPathInArchive ) : void	Adds or updates a set of files to the `ZipFile`, using the specified directory path in the archive. Any files that already exist in the archive are updated. Any files that don't yet exist in the archive are added. For `ZipFile` properties including Encryption, , SetCompression, , ExtractExistingFile, ZipErrorAction, and CompressionLevel, their respective values at the time of this call will be applied to each ZipEntry added.
UpdateItem ( string itemName ) : void	Add or update a file or directory in the zip archive. This is useful when the application is not sure or does not care if the item to be added is a file or directory, and does not know or does not care if the item already exists in the `ZipFile`. Calling this method is equivalent to calling `RemoveEntry()` if an entry by the same name already exists, followed calling by `AddItem()`. For `ZipFile` properties including Encryption, , SetCompression, , ExtractExistingFile, ZipErrorAction, and CompressionLevel, their respective values at the time of this call will be applied to the `ZipEntry` added.
UpdateItem ( string itemName, string directoryPathInArchive ) : void	Add or update a file or directory. This method is useful when the application is not sure or does not care if the item to be added is a file or directory, and does not know or does not care if the item already exists in the `ZipFile`. Calling this method is equivalent to calling `RemoveEntry()`, if an entry by that name exists, and then calling `AddItem()`. This version of the method allows the caller to explicitly specify the directory path to be used for the item being added to the archive. The entry or entries that are added or updated will use the specified `DirectoryPathInArchive`. Extracting the entry from the archive will result in a file stored in that directory path. For `ZipFile` properties including Encryption, , SetCompression, , ExtractExistingFile, ZipErrorAction, and CompressionLevel, their respective values at the time of this call will be applied to the `ZipEntry` added.

Private Methods

Method	Description
AddOrUpdateDirectoryImpl ( string directoryName, string rootDirectoryPathInArchive, AddOrUpdateAction action ) : ZipEntry
AddOrUpdateDirectoryImpl ( string directoryName, string rootDirectoryPathInArchive, AddOrUpdateAction action, bool recurse, int level ) : ZipEntry
CleanupAfterSaveOperation ( ) : void
DeleteFileWithRetry ( string filename ) : void	Delete file with retry on UnauthorizedAccessException. When calling File.Delete() on a file that has been "recently" created, the call sometimes fails with UnauthorizedAccessException. This method simply retries the Delete 3 times with a sleep between tries.
InternalAddEntry ( String name, ZipEntry entry ) : void
NotifyEntriesSaveComplete ( ICollection c ) : void
RemoveEntryForUpdate ( string entryName ) : void
RemoveTempFile ( ) : void
_InternalAddEntry ( ZipEntry ze ) : ZipEntry

Method Details

AddDirectory() public method

Adds the contents of a filesystem directory to a Zip file archive.

The name of the directory may be a relative path or a fully-qualified path. Any files within the named directory are added to the archive. Any subdirectories within the named directory are also added to the archive, recursively.

Top-level entries in the named directory will appear as top-level entries in the zip archive. Entries in subdirectories in the named directory will result in entries in subdirectories in the zip archive.

If you want the entries to appear in a containing directory in the zip archive itself, then you should call the AddDirectory() overload that allows you to explicitly specify a directory path for use in the archive.

For ZipFile properties including Encryption, , SetCompression, , ExtractExistingFile, ZipErrorAction, and CompressionLevel, their respective values at the time of this call will be applied to each ZipEntry added.

public AddDirectory ( string directoryName ) : ZipEntry
directoryName	string	The name of the directory to add.
return	ZipEntry

AddDirectory() public method

Adds the contents of a filesystem directory to a Zip file archive, overriding the path to be used for entries in the archive.

The name of the directory may be a relative path or a fully-qualified path. The add operation is recursive, so that any files or subdirectories within the name directory are also added to the archive.

public AddDirectory ( string directoryName, string directoryPathInArchive ) : ZipEntry
directoryName	string	The name of the directory to add.
directoryPathInArchive	string	/// Specifies a directory path to use to override any path in the /// DirectoryName. This path may, or may not, correspond to a real directory /// in the current filesystem. If the zip is later extracted, this is the /// path used for the extracted file or directory. Passing null /// (Nothing in VB) or the empty string ("") will insert the items at /// the root path within the archive. ///
return	ZipEntry

AddDirectoryByName() public method

Creates a directory in the zip archive.

Use this when you want to create a directory in the archive but there is no corresponding filesystem representation for that directory.

You will probably not need to do this in your code. One of the only times you will want to do this is if you want an empty directory in the zip archive. The reason: if you add a file to a zip archive that is stored within a multi-level directory, all of the directory tree is implicitly created in the zip archive.

public AddDirectoryByName ( string directoryNameInArchive ) : ZipEntry
directoryNameInArchive	string	/// The name of the directory to create in the archive. ///
return	ZipEntry

AddEntry() public method

Add an entry, for which the application will provide a stream containing the entry data, on a just-in-time basis.

In cases where the application wishes to open the stream that holds the content for the ZipEntry, on a just-in-time basis, the application can use this method. The application provides an opener delegate that will be called by the DotNetZip library to obtain a readable stream that can be read to get the bytes for the given entry. Typically, this delegate opens a stream. Optionally, the application can provide a closer delegate as well, which will be called by DotNetZip when all bytes have been read from the entry.

These delegates are called from within the scope of the call to ZipFile.Save().

public AddEntry ( string entryName, OpenDelegate opener, CloseDelegate closer ) : ZipEntry
entryName	string	the name of the entry to add
opener	OpenDelegate	/// the delegate that will be invoked by ZipFile.Save() to get the /// readable stream for the given entry. ZipFile.Save() will call /// read on this stream to obtain the data for the entry. This data /// will then be compressed and written to the newly created zip /// file. ///
closer	CloseDelegate	/// the delegate that will be invoked to close the stream. This may /// be null (Nothing in VB), in which case no call is makde to close /// the stream. ///
return	ZipEntry

AddEntry() public method

Create an entry in the ZipFile using the given Stream as input. The entry will have the given filename.

The application should provide an open, readable stream; in this case it will be read during the call to ZipFile.Save() or one of its overloads.

The passed stream will be read from its current position. If necessary, callers should set the position in the stream before calling AddEntry(). This might be appropriate when using this method with a MemoryStream, for example.

In cases where a large number of streams will be added to the ZipFile, the application may wish to avoid maintaining all of the streams open simultaneously. To handle this situation, the application should use the AddEntry(string, OpenDelegate, CloseDelegate) overload.

public AddEntry ( string entryName, Stream stream ) : ZipEntry
entryName	string	/// The name, including any path, which is shown in the zip file for the added /// entry. ///
stream	Stream	/// The input stream from which to grab content for the file ///
return	ZipEntry

AddEntry() public method

Add a ZipEntry for which content is written directly by the application.

When the application needs to write the zip entry data, use this method to add the ZipEntry. For example, in the case that the application wishes to write the XML representation of a DataSet into a ZipEntry, the application can use this method to do so.

About progress events: When using the WriteDelegate, DotNetZip does not issue any SaveProgress events with EventType = Saving_EntryBytesRead. (This is because it is the application's code that runs in WriteDelegate - there's no way for DotNetZip to know when to issue a EntryBytesRead event.) Applications that want to update a progress bar or similar status indicator should do so from within the WriteDelegate itself. DotNetZip will issue the other SaveProgress events, including Saving_Started, Saving_BeforeWriteEntry, and Saving_AfterWriteEntry.

Note: When you use PKZip encryption, it's normally necessary to compute the CRC of the content to be encrypted, before compressing or encrypting it. Therefore, when using PKZip encryption with a WriteDelegate, the WriteDelegate CAN BE called twice: once to compute the CRC, and the second time to potentially compress and encrypt. Surprising, but true. This is because PKWARE specified that the encryption initialization data depends on the CRC. If this happens, for each call of the delegate, your application must stream the same entry data in its entirety. If your application writes different data during the second call, it will result in a corrupt zip file.

The double-read behavior happens with all types of entries, not only those that use WriteDelegate. It happens if you add an entry from a filesystem file, or using a string, or a stream, or an opener/closer pair. But in those cases, DotNetZip takes care of reading twice; in the case of the WriteDelegate, the application code gets invoked twice. Be aware.

As you can imagine, this can cause performance problems for large streams, and it can lead to correctness problems when you use a WriteDelegate. This is a pretty big pitfall. There are two ways to avoid it. First, and most preferred: don't use PKZIP encryption. If you use the WinZip AES encryption, this problem doesn't occur, because the encryption protocol doesn't require the CRC up front. Second: if you do choose to use PKZIP encryption, write out to a non-seekable stream (like standard output, or the Response.OutputStream in an ASP.NET application). In this case, DotNetZip will use an alternative encryption protocol that does not rely on the CRC of the content. This also implies setting bit 3 in the zip entry, which still presents problems for some zip tools.

In the future I may modify DotNetZip to *always* use bit 3 when PKZIP encryption is in use. This seems like a win overall, but there will be some work involved. If you feel strongly about it, visit the DotNetZip forums and vote up the Workitem tracking this issue.

public AddEntry ( string entryName, WriteDelegate writer ) : ZipEntry
entryName	string	the name of the entry to add
writer	WriteDelegate	the delegate which will write the entry content
return	ZipEntry

AddEntry() public method

Add an entry into the zip archive using the given filename and directory path within the archive, and the given content for the file. No file is created in the filesystem.

public AddEntry ( string entryName, byte byteContent ) : ZipEntry
entryName	string	/// The name, including any path, to use within the archive for the entry. ///
byteContent	byte	The data to use for the entry.
return	ZipEntry

AddEntry() public method

Adds a named entry into the zip archive, taking content for the entry from a string.

Calling this method creates an entry using the given fileName and directory path within the archive. There is no need for a file by the given name to exist in the filesystem; the name is used within the zip archive only. The content for the entry is encoded using the default text encoding for the machine, or on Silverlight, using UTF-8.

public AddEntry ( string entryName, string content ) : ZipEntry
entryName	string	/// The name, including any path, to use for the entry within the archive. ///
content	string	/// The content of the file, should it be extracted from the zip. ///
return	ZipEntry

AddEntry() public method

Adds a named entry into the zip archive, taking content for the entry from a string, and using the specified text encoding.

The content for the entry, a string value, is encoded using the given text encoding. A BOM (byte-order-mark) is emitted into the file, if the Encoding parameter is set for that.

Most Encoding classes support a constructor that accepts a boolean, indicating whether to emit a BOM or not. For example see .

public AddEntry ( string entryName, string content, System encoding ) : ZipEntry
entryName	string	/// The name, including any path, to use within the archive for the entry. ///
content	string	/// The content of the file, should it be extracted from the zip. ///
encoding	System	/// The text encoding to use when encoding the string. Be aware: This is /// distinct from the text encoding used to encode the fileName, as specified /// in . ///
return	ZipEntry

AddFile() public method

Adds a File to a Zip file archive.

This call collects metadata for the named file in the filesystem, including the file attributes and the timestamp, and inserts that metadata into the resulting ZipEntry. Only when the application calls Save() on the ZipFile, does DotNetZip read the file from the filesystem and then write the content to the zip file archive.

This method will throw an exception if an entry with the same name already exists in the ZipFile.

public AddFile ( string fileName ) : ZipEntry
fileName	string	/// The name of the file to add. It should refer to a file in the filesystem. /// The name of the file may be a relative path or a fully-qualified path. ///
return	ZipEntry

AddFile() public method

Adds a File to a Zip file archive, potentially overriding the path to be used within the zip archive.

The file added by this call to the ZipFile is not written to the zip file archive until the application calls Save() on the ZipFile.

This method will throw an exception if an entry with the same name already exists in the ZipFile.

This version of the method allows the caller to explicitly specify the directory path to be used in the archive.

public AddFile ( string fileName, String directoryPathInArchive ) : ZipEntry
fileName	string	/// The name of the file to add. The name of the file may be a relative path /// or a fully-qualified path. ///
directoryPathInArchive	String	/// Specifies a directory path to use to override any path in the fileName. /// This path may, or may not, correspond to a real directory in the current /// filesystem. If the files within the zip are later extracted, this is the /// path used for the extracted file. Passing null (Nothing in /// VB) will use the path on the fileName, if any. Passing the empty string /// ("") will insert the item at the root path within the archive. ///
return	ZipEntry

AddFiles() public method

This method adds a set of files to the ZipFile.

Use this method to add a set of files to the zip archive, in one call. For example, a list of files received from System.IO.Directory.GetFiles() can be added to a zip archive in one call.

public AddFiles ( System fileNames ) : void
fileNames	System	/// The collection of names of the files to add. Each string should refer to a /// file in the filesystem. The name of the file may be a relative path or a /// fully-qualified path. ///
return	void

AddFiles() public method

Adds a set of files to the ZipFile, using the specified directory path in the archive.

Any directory structure that may be present in the filenames contained in the list is "flattened" in the archive. Each file in the list is added to the archive in the specified top-level directory.

For ZipFile properties including , Password, , , , , and , their respective values at the time of this call will be applied to each ZipEntry added.

public AddFiles ( System fileNames, String directoryPathInArchive ) : void
fileNames	System	/// The names of the files to add. Each string should refer to /// a file in the filesystem. The name of the file may be a /// relative path or a fully-qualified path. ///
directoryPathInArchive	String	/// Specifies a directory path to use to override any path in the file name. /// Th is path may, or may not, correspond to a real directory in the current /// filesystem. If the files within the zip are later extracted, this is the /// path used for the extracted file. Passing null (Nothing in /// VB) will use the path on each of the fileNames, if any. Passing /// the empty string ("") will insert the item at the root path within the /// archive. ///
return	void

AddFiles() public method

Adds a set of files to the ZipFile, using the specified directory path in the archive, and preserving the full directory structure in the filenames.

Think of the directoryPathInArchive as a "root" or base directory used in the archive for the files that get added. when preserveDirHierarchy is true, the hierarchy of files found in the filesystem will be placed, with the hierarchy intact, starting at that root in the archive. When preserveDirHierarchy is false, the path hierarchy of files is flattned, and the flattened set of files gets placed in the root within the archive as specified in directoryPathInArchive.

public AddFiles ( System fileNames, bool preserveDirHierarchy, String directoryPathInArchive ) : void
fileNames	System	/// The names of the files to add. Each string should refer to a file in the /// filesystem. The name of the file may be a relative path or a /// fully-qualified path. ///
preserveDirHierarchy	bool	/// whether the entries in the zip archive will reflect the directory /// hierarchy that is present in the various filenames. For example, if /// includes two paths, /// \Animalia\Chordata\Mammalia\Info.txt and /// \Plantae\Magnoliophyta\Dicotyledon\Info.txt, then calling this method /// with = false will /// result in an exception because of a duplicate entry name, while /// calling this method with = /// true will result in the full direcory paths being included in /// the entries added to the ZipFile. ///
directoryPathInArchive	String	/// Specifies a directory path to use as a prefix for each entry name. /// This path may, or may not, correspond to a real directory in the current /// filesystem. If the files within the zip are later extracted, this is the /// path used for the extracted file. Passing null (Nothing in /// VB) will use the path on each of the fileNames, if any. Passing /// the empty string ("") will insert the item at the root path within the /// archive. ///
return	void

AddItem() public method

Adds an item, either a file or a directory, to a zip file archive, explicitly specifying the directory path to be used in the archive.

If adding a directory, the add is recursive on all files and subdirectories contained within it.

The name of the item may be a relative path or a fully-qualified path. The item added by this call to the ZipFile is not read from the disk nor written to the zip file archive until the application calls Save() on the ZipFile.

This version of the method allows the caller to explicitly specify the directory path to be used in the archive, which would override the "natural" path of the filesystem file.

Encryption will be used on the file data if the Password has been set on the ZipFile object, prior to calling this method.

/// Thrown if the file or directory passed in does not exist. ///

public AddItem ( String fileOrDirectoryName, String directoryPathInArchive ) : ZipEntry
fileOrDirectoryName	String	the name of the file or directory to add. ///
directoryPathInArchive	String	/// The name of the directory path to use within the zip archive. This path /// need not refer to an extant directory in the current filesystem. If the /// files within the zip are later extracted, this is the path used for the /// extracted file. Passing null (Nothing in VB) will use the /// path on the fileOrDirectoryName. Passing the empty string ("") will /// insert the item at the root path within the archive. ///
return	ZipEntry

AddItem() public method

Adds an item, either a file or a directory, to a zip file archive.

This method is handy if you are adding things to zip archive and don't want to bother distinguishing between directories or files. Any files are added as single entries. A directory added through this method is added recursively: all files and subdirectories contained within the directory are added to the ZipFile.

The name of the item may be a relative path or a fully-qualified path. Remember, the items contained in ZipFile instance get written to the disk only when you call ZipFile.Save() or a similar save method.

The directory name used for the file within the archive is the same as the directory name (potentially a relative path) specified in the fileOrDirectoryName.

public AddItem ( string fileOrDirectoryName ) : ZipEntry
fileOrDirectoryName	string	/// the name of the file or directory to add.
return	ZipEntry

RemoveEntries() public method

This method removes a collection of entries from the ZipFile, by name.

public RemoveEntries ( System entriesToRemove ) : void
entriesToRemove	System	/// A collection of strings that refer to names of entries to be removed /// from the ZipFile. For example, you can pass in an array or a /// List of Strings that provide the names of entries to be removed. ///
return	void

RemoveEntries() public method

This method removes a collection of entries from the ZipFile.

public RemoveEntries ( System entriesToRemove ) : void
entriesToRemove	System	/// A collection of ZipEntry instances from this zip file to be removed. For /// example, you can pass in an array of ZipEntry instances; or you can call /// SelectEntries(), and then add or remove entries from that /// ICollection<ZipEntry> (ICollection(Of ZipEntry) in VB), and pass /// that ICollection to this method. ///
return	void

Save() public method

Saves the Zip archive to a file, specified by the Name property of the ZipFile.

The ZipFile instance is written to storage, typically a zip file in a filesystem, only when the caller calls Save. In the typical case, the Save operation writes the zip content to a temporary file, and then renames the temporary file to the desired name. If necessary, this method will delete a pre-existing file before the rename.

The ZipFile.Name property is specified either explicitly, or implicitly using one of the parameterized ZipFile constructors. For COM Automation clients, the Name property must be set explicitly, because COM Automation clients cannot call parameterized constructors.

When using a filesystem file for the Zip output, it is possible to call Save multiple times on the ZipFile instance. With each call the zip content is re-written to the same output file.

Data for entries that have been added to the ZipFile instance is written to the output when the Save method is called. This means that the input streams for those entries must be available at the time the application calls Save. If, for example, the application adds entries with AddEntry using a dynamically-allocated MemoryStream, the memory stream must not have been disposed before the call to Save. See the property for more discussion of the availability requirements of the input stream for an entry, and an approach for providing just-in-time stream lifecycle management.

/// Thrown if you haven't specified a location or stream for saving the zip, /// either in the constructor or by setting the Name property, or if you try /// to save a regular zip archive to a filename with a .exe extension. /// /// Thrown if is non-zero, and the number /// of segments that would be generated for the spanned zip file during the /// save operation exceeds 99. If this happens, you need to increase the /// segment size. ///

public Save ( ) : void
return	void

Save() public method

Save the zip archive to the specified stream.

The ZipFile instance is written to storage - typically a zip file in a filesystem, but using this overload, the storage can be anything accessible via a writable stream - only when the caller calls Save.

Use this method to save the zip content to a stream directly. A common scenario is an ASP.NET application that dynamically generates a zip file and allows the browser to download it. The application can call Save(Response.OutputStream) to write a zipfile directly to the output stream, without creating a zip file on the disk on the ASP.NET server.

Be careful when saving a file to a non-seekable stream, including Response.OutputStream. When DotNetZip writes to a non-seekable stream, the zip archive is formatted in such a way that may not be compatible with all zip tools on all platforms. It's a perfectly legal and compliant zip file, but some people have reported problems opening files produced this way using the Mac OS archive utility.

public Save ( Stream outputStream ) : void
outputStream	Stream	/// The System.IO.Stream to write to. It must be /// writable. If you created the ZipFile instance by calling /// ZipFile.Read(), this stream must not be the same stream /// you passed to ZipFile.Read(). ///
return	void

Save() public method

Save the file to a new zipfile, with the given name.

This method allows the application to explicitly specify the name of the zip file when saving. Use this when creating a new zip file, or when updating a zip archive.

An application can also save a zip archive in several places by calling this method multiple times in succession, with different filenames.

The ZipFile instance is written to storage, typically a zip file in a filesystem, only when the caller calls Save. The Save operation writes the zip content to a temporary file, and then renames the temporary file to the desired name. If necessary, this method will delete a pre-existing file before the rename.

/// Thrown if you specify a directory for the filename. ///

public Save ( String fileName ) : void
fileName	String	/// The name of the zip archive to save to. Existing files will /// be overwritten with great prejudice. ///
return	void

UpdateDirectory() public method

Add or update a directory in a zip archive.

If the specified directory does not exist in the archive, then this method is equivalent to calling AddDirectory(). If the specified directory already exists in the archive, then this method updates any existing entries, and adds any new entries. Any entries that are in the zip archive but not in the specified directory, are left alone. In other words, the contents of the zip file will be a union of the previous contents and the new files.

public UpdateDirectory ( string directoryName ) : ZipEntry
directoryName	string	/// The path to the directory to be added to the zip archive, or updated in /// the zip archive. ///
return	ZipEntry

UpdateDirectory() public method

Add or update a directory in the zip archive at the specified root directory in the archive.

public UpdateDirectory ( string directoryName, String directoryPathInArchive ) : ZipEntry
directoryName	string	/// The path to the directory to be added to the zip archive, or updated /// in the zip archive. ///
directoryPathInArchive	String	/// Specifies a directory path to use to override any path in the /// directoryName. This path may, or may not, correspond to a real /// directory in the current filesystem. If the files within the zip are /// later extracted, this is the path used for the extracted file. Passing /// null (Nothing in VB) will use the path on the /// directoryName, if any. Passing the empty string ("") will insert /// the item at the root path within the archive. ///
return	ZipEntry

UpdateEntry() public method

Updates the given entry in the ZipFile, using the given delegates to open and close the stream that provides the content for the ZipEntry.

Calling this method is equivalent to removing the ZipEntry for the given file name and directory path, if it exists, and then calling . See the documentation for that method for further explanation.

public UpdateEntry ( string entryName, OpenDelegate opener, CloseDelegate closer ) : ZipEntry
entryName	string	/// The name, including any path, to use within the archive for the entry. ///
opener	OpenDelegate	/// the delegate that will be invoked to open the stream ///
closer	CloseDelegate	/// the delegate that will be invoked to close the stream ///
return	ZipEntry

UpdateEntry() public method

Updates the given entry in the ZipFile, using the given stream as input, and the given filename and given directory Path.

Calling the method is equivalent to calling RemoveEntry() if an entry by the same name already exists, and then calling AddEntry() with the given fileName and stream.

The stream must be open and readable during the call to ZipFile.Save. You can dispense the stream on a just-in-time basis using the ZipEntry.InputStream property. Check the documentation of that property for more information.

public UpdateEntry ( string entryName, Stream stream ) : ZipEntry
entryName	string	/// The name, including any path, to use within the archive for the entry. ///
stream	Stream	The input stream from which to read file data.
return	ZipEntry

UpdateEntry() public method

Updates the given entry in the ZipFile, using the given delegate as the source for content for the ZipEntry.

public UpdateEntry ( string entryName, WriteDelegate writer ) : ZipEntry
entryName	string	/// The name, including any path, to use within the archive for the entry. ///
writer	WriteDelegate	the delegate which will write the entry content.
return	ZipEntry

UpdateEntry() public method

Updates the given entry in the ZipFile, using the given byte array as content for the entry.

Calling this method is equivalent to removing the ZipEntry for the given filename and directory path, if it exists, and then calling AddEntry(String,byte[]). See the documentation for that method for further explanation.

public UpdateEntry ( string entryName, byte byteContent ) : ZipEntry
entryName	string	/// The name, including any path, to use within the archive for the entry. ///
byteContent	byte	The content to use for the ZipEntry.
return	ZipEntry

UpdateEntry() public method

Updates the given entry in the ZipFile, using the given string as content for the ZipEntry.

Calling this method is equivalent to removing the ZipEntry for the given file name and directory path, if it exists, and then calling AddEntry(String,String). See the documentation for that method for further explanation. The string content is encoded using the default encoding for the machine, or on Silverlight, using UTF-8. This encoding is distinct from the encoding used for the filename itself. See AlternateEncoding.

public UpdateEntry ( string entryName, string content ) : ZipEntry
entryName	string	/// The name, including any path, to use within the archive for the entry. ///
content	string	/// The content of the file, should it be extracted from the zip. ///
return	ZipEntry

UpdateEntry() public method

Updates the given entry in the ZipFile, using the given string as content for the ZipEntry.

public UpdateEntry ( string entryName, string content, System encoding ) : ZipEntry
entryName	string	/// The name, including any path, to use within the archive for the entry. ///
content	string	/// The content of the file, should it be extracted from the zip. ///
encoding	System	/// The text encoding to use when encoding the string. Be aware: This is /// distinct from the text encoding used to encode the filename. See . ///
return	ZipEntry

UpdateFile() public method

Adds or Updates a File in a Zip file archive.

This method adds a file to a zip archive, or, if the file already exists in the zip archive, this method Updates the content of that given filename in the zip archive. The UpdateFile method might more accurately be called "AddOrUpdateFile".

Upon success, there is no way for the application to learn whether the file was added versus updated.

public UpdateFile ( string fileName ) : ZipEntry
fileName	string	/// The name of the file to add or update. It should refer to a file in the /// filesystem. The name of the file may be a relative path or a /// fully-qualified path. ///
return	ZipEntry

UpdateFile() public method

Adds or Updates a File in a Zip file archive.

This method adds a file to a zip archive, or, if the file already exists in the zip archive, this method Updates the content of that given filename in the zip archive.

This version of the method allows the caller to explicitly specify the directory path to be used in the archive. The entry to be added or updated is found by using the specified directory path, combined with the basename of the specified filename.

Upon success, there is no way for the application to learn if the file was added versus updated.

public UpdateFile ( string fileName, String directoryPathInArchive ) : ZipEntry
fileName	string	/// The name of the file to add or update. It should refer to a file in the /// filesystem. The name of the file may be a relative path or a /// fully-qualified path. ///
directoryPathInArchive	String	/// Specifies a directory path to use to override any path in the /// fileName. This path may, or may not, correspond to a real /// directory in the current filesystem. If the files within the zip are /// later extracted, this is the path used for the extracted file. Passing /// null (Nothing in VB) will use the path on the /// fileName, if any. Passing the empty string ("") will insert the /// item at the root path within the archive. ///
return	ZipEntry

UpdateFiles() public method

Adds or updates a set of files in the ZipFile.

Any files that already exist in the archive are updated. Any files that don't yet exist in the archive are added.

public UpdateFiles ( System fileNames ) : void
fileNames	System	/// The collection of names of the files to update. Each string should refer to a file in /// the filesystem. The name of the file may be a relative path or a fully-qualified path. ///
return	void

UpdateFiles() public method

Adds or updates a set of files to the ZipFile, using the specified directory path in the archive.

Any files that already exist in the archive are updated. Any files that don't yet exist in the archive are added.

public UpdateFiles ( System fileNames, String directoryPathInArchive ) : void
fileNames	System	/// The names of the files to add or update. Each string should refer to a /// file in the filesystem. The name of the file may be a relative path or a /// fully-qualified path. ///
directoryPathInArchive	String	/// Specifies a directory path to use to override any path in the file name. /// This path may, or may not, correspond to a real directory in the current /// filesystem. If the files within the zip are later extracted, this is the /// path used for the extracted file. Passing null (Nothing in /// VB) will use the path on each of the fileNames, if any. Passing /// the empty string ("") will insert the item at the root path within the /// archive. ///
return	void

UpdateItem() public method

Add or update a file or directory in the zip archive.

This is useful when the application is not sure or does not care if the item to be added is a file or directory, and does not know or does not care if the item already exists in the ZipFile. Calling this method is equivalent to calling RemoveEntry() if an entry by the same name already exists, followed calling by AddItem().

public UpdateItem ( string itemName ) : void
itemName	string	/// the path to the file or directory to be added or updated. ///
return	void

UpdateItem() public method

Add or update a file or directory.

This method is useful when the application is not sure or does not care if the item to be added is a file or directory, and does not know or does not care if the item already exists in the ZipFile. Calling this method is equivalent to calling RemoveEntry(), if an entry by that name exists, and then calling AddItem().

This version of the method allows the caller to explicitly specify the directory path to be used for the item being added to the archive. The entry or entries that are added or updated will use the specified DirectoryPathInArchive. Extracting the entry from the archive will result in a file stored in that directory path.

public UpdateItem ( string itemName, string directoryPathInArchive ) : void
itemName	string	/// The path for the File or Directory to be added or updated. ///
directoryPathInArchive	string	/// Specifies a directory path to use to override any path in the /// itemName. This path may, or may not, correspond to a real /// directory in the current filesystem. If the files within the zip are /// later extracted, this is the path used for the extracted file. Passing /// null (Nothing in VB) will use the path on the /// itemName, if any. Passing the empty string ("") will insert the /// item at the root path within the archive. ///
return	void