---
product: Chilkat
product_version: 11.7.0
language: csharp
language_label: C#
class: PrivateKey
license: free
deprecated: false
reference_html: https://www.chilkatsoft.com/refdoc/csPrivateKeyRef.html
---
# Chilkat PrivateKey — C# — v11.7.0

> Chilkat 11.7.0 · language=csharp · class=PrivateKey
> Other versions: replace `11.7.0` in this URL. Other languages: `https://www.chilkatsoft.com/ai-docs/v/11.7.0/<lang>/classes/PrivateKey.md`.
> Language-wide rules (install, unlock, error model, strings/bytes): `https://www.chilkatsoft.com/ai-docs/v/11.7.0/csharp/guide.md`.

## Purpose

PrivateKey

**Load, inspect, export, save, and convert one private key.**

`PrivateKey` is a key-container class. It holds one current RSA, DSA, EC, or Ed25519 private key and provides format conversion, persistence, JWK/XML access, raw EC and Ed25519 access, and public-key extraction. Cryptographic operations such as signing, decryption, TLS authentication, and SSH authentication are performed by other Chilkat classes that receive the loaded `PrivateKey`.

**Content-based loading**

Named load methods inspect the content and recognize supported unencrypted formats. Password-taking loaders also recognize encrypted PKCS #8 and unencrypted input.

**Standard export choices**

Use PKCS #8 for modern algorithm-independent interchange, encrypted PKCS #8 for password-protected storage, JWK for JOSE, and traditional PEM only when required by a legacy consumer.

**One-key state**

A successful load replaces the current key. A failed load leaves the object empty. Check `KeyType` and `BitLength` after loading when the expected algorithm matters.

**Independent public key**

`ToPublicKey` creates an independent `PublicKey` that is unaffected when this object is reloaded with another key.

**Key generation**

Generate new keys with `Rsa`, `Ecc`, or `EdDSA`, which can place the generated key into a `PrivateKey`.

**Certificates are separate**

A private key does not contain a certificate or chain. Use `Cert` or `Pfx` when certificate association is required.

**Recommended format selection:** Prefer unencrypted PKCS #8 for transient interchange, encrypted PKCS #8 with `aes256` and a strong password for stored key files, JWK for JWT/JWS/JWE workflows, and traditional RSA or EC PEM only when the receiving software requires it.

**Protect private material:** Base64, hexadecimal, PEM, JWK, and XML are encodings or containers, not encryption. Avoid exporting a private key unless necessary, and protect every unencrypted representation as sensitive data.

For an extended overview, see [PrivateKey Class Overview](https://www.chilkatsoft.com/privatekey_class_overview.asp).

## Object creation, unlocking and error handling

**Object Creation**

```csharp
Chilkat.PrivateKey obj = new Chilkat.PrivateKey();
```

Call `Global.UnlockBundle` once at the start of the program, before using this or any other Chilkat class. Any string unlocks a fully functional 30-day trial; a purchased unlock code is used in production. See `guide.md` for the exact code in C#.

Minimal complete program:

```csharp
// Required once per process. Any string unlocks a 30-day trial; use your purchased code in production.
Chilkat.Global glob = new Chilkat.Global();
if (!glob.UnlockBundle("Anything for 30-day trial"))
{
    Console.WriteLine(glob.LastErrorText);
    return;
}

Chilkat.PrivateKey privateKey = new Chilkat.PrivateKey();

bool success = privateKey.LoadAnyFormatFile("<path>", "<password>");
if (!success)
{
    Console.WriteLine(privateKey.LastErrorText);   // full diagnostic of what went wrong
    return;
}
```

How failure is reported depends on the method's return type and is stated in the note under each method below. In every case the diagnostic text is in the `LastErrorText` property of the object whose method was called.

## Members common to every Chilkat class

Documented once per language in `common-members.md`; listed here so this page is self-contained.

| Property | Signature | Access | Meaning |
|---|---|---|---|
| `DebugLogFilePath` | `public string DebugLogFilePath {get; set; }` | read/write | If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. |
| `LastErrorHtml` | `public string LastErrorHtml {get; }` | read-only | Provides HTML-formatted information about the last called method or property. |
| `LastErrorText` | `public string LastErrorText {get; }` | read-only | Provides plain text information about the last called method or property. |
| `LastErrorXml` | `public string LastErrorXml {get; }` | read-only | Provides XML-formatted information about the last called method or property. |
| `LastMethodSuccess` | `public bool LastMethodSuccess {get; set; }` | read/write | Indicates the success or failure of the most recent method call: `true` means success, `false` means failure. |
| `VerboseLogging` | `public bool VerboseLogging {get; set; }` | read/write | If set to `true`, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. |
| `Version` | `public string Version {get; }` | read-only | Version of the component/library, such as "10.1.0" |

## Member index

| Member | Kind | Signature |
|---|---|---|
| `BitLength` | property, read-only | `public int BitLength {get; }` |
| `KeyType` | property, read-only | `public string KeyType {get; }` |
| `Pkcs8EncryptAlg` | property, read/write | `public string Pkcs8EncryptAlg {get; set; }` |
| `UncommonOptions` | property, read/write | `public string UncommonOptions {get; set; }` |
| `GetJwk` | method | `public string GetJwk();` |
| `GetJwkThumbprint` | method | `public string GetJwkThumbprint(string hashAlg);` |
| `GetPkcs1` | method | `public byte[] GetPkcs1();` |
| `GetPkcs1ENC` | method | `public string GetPkcs1ENC(string encoding);` |
| `GetPkcs1Pem` | method | `public string GetPkcs1Pem();` |
| `GetPkcs8` | method | `public byte[] GetPkcs8();` |
| `GetPkcs8ENC` | method | `public string GetPkcs8ENC(string encoding);` |
| `GetPkcs8Encrypted` | method | `public byte[] GetPkcs8Encrypted(string password);` |
| `GetPkcs8EncryptedENC` | method | `public string GetPkcs8EncryptedENC(string encoding, string password);` |
| `GetPkcs8EncryptedPem` | method | `public string GetPkcs8EncryptedPem(string password);` |
| `GetPkcs8Pem` | method | `public string GetPkcs8Pem();` |
| `GetPkcsBd` | method | `public bool GetPkcsBd(bool pkcs1, string password, BinData bd);` |
| `GetRawHex` | method | `public string GetRawHex(StringBuilder pubKey);` |
| `GetXml` | method | `public string GetXml();` |
| `LoadAnyFormat` | method | `public bool LoadAnyFormat(BinData privKeyData, string password);` |
| `LoadAnyFormatFile` | method | `public bool LoadAnyFormatFile(string path, string password);` |
| `LoadEd25519` | method | `public bool LoadEd25519(string privKey, string pubKey);` |
| `LoadEncryptedPem` | method | `public bool LoadEncryptedPem(string pemStr, string password);` |
| `LoadEncryptedPemFile` | method | `public bool LoadEncryptedPemFile(string path, string password);` |
| `LoadJwk` | method | `public bool LoadJwk(string jsonStr);` |
| `LoadPem` | method | `public bool LoadPem(string str);` |
| `LoadPemFile` | method | `public bool LoadPemFile(string path);` |
| `LoadPkcs1` | method | `public bool LoadPkcs1(byte[] data);` |
| `LoadPkcs1File` | method | `public bool LoadPkcs1File(string path);` |
| `LoadPkcs8` | method | `public bool LoadPkcs8(byte[] data);` |
| `LoadPkcs8Encrypted` | method | `public bool LoadPkcs8Encrypted(byte[] data, string password);` |
| `LoadPkcs8EncryptedFile` | method | `public bool LoadPkcs8EncryptedFile(string path, string password);` |
| `LoadPkcs8File` | method | `public bool LoadPkcs8File(string path);` |
| `LoadPvk` | method | `public bool LoadPvk(byte[] data, string password);` |
| `LoadPvkFile` | method | `public bool LoadPvkFile(string path, string password);` |
| `LoadXml` | method | `public bool LoadXml(string xml);` |
| `LoadXmlFile` | method | `public bool LoadXmlFile(string path);` |
| `SavePemFile` | method | `public bool SavePemFile(string path);` |
| `SavePkcs1File` | method | `public bool SavePkcs1File(string path);` |
| `SavePkcs8EncryptedFile` | method | `public bool SavePkcs8EncryptedFile(string password, string path);` |
| `SavePkcs8EncryptedPemFile` | method | `public bool SavePkcs8EncryptedPemFile(string password, string path);` |
| `SavePkcs8File` | method | `public bool SavePkcs8File(string path);` |
| `SavePkcs8PemFile` | method | `public bool SavePkcs8PemFile(string path);` |
| `SaveXmlFile` | method | `public bool SaveXmlFile(string path);` |
| `ToPublicKey` | method | `public bool ToPublicKey(PublicKey pubKey);` |
| `UploadToCloud` | method | `public bool UploadToCloud(JsonObject jsonIn, JsonObject jsonOut);` |

Deprecated members are listed at the end of this file with their replacements; do not use them in new code.

## Properties

### PrivateKey.BitLength

`Chilkat 11.7.0 · csharp · PrivateKey · BitLength · property · read-only · since 9.5.0.49`

```csharp
public int BitLength {get; }
```

Returns the nominal size of the loaded private key, in bits. The value is `0` when the object is empty. For RSA it is the modulus size; for DSA it is the size of `p`; for EC it is the named-curve field size; and for Ed25519 it is `256`.

**Comparing strength:** Bit lengths are meaningful only within the context of the algorithm. A 256-bit EC key and a 256-bit RSA key do not provide comparable security.

### PrivateKey.KeyType

`Chilkat 11.7.0 · csharp · PrivateKey · KeyType · property · read-only · since 9.5.0.52`

```csharp
public string KeyType {get; }
```

Identifies the algorithm of the currently loaded key. The value is one of `empty`, `rsa`, `dsa`, `ecc`, or `ed25519`. `empty` means that no usable private key is loaded.

**One-key state model:** A `PrivateKey` object holds one current key. Loading another key replaces it; a failed load leaves the object empty.

### PrivateKey.Pkcs8EncryptAlg

`Chilkat 11.7.0 · csharp · PrivateKey · Pkcs8EncryptAlg · property · read/write · since 9.5.0.49`

```csharp
public string Pkcs8EncryptAlg {get; set; }
```

Controls the block cipher used by encrypted PKCS #8 export methods. Supported values are `3des`, `aes128`, `aes192`, and `aes256`. Values are case-insensitive and are normalized to lowercase. The default is `3des`. Assigning an empty or unrecognized value resets the property to `3des`. All choices use CBC mode.

Encrypted PKCS #8 output uses PBES2 with PBKDF2. The generated parameters use an 8-byte salt, 2048 PBKDF2 iterations, and the default PBKDF2 PRF (HMAC-SHA-1). The selected cipher uses CBC mode with a newly generated IV.

**Recommended setting:** Prefer `aes256` for new output unless an older consumer requires 3DES. This property selects encryption parameters only; password quality remains essential.

### PrivateKey.UncommonOptions

`Chilkat 11.7.0 · csharp · PrivateKey · UncommonOptions · property · read/write · since 9.5.0.96`

```csharp
public string UncommonOptions {get; set; }
```

Provides a catch-all string for specialized compatibility options that are not exposed as ordinary properties. The default is the empty string, which is appropriate for normal use.

**Leave empty unless instructed:** Set this property only when a Chilkat example, release note, or support response documents a specific option needed for an unusual interoperability case.

## Methods

### PrivateKey.GetJwk

`Chilkat 11.7.0 · csharp · PrivateKey · GetJwk · method · since 9.5.0.66`

```csharp
public string GetJwk();
```

Exports the key as a compact JWK (JSON Web Key). Binary integers and byte strings use Base64url without padding.

| Key type | Members emitted |
| :--- | :--- |
| RSA | `kty`, `n`, `e`, `d`, `p`, `q`, `dp`, `dq`, `qi` |
| EC | `kty`, `crv`, `x`, `y`, `d` |
| Ed25519 | `kty`=`OKP`, `crv`=`Ed25519`, `x`, `d`, and `use`=`sig` |

**Key material only:** Optional JOSE metadata loaded from a JWK, such as `kid`, `alg`, `key_ops`, or a caller-supplied `use`, is not retained for re-export. The Ed25519 `use`=`sig` member is emitted by Chilkat.

**Private output:** The returned JSON contains private key material and must be protected accordingly.

Returns `null` on failure

### PrivateKey.GetJwkThumbprint

`Chilkat 11.7.0 · csharp · PrivateKey · GetJwkThumbprint · method · since 9.5.0.66`

```csharp
public string GetJwkThumbprint(string hashAlg);
```

Computes the RFC 7638 thumbprint of the public portion of the loaded key using the hash algorithm named by `hashAlg`. Supported values include `md5`, `sha1`, `sha256`, `sha384`, and `sha512`. An unsupported name causes the method to fail. The returned digest is Base64url-encoded without padding.

**Public-key identity:** The canonical thumbprint input contains only the required public JWK members. Private members and optional metadata such as `kid`, `use`, and `alg` are excluded, so the result matches the thumbprint of the corresponding `PublicKey`.

**Recommended hash:** Use `sha256` for normal RFC 7638 interoperability. MD5 and SHA-1 are available for compatibility but should not be chosen for new security-sensitive identifiers.

Returns `null` on failure

### PrivateKey.GetPkcs1

`Chilkat 11.7.0 · csharp · PrivateKey · GetPkcs1 · method · since 9.5.0.58`

```csharp
public byte[] GetPkcs1();
```

Exports the key as the traditional or preferred unencrypted binary DER representation.

**Historical method name:** PKCS #1 is specifically an RSA standard. For non-RSA key types, this method returns the applicable traditional structure or a PKCS #8 fallback.

| Key type | Returned representation |
| :--- | :--- |
| RSA | `RSAPrivateKey` DER from PKCS #1. |
| DSA | The traditional six-integer DSA private-key structure. |
| EC | `ECPrivateKey` DER from RFC 5915. |
| Ed25519 | PKCS #8 `PrivateKeyInfo` DER using the Ed25519 OID `1.3.101.112`, because Ed25519 has no traditional PKCS #1 form. |

For RSA, the DER contains:

```
RSAPrivateKey ::= SEQUENCE {
    version           Version,
    modulus           INTEGER,  -- n
    publicExponent    INTEGER,  -- e
    privateExponent   INTEGER,  -- d
    prime1            INTEGER,  -- p
    prime2            INTEGER,  -- q
    exponent1         INTEGER,  -- d mod (p-1)
    exponent2         INTEGER,  -- d mod (q-1)
    coefficient       INTEGER,  -- (inverse of q) mod p
    otherPrimeInfos   OtherPrimeInfos OPTIONAL
}
```

For EC, the traditional structure is:

```
ECPrivateKey ::= SEQUENCE {
    version        INTEGER { ecPrivkeyVer1(1) },
    privateKey     OCTET STRING,
    parameters [0] ECParameters OPTIONAL,
    publicKey  [1] BIT STRING OPTIONAL
}
```

**Modern binary API:** For new code, `GetPkcsBd` returns the same family of representations in a `BinData`.

Returns an empty byte array on failure

### PrivateKey.GetPkcs1ENC

`Chilkat 11.7.0 · csharp · PrivateKey · GetPkcs1ENC · method · since 9.5.0.52`

```csharp
public string GetPkcs1ENC(string encoding);
```

**Full documentation for this method (same in every language):** [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Exports the key as the traditional or preferred unencrypted DER representation and encodes the DER as text using the binary encoding named by `encoding`. The binary bytes are the same as returned by `GetPkcs1`.

**Historical method name:** PKCS #1 is specifically an RSA standard. For non-RSA key types, this method returns the applicable traditional structure or a PKCS #8 fallback.

| Key type | Returned representation |
| :--- | :--- |
| RSA | `RSAPrivateKey` DER from PKCS #1. |
| DSA | The traditional six-integer DSA private-key structure. |
| EC | `ECPrivateKey` DER from RFC 5915. |
| Ed25519 | PKCS #8 `PrivateKeyInfo` DER using the Ed25519 OID `1.3.101.112`, because Ed25519 has no traditional PKCS #1 form. |

For RSA, the DER contains:

```
RSAPrivateKey ::= SEQUENCE {
    version           Version,
    modulus           INTEGER,  -- n
    publicExponent    INTEGER,  -- e
    privateExponent   INTEGER,  -- d
    prime1            INTEGER,  -- p
    prime2            INTEGER,  -- q
    exponent1         INTEGER,  -- d mod (p-1)
    exponent2         INTEGER,  -- d mod (q-1)
    coefficient       INTEGER,  -- (inverse of q) mod p
    otherPrimeInfos   OtherPrimeInfos OPTIONAL
}
```

For EC, the traditional structure is:

```
ECPrivateKey ::= SEQUENCE {
    version        INTEGER { ecPrivkeyVer1(1) },
    privateKey     OCTET STRING,
    parameters [0] ECParameters OPTIONAL,
    publicKey  [1] BIT STRING OPTIONAL
}
```

**Encoding validation:** An unsupported `encoding` encoding name causes the method to fail; it does not silently select another encoding.

Returns `null` on failure

### PrivateKey.GetPkcs1Pem

`Chilkat 11.7.0 · csharp · PrivateKey · GetPkcs1Pem · method · since 9.5.0.58`

```csharp
public string GetPkcs1Pem();
```

Exports the key as unencrypted PEM, preferring the traditional algorithm-specific representation when one exists.

| Key type | PEM label | Body |
| :--- | :--- | :--- |
| RSA | `RSA PRIVATE KEY` | PKCS #1 DER |
| DSA | `DSA PRIVATE KEY` | Traditional DSA DER |
| EC | `EC PRIVATE KEY` | RFC 5915 DER |
| Ed25519 | `PRIVATE KEY` | PKCS #8 DER |

**Generated PEM formatting:** PEM output uses CRLF line endings, Base64 lines of at most 64 characters, and a final CRLF.

**Security note:** The returned private key is not encrypted.

Returns `null` on failure

### PrivateKey.GetPkcs8

`Chilkat 11.7.0 · csharp · PrivateKey · GetPkcs8 · method`

```csharp
public byte[] GetPkcs8();
```

Exports the key as unencrypted PKCS #8 DER. PKCS #8 is an algorithm-independent private-key container. Chilkat emits the classic version-0 `PrivateKeyInfo` structure, with the algorithm-specific private-key DER in an `OCTET STRING`.

```
PrivateKeyInfo ::= SEQUENCE {
    version                   Version,
    privateKeyAlgorithm       AlgorithmIdentifier,
    privateKey                OCTET STRING,
    attributes           [0]  IMPLICIT Attributes OPTIONAL
}
```

**Security note:** PKCS #8 is a container format and is not inherently encrypted. This method returns cleartext private-key material.

Returns an empty byte array on failure

### PrivateKey.GetPkcs8ENC

`Chilkat 11.7.0 · csharp · PrivateKey · GetPkcs8ENC · method · since 9.5.0.52`

```csharp
public string GetPkcs8ENC(string encoding);
```

**Full documentation for this method (same in every language):** [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Exports the key as unencrypted PKCS #8 DER and encodes the DER as text using the binary encoding named by `encoding`. PKCS #8 is an algorithm-independent private-key container. Chilkat emits the classic version-0 `PrivateKeyInfo` structure, with the algorithm-specific private-key DER in an `OCTET STRING`.

```
PrivateKeyInfo ::= SEQUENCE {
    version                   Version,
    privateKeyAlgorithm       AlgorithmIdentifier,
    privateKey                OCTET STRING,
    attributes           [0]  IMPLICIT Attributes OPTIONAL
}
```

**Encoding validation:** An unsupported `encoding` encoding name causes the method to fail; it does not silently select another encoding.

**Encoding is not encryption:** Base64, hexadecimal, and similar encodings only represent the DER bytes as text. They do not protect the private key.

Returns `null` on failure

### PrivateKey.GetPkcs8Encrypted

`Chilkat 11.7.0 · csharp · PrivateKey · GetPkcs8Encrypted · method`

```csharp
public byte[] GetPkcs8Encrypted(string password);
```

Exports the key as password-protected PKCS #8 DER using `password` as the password. The block cipher is selected by `Pkcs8EncryptAlg`.

```
EncryptedPrivateKeyInfo ::= SEQUENCE {
    encryptionAlgorithm  AlgorithmIdentifier,
    encryptedData        OCTET STRING
}
```

Encrypted PKCS #8 output uses PBES2 with PBKDF2. The generated parameters use an 8-byte salt, 2048 PBKDF2 iterations, and the default PBKDF2 PRF (HMAC-SHA-1). The selected cipher uses CBC mode with a newly generated IV.

**Empty passwords:** An empty `password` still produces an encrypted PKCS #8 container that can be reopened with an empty password, but it provides no meaningful password protection.

Returns an empty byte array on failure

### PrivateKey.GetPkcs8EncryptedENC

`Chilkat 11.7.0 · csharp · PrivateKey · GetPkcs8EncryptedENC · method · since 9.5.0.52`

```csharp
public string GetPkcs8EncryptedENC(string encoding, string password);
```

**Full documentation for this method (same in every language):** [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Exports the key as password-protected PKCS #8 DER, then encodes the encrypted DER as text. `encoding` names the binary encoding and `password` supplies the password. The cipher is selected by `Pkcs8EncryptAlg`.

Encrypted PKCS #8 output uses PBES2 with PBKDF2. The generated parameters use an 8-byte salt, 2048 PBKDF2 iterations, and the default PBKDF2 PRF (HMAC-SHA-1). The selected cipher uses CBC mode with a newly generated IV.

**Encoding validation:** An unsupported `encoding` encoding name causes the method to fail.

**Empty passwords:** A nonempty, strong password should be used. An empty `password` is accepted but provides no meaningful password protection.

Returns `null` on failure

### PrivateKey.GetPkcs8EncryptedPem

`Chilkat 11.7.0 · csharp · PrivateKey · GetPkcs8EncryptedPem · method`

```csharp
public string GetPkcs8EncryptedPem(string password);
```

Exports the key as password-protected PKCS #8 PEM using `password` as the password. The cipher is selected by `Pkcs8EncryptAlg`. The output uses:

```
-----BEGIN ENCRYPTED PRIVATE KEY-----
...
-----END ENCRYPTED PRIVATE KEY-----
```

Encrypted PKCS #8 output uses PBES2 with PBKDF2. The generated parameters use an 8-byte salt, 2048 PBKDF2 iterations, and the default PBKDF2 PRF (HMAC-SHA-1). The selected cipher uses CBC mode with a newly generated IV.

**Generated PEM formatting:** PEM output uses CRLF line endings, Base64 lines of at most 64 characters, and a final CRLF.

**Empty passwords:** An empty `password` is accepted and still produces encrypted PKCS #8, but it provides no meaningful password protection.

Returns `null` on failure

### PrivateKey.GetPkcs8Pem

`Chilkat 11.7.0 · csharp · PrivateKey · GetPkcs8Pem · method`

```csharp
public string GetPkcs8Pem();
```

Exports the key as unencrypted PKCS #8 PEM. For RSA, EC, and Ed25519, the PEM armor is:

```
-----BEGIN PRIVATE KEY-----
...
-----END PRIVATE KEY-----
```

PKCS #8 is an algorithm-independent private-key container. Chilkat emits the classic version-0 `PrivateKeyInfo` structure, with the algorithm-specific private-key DER in an `OCTET STRING`.

```
PrivateKeyInfo ::= SEQUENCE {
    version                   Version,
    privateKeyAlgorithm       AlgorithmIdentifier,
    privateKey                OCTET STRING,
    attributes           [0]  IMPLICIT Attributes OPTIONAL
}
```

**Generated PEM formatting:** PEM output uses CRLF line endings, Base64 lines of at most 64 characters, and a final CRLF.

**Security note:** This output is not password-protected.

Returns `null` on failure

### PrivateKey.GetPkcsBd

`Chilkat 11.7.0 · csharp · PrivateKey · GetPkcsBd · method · since 11.0.0`

```csharp
public bool GetPkcsBd(bool pkcs1, string password, BinData bd);
```

Exports the key as DER and replaces the contents of the `BinData` in `bd`.

| `pkcs1` | `password` | Output |
| :--- | :--- | :--- |
| `true` | Ignored for encryption. | RSA PKCS #1, traditional DSA, RFC 5915 EC, or PKCS #8 for Ed25519. |
| `false` | Empty string. | Unencrypted PKCS #8 DER. |
| `false` | Nonempty password. | Encrypted PKCS #8 DER using `Pkcs8EncryptAlg`. |

**Output state:** A successful call replaces any existing `bd` content. If the call fails, `bd` is cleared.

**Password behavior:** When `pkcs1` is `true`, `password` does not encrypt the output. To obtain encrypted output, set `pkcs1` to `false` and provide a nonempty `password`.

Returns true for success, false for failure.

### PrivateKey.GetRawHex

`Chilkat 11.7.0 · csharp · PrivateKey · GetRawHex · method · since 9.5.0.83`

```csharp
public string GetRawHex(StringBuilder pubKey);
```

Exports the raw private value as lowercase hexadecimal and replaces the contents of the `StringBuilder` in `pubKey` with the corresponding raw public key.

| Key type | Returned private value | Public value in `pubKey` |
| :--- | :--- | :--- |
| Ed25519 | The 32-byte seed accepted by `LoadEd25519`, as 64 hex characters. | The 32-byte public key, as 64 hex characters. |
| EC | The private scalar, padded to the curve size as needed. | The uncompressed point `04 \|\| HEX(x) \|\| HEX(y)`. |

**Applicable key types:** This method supports Ed25519 and ordinary EC keys. RSA and DSA keys do not have a single simple raw representation and cause the method to fail.

**Output on failure:** If the method fails, `pubKey` is cleared.

Returns `null` on failure

### PrivateKey.GetXml

`Chilkat 11.7.0 · csharp · PrivateKey · GetXml · method`

```csharp
public string GetXml();
```

Exports the key in Chilkat-compatible XML. The XML is not encrypted. RSA and DSA components use ordinary Base64.

RSA keys use:

```
<RSAKeyValue>
  <Modulus>...</Modulus>
  <Exponent>...</Exponent>
  <D>...</D>
  <P>...</P>
  <Q>...</Q>
  <DP>...</DP>
  <DQ>...</DQ>
  <InverseQ>...</InverseQ>
</RSAKeyValue>
```

DSA keys use:

```
<DSAKeyValue>
  <P>...</P>
  <Q>...</Q>
  <G>...</G>
  <Y>...</Y>
  <X>...</X>
</DSAKeyValue>
```

EC keys place the named curve in the `curve` attribute and Base64-encode the RFC 5915 `ECPrivateKey` DER in the element content:

```
<ECCKeyValue curve="secp256r1">...</ECCKeyValue>
```

Ed25519 keys Base64-encode 64 bytes consisting of the 32-byte private seed followed by the 32-byte public key:

```
<Ed25519KeyValue>...</Ed25519KeyValue>
```

**Round-trip support:** XML produced by this method can be loaded by `LoadXml`, `LoadXmlFile`, or the general format-detection methods.

**Interoperability note:** These XML forms are Chilkat-compatible representations. Prefer PKCS #8, PEM, or JWK when interoperating with systems that expect standard key containers.

Returns `null` on failure

### PrivateKey.LoadAnyFormat

`Chilkat 11.7.0 · csharp · PrivateKey · LoadAnyFormat · method · since 9.5.0.75`

```csharp
public bool LoadAnyFormat(BinData privKeyData, string password);
```

Loads a private key from the data in `privKeyData` by inspecting its contents. Recognized representations include RSA PKCS #1 DER, traditional DSA and EC DER, PKCS #8 DER, encrypted PKCS #8, PEM, JWK, Chilkat-compatible XML, Microsoft PVK, and supported Ed25519 representations. `password` supplies the password when the detected representation is encrypted; otherwise it may be empty.

**Text and binary input:** `privKeyData` contains the exact bytes to inspect. Textual PEM, JWK, and XML are detected from those bytes; a filename extension is not involved.

**Trailing DER data:** If the input begins with one complete supported DER key followed by extra bytes or another DER object, the first key is loaded and trailing data is ignored.

**Object state:** A successful load replaces any key already held by this object. If loading fails, this object is left empty.

Returns true for success, false for failure.

### PrivateKey.LoadAnyFormatFile

`Chilkat 11.7.0 · csharp · PrivateKey · LoadAnyFormatFile · method · since 9.5.0.83`

```csharp
public bool LoadAnyFormatFile(string path, string password);
```

Loads a private key from the file at `path` by inspecting its contents. Recognized representations include RSA PKCS #1 DER, traditional DSA and EC DER, PKCS #8 DER, encrypted PKCS #8, PEM, JWK, Chilkat-compatible XML, Microsoft PVK, and supported Ed25519 representations. `password` supplies the password when needed.

**Filename extensions are advisory:** The file content determines the format; a nonstandard or misleading extension does not prevent recognition.

**Object state:** A successful load replaces any key already held by this object. If loading fails, this object is left empty.

Returns true for success, false for failure.

### PrivateKey.LoadEd25519

`Chilkat 11.7.0 · csharp · PrivateKey · LoadEd25519 · method · since 9.5.0.83`

```csharp
public bool LoadEd25519(string privKey, string pubKey);
```

Loads an Ed25519 key pair from raw hexadecimal values. `privKey` is the 32-byte Ed25519 private seed. `pubKey` is the 32-byte public key. Each nonempty value must contain exactly 64 hexadecimal digits. Uppercase hexadecimal and an optional `0x` prefix are accepted; embedded whitespace is not accepted. `pubKey` may be empty, in which case Chilkat derives the public key from the seed.

**Supplied public key is not verified:** When `pubKey` is nonempty, Chilkat stores the supplied public value without checking that it corresponds to `privKey`. Pass an empty `pubKey` when the public key should be derived and guaranteed to match the private seed.

**Object state:** A successful load replaces any key already held by this object. If loading fails, this object is left empty.

Returns true for success, false for failure.

### PrivateKey.LoadEncryptedPem

`Chilkat 11.7.0 · csharp · PrivateKey · LoadEncryptedPem · method`

```csharp
public bool LoadEncryptedPem(string pemStr, string password);
```

Loads a private key from the PEM text in `pemStr`. `password` supplies the password when the PEM is encrypted. The method accepts encrypted PKCS #8 PEM and also loads supported unencrypted PEM.

```
-----BEGIN ENCRYPTED PRIVATE KEY-----
...
-----END ENCRYPTED PRIVATE KEY-----
```

**Content auto-detection:** Chilkat examines the content rather than relying on the method name or filename extension. This password-taking method can load both encrypted and unencrypted supported private-key representations.

**Object state:** A successful load replaces any key already held by this object. If loading fails, this object is left empty.

**Password failure:** An incorrect password causes loading to fail and leaves this object empty.

Returns true for success, false for failure.

### PrivateKey.LoadEncryptedPemFile

`Chilkat 11.7.0 · csharp · PrivateKey · LoadEncryptedPemFile · method`

```csharp
public bool LoadEncryptedPemFile(string path, string password);
```

Loads a private key from the file at `path`, using `password` when the detected key is encrypted. The file may contain encrypted PKCS #8 PEM or another supported encrypted or unencrypted representation.

**Content auto-detection:** Chilkat examines the content rather than relying on the method name or filename extension. This password-taking method can load both encrypted and unencrypted supported private-key representations.

**Object state:** A successful load replaces any key already held by this object. If loading fails, this object is left empty.

Returns true for success, false for failure.

### PrivateKey.LoadJwk

`Chilkat 11.7.0 · csharp · PrivateKey · LoadJwk · method · since 9.5.0.66`

```csharp
public bool LoadJwk(string jsonStr);
```

Loads a private key from the JWK JSON in `jsonStr`. Supported private JWK key types are RSA (`kty`=`RSA`), EC (`kty`=`EC`), and Ed25519 (`kty`=`OKP`, `crv`=`Ed25519`). An unsupported `kty` causes the method to fail.

**Private key material required:** A JWK containing only public members belongs in a `PublicKey`. This method is for JWKs that contain private key material.

**Metadata handling:** Optional JOSE metadata such as `kid`, `use`, `alg`, and `key_ops` may be present but is not retained by `PrivateKey`.

**Object state:** A successful load replaces any key already held by this object. If loading fails, this object is left empty.

Returns true for success, false for failure.

### PrivateKey.LoadPem

`Chilkat 11.7.0 · csharp · PrivateKey · LoadPem · method`

```csharp
public bool LoadPem(string str);
```

Loads a private key from the PEM text in `str`. This method has no password argument and therefore cannot load password-protected PEM. Use `LoadEncryptedPem` for encrypted input.

**Content auto-detection:** The method name identifies the expected or traditional use, but Chilkat examines the content and can load other supported unencrypted private-key representations. Encrypted input requires a load method that accepts a password.

**PEM block selection:** If the text contains multiple PEM blocks, Chilkat selects the first supported private-key block. It skips preceding public-key or unrelated PEM blocks.

**Accepted surrounding content:** Leading and trailing whitespace, a UTF-8 BOM, and trailing non-PEM text are accepted.

**Object state:** A successful load replaces any key already held by this object. If loading fails, this object is left empty.

Returns true for success, false for failure.

### PrivateKey.LoadPemFile

`Chilkat 11.7.0 · csharp · PrivateKey · LoadPemFile · method`

```csharp
public bool LoadPemFile(string path);
```

Loads a private key from the file at `path`. This method has no password argument and therefore cannot load a password-protected key. Use `LoadEncryptedPemFile` or `LoadAnyFormatFile` when a password may be required.

**Content auto-detection:** The method name identifies the expected or traditional use, but Chilkat examines the content and can load other supported unencrypted private-key representations. Encrypted input requires a load method that accepts a password.

**PEM block selection:** For a file containing multiple PEM blocks, Chilkat selects the first supported private-key block and skips preceding public-key or unrelated blocks.

**Object state:** A successful load replaces any key already held by this object. If loading fails, this object is left empty.

Returns true for success, false for failure.

### PrivateKey.LoadPkcs1

`Chilkat 11.7.0 · csharp · PrivateKey · LoadPkcs1 · method · since 9.5.0.58`

```csharp
public bool LoadPkcs1(byte[] data);
```

Loads a private key from the in-memory data in `data`. Despite the historical PKCS #1 name, Chilkat examines the content and accepts supported unencrypted RSA, DSA, EC, Ed25519, PKCS #8, PEM, JWK, and XML representations.

**Content auto-detection:** The method name identifies the expected or traditional use, but Chilkat examines the content and can load other supported unencrypted private-key representations. Encrypted input requires a load method that accepts a password.

**Object state:** A successful load replaces any key already held by this object. If loading fails, this object is left empty.

**Modern binary API:** For new code that already has a `BinData`, use `LoadAnyFormat`.

Returns true for success, false for failure.

### PrivateKey.LoadPkcs1File

`Chilkat 11.7.0 · csharp · PrivateKey · LoadPkcs1File · method · since 9.5.0.58`

```csharp
public bool LoadPkcs1File(string path);
```

Loads a private key from the file at `path`. Despite the historical PKCS #1 name, the method examines the content and accepts supported unencrypted private-key representations.

**Content auto-detection:** The method name identifies the expected or traditional use, but Chilkat examines the content and can load other supported unencrypted private-key representations. Encrypted input requires a load method that accepts a password.

**Object state:** A successful load replaces any key already held by this object. If loading fails, this object is left empty.

Returns true for success, false for failure.

### PrivateKey.LoadPkcs8

`Chilkat 11.7.0 · csharp · PrivateKey · LoadPkcs8 · method`

```csharp
public bool LoadPkcs8(byte[] data);
```

Loads a private key from the in-memory data in `data`. Although this method is named for unencrypted PKCS #8 DER, Chilkat examines the content and accepts other supported unencrypted private-key representations.

**Content auto-detection:** The method name identifies the expected or traditional use, but Chilkat examines the content and can load other supported unencrypted private-key representations. Encrypted input requires a load method that accepts a password.

**Object state:** A successful load replaces any key already held by this object. If loading fails, this object is left empty.

**Modern binary API:** For new code that already has a `BinData`, `LoadAnyFormat` avoids the older byte-array API.

Returns true for success, false for failure.

### PrivateKey.LoadPkcs8Encrypted

`Chilkat 11.7.0 · csharp · PrivateKey · LoadPkcs8Encrypted · method`

```csharp
public bool LoadPkcs8Encrypted(byte[] data, string password);
```

Loads a private key from the in-memory data in `data`, using `password` when the detected key is encrypted. The method can load encrypted PKCS #8 and other supported encrypted or unencrypted representations.

**Content auto-detection:** Chilkat examines the content rather than relying on the method name or filename extension. This password-taking method can load both encrypted and unencrypted supported private-key representations.

**Object state:** A successful load replaces any key already held by this object. If loading fails, this object is left empty.

Returns true for success, false for failure.

### PrivateKey.LoadPkcs8EncryptedFile

`Chilkat 11.7.0 · csharp · PrivateKey · LoadPkcs8EncryptedFile · method`

```csharp
public bool LoadPkcs8EncryptedFile(string path, string password);
```

Loads a private key from the file at `path`, using `password` when the detected key is encrypted. The method can load encrypted PKCS #8 DER or PEM and also supported unencrypted representations.

**Content auto-detection:** Chilkat examines the content rather than relying on the method name or filename extension. This password-taking method can load both encrypted and unencrypted supported private-key representations.

**Object state:** A successful load replaces any key already held by this object. If loading fails, this object is left empty.

Returns true for success, false for failure.

### PrivateKey.LoadPkcs8File

`Chilkat 11.7.0 · csharp · PrivateKey · LoadPkcs8File · method`

```csharp
public bool LoadPkcs8File(string path);
```

Loads a private key from the file at `path`. Although named for unencrypted PKCS #8, the method examines the file content and accepts other supported unencrypted private-key representations.

**Content auto-detection:** The method name identifies the expected or traditional use, but Chilkat examines the content and can load other supported unencrypted private-key representations. Encrypted input requires a load method that accepts a password.

**Trailing DER data:** When the file begins with a complete supported DER private-key object, trailing bytes or a second concatenated DER object are ignored; the first key is loaded.

**Object state:** A successful load replaces any key already held by this object. If loading fails, this object is left empty.

Returns true for success, false for failure.

### PrivateKey.LoadPvk

`Chilkat 11.7.0 · csharp · PrivateKey · LoadPvk · method`

```csharp
public bool LoadPvk(byte[] data, string password);
```

Loads a private key from the in-memory data in `data`, using `password` if the detected representation is encrypted. This Windows-only method supports Microsoft PVK and also participates in Chilkat private-key content auto-detection.

**Content auto-detection:** Chilkat examines the content rather than relying on the method name or filename extension. This password-taking method can load both encrypted and unencrypted supported private-key representations.

**Object state:** A successful load replaces any key already held by this object. If loading fails, this object is left empty.

Returns true for success, false for failure.

### PrivateKey.LoadPvkFile

`Chilkat 11.7.0 · csharp · PrivateKey · LoadPvkFile · method`

```csharp
public bool LoadPvkFile(string path, string password);
```

Loads a private key from the file at `path`, using `password` if the detected representation is encrypted. This Windows-only method supports Microsoft PVK and also participates in Chilkat private-key content auto-detection.

**Content auto-detection:** Chilkat examines the content rather than relying on the method name or filename extension. This password-taking method can load both encrypted and unencrypted supported private-key representations.

**Object state:** A successful load replaces any key already held by this object. If loading fails, this object is left empty.

Returns true for success, false for failure.

### PrivateKey.LoadXml

`Chilkat 11.7.0 · csharp · PrivateKey · LoadXml · method`

```csharp
public bool LoadXml(string xml);
```

Loads a private key from the XML text in `xml`. Supported Chilkat-compatible XML roots include `RSAKeyValue`, `DSAKeyValue`, `ECCKeyValue`, and `Ed25519KeyValue`.

**Content auto-detection:** The method name identifies the expected or traditional use, but Chilkat examines the content and can load other supported unencrypted private-key representations. Encrypted input requires a load method that accepts a password.

**Ed25519 XML:** The `Ed25519KeyValue` content is ordinary Base64 for the 32-byte private seed followed by the 32-byte public key.

**Object state:** A successful load replaces any key already held by this object. If loading fails, this object is left empty.

Returns true for success, false for failure.

### PrivateKey.LoadXmlFile

`Chilkat 11.7.0 · csharp · PrivateKey · LoadXmlFile · method`

```csharp
public bool LoadXmlFile(string path);
```

Loads a private key from the file at `path`. Chilkat recognizes RSA, DSA, EC, and Ed25519 XML produced by `GetXml`, and also auto-detects other supported unencrypted private-key representations.

**Content auto-detection:** The method name identifies the expected or traditional use, but Chilkat examines the content and can load other supported unencrypted private-key representations. Encrypted input requires a load method that accepts a password.

**Object state:** A successful load replaces any key already held by this object. If loading fails, this object is left empty.

Returns true for success, false for failure.

### PrivateKey.SavePemFile

`Chilkat 11.7.0 · csharp · PrivateKey · SavePemFile · method · since 9.5.0.58`

```csharp
public bool SavePemFile(string path);
```

Saves the key at `path` as unencrypted PEM, preferring a traditional algorithm-specific representation when one exists. RSA uses `RSA PRIVATE KEY`, DSA uses `DSA PRIVATE KEY`, EC uses `EC PRIVATE KEY`, and Ed25519 uses the PKCS #8 `PRIVATE KEY` form.

**Generated PEM formatting:** PEM output uses CRLF line endings, Base64 lines of at most 64 characters, and a final CRLF.

**File behavior:** An existing destination file is replaced. Parent directories are not created; the parent directory must already exist.

**PKCS #8 alternative:** Use `SavePkcs8PemFile` to always request the algorithm-independent PKCS #8 `PRIVATE KEY` form.

**Security note:** The file is not password-protected.

Returns true for success, false for failure.

### PrivateKey.SavePkcs1File

`Chilkat 11.7.0 · csharp · PrivateKey · SavePkcs1File · method · since 9.5.0.58`

```csharp
public bool SavePkcs1File(string path);
```

Saves the key at `path` using the traditional or preferred unencrypted DER representation.

**Historical method name:** RSA is saved as PKCS #1, EC as RFC 5915, DSA in its traditional structure, and Ed25519 as PKCS #8 because no traditional PKCS #1 form exists.

**File behavior:** An existing destination file is replaced. Parent directories are not created; the parent directory must already exist.

**Security note:** The file contains cleartext private-key material.

Returns true for success, false for failure.

### PrivateKey.SavePkcs8EncryptedFile

`Chilkat 11.7.0 · csharp · PrivateKey · SavePkcs8EncryptedFile · method`

```csharp
public bool SavePkcs8EncryptedFile(string password, string path);
```

Saves the key as password-protected PKCS #8 DER. `password` supplies the password and `path` is the destination path. The cipher is selected by `Pkcs8EncryptAlg`.

Encrypted PKCS #8 output uses PBES2 with PBKDF2. The generated parameters use an 8-byte salt, 2048 PBKDF2 iterations, and the default PBKDF2 PRF (HMAC-SHA-1). The selected cipher uses CBC mode with a newly generated IV.

**File behavior:** An existing destination file is replaced. Parent directories are not created; the parent directory must already exist.

**Empty passwords:** An empty `password` is accepted but provides no meaningful password protection.

Returns true for success, false for failure.

### PrivateKey.SavePkcs8EncryptedPemFile

`Chilkat 11.7.0 · csharp · PrivateKey · SavePkcs8EncryptedPemFile · method`

```csharp
public bool SavePkcs8EncryptedPemFile(string password, string path);
```

Saves the key as password-protected PKCS #8 PEM. `password` supplies the password and `path` is the destination path. The file uses the `ENCRYPTED PRIVATE KEY` PEM label, and the cipher is selected by `Pkcs8EncryptAlg`.

Encrypted PKCS #8 output uses PBES2 with PBKDF2. The generated parameters use an 8-byte salt, 2048 PBKDF2 iterations, and the default PBKDF2 PRF (HMAC-SHA-1). The selected cipher uses CBC mode with a newly generated IV.

**Generated PEM formatting:** PEM output uses CRLF line endings, Base64 lines of at most 64 characters, and a final CRLF.

**File behavior:** An existing destination file is replaced. Parent directories are not created; the parent directory must already exist.

**Empty passwords:** An empty `password` is accepted but provides no meaningful password protection.

Returns true for success, false for failure.

### PrivateKey.SavePkcs8File

`Chilkat 11.7.0 · csharp · PrivateKey · SavePkcs8File · method`

```csharp
public bool SavePkcs8File(string path);
```

Saves the key as unencrypted PKCS #8 DER at `path`. PKCS #8 is an algorithm-independent private-key container. Chilkat emits the classic version-0 `PrivateKeyInfo` structure, with the algorithm-specific private-key DER in an `OCTET STRING`.

```
PrivateKeyInfo ::= SEQUENCE {
    version                   Version,
    privateKeyAlgorithm       AlgorithmIdentifier,
    privateKey                OCTET STRING,
    attributes           [0]  IMPLICIT Attributes OPTIONAL
}
```

**File behavior:** An existing destination file is replaced. Parent directories are not created; the parent directory must already exist.

**macOS Keychain:** Starting in Chilkat v10.0.0, `path` may be formatted as `keychain:<label>` to save the private key to the Apple Keychain.

**Security note:** The file contains cleartext private-key material.

Returns true for success, false for failure.

### PrivateKey.SavePkcs8PemFile

`Chilkat 11.7.0 · csharp · PrivateKey · SavePkcs8PemFile · method`

```csharp
public bool SavePkcs8PemFile(string path);
```

Saves the key as unencrypted PKCS #8 PEM at `path`. The PEM label is `PRIVATE KEY` for RSA, EC, Ed25519, and other supported PKCS #8 key types.PKCS #8 is an algorithm-independent private-key container. Chilkat emits the classic version-0 `PrivateKeyInfo` structure, with the algorithm-specific private-key DER in an `OCTET STRING`.

```
PrivateKeyInfo ::= SEQUENCE {
    version                   Version,
    privateKeyAlgorithm       AlgorithmIdentifier,
    privateKey                OCTET STRING,
    attributes           [0]  IMPLICIT Attributes OPTIONAL
}
```

**Generated PEM formatting:** PEM output uses CRLF line endings, Base64 lines of at most 64 characters, and a final CRLF.

**File behavior:** An existing destination file is replaced. Parent directories are not created; the parent directory must already exist.

**Security note:** The file is not password-protected.

Returns true for success, false for failure.

### PrivateKey.SaveXmlFile

`Chilkat 11.7.0 · csharp · PrivateKey · SaveXmlFile · method`

```csharp
public bool SaveXmlFile(string path);
```

Saves the key as unencrypted Chilkat-compatible XML at `path`. The XML representation is the same as returned by `GetXml`.

**File behavior:** An existing destination file is replaced. Parent directories are not created; the parent directory must already exist.

**Security note:** The XML contains cleartext private-key material.

Returns true for success, false for failure.

### PrivateKey.ToPublicKey

`Chilkat 11.7.0 · csharp · PrivateKey · ToPublicKey · method · since 11.0.0`

```csharp
public bool ToPublicKey(PublicKey pubKey);
```

Extracts the public portion of the loaded private key and stores an independent copy in the `PublicKey` supplied in `pubKey`. The resulting public key is unaffected if this `PrivateKey` is later reloaded with a different key.

**Target state on failure:** If extraction fails, an existing key already held by `pubKey` is preserved.

Returns true for success, false for failure.

### PrivateKey.UploadToCloud

`Chilkat 11.7.0 · csharp · PrivateKey · UploadToCloud · method · since 9.5.0.96`

```csharp
public bool UploadToCloud(JsonObject jsonIn, JsonObject jsonOut);
```

Uploads or imports the private key to a supported cloud key-management service. `jsonIn` supplies service-specific input parameters as a `JsonObject`, and `jsonOut` receives service-specific result information.

**Open-ended interface:** The required JSON members and returned JSON depend on the target service and operation. Follow the corresponding Chilkat example for AWS KMS, Azure Key Vault, or another supported provider rather than assuming one common schema.

**Security note:** Cloud import operations may transmit private-key material. Use only the provider endpoint, authentication, and transport settings documented for the intended service.

Returns true for success, false for failure.

Async variant: `UploadToCloudAsync` — same arguments, returns a `Task` (see Async variants below).

## Events and callbacks

### PrivateKey.AbortCheck (event)

`Chilkat 11.7.0 · csharp · PrivateKey · AbortCheck · event`

```csharp
public event AbortCheckEventHandler OnAbortCheck;
```

Enables a method call to be aborted by triggering the AbortCheck event at intervals defined by the `HeartbeatMs` property. If HeartbeatMs is set to its default value of 0, no events will occur. For instance, set HeartbeatMs to 200 to trigger 5 AbortCheck events per second.

### Chilkat .NET Framework Event Implementation

Args are passed using Chilkat.AbortCheckEventArgs

**Event callback implementation:**

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

**To add an event handler:**

```csharp
Chilkat.PrivateKey privatekey = new Chilkat.PrivateKey();
privatekey.OnAbortCheck += privatekey_OnAbortCheck;
```

### Chilkat .NET Core Event Implementation

**Event callback implementation:**

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

**To add an event handler:**

```csharp
Chilkat.PrivateKey privatekey = new Chilkat.PrivateKey();
// ...
Chilkat.PrivateKey.AbortCheck abortCheck = new Chilkat.PrivateKey.AbortCheck(handleAbortCheck);
privatekey.setAbortCheckCb(abortCheck);
```

### PrivateKey.PercentDone (event)

`Chilkat 11.7.0 · csharp · PrivateKey · PercentDone · event`

```csharp
public event PercentDoneEventHandler OnPercentDone;
```

This provides the percentage completion for any method involving network communications or time-consuming processing, assuming the progress can be measured as a percentage. This event is triggered only when it's possible and logical to express the operation's progress as a percentage. The `pctDone` argument will range from 1 to 100. For methods that finish quickly, the number of PercentDone callbacks may vary, but the final callback will have `pctDone` equal to 100. For longer operations, callbacks will not exceed one per percentage point (e.g., 1, 2, 3, ..., 98, 99, 100).

The PercentDone callback also acts as an `AbortCheck` event. For fast methods where PercentDone fires, an AbortCheck event may not trigger since the PercentDone callback already provides an opportunity to abort. For longer operations, where time between PercentDone callbacks is extended, AbortCheck callbacks enable more responsive operation termination.

To abort the operation, set the `abort` output argument to `true`. This will cause the method to terminate and return a failure status or corresponding failure value.

### Chilkat .NET Framework Event Implementation

Args are passed using Chilkat.PercentDoneEventArgs

**Event callback implementation:**

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

**To add an event handler:**

```csharp
Chilkat.PrivateKey privatekey = new Chilkat.PrivateKey();
privatekey.OnPercentDone += privatekey_OnPercentDone;
```

### Chilkat .NET Core Event Implementation

**Event callback implementation:**

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

**To add an event handler:**

```csharp
Chilkat.PrivateKey privatekey = new Chilkat.PrivateKey();
// ...
Chilkat.PrivateKey.PercentDone percentDone = new Chilkat.PrivateKey.PercentDone(handlePercentDone);
privatekey.setPercentDoneCb(percentDone);
```

### PrivateKey.ProgressInfo (event)

`Chilkat 11.7.0 · csharp · PrivateKey · ProgressInfo · event`

```csharp
public event ProgressInfoEventHandler OnProgressInfo;
```

This event callback provides `tag name`/value pairs that detail what occurs during a method call. To discover existing tag names, create code to handle the event, emit the pairs, and review them. Most tag names are self-explanatory.

Note: Some Chilkat methods don't fire any ProgressInfo events.

### Chilkat .NET Framework Event Implementation

Args are passed using Chilkat.ProgressInfoEventArgs

**Event callback implementation:**

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

**To add an event handler:**

```csharp
Chilkat.PrivateKey privatekey = new Chilkat.PrivateKey();
privatekey.OnProgressInfo += privatekey_OnProgressInfo;
```

### Chilkat .NET Core Event Implementation

**Event callback implementation:**

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

**To add an event handler:**

```csharp
Chilkat.PrivateKey privatekey = new Chilkat.PrivateKey();
// ...
Chilkat.PrivateKey.ProgressInfo progressInfo = new Chilkat.PrivateKey.ProgressInfo(handleProgressInfo);
privatekey.setProgressInfoCb(progressInfo);
```

### PrivateKey.TaskCompleted (event)

`Chilkat 11.7.0 · csharp · PrivateKey · TaskCompleted · event`

```csharp
public event TaskCompletedEventHandler OnTaskCompleted;
```

Called from the background thread when an asynchronous task completes.

### Chilkat .NET Framework Event Implementation

Args are passed using Chilkat.TaskCompletedEventArgs

**Event callback implementation:**

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

**To add an event handler:**

```csharp
Chilkat.PrivateKey privatekey = new Chilkat.PrivateKey();
privatekey.OnTaskCompleted += privatekey_OnTaskCompleted;
```

### Chilkat .NET Core Event Implementation

**Event callback implementation:**

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

**To add an event handler:**

```csharp
Chilkat.PrivateKey privatekey = new Chilkat.PrivateKey();
// ...
Chilkat.PrivateKey.TaskIdCompleted taskIdCompleted = new Chilkat.PrivateKey.TaskIdCompleted(handleTaskIdCompleted);
privatekey.setTaskIdCompletedCb(taskIdCompleted);
```

## Async variants

Each returns a `Task` instead of the result and takes the same arguments as the synchronous method; run the task, wait for `Finished`, then read the result from the task. No new Async methods are added from 11.7.0 on.

```csharp
public Task UploadToCloudAsync(JsonObject jsonIn, JsonObject jsonOut);
```

## Deprecated members — do not use in new code

| Member | Kind | Deprecated in | Use instead |
|---|---|---|---|
| `GetPublicKey` | method | before 11.6.1 | `ToPublicKey` |

## Related classes

[`BinData`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/csharp/classes/BinData.md), [`JsonObject`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/csharp/classes/JsonObject.md), [`PublicKey`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/csharp/classes/PublicKey.md), [`StringBuilder`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/csharp/classes/StringBuilder.md)