Zip C# Reference Documentation

Zip

Current Version: 9.5.0.97

Zip compression component.

Object Creation

Chilkat.Zip obj = new Chilkat.Zip();

Properties

AbortCurrent
public bool AbortCurrent {get; set; }
Introduced in version 9.5.0.58

When set to true, causes the currently running method to abort. Methods that always finish quickly (i.e.have no length file operations or network communications) are not affected. If no method is running, then this property is automatically reset to false when the next method is called. When the abort occurs, this property is reset to false. Both synchronous and asynchronous method calls can be aborted. (A synchronous method call could be aborted by setting this property from a separate thread.)

top
AppendFromDir
public string AppendFromDir {get; set; }

When files are added to a Zip archive, they are appended from this directory. For example, to add all the files under c:/abc/123/myAppDir, this property could be set to "c:/abc/123", and "myAppDir/*" would be passed to AppendFiles. The path that is saved in the .zip would be "myAppDir/". (The value of the AppendFromDir property does not become part of the file path saved in the .zip.)

top
AutoRun
public string AutoRun {get; set; }

(Relevant only when running on a Microsoft Windows operating system.) Optional when creating Windows-based self-extracting EXEs. This is the name of an executable contained within the to-be-created EXE that will automatically be run after extraction. (This is typically something like "setup.exe")

top
AutoRunParams
public string AutoRunParams {get; set; }

(Relevant only when running on a Microsoft Windows operating system.) Command line parameters that get passed to the AutoRun executable.

top
AutoTemp
public bool AutoTemp {get; set; }

(Relevant only when running on a Microsoft Windows operating system.) This option applies to creating Windows-based self-extracting EXEs. If true, the to-be-created EXE will automatically select and create a temporary directory for unzipping. This property is often used in conjunction with the AutoRun property to create a self-extracting EXE that automatically unzips to a temp directory and runs a setup.exe without interaction with the user.

Note: To create a self-extracting EXE with no user-interaction, set the following properties to these values:

ExeSilentProgress = false
ExeNoInterface = true
ExeFinishNotifier = false

The default AutoTemp value is false.

top
CaseSensitive
public bool CaseSensitive {get; set; }

If true then all methods that get or search for zip entries by name will use case-sensitive filename matching. If false then filename matching will be case insensitive. Methods affected by this property include GetEntryByName, UnzipMatching, FirstMatchingEntry, etc.

The default value is false.

top
ClearArchiveAttribute
public bool ClearArchiveAttribute {get; set; }

Set this to true to clear the FILE_ATTRIBUTE_ARCHIVE file attribute of each file (in the local filesystem) during a zipping operation.

The default value is false.

Note: The archive attribute or bit, is a Windows file attribute that when is set, it indicates that the file has changed since the last backup operation. When this property is true, Chilkat Zip will clear the archive attribute of each local file after it has been successfully added to the zip.

top
ClearReadOnlyAttr
public bool ClearReadOnlyAttr {get; set; }

If true, the read-only attribute is automatically cleared when unzipping. The default value of this property is false, which leaves the read-only attribute unchanged when unzipping.

top
Comment
public string Comment {get; set; }

The global Zip file comment.

top
DebugLogFilePath
public string DebugLogFilePath {get; set; }

If set to a file path, causes each Chilkat method or property call to automatically append it's LastErrorText to the specified log file. The information is appended such that if a hang or crash occurs, it is possible to see the context in which the problem occurred, as well as a history of all Chilkat calls up to the point of the problem. The VerboseLogging property can be set to provide more detailed information.

This property is typically used for debugging the rare cases where a Chilkat method call hangs or generates an exception that halts program execution (i.e. crashes). A hang or crash should generally never happen. The typical causes of a hang are:

  1. a timeout related property was set to 0 to explicitly indicate that an infinite timeout is desired,
  2. the hang is actually a hang within an event callback (i.e. it is a hang within the application code), or
  3. there is an internal problem (bug) in the Chilkat code that causes the hang.

top
DecryptPassword
public string DecryptPassword {get; set; }

When opening a password-protected or AES encrypted Zip, this is the password to be used for decryption. Encrypted Zips may be opened without setting a password, but the contents cannot be unzipped without setting this password.

Note:The SetPassword method has the effect of setting both this property as well as the EncryptPassword property. The SetPassword method should no longer be used. It has been replaced by the DecryptPassword and EncryptPassword properties to make it possible to open an encrypted zip and re-write it with a new password.

top
DiscardPaths
public bool DiscardPaths {get; set; }

If true, discards all file path information when zipping. The default value is false.

top
Encryption
public int Encryption {get; set; }

Indicate whether the Zip is to be strong encrypted or not. Valid values are 0 (not encrypted) or 4 (AES encrypted). When this property is set to the value 4, WinZip AES compatible encrypted zip archives are produced.

Note: Prior to Chilkat v9.4.1, other possible values for this property were: 1 (blowfish), 2 (twofish), and 3 (rijndael). These settings originally provided a way to produce strong encrypted zips prior to when the AES encrypted Zip standard existed. Using these legacy values (1, 2, or 3) produced encrypted zips that only applications using Chilkat could read. Chilkat no longer supports these custom modes of encryption. If using an older version of Chilkat with one of these deprecated encryption modes, make sure to decrypt using the old Chilkat version and re-encrypt using mode 4 (WinZip compatible AES encryption) prior to updating to the new Chilkat version.

Important:The Encryption and PasswordProtect properties are mutually exclusive. PasswordProtect corresponds to the older Zip 2.0 encryption, commonly referred to as a "password-protected" zip. If the PasswordProtect is set to true, the Encryption property should be set to 0. If the Encryption property is set to a non-zero value, then PasswordProtect should be set to false. A zip cannot be both password-protected and strong-encrypted.

top
EncryptKeyLength
public int EncryptKeyLength {get; set; }

The encryption key length if AES, Blowfish, Twofish, or WinZip-compatible AES encryption is used. This value must be 128, 192, or 256. The default value is 128.

top
EncryptPassword
public string EncryptPassword {get; set; }

The password used when writing a password-protected or strong-encrytped Zip.

Note:The SetPassword method has the effect of setting both this property as well as the DecryptPassword property. The SetPassword method should no longer be used. It has been replaced by the DecryptPassword and EncryptPassword properties to make it possible to open an encrypted zip and re-write it with a new password.

top
ExeDefaultDir
public string ExeDefaultDir {get; set; }

(Relevant only when running on a Microsoft Windows operating system.) Specifies the default unzip directory path to appear in the user-interface dialog box when the Windows-based self-extracting EXE is run.

top
ExeFinishNotifier
public bool ExeFinishNotifier {get; set; }

(Relevant only when running on a Microsoft Windows operating system.) If set to true, a "Finished" dialog box is displayed when the self-extracting EXE is finished extracting. The caption, title, and button text of the finish notifier dialog may be customized by calling SetExeConfigParam. The default value is false.

top
ExeIconFile
public string ExeIconFile {get; set; }

(Relevant only when running on a Microsoft Windows operating system.) Applies to creating self-extracting EXEs. This property can be set to a pre-existing icon filename (.ico) that will be embedded within the to-be-created EXE and set as its default icon.

Note: This property is only possible for 32-bit applications. (Meaning that the application that is creating the self-extracting EXE must be a 32-bit application if an ExeIconFile is to be used.)

top
ExeNoInterface
public bool ExeNoInterface {get; set; }

(Relevant only when running on a Microsoft Windows operating system.) Applies to creating Windows-based self-extracting EXEs. When set to true, the to-be-created EXE will run without a user-interface. The default value is false.

Note: The ExeSilentProgress property needs to be set to true for the extract to be truly silent.

Important: If the AutoTemp property = true and there is no AutoRun EXE, and there is no ExeUnzipDir set, then the self-extracting EXE will always display a dialog to get the unzip directory. The reason is that it makes no sense to silently unzip to an auto-selected (and unknown) temp directory without anything happening afterwards.

Important: If the self-extracting EXE is encrypted, a password dialog will be displayed. The password dialog may be suppressed if the password is provided on the command line via the -pwd command-line option.

top
ExeSilentProgress
public bool ExeSilentProgress {get; set; }

(Relevant only when running on a Microsoft Windows operating system.) Determines whether a progress dialog is displayed when the self-extracting EXE is run. If ExeNoInterface = false (i.e. there is a main dialog with the ability to select the unzip directory), then the progress dialog is (by default) shown as a progress bar within the main dialog -- and this property has no effect. If ExeNoInterface = true, then a progress-only dialog is displayed if ExeSilentProgress = false. The default value of ExeSilentProgress is true.

top
ExeTitle
public string ExeTitle {get; set; }

(Relevant only when running on a Microsoft Windows operating system.) Applies to creating Windows-based self-extracting EXEs. Sets the title of the main user-interface dialog that appears when the self-extracting EXE runs.

top
ExeUnzipCaption
public string ExeUnzipCaption {get; set; }

(Relevant only when running on a Microsoft Windows operating system.) Applies to creating MS Windows-based self-extracting EXEs. Sets the unzipping caption of the main user-interface dialog that appears when the self-extracting EXE runs.

top
ExeUnzipDir
public string ExeUnzipDir {get; set; }

(Relevant only when running on a Microsoft Windows operating system.) Applies to creating MS Windows self-extracting EXEs. Stores a pre-defined unzip directory within the self-extracting EXE so that it automatically unzips to this directory without user-intervention.

Environment variables may be included if surrounded by percent characters. For example: %TEMP%. Environment variables are expanded (i.e. resolved) when the self-extracting EXE runs.

Note: UNC paths, such as \\servername\path, are not supported.

Note: To create a self-extracting EXE with no user-interaction, set the following properties to these values:

ExeSilentProgress  = false<br>
ExeNoInterface = true<br>
ExeFinishNotifier = false

top
ExeWaitForSetup
public bool ExeWaitForSetup {get; set; }

(Relevant only when running on a Microsoft Windows operating system.) If true, the self-extracting EXE will wait for the AutoRun EXE to complete before it exits. If false, the self-extracting EXE dialog (or process if running silently with no user-interface), is allowed to exit prior to the completion of the AutoRun EXE. The default value is true.

top
ExeXmlConfig
public string ExeXmlConfig {get; set; }

(Relevant only when running on a Microsoft Windows operating system.) Allows for an XML config document to be used to specify all possible options for self-extracting EXEs. This property is a string containing the XML config document.

The XML should have this format:

<SfxConfig>
	<ErrPwdTitle>Title for incorrect password dialog</ErrPwdTitle>
	<ErrPwdCaption>Caption for incorrect password dialog</ErrPwdCaption>
	<FinOkBtn>Text on finish notifier button</FinOkBtn>
	<PwdOkBtn>Text on password challenge dialog's "OK" button.</PwdOkBtn>
	<PwdCancelBtn>Text on password challenge dialog's Cancel button.</PwdCancelBtn>
	<ErrInvalidPassword>Incorrect password error message.</ErrInvalidPassword>
	<MainUnzipBtn>Text on main dialog's unzip button</MainUnzipBtn>
	<MainCloseBtn>Text on main dialog's quit/exit button</MainCloseBtn>
	<MainBrowseBtn>Text on main dialog's browse-for-directory button.</MainBrowseBtn>
	<MainUnzipLabel>Caption displayed in main dialog.</MainUnzipLabel>
	<AutoTemp>"1|0 (Maps to the AutoTemp property)"</AutoTemp>
	<Cleanup>"1|0 (Deletes extracted files after the SetupExe is run.)"</Cleanup>
	<Debug>"1|0  (If 1, the EXE will not extract any files.)"</Debug>
	<Verbose>"1|0 (If 1, then verbose information is sent to the log.)"</Verbose>
	<ShowFin>"1|0" Maps to ExeFinishNotifier property.</ShowFin>
	<ShowMain>"1|0" Maps to ExeNoInterface property.</ShowMain>
	<ShowProgress>"1|0" Maps to ExeSilentProgress property.</ShowProgress>
	<WaitForSetup>"1|0" Maps to ExeWaitForSetup property.</WaitForSetup>
	<Encryption>"1|0"  1=Yes, 0=No</Encryption>
	<KeyLength>128|192|256</KeyLength>
	<SetupExe>EXE to run after extracting. (Maps to AutoRun property)</SetupExe>
	<UnzipDir>Pre-defined unzip directory. (Maps to ExeUnzipDir property, 
                                                UNC paths, such as \\servername\path, are not supported.)>
	<DefaultDir>Default unzip directory to appear in the main dialog. 
                                                (Maps to ExeDefaultDir property)</DefaultDir>
	<IconFile>Icon file to be used (Maps to ExeIconFile property)</IconFile>
	<Url>Maps to ExeSourceUrl property.</Url>
	<MainTitle>Maps to ExeTitle property.</MainTitle>
	<MainCaption>Maps to ExeUnzipCaption property.</MainCaption>
	<FinTitle>Title for the finish notifier dialog.</FinTitle>
	<FinCaption>Caption for the finish notifier dialog.</FinTitle>
	<ProgressTitle>Title for the progress dialog.</ProgressTitle>
	<ProgressCaption>Caption for the progress dialog.</ProgressCaption>
	<PwTitle>Title for the password challenge dialog.</PwTitle>
	<PwCaption>Caption for the password challenge dialog.</PwCaption>
</SfxConfig>

A self-extracting EXE can be run from the command line with the "-log {logFilePath}" option to create a log with information for debugging.

top
FileCount
public int FileCount {get; }

The number of files (excluding directories) contained within the Zip.

top
FileName
public string FileName {get; set; }

The path (absolute or relative) of the Zip archive. This is the path of the file that is created or overwritten when the zip is saved.

top
HasZipFormatErrors
public bool HasZipFormatErrors {get; }

true if the opened zip contained file format errors (that were not severe enough to prevent the zip from being opened and parsed).

top
HeartbeatMs
public int HeartbeatMs {get; set; }

The number of milliseconds between each AbortCheck event callback. The AbortCheck callback allows an application to abort any method call prior to completion. If HeartbeatMs is 0 (the default), no AbortCheck event callbacks will fire.

top
IgnoreAccessDenied
public bool IgnoreAccessDenied {get; set; }

If true, then files that cannot be read due to "access denied" (i.e. a file permission error) will be ignored and the call to WriteZip, WriteZipAndClose, WriteExe, etc. will return a success status. If false, then the "access denied" filesystem errors are not ignored and any occurrence will cause the zip writing to fail. The default value is true.

top
LastErrorHtml
public string LastErrorHtml {get; }

Provides information in HTML format about the last method/property called. If a method call returns a value indicating failure, or behaves unexpectedly, examine this property to get more information.

top
LastErrorText
public string LastErrorText {get; }

Provides information in plain-text format about the last method/property called. If a method call returns a value indicating failure, or behaves unexpectedly, examine this property to get more information.

top
LastErrorXml
public string LastErrorXml {get; }

Provides information in XML format about the last method/property called. If a method call returns a value indicating failure, or behaves unexpectedly, examine this property to get more information.

top
LastMethodSuccess
public bool LastMethodSuccess {get; set; }

Indicate whether the last method call succeeded or failed. A value of true indicates success, a value of false indicates failure. This property is automatically set for method calls. It is not modified by property accesses. The property is automatically set to indicate success for the following types of method calls:

  • Any method that returns a string.
  • Any method returning a Chilkat object, binary bytes, or a date/time.
  • Any method returning a standard boolean status value where success = true and failure = false.
  • Any method returning an integer where failure is defined by a return value less than zero.

Note: Methods that do not fit the above requirements will always set this property equal to true. For example, a method that returns no value (such as a "void" in C++) will technically always succeed.

top
MaxUncompressSize
public uint MaxUncompressSize {get; set; }
Introduced in version 9.5.0.96

An application can set this property to prevent unzipping any files larger than a max size uncompressed. The default value of this property is 0, which means any size file can be unzipped.

top
NumEntries
public int NumEntries {get; }

The number of entries in the Zip, including both files and directories.

top
OemCodePage
public int OemCodePage {get; set; }

Sets the OEM code page to be used for Unicode filenames. This property defaults to the OEM code page of the computer.

top
OverwriteExisting
public bool OverwriteExisting {get; set; }

Determines whether existing files are overwritten during unzipping. The default is true, which means that already-existing files will be overwritten. Set this property = false to prevent existing files from being overwritten when unzipping.

top
PasswordProtect
public bool PasswordProtect {get; set; }

true if the Zip should be password-protected using older Zip 2.0 encryption, commonly referred to as "password-protection".

This property is set when a zip archive is opened by any of the Open* methods, such as OpenZip, OpenFromMemory, etc.

top
PathPrefix
public string PathPrefix {get; set; }

A prefix that is added to each filename when zipping. One might set the PathPrefix to "subdir/" so that files are unzipped to a specified subdirectory when unzipping.

top
PercentDoneScale
public int PercentDoneScale {get; set; }
Introduced in version 9.5.0.49

This property is only valid in programming environment and languages that allow for event callbacks.

Sets the value to be defined as 100% complete for the purpose of PercentDone event callbacks. The defaut value of 100 means that at most 100 event PercentDone callbacks will occur in a method that (1) is event enabled and (2) is such that it is possible to measure progress as a percentage completed. This property may be set to larger numbers to get more fine-grained PercentDone callbacks. For example, setting this property equal to 1000 will provide callbacks with .1 percent granularity. For example, a value of 453 would indicate 45.3% competed. This property is clamped to a minimum value of 10, and a maximum value of 100000.

top
PwdProtCharset
public string PwdProtCharset {get; set; }
Introduced in version 9.5.0.73

For older password-protected Zip archives (Zip 2.0 encryption), specifies the charset used for the binary representation of the decrypt password. The default value is "ansi". Other possible choices are cp850, cp437, or any of the code pages listed at the link below.

top
TempDir
public string TempDir {get; set; }

The temporary directory to use when unzipping files or writing a .zip (see the note below). When running in ASP or ASP.NET, the default value of TempDir is set to the directory where the .zip is being written. Set this property to override the default.

Note: When writing a .zip, a temp file is only used if overwriting an existing .zip. The reason is to prevent losing the existing .zip if something fails when writing the new .zip. If the new .zip is successfully written, then the existing .zip is replaced with the new .zip.

top
TextFlag
public bool TextFlag {get; set; }

If set to true, the component will set the "text flag" for each file having these filename extensions: .txt, .xml, .htm, and .html. It will also preserve the "text flag" for existing zips that are opened and rewritten. By default, this property is set to false.

It is generally not necessary to set the text flag for a zip entry.

top
UncommonOptions
public string UncommonOptions {get; set; }
Introduced in version 9.5.0.84

This is a catch-all property to be used for uncommon needs. This property defaults to the empty string, and should typically remain empty.

Currently, the only possible option is "ForceZip64".

  • "ForceZip64" - Force the zip to be written with the Zip64 file format, even if not necessary.

top
VerboseLogging
public bool VerboseLogging {get; set; }

If set to true, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. The default value is false. Verbose logging should only be used for debugging. The potentially large quantity of logged information may adversely affect peformance.

top
Version
public string Version {get; }

Version of the component/library, such as "9.5.0.94"

top
Zipx
public bool Zipx {get; set; }

Starting in v9.4.1, Chilkat Zip will automatically unzip ZIPX files using any of the following compression methods: BZIP2, PPMd, LZMA, and Deflate64 ("Deflate64" is a trademark of PKWare, Inc.)

This property, however, controls whether or not a ZipX is automatically produced where the best compression algorithm for each file is automatically chosen based on file type. This property is for writing zip archives. It does not apply to when unzipping ZIPX archives, Chilkat Zip automatically handles the various compression algorithms when unzipping.

top
ZipxDefaultAlg
public string ZipxDefaultAlg {get; set; }

The default compression algorithm to be used when creating ZIPX archives. The default value is "deflate". Other possible values are "ppmd", "lzma", "bzip2" and "deflate64". When writing a ZIPX archive, if the file extension does not indicate an obvious choice for the appropriate compression algorithm, then the ZipxDefaultAlg is used.

top

Methods

AddEmbedded
public bool AddEmbedded(string exeFilename, string resourceName, string zipFilename);

(Relevant only when running on a Microsoft Windows operating system.) Embeds a Zip file into an EXE as a custom resource. This resource can be opened by the EXE containing it at runtime by using the OpenMyEmbedded method.

Important: In Visual Studio 2010, the linker has a property "Randomized Base Address" (Project Properties/Linker) that defaults to "YES", but the default is "NO" in Visual Studio 2008. (The property is nonexistent in Visual Studio 2005 and earlier.) This enables ASLR ( Address Space Layout Randomization) in Vista and up, and prevents the proper code injection in the executable address space. To successfully embed a .zip as a resource within an EXE, this Visual Studio property must be set to "NO".

Returns true for success, false for failure.

top
AddNoCompressExtension
public void AddNoCompressExtension(string fileExtension);

Attempting to compress already-compressed data is usually a waste of CPU cycles with little or no benefit. In fact, it is possible that attempting to compress already-compressed data results in a slightly increased size. The Zip file format allows for files to be "stored" rather than compressed. This allows the file data to be streamed directly into a .zip without compression.

An instance of the Zip object has an internal list of "no compress" extensions. A filename with a "no compress" extension is "stored" rather than compressed. Additional "no compress" extensions may be added by calling this method (once per file extension). You should pass the file extension, such as ".xyz" in fileExtension.

"no compress" extensions may be removed by calling RemoveNoCompressExtension.

The default "no compress" extensions are: .zip, .gif, .jpg, .gz, .rar, .jar, .tgz, .bz2, .z, .rpm, .msi, .png

top
AppendBase64
public ZipEntry AppendBase64(string fileName, string encodedCompressedData);

Creates a new Zip entry and initializes it with already-compressed data that is Base64 encoded. (The ZipEntry.CopyBase64 method can be used to retrieve the compressed data in Base64 format.)

Note 1: This method only updates the zip object. To update (rewrite) a zip file, either the WriteZip or WriteZipAndClose method would need to be called.

Note 2: It is assumed that the compressed data is unencrypted deflated data. (Meaning data compressed using the "deflate" compression algorithm.)

Returns null on failure

top
AppendBd
public ZipEntry AppendBd(string pathInZip, BinData byteData);
Introduced in version 9.5.0.70

Appends the contents of byteData as a new entry to this zip object. The zip entry object containing the data is returned.

Returns null on failure

top
AppendCompressed
public ZipEntry AppendCompressed(string filename, byte[] inData);

Append memory data that is already Zip-compressed to the Zip object. The ZipEntry object containing the compressed data is returned. Note: This method appends the compressed data for a single zip entry. To load an entire in-memory .zip, call OpenFromMemory instead.

Note 1: This method only updates the zip object. To update (rewrite) a zip file, either the WriteZip or WriteZipAndClose method would need to be called.

Note 2: It is assumed that the compressed data is unencrypted deflated data. (Meaning data compressed using the "deflate" compression algorithm.)

Returns null on failure

top
AppendData
public ZipEntry AppendData(string fileName, byte[] inData);

Appends in-memory data as a new entry to a Zip object. The ZipEntry object containing the data is returned.

Note: This method only updates the zip object. To update (rewrite) a zip file, either the WriteZip or WriteZipAndClose method would need to be called.

Returns null on failure

top
AppendDataEncoded
public ZipEntry AppendDataEncoded(string filename, string encoding, string data);
Introduced in version 9.5.0.59

Appends in-memory data as a new entry to a Zip object. The filename is the filename of the entry as it will appear within the zip. The encoding is the encoding of the data, such as "base64", "hex", etc. The full list of encodings is listed at the web page linked below.

Returns the zip entry object.

Note: This method only updates the zip object. To update (rewrite) a zip file, either the WriteZip or WriteZipAndClose method would need to be called.

Returns null on failure

More Information and Examples
top
AppendFiles
public bool AppendFiles(string filePattern, bool recurse);

Appends one or more files to the Zip object. The filePattern can use the "*" wildcard character for 0 or more of any characterSet recurse equal to True to recursively add all subdirectories, or False to only add files in the current directory.

Note: This method only updates the zip object. To update (rewrite) a zip file, either the WriteZip or WriteZipAndClose method would need to be called.

Returns true for success, false for failure.

top
AppendFilesAsync (.NET Core C#) (C#) (Mono C#) (PowerShell)
public Task AppendFilesAsync(string filePattern, bool recurse);

Creates an asynchronous task to call the AppendFiles method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns null on failure

top
AppendFilesEx
public bool AppendFilesEx(string filePattern, bool recurse, bool saveExtraPath, bool archiveOnly, bool includeHidden, bool includeSystem);

Appends one or more files to the Zip object. The filePattern can use the "*" to mean 0 or more of any character. The recurse controls whether directories are recursively traversed. Set recurse equal to true to append files and subdirectories in the directory tree. Set recurse equal to false to add files only from the indicated directory.

The saveExtraPath only applies when the filePattern is an absolute path pattern, such as "C:/temp/abc/*.txt". If saveExtraPath is true, then the absolute path will be included in the zip entry filenames as relative paths. For example, "temp/abc/xyz.txt".

The archiveOnly, includeHidden, and includeSystem flags only apply when on the Windows operating system. If archiveOnly is true, then only files that have the archive bit set will be included in the zip. If includeHidden is false, then hidden files are not included. If includeSystem is false, then files having the System attribute are not included.

Note: This method does not write the zip archive. It simply adds references to the files that will be included in the .zip when the WriteZip or WriteZipAndClose methods are eventually called. Files and/or data may be added to the zip object by calling any combination of the Append* methods before finally writing the zip via one of the Write* methods.

Returns true for success, false for failure.

top
AppendFilesExAsync (.NET Core C#) (C#) (Mono C#) (PowerShell)
public Task AppendFilesExAsync(string filePattern, bool recurse, bool saveExtraPath, bool archiveOnly, bool includeHidden, bool includeSystem);

Creates an asynchronous task to call the AppendFilesEx method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns null on failure

top
AppendHex
public ZipEntry AppendHex(string fileName, string encodedCompressedData);

Creates a new Zip entry and initializes it with already-compressed data that is hexidecimal encoded. (The ZipEntry.CopyHex method can be used to retrieve the compressed data in Hex format.)

Note 1: This method only updates the zip object. To update (rewrite) a zip file, either the WriteZip or WriteZipAndClose method would need to be called.

Note 2: It is assumed that the compressed data is unencrypted deflated data. (Meaning data compressed using the "deflate" compression algorithm.)

Returns null on failure

top
AppendMultiple
public bool AppendMultiple(StringArray fileSpecs, bool recurse);

This method is the same as calling AppendFiles multiple times - once for each file pattern in fileSpecs

Note: This method only updates the zip object. To update (rewrite) a zip file, either the WriteZip or WriteZipAndClose method would need to be called.

Returns true for success, false for failure.

top
AppendMultipleAsync (.NET Core C#) (C#) (Mono C#) (PowerShell)
public Task AppendMultipleAsync(StringArray fileSpecs, bool recurse);

Creates an asynchronous task to call the AppendMultiple method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns null on failure

top
AppendNew
public ZipEntry AppendNew(string fileName);

Appends a new and empty entry to the Zip object and returns the ZipEntry object. Data can be appended to the entry by calling ZipEntry.AppendData.

Important: To append an already-existing file, call the AppendOneFileOrDir method. The AppendNew method inserts a new and empty file entry within the Zip object. The purpose of AppendNew is to either create an empty file within the Zip, or to create a new file entry which can then be filled with data by calling the entry's AppendData method.

Note: This method only updates the zip object. To update (rewrite) a zip file, either the WriteZip or WriteZipAndClose method would need to be called.

Returns null on failure

top
AppendNewDir
public ZipEntry AppendNewDir(string dirName);

Adds an entry to the zip so that when it unzips, a new directory (with no files) is created. The directory does not need to exist on the local filesystem when calling this method. The dirName is simply a string that is used as the directory path for the entry added to the zip. The zip entry object is returned.

Note: This method only updates the zip object. To update (rewrite) a zip file, either the WriteZip or WriteZipAndClose method would need to be called.

Returns null on failure

top
AppendOneFileOrDir
public bool AppendOneFileOrDir(string fileOrDirPath, bool saveExtraPath);

Appends a single file or directory to the Zip object. The saveExtraPath applies when fileOrDirPath is an absolute (non-relative) path. If saveExtraPath is true, then the absolute path is made relative and saved in the zip. For example, if the fileOrDirPath is "C:/temp/xyz/test.txt" and saveExtraPath is true, then the path in the zip will be "./temp/xyz/test.txt". If however, fileOrDirPath contains a relative path, then saveExtraPath has no effect.

Returns true for success, false for failure.

top
AppendOneFileOrDirAsync (.NET Core C#) (C#) (Mono C#) (PowerShell)
public Task AppendOneFileOrDirAsync(string fileOrDirPath, bool saveExtraPath);

Creates an asynchronous task to call the AppendOneFileOrDir method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns null on failure

top
AppendString
public ZipEntry AppendString(string internalZipFilepath, string textData);

Adds an in-memory string to the Zip object. The textData argument is converted to the ANSI charset before being added to the Zip. If the Zip were written to disk by calling WriteZip, and later unzipped, the entry would unzip to an ANSI text file.

Note: This method only updates the zip object. To update (rewrite) a zip file, either the WriteZip or WriteZipAndClose method would need to be called.

Returns null on failure

top
AppendString2
public ZipEntry AppendString2(string internalZipFilepath, string textData, string charset);

Same as AppendString, but allows the charset to be specified. The textData is converted to charset before being added to the zip. The internalZipFilepath is the path of the file that will be stored within the zip.

Note: This method only updates the zip object. To update (rewrite) a zip file, either the WriteZip or WriteZipAndClose method would need to be called.

Returns null on failure

top
AppendZip
public bool AppendZip(string zipFileName);

Adds the contents of another existing Zip file to this Zip object.

Returns true for success, false for failure.

top
CloseZip
public void CloseZip();

Closes an open Zip file. This is identical to calling NewZip. (NewZip closes the current Zip file, if open, and initializes the Zip object to be empty. Zip files are only created when WriteZip is called.)

top
DeleteEntry
public bool DeleteEntry(ZipEntry entry);

Removes a Zip entry from the calling Zip object.

Returns true for success, false for failure.

top
ExcludeDir
public void ExcludeDir(string dirName);

Adds a directory name to be excluded when AppendFiles is called to add an entire directory tree. All directories having a name equal to an excluded directory will not be included when AppendFiles (or AppendFileEx) is called. Multiple directories can be excluded by calling ExcludeDir multiple times. The name comparison is case-insensitive.

top
Extract
public bool Extract(string dirPath);

Unzip all the files into the specified directory. Subdirectories are automatically created as needed.

Returns true for success, false for failure.

top
ExtractAsync (.NET Core C#) (C#) (Mono C#) (PowerShell)
public Task ExtractAsync(string dirPath);

Creates an asynchronous task to call the Extract method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns null on failure

top
ExtractExe
public bool ExtractExe(string exePath, string dirPath);
Introduced in version 9.5.0.44

Extracts files from a Chilkat produced self-extracting EXE into the specified directory. Subdirectories are automatically created as needed. If the self-extracting EXE is encrypted, be sure to set the DecryptPassword property prior to calling this method.

Returns true for success, false for failure.

top
ExtractExeAsync (.NET Core C#) (C#) (Mono C#) (PowerShell)
public Task ExtractExeAsync(string exePath, string dirPath);
Introduced in version 9.5.0.44

Creates an asynchronous task to call the ExtractExe method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns null on failure

top
ExtractInto
public bool ExtractInto(string dirPath);

Unzips all the files in a Zip into a single directory regardless of the path stored in the Zip

Returns true for success, false for failure.

top
ExtractIntoAsync (.NET Core C#) (C#) (Mono C#) (PowerShell)
public Task ExtractIntoAsync(string dirPath);

Creates an asynchronous task to call the ExtractInto method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns null on failure

top
ExtractMatching
public bool ExtractMatching(string dirPath, string pattern);

Unzip all files matching a wildcard pattern.

Returns true for success, false for failure.

top
ExtractMatchingAsync (.NET Core C#) (C#) (Mono C#) (PowerShell)
public Task ExtractMatchingAsync(string dirPath, string pattern);

Creates an asynchronous task to call the ExtractMatching method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns null on failure

top
ExtractNewer
public bool ExtractNewer(string dirPath);

Extracts only the files that have more recent last-modified-times than the files on disk. This allows you to easily refresh only the files that have been updated.

Returns true for success, false for failure.

top
ExtractNewerAsync (.NET Core C#) (C#) (Mono C#) (PowerShell)
public Task ExtractNewerAsync(string dirPath);

Creates an asynchronous task to call the ExtractNewer method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns null on failure

top
FirstEntry
public ZipEntry FirstEntry();

Return the first entry in the Zip. Call ZipEntry.NextEntry to iterate over the entries in a Zip until a NULL is returned.

Returns null on failure

top
FirstMatchingEntry
public ZipEntry FirstMatchingEntry(string pattern);

Returns the first entry having a filename matching a pattern. The "*" characters matches 0 or more of any character. The full filename, including path, is used when matching against the pattern. A NULL is returned if nothing matches.

Returns null on failure

top
GetDirectoryAsXML
public string GetDirectoryAsXML();

Return the contents of the Zip file directory in an XML formatted string

Returns null on failure

top
GetEntryByID
public ZipEntry GetEntryByID(int entryID);

Retrieves a ZipEntry by ID. Chilkat Zip.NET automatically assigns a unique ID to each ZipEntry in the Zip. This feature makes it easy to associate an item in a UI control with a ZipEntry.

Returns null on failure

top
GetEntryByIndex
public ZipEntry GetEntryByIndex(int index);

Retrieves a ZipEntry by index. The first entry is at index 0. This will return directory entries as well as files.

Returns null on failure

top
GetEntryByName
public ZipEntry GetEntryByName(string entryName);

Returns a ZipEntry by filename. If a full or partial path is part of the filename, this must be included in the entryName. Zip archives generally use forward slashes for directory separators. Use a forward slashes instead of backslash chars conventionally used in Windows.

Returns null on failure

top
GetExclusions
public StringArray GetExclusions();

Returns the current collection of exclusion patterns that have been set by SetExclusions.

Returns null on failure

top
GetExeConfigParam
public string GetExeConfigParam(string name);

(Relevant only when running on a Microsoft Windows operating system.) Gets the value of an EXE config param as described in the ExeXmlConfig property.

Returns null on failure

top
GetMaxUncompressedSize
public string GetMaxUncompressedSize();
Introduced in version 9.5.0.96

Returns the size of the file contained within the Zip that has the largest uncompressed size. The size is returned in string form because it could be larger than what can be held in a 32-bit unsigned integer, and we leave it to the application to convert the string to an integer number. (If necessary. Perhaps your application is only interested in the order of magnitude, which can be known by the length of the string.)

Returns null on failure

top
InsertNew
public ZipEntry InsertNew(string fileName, int beforeIndex);

Inserts a new and empty entry into the Zip object. To insert at the beginning of the Zip, beforeIndex should be 0. The ZipEntry's FileName property is initialized to fileName parameter.

Returns null on failure

top
IsNoCompressExtension
public bool IsNoCompressExtension(string fileExtension);

Returns true if the fileExtension is contained in the set of "no compress" extensions, otherwise returns false. (See the documentation for the AddNoCompressExtension method.) The fileExtension may be passed with or without the ".". For example, both ".jpg" and "jpg" are acceptable.

top
IsPasswordProtected
public bool IsPasswordProtected(string zipFilename);

Return True if a Zip file is password protected

top
LoadTaskCaller
public bool LoadTaskCaller(Task task);
Introduced in version 9.5.0.80

Loads the caller of the task's async method.

Returns true for success, false for failure.

top
NewZip
public bool NewZip(string zipFilePath);

Clears and initializes the contents of the Zip object. If a Zip file was open, it is closed and all entries are removed from the object. The FileName property is set to the zipFilePath argument.

top
OpenBd
public bool OpenBd(BinData binData);
Introduced in version 9.5.0.66

Open a Zip contained in binData.

When a zip is opened, the PasswordProtect and Encryption properties will be appropriately set. If the zip is password protected (i.e. uses older Zip 2.0 encrypion), then the PasswordProtect property will be set to true. If the zip is strong encrypted, the Encryption property will be set to a value 1 through 4, where 4 indicates WinZip compatible AES encryption.

Returns true for success, false for failure.

top
OpenEmbedded
public bool OpenEmbedded(string exeFilename, string resourceName);

(Relevant only when running on a Microsoft Windows operating system.) Opens a Zip embedded in an MS Windows EXE

Returns true for success, false for failure.

top
OpenFromByteData
public bool OpenFromByteData(byte[] byteData);

Same as OpenFromMemory.

When a zip is opened, the PasswordProtect and Encryption properties will be appropriately set. If the zip is password protected (i.e. uses older Zip 2.0 encrypion), then the PasswordProtect property will be set to true. If the zip is strong encrypted, the Encryption property will be set to a value 1 through 4, where 4 indicates WinZip compatible AES encryption.

Returns true for success, false for failure.

top
OpenFromMemory
public bool OpenFromMemory(byte[] inData);

Open a Zip that is completely in-memory. This allows for Zip files to be opened from non-filesystem sources, such as a database.

When a zip is opened, the PasswordProtect and Encryption properties will be appropriately set. If the zip is password protected (i.e. uses older Zip 2.0 encrypion), then the PasswordProtect property will be set to true. If the zip is strong encrypted, the Encryption property will be set to a value 1 through 4, where 4 indicates WinZip compatible AES encryption.

Returns true for success, false for failure.

top
OpenMyEmbedded
public bool OpenMyEmbedded(string resourceName);

(Relevant only when running on a Microsoft Windows operating system.) Opens a Zip embedded within the caller's MS Windows EXE.

Returns true for success, false for failure.

top
OpenZip
public bool OpenZip(string zipPath);

Opens a Zip archive. Encrypted and password-protected zips may be opened without providing the password, but their contents may not be unzipped unless the correct password is provided via the DecryptPassword proprety, or the SetPassword method.

When a zip is opened, the PasswordProtect and Encryption properties will be appropriately set. If the zip is password protected (i.e. uses older Zip 2.0 encrypion), then the PasswordProtect property will be set to true. If the zip is strong encrypted, the Encryption property will be set to a value 1 through 4, where 4 indicates WinZip compatible AES encryption.

Returns true for success, false for failure.

top
OpenZipAsync (.NET Core C#) (C#) (Mono C#) (PowerShell)
public Task OpenZipAsync(string zipPath);

Creates an asynchronous task to call the OpenZip method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns null on failure

top
QuickAppend
public bool QuickAppend(string ZipFileName);

Efficiently appends additional files to an existing zip archive. QuickAppend leaves all entries in the existing .zip untouched. It operates by appending new files and updating the internal "central directory" of the zip archive.

Returns true for success, false for failure.

top
QuickAppendAsync (.NET Core C#) (C#) (Mono C#) (PowerShell)
public Task QuickAppendAsync(string ZipFileName);

Creates an asynchronous task to call the QuickAppend method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns null on failure

top
RemoveEmbedded
public bool RemoveEmbedded(string exeFilename, string resourceName);

(Relevant only when running on a Microsoft Windows operating system.) Removes an embedded Zip from an MS-Windows EXE

Returns true for success, false for failure.

top
RemoveNoCompressExtension
public void RemoveNoCompressExtension(string fileExtension);

Removes a file extension from the zip object's internal list of "no compress" extensions. (For more information, see AddNoCompressExtension.)

top
ReplaceEmbedded
public bool ReplaceEmbedded(string exeFilename, string resourceName, string zipFilename);

(Relevant only when running on a Microsoft Windows operating system.) Replace a Zip embedded in an MS-Windows EXE with another Zip file.

Returns true for success, false for failure.

top
SetCompressionLevel
public void SetCompressionLevel(int level);

Sets the compression level for all file and data entries. The compression level for a mapped entry (i.e. an entry that is contained within an opened .zip, cannot be changed.) The default compression level is 6. A compression level of 0 is equivalent to no compression. The maximum compression level is 9.

The zip.SetCompressionLevel method must be called after appending the files (i.e. after the calls to AppendFile*, AppendData, or AppendOneFileOrDir).

A single call to SetCompressionLevel will set the compression level for all existing file and data entries.

top
SetExclusions
public void SetExclusions(StringArray excludePatterns);

Specify a collection of exclusion patterns to be used when adding files to a Zip. Each pattern in the collection can use the "*" wildcard character, where "*" indicates 0 or more occurrences of any character.

top
SetExeConfigParam
public void SetExeConfigParam(string paramName, string paramValue);

Sets a self-extractor property that is embedded in the resultant EXE created by the WriteExe or WriteExe2 methods. The paramName is one of the XML tags listed in the ExeXmlConfig property.

For example, to specify the text for the self-extractor's main dialog unzip button, paramName would be "MainUnzipBtn".

top
SetPassword
public void SetPassword(string password);

Set the password for an encrypted or password-protected Zip.

Note: The SetPassword method has the effect of setting both the EncryptPassword property as well as the DecryptPassword property. The SetPassword method should no longer be used. It has been replaced by the DecryptPassword and EncryptPassword properties to make it possible to open an encrypted zip and re-write it with a new password.

top
Unzip
public int Unzip(string dirPath);

Unzips and returns the number of files unzipped, or -1 if a failure occurs. Subdirectories are automatically created during the unzipping process.

top
UnzipAsync (.NET Core C#) (C#) (Mono C#) (PowerShell)
public Task UnzipAsync(string dirPath);

Creates an asynchronous task to call the Unzip method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns null on failure

top
UnzipInto
public int UnzipInto(string dirPath);

Unzips and returns the number of files unzipped, or -1 if a failure occurs. All files in the Zip are unzipped into the specfied dirPath regardless of the directory path information contained in the Zip. This has the effect of collapsing all files into a single directory. If several files in the Zip have the same name, the files unzipped last will overwrite the files already unzipped.

top
UnzipIntoAsync (.NET Core C#) (C#) (Mono C#) (PowerShell)
public Task UnzipIntoAsync(string dirPath);

Creates an asynchronous task to call the UnzipInto method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns null on failure

top
UnzipMatching
public int UnzipMatching(string dirPath, string pattern, bool verbose);

Same as Unzip, but only unzips files matching a pattern. If no wildcard characters ('*') are used, then only files that exactly match the pattern will be unzipped. The "*" characters matches 0 or more of any character.

top
UnzipMatchingAsync (.NET Core C#) (C#) (Mono C#) (PowerShell)
public Task UnzipMatchingAsync(string dirPath, string pattern, bool verbose);

Creates an asynchronous task to call the UnzipMatching method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns null on failure

top
UnzipMatchingInto
public int UnzipMatchingInto(string dirPath, string pattern, bool verbose);

Unzips matching files into a single directory, ignoring all path information stored in the Zip.

top
UnzipMatchingIntoAsync (.NET Core C#) (C#) (Mono C#) (PowerShell)
public Task UnzipMatchingIntoAsync(string dirPath, string pattern, bool verbose);

Creates an asynchronous task to call the UnzipMatchingInto method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns null on failure

top
UnzipNewer
public int UnzipNewer(string dirPath);

Same as Unzip, but only files that don't already exist on disk, or have later file modification dates are unzipped.

top
UnzipNewerAsync (.NET Core C#) (C#) (Mono C#) (PowerShell)
public Task UnzipNewerAsync(string dirPath);

Creates an asynchronous task to call the UnzipNewer method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns null on failure

top
VerifyPassword
public bool VerifyPassword();

Tests the current DecryptPassword setting against the currently opened zip. Returns true if the password is valid, otherwise returns false.

top
WriteBd
public bool WriteBd(BinData binData);
Introduced in version 9.5.0.66

Same as WriteZip, but instead of writing the Zip to a file, it writes to binData. Zips that are written to binData can be opened by calling OpenBd. Note: Both WriteBd and OpenBd are added in Chilkat v9.5.0.66

Returns true for success, false for failure.

top
WriteBdAsync (.NET Core C#) (C#) (Mono C#) (PowerShell)
public Task WriteBdAsync(BinData binData);
Introduced in version 9.5.0.66

Creates an asynchronous task to call the WriteBd method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns null on failure

top
WriteExe
public bool WriteExe(string exeFilename);

(Relevant only when running on a Microsoft Windows operating system.) Writes an MS-Windows self-extracting executable. There are no limitations on the total size, individual file size, or number of files that can be added to a self-extracting EXE.

If the resultant EXE will automatically accept these command-line arguments when run:

-log logFileName
Creates a log file that lists the settings embedded within the EXE and logs the errors, warnings, and other information about the self-extraction.
-unzipDir unzipDirectoryPath
Unzips to this directory path without user intervention. (UNC paths, such as \\servername\path, are not supported.)
-pwd password
Specifies the password for an encrypted EXE
-ap autoRunParams
Specifies the command line parameters to be passed to the AutoRun executable (embedded within the EXE).

Returns true for success, false for failure.

top
WriteExeAsync (.NET Core C#) (C#) (Mono C#) (PowerShell)
public Task WriteExeAsync(string exeFilename);

Creates an asynchronous task to call the WriteExe method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns null on failure

top
WriteExeToMemory
public byte[] WriteExeToMemory();

(Relevant only when running on a Microsoft Windows operating system.) Same as WriteExe, but instead of writing a file, the MS-Windows EXE is written to memory.

Returns an empty byte array on failure

top
WriteExeToMemoryAsync (.NET Core C#) (C#) (Mono C#) (PowerShell)
public Task WriteExeToMemoryAsync();

Creates an asynchronous task to call the WriteExeToMemory method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns null on failure

top
WriteToMemory
public byte[] WriteToMemory();

Same as WriteZip, but instead of writing the Zip to a file, it writes to memory. Zips that are written to memory can also be opened from memory by calling OpenFromMemory.

Returns an empty byte array on failure

top
WriteToMemoryAsync (.NET Core C#) (C#) (Mono C#) (PowerShell)
public Task WriteToMemoryAsync();

Creates an asynchronous task to call the WriteToMemory method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns null on failure

top
WriteZip
public bool WriteZip();

Saves the Zip to a file and implictly re-opens it so further operations can continue. Use WriteZipAndClose to write and close the Zip. There is no limitation on the size of files that may be contained within a .zip, the total number of files in a .zip, or the total size of a .zip. If necessary, WriteZip will use the ZIP64 file format extensions when 4GB or file count limitations of the old zip file format are exceeded.

Returns true for success, false for failure.

top
WriteZipAsync (.NET Core C#) (C#) (Mono C#) (PowerShell)
public Task WriteZipAsync();

Creates an asynchronous task to call the WriteZip method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns null on failure

top
WriteZipAndClose
public bool WriteZipAndClose();

Saves the Zip to a file and closes it. On return, the Zip object will be in the state as if NewZip had been called. There is no limitation on the size of files that may be contained within a .zip, the total number of files in a .zip, or the total size of a .zip. If necessary, WriteZip will use the ZIP64 file format extensions when 4GB or file count limitations of the old zip file format are exceeded.

Returns true for success, false for failure.

top
WriteZipAndCloseAsync (.NET Core C#) (C#) (Mono C#) (PowerShell)
public Task WriteZipAndCloseAsync();

Creates an asynchronous task to call the WriteZipAndClose method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns null on failure

top

Events

AbortCheck
public event AbortCheckEventHandler OnAbortCheck;

Provides the opportunity for a method call to be aborted. The AbortCheck event is fired periodically based on the value of the HeartbeatMs property. If HeartbeatMs is 0, then no AbortCheck events will fire. As an example, to fire 5 AbortCheck events per second, set the HeartbeatMs property equal to 200.

Chilkat .NET Event Implementation

Args are passed using Chilkat.AbortCheckEventArgs

Event callback implementation:

private void zip_OnAbortCheck(object sender, Chilkat.AbortCheckEventArgs args)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
zip.OnAbortCheck += zip_OnAbortCheck;

Chilkat Mono/.NET Core Event Implementation

Event callback implementation:

public void handleAbortCheck(out bool abort)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
// ...
Chilkat.Zip.AbortCheck abortCheck = new Chilkat.Zip.AbortCheck(handleAbortCheck);
zip.setAbortCheckCb(abortCheck);
top
AddFilesBegin
public event AddFilesBeginEventHandler OnAddFilesBegin;

Fired at the start of the AppendFiles or AppendFIlesEx method.

Chilkat .NET Event Implementation

Event callback implementation:

void zip_OnAddFilesBegin(object sender, EventArgs args)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
zip.OnAddFilesBegin += zip_OnAddFilesBegin;

Chilkat Mono/.NET Core Event Implementation

Event callback implementation:

public void handleAddFilesBegin()
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
// ...
Chilkat.Zip.AddFilesBegin addFilesBegin = new Chilkat.Zip.AddFilesBegin(handleAddFilesBegin);
zip.setAddFilesBeginCb(addFilesBegin);
top
AddFilesEnd
public event AddFilesEndEventHandler OnAddFilesEnd;

Fired at the end of the AppendFiles or AppendFIlesEx method.

Chilkat .NET Event Implementation

Event callback implementation:

void zip_OnAddFilesEnd(object sender, EventArgs args)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
zip.OnAddFilesEnd += zip_OnAddFilesEnd;

Chilkat Mono/.NET Core Event Implementation

Event callback implementation:

public void handleAddFilesEnd()
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
// ...
Chilkat.Zip.AddFilesEnd addFilesEnd = new Chilkat.Zip.AddFilesEnd(handleAddFilesEnd);
zip.setAddFilesEndCb(addFilesEnd);
top
DirToBeAdded
public event DirToBeAddedEventHandler OnDirToBeAdded;

This event fires during the AppendFiles and AppendFilesEx method calls. It is called just before each directory is to be added. The skip output-only argument may be set to true to prevent the directory and everything it contains from being added.

Chilkat .NET Event Implementation

Args are passed using Chilkat.DirToBeAddedEventArgs

Event callback implementation:

private void zip_OnDirToBeAdded(object sender, Chilkat.DirToBeAddedEventArgs args)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
zip.OnDirToBeAdded += zip_OnDirToBeAdded;

Chilkat Mono/.NET Core Event Implementation

Event callback implementation:

public void handleDirToBeAdded(string path, out bool skip)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
// ...
Chilkat.Zip.DirToBeAdded dirToBeAdded = new Chilkat.Zip.DirToBeAdded(handleDirToBeAdded);
zip.setDirToBeAddedCb(dirToBeAdded);
top
FileAdded
public event FileAddedEventHandler OnFileAdded;

This event fires during the AppendFiles and AppendFilesEx method calls. It is called just after each file is added. The abort output-only argument may be set to true to abort the method call.

Chilkat .NET Event Implementation

Args are passed using Chilkat.FileAddedEventArgs

Event callback implementation:

private void zip_OnFileAdded(object sender, Chilkat.FileAddedEventArgs args)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
zip.OnFileAdded += zip_OnFileAdded;

Chilkat Mono/.NET Core Event Implementation

Event callback implementation:

public void handleFileAdded(string path, long fileSize, out bool abort)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
// ...
Chilkat.Zip.FileAdded fileAdded = new Chilkat.Zip.FileAdded(handleFileAdded);
zip.setFileAddedCb(fileAdded);
top
FileUnzipped
public event FileUnzippedEventHandler OnFileUnzipped;

This event fires during method calls that unzip a zip archive. It is called just after each file is unzipped. The abort output-only argument may be set to true to abort the method call.

Chilkat .NET Event Implementation

Args are passed using Chilkat.FileUnzippedEventArgs

Event callback implementation:

private void zip_OnFileUnzipped(object sender, Chilkat.FileUnzippedEventArgs args)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
zip.OnFileUnzipped += zip_OnFileUnzipped;

Chilkat Mono/.NET Core Event Implementation

Event callback implementation:

public void handleFileUnzipped(string path, long compressedSize, long fileSize, out bool abort)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
// ...
Chilkat.Zip.FileUnzipped fileUnzipped = new Chilkat.Zip.FileUnzipped(handleFileUnzipped);
zip.setFileUnzippedCb(fileUnzipped);
top
FileZipped
public event FileZippedEventHandler OnFileZipped;

This event fires during method calls that write a zip archive. It is called just after each file is zipped. The abort output-only argument may be set to true to abort the method call.

Chilkat .NET Event Implementation

Args are passed using Chilkat.FileZippedEventArgs

Event callback implementation:

private void zip_OnFileZipped(object sender, Chilkat.FileZippedEventArgs args)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
zip.OnFileZipped += zip_OnFileZipped;

Chilkat Mono/.NET Core Event Implementation

Event callback implementation:

public void handleFileZipped(string path, long fileSize, long compressedSize, out bool abort)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
// ...
Chilkat.Zip.FileZipped fileZipped = new Chilkat.Zip.FileZipped(handleFileZipped);
zip.setFileZippedCb(fileZipped);
top
PercentDone
public event PercentDoneEventHandler OnPercentDone;

Provides the percentage completed for any method that involves network communications or time-consuming processing (assuming it is a method where a percentage completion can be measured). This event is only fired when it is possible to know a percentage completion, and when it makes sense to express the operation as a percentage completed. The pctDone argument will have a value from 1 to 100. For operations (Chilkat method calls) that complete very quickly, the number of PercentDone callbacks will vary, but the final callback should have a value of 100. For long running operations, no more than one callback per percentage point will occur (for example: 1, 2, 3, ... 98, 99, 100).

The PercentDone callback counts as an AbortCheck event. For method calls that complete quickly such that PercentDone events fire, it may be that AbortCheck events don't fire because the opportunity to abort is already provided in the PercentDone callback. For time consuming operations, where the amount of time between PercentDone callbacks are long, AbortCheck callbacks may be used to allow for the operation to be aborted in a more responsive manner.

The abort output argument provides a means for aborting the operation. Setting it to true will cause the method to abort and return a failed status (or whatever return value indicates failure).

Chilkat .NET Event Implementation

Args are passed using Chilkat.PercentDoneEventArgs

Event callback implementation:

private void zip_OnPercentDone(object sender, Chilkat.PercentDoneEventArgs args)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
zip.OnPercentDone += zip_OnPercentDone;

Chilkat Mono/.NET Core Event Implementation

Event callback implementation:

public void handlePercentDone(int pctDone, out bool abort)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
// ...
Chilkat.Zip.PercentDone percentDone = new Chilkat.Zip.PercentDone(handlePercentDone);
zip.setPercentDoneCb(percentDone);
top
ProgressInfo
public event ProgressInfoEventHandler OnProgressInfo;

A general name/value event that provides information about what is happening during a method call. To find out what information is available, write code to handle this event and log the name/value pairs. Most are self-explanatory.

Chilkat .NET Event Implementation

Args are passed using Chilkat.ProgressInfoEventArgs

Event callback implementation:

private void zip_OnProgressInfo(object sender, Chilkat.ProgressInfoEventArgs args)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
zip.OnProgressInfo += zip_OnProgressInfo;

Chilkat Mono/.NET Core Event Implementation

Event callback implementation:

public void handleProgressInfo(string name, string value)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
// ...
Chilkat.Zip.ProgressInfo progressInfo = new Chilkat.Zip.ProgressInfo(handleProgressInfo);
zip.setProgressInfoCb(progressInfo);
top
SkippedForUnzip
public event SkippedForUnzipEventHandler OnSkippedForUnzip;

This event fires during method calls that unzip a zip archive. It is called for each file that was skipped for some reason (such as for when UnzipNewer or UnzipMatching is called).

Chilkat .NET Event Implementation

Args are passed using Chilkat.ToBeUnzippedEventArgs

Event callback implementation:

private void zip_OnSkippedForUnzip(object sender, Chilkat.ToBeUnzippedEventArgs args)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
zip.OnSkippedForUnzip += zip_OnSkippedForUnzip;

Chilkat Mono/.NET Core Event Implementation

Event callback implementation:

public void handleSkippedForUnzip(string path, long compressedSize, long fileSize, bool isDirectory)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
// ...
Chilkat.Zip.SkippedForUnzip skippedForUnzip = new Chilkat.Zip.SkippedForUnzip(handleSkippedForUnzip);
zip.setSkippedForUnzipCb(skippedForUnzip);
top
TaskCompleted
public event TaskCompletedEventHandler OnTaskCompleted;

Called in the background thread when an asynchronous task completes.

Chilkat .NET Event Implementation

Args are passed using Chilkat.TaskCompletedEventArgs

Event callback implementation:

private void zip_OnTaskCompleted(object sender, Chilkat.TaskCompletedEventArgs args)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
zip.OnTaskCompleted += zip_OnTaskCompleted;

Chilkat Mono/.NET Core Event Implementation

Event callback implementation:

public void handleTaskIdCompleted(int taskId)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
// ...
Chilkat.Zip.TaskIdCompleted taskIdCompleted = new Chilkat.Zip.TaskIdCompleted(handleTaskIdCompleted);
zip.setTaskIdCompletedCb(taskIdCompleted);
top
ToBeAdded
public event ToBeAddedEventHandler OnToBeAdded;

This event fires during the AppendFiles and AppendFilesEx method calls. It is called just before each file is to be added. The skip output-only argument may be set to true to prevent the file from being added.

Chilkat .NET Event Implementation

Args are passed using Chilkat.ToBeAddedEventArgs

Event callback implementation:

private void zip_OnToBeAdded(object sender, Chilkat.ToBeAddedEventArgs args)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
zip.OnToBeAdded += zip_OnToBeAdded;

Chilkat Mono/.NET Core Event Implementation

Event callback implementation:

public void handleToBeAdded(string path, long fileSize, out bool skip)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
// ...
Chilkat.Zip.ToBeAdded toBeAdded = new Chilkat.Zip.ToBeAdded(handleToBeAdded);
zip.setToBeAddedCb(toBeAdded);
top
ToBeUnzipped
public event ToBeUnzippedEventHandler OnToBeUnzipped;

This event fires during method calls that unzip a zip archive. It is called just before each file is unzipped. The skip output-only argument may be set to true to prevent the file from being unzipped.

Chilkat .NET Event Implementation

Args are passed using Chilkat.ToBeUnzippedEventArgs

Event callback implementation:

private void zip_OnToBeUnzipped(object sender, Chilkat.ToBeUnzippedEventArgs args)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
zip.OnToBeUnzipped += zip_OnToBeUnzipped;

Chilkat Mono/.NET Core Event Implementation

Event callback implementation:

public void handleToBeUnzipped(string path, long compressedSize, long fileSize, out bool skip)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
// ...
Chilkat.Zip.ToBeUnzipped toBeUnzipped = new Chilkat.Zip.ToBeUnzipped(handleToBeUnzipped);
zip.setToBeUnzippedCb(toBeUnzipped);
top
ToBeZipped
public event ToBeZippedEventHandler OnToBeZipped;

This event fires during method calls that create a zip archive. It is called just before each file is to be zipped. The skip output-only argument may be set to true to prevent the file from being zipped.

Chilkat .NET Event Implementation

Args are passed using Chilkat.ToBeZippedEventArgs

Event callback implementation:

private void zip_OnToBeZipped(object sender, Chilkat.ToBeZippedEventArgs args)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
zip.OnToBeZipped += zip_OnToBeZipped;

Chilkat Mono/.NET Core Event Implementation

Event callback implementation:

public void handleToBeZipped(string path, long fileSize, out bool skip)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
// ...
Chilkat.Zip.ToBeZipped toBeZipped = new Chilkat.Zip.ToBeZipped(handleToBeZipped);
zip.setToBeZippedCb(toBeZipped);
top
UnzipBegin
public event UnzipBeginEventHandler OnUnzipBegin;

To be documented soon...

Chilkat .NET Event Implementation

Event callback implementation:

void zip_OnUnzipBegin(object sender, EventArgs args)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
zip.OnUnzipBegin += zip_OnUnzipBegin;

Chilkat Mono/.NET Core Event Implementation

Event callback implementation:

public void handleUnzipBegin()
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
// ...
Chilkat.Zip.UnzipBegin unzipBegin = new Chilkat.Zip.UnzipBegin(handleUnzipBegin);
zip.setUnzipBeginCb(unzipBegin);
top
UnzipEnd
public event UnzipEndEventHandler OnUnzipEnd;

Fired when finished unzipping.

Chilkat .NET Event Implementation

Event callback implementation:

void zip_OnUnzipEnd(object sender, EventArgs args)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
zip.OnUnzipEnd += zip_OnUnzipEnd;

Chilkat Mono/.NET Core Event Implementation

Event callback implementation:

public void handleUnzipEnd()
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
// ...
Chilkat.Zip.UnzipEnd unzipEnd = new Chilkat.Zip.UnzipEnd(handleUnzipEnd);
zip.setUnzipEndCb(unzipEnd);
top
WriteZipBegin
public event WriteZipBeginEventHandler OnWriteZipBegin;

Fired when starting to write a zip.

Chilkat .NET Event Implementation

Event callback implementation:

void zip_OnWriteZipBegin(object sender, EventArgs args)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
zip.OnWriteZipBegin += zip_OnWriteZipBegin;

Chilkat Mono/.NET Core Event Implementation

Event callback implementation:

public void handleWriteZipBegin()
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
// ...
Chilkat.Zip.WriteZipBegin writeZipBegin = new Chilkat.Zip.WriteZipBegin(handleWriteZipBegin);
zip.setWriteZipBeginCb(writeZipBegin);
top
WriteZipEnd
public event WriteZipEndEventHandler OnWriteZipEnd;

Fired when finished writing a zip.

Chilkat .NET Event Implementation

Event callback implementation:

void zip_OnWriteZipEnd(object sender, EventArgs args)
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
zip.OnWriteZipEnd += zip_OnWriteZipEnd;

Chilkat Mono/.NET Core Event Implementation

Event callback implementation:

public void handleWriteZipEnd()
	{
	    // application code goes here.
	}

To add an event handler:

Chilkat.Zip zip = new Chilkat.Zip();
// ...
Chilkat.Zip.WriteZipEnd writeZipEnd = new Chilkat.Zip.WriteZipEnd(handleWriteZipEnd);
zip.setWriteZipEndCb(writeZipEnd);
top