---
product: Chilkat
product_version: 11.7.0
language: delphidll
language_label: Delphi DLL
class: BinData
license: free
deprecated: false
reference_html: https://www.chilkatsoft.com/refdoc/dd_CkBinDataRef.html
---
# Chilkat BinData — Delphi DLL — v11.7.0

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

## Purpose

**Build, transform, encode, decode, inspect, and save binary data.**

`Chilkat.BinData` is a general-purpose mutable byte container used throughout Chilkat for working with binary content in memory. It can load bytes from files, byte arrays, strings, and encoded text; append additional data in many forms; retrieve content as raw bytes, chunks, text, or encoded strings; compute hashes; convert character encodings; validate UTF-8; remove byte ranges; and write the final result to files.

**Load binary content**

Load data from files, byte arrays, strings, encoded strings, or other Chilkat objects that produce binary output.

**Append and build data**

Append bytes, strings, integers, BOMs, counted strings, padded fields, encoded data, and other `BinData` objects.

**Encode and decode**

Convert binary data to and from text encodings such as Base64, hex, URL encoding, and other supported binary encodings.

**Text and charset handling**

Interpret bytes as text, append strings using a specified charset, convert character encodings, and validate UTF-8 content.

**Inspect and modify bytes**

Get byte counts, extract chunks, remove ranges, compare data, and work with specific portions of a binary buffer.

**Hash and save output**

Compute hashes for the contained data and write the resulting bytes to files or pass them to other Chilkat classes.

**Common pattern:** Load or append binary data, perform any needed encoding, decoding, hashing, charset conversion, or byte-level edits, then retrieve the result as bytes, text, an encoded string, or a file. Use `BinData` whenever a Chilkat method needs a mutable in-memory binary buffer.

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

## Object creation, unlocking and error handling

**Create/Dispose**

```pascal
var
myObject: HCkBinData;

begin
myObject := CkBinData_Create();

// ...

CkBinData_Dispose(myObject);
end;
```

`function CkBinData_Create: HCkBinData; stdcall;`

Creates an instance of the HCkBinData object and returns a handle (i.e. a Pointer). The handle is passed in the 1st argument for the functions listed on this page.

`procedure CkBinData_Dispose(handle: HCkBinData); stdcall;`

Objects created by calling CkBinData_Create must be freed by calling this method. A memory leak occurs if a handle is not disposed by calling this function.

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 Delphi DLL.

## 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` | `procedure CkBinData_getDebugLogFilePath(objHandle: HCkBinData; outPropVal: HCkString); stdcall; procedure CkBinData_putDebugLogFilePath(objHandle: HCkBinData; newPropVal: PWideChar); stdcall; function CkBinData__debugLogFilePath(objHandle: HCkBinData): PWideChar; stdcall;` | 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` | `procedure CkBinData_getLastErrorHtml(objHandle: HCkBinData; outPropVal: HCkString); stdcall; function CkBinData__lastErrorHtml(objHandle: HCkBinData): PWideChar; stdcall;` | read-only | Provides HTML-formatted information about the last called method or property. |
| `LastErrorText` | `procedure CkBinData_getLastErrorText(objHandle: HCkBinData; outPropVal: HCkString); stdcall; function CkBinData__lastErrorText(objHandle: HCkBinData): PWideChar; stdcall;` | read-only | Provides plain text information about the last called method or property. |
| `LastErrorXml` | `procedure CkBinData_getLastErrorXml(objHandle: HCkBinData; outPropVal: HCkString); stdcall; function CkBinData__lastErrorXml(objHandle: HCkBinData): PWideChar; stdcall;` | read-only | Provides XML-formatted information about the last called method or property. |
| `LastMethodSuccess` | `function CkBinData_getLastMethodSuccess(objHandle: HCkBinData): wordbool; stdcall; procedure CkBinData_putLastMethodSuccess(objHandle: HCkBinData; newPropVal: wordbool); stdcall;` | read/write | Indicates the success or failure of the most recent method call: `True` means success, `False` means failure. |
| `VerboseLogging` | `function CkBinData_getVerboseLogging(objHandle: HCkBinData): wordbool; stdcall; procedure CkBinData_putVerboseLogging(objHandle: HCkBinData; newPropVal: wordbool); stdcall;` | read/write | If set to `True`, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. |
| `Version` | `procedure CkBinData_getVersion(objHandle: HCkBinData; outPropVal: HCkString); stdcall; function CkBinData__version(objHandle: HCkBinData): PWideChar; stdcall;` | read-only | Version of the component/library, such as "10.1.0" |

## Member index

| Member | Kind | Signature |
|---|---|---|
| `NumBytes` | property, read-only | `function CkBinData_getNumBytes(objHandle: HCkBinData): Integer; stdcall;` |
| `AppendBd` | method | `function CkBinData_AppendBd(objHandle: HCkBinData;     binData: HCkBinData): wordbool; stdcall;` |
| `AppendBom` | method | `function CkBinData_AppendBom(objHandle: HCkBinData;     charset: PWideChar): wordbool; stdcall;` |
| `AppendByte` | method | `function CkBinData_AppendByte(objHandle: HCkBinData;     byteValue: Integer): wordbool; stdcall;` |
| `AppendCountedString` | method | `function CkBinData_AppendCountedString(objHandle: HCkBinData;     numCountBytes: Integer;     bigEndian: wordbool;     str: PWideChar;     charset: PWideChar): wordbool; stdcall;` |
| `AppendData` | method | `function CkBinData_AppendData(objHandle: HCkBinData;     data: TBytes;     numBytes: Integer): wordbool; stdcall;` |
| `AppendEncoded` | method | `function CkBinData_AppendEncoded(objHandle: HCkBinData;     encData: PWideChar;     encoding: PWideChar): wordbool; stdcall;` |
| `AppendEncodedSb` | method | `function CkBinData_AppendEncodedSb(objHandle: HCkBinData;     sb: HCkStringBuilder;     encoding: PWideChar): wordbool; stdcall;` |
| `AppendInt2` | method | `function CkBinData_AppendInt2(objHandle: HCkBinData;     value: Integer;     littleEndian: wordbool): wordbool; stdcall;` |
| `AppendInt4` | method | `function CkBinData_AppendInt4(objHandle: HCkBinData;     value: Integer;     littleEndian: wordbool): wordbool; stdcall;` |
| `AppendPadded` | method | `function CkBinData_AppendPadded(objHandle: HCkBinData;     str: PWideChar;     charset: PWideChar;     padWithSpace: wordbool;     fieldLen: Integer): wordbool; stdcall;` |
| `AppendSb` | method | `function CkBinData_AppendSb(objHandle: HCkBinData;     sb: HCkStringBuilder;     charset: PWideChar): wordbool; stdcall;` |
| `AppendString` | method | `function CkBinData_AppendString(objHandle: HCkBinData;     str: PWideChar;     charset: PWideChar): wordbool; stdcall;` |
| `ByteSwap` | method | `procedure CkBinData_ByteSwap(objHandle: HCkBinData;     size: Integer) stdcall;` |
| `CharsetConvert` | method | `function CkBinData_CharsetConvert(objHandle: HCkBinData;     fromCharset: PWideChar;     toCharset: PWideChar;     allOrNone: wordbool): wordbool; stdcall;` |
| `Clear` | method | `function CkBinData_Clear(objHandle: HCkBinData): wordbool; stdcall;` |
| `ContentsEqual` | method | `function CkBinData_ContentsEqual(objHandle: HCkBinData;     binData: HCkBinData): wordbool; stdcall;` |
| `FindString` | method | `function CkBinData_FindString(objHandle: HCkBinData;     str: PWideChar;     startIdx: Integer;     charset: PWideChar): Integer; stdcall;` |
| `GetByte` | method | `function CkBinData_GetByte(objHandle: HCkBinData;     index: Integer): Integer; stdcall;` |
| `GetData` | method | `function CkBinData_GetData(objHandle: HCkBinData): Pointer; stdcall;` |
| `GetDataChunk` | method | `function CkBinData_GetDataChunk(objHandle: HCkBinData;     offset: Integer;     numBytes: Integer): Pointer; stdcall;` |
| `GetEncoded` | method | `function CkBinData_GetEncoded(objHandle: HCkBinData;     encoding: PWideChar;     outStr: HCkString): wordbool; stdcall; function CkBinData__getEncoded(objHandle: HCkBinData;     encoding: PWideChar): PWideChar; stdcall;` |
| `GetEncodedChunk` | method | `function CkBinData_GetEncodedChunk(objHandle: HCkBinData;     offset: Integer;     numBytes: Integer;     encoding: PWideChar;     outStr: HCkString): wordbool; stdcall; function CkBinData__getEncodedChunk(objHandle: HCkBinData;     offset: Integer;     numBytes: Integer;     encoding: PWideChar): PWideChar; stdcall;` |
| `GetEncodedSb` | method | `function CkBinData_GetEncodedSb(objHandle: HCkBinData;     encoding: PWideChar;     sb: HCkStringBuilder): wordbool; stdcall;` |
| `GetHash` | method | `function CkBinData_GetHash(objHandle: HCkBinData;     algorithm: PWideChar;     encoding: PWideChar;     outStr: HCkString): wordbool; stdcall; function CkBinData__getHash(objHandle: HCkBinData;     algorithm: PWideChar;     encoding: PWideChar): PWideChar; stdcall;` |
| `GetInt2` | method | `function CkBinData_GetInt2(objHandle: HCkBinData;     index: Integer;     littleEndian: wordbool): Integer; stdcall;` |
| `GetInt4` | method | `function CkBinData_GetInt4(objHandle: HCkBinData;     index: Integer;     littleEndian: wordbool): Integer; stdcall;` |
| `GetString` | method | `function CkBinData_GetString(objHandle: HCkBinData;     charset: PWideChar;     outStr: HCkString): wordbool; stdcall; function CkBinData__getString(objHandle: HCkBinData;     charset: PWideChar): PWideChar; stdcall;` |
| `GetTextChunk` | method | `function CkBinData_GetTextChunk(objHandle: HCkBinData;     startIdx: Integer;     numBytes: Integer;     charset: PWideChar;     outStr: HCkString): wordbool; stdcall; function CkBinData__getTextChunk(objHandle: HCkBinData;     startIdx: Integer;     numBytes: Integer;     charset: PWideChar): PWideChar; stdcall;` |
| `GetUInt2` | method | `function CkBinData_GetUInt2(objHandle: HCkBinData;     index: Integer;     littleEndian: wordbool): LongWord; stdcall;` |
| `GetUInt4` | method | `function CkBinData_GetUInt4(objHandle: HCkBinData;     index: Integer;     littleEndian: wordbool): LongWord; stdcall;` |
| `IsValidUtf8` | method | `function CkBinData_IsValidUtf8(objHandle: HCkBinData): wordbool; stdcall;` |
| `LoadEncoded` | method | `function CkBinData_LoadEncoded(objHandle: HCkBinData;     encData: PWideChar;     encoding: PWideChar): wordbool; stdcall;` |
| `LoadFile` | method | `function CkBinData_LoadFile(objHandle: HCkBinData;     path: PWideChar): wordbool; stdcall;` |
| `RemoveByteVal` | method | `procedure CkBinData_RemoveByteVal(objHandle: HCkBinData;     value: Integer) stdcall;` |
| `RemoveChunk` | method | `function CkBinData_RemoveChunk(objHandle: HCkBinData;     offset: Integer;     numBytes: Integer): wordbool; stdcall;` |
| `SecureClear` | method | `function CkBinData_SecureClear(objHandle: HCkBinData): wordbool; stdcall;` |
| `WriteAppendFile` | method | `function CkBinData_WriteAppendFile(objHandle: HCkBinData;     path: PWideChar): wordbool; stdcall;` |
| `WriteFile` | method | `function CkBinData_WriteFile(objHandle: HCkBinData;     path: PWideChar): wordbool; stdcall;` |

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

## Properties

### BinData.NumBytes

`Chilkat 11.7.0 · delphidll · BinData · NumBytes · property · read-only · since 9.5.0.51`

```pascal
function CkBinData_getNumBytes(objHandle: HCkBinData): Integer; stdcall;
```

The number of bytes contained within the object.

## Methods

### BinData.AppendBd

`Chilkat 11.7.0 · delphidll · BinData · AppendBd · method · since 9.5.0.62`

```pascal
function CkBinData_AppendBd(objHandle: HCkBinData;
    binData: HCkBinData): wordbool; stdcall;
```

Appends the contents of another BinData to this object.

Returns True for success, False for failure.

### BinData.AppendBom

`Chilkat 11.7.0 · delphidll · BinData · AppendBom · method · since 9.5.0.62`

```pascal
function CkBinData_AppendBom(objHandle: HCkBinData;
    charset: PWideChar): wordbool; stdcall;
```

Appends the appropriate BOM (byte order mark), also known as a `preamble`, for the given charset. If the `charset` has no defined BOM, then nothing is appended. An application would typically call this to append the utf-8, utf-16, or utf-32 BOM.

Returns True for success, False for failure.

### BinData.AppendByte

`Chilkat 11.7.0 · delphidll · BinData · AppendByte · method · since 9.5.0.77`

```pascal
function CkBinData_AppendByte(objHandle: HCkBinData;
    byteValue: Integer): wordbool; stdcall;
```

Appends a single byte. The `byteValue` should be a value from 0 to 255.

Returns True for success, False for failure.

### BinData.AppendCountedString

`Chilkat 11.7.0 · delphidll · BinData · AppendCountedString · method · since 9.5.0.91`

```pascal
function CkBinData_AppendCountedString(objHandle: HCkBinData;
    numCountBytes: Integer;
    bigEndian: wordbool;
    str: PWideChar;
    charset: PWideChar): wordbool; stdcall;
```

Appends a byte count followed by the string in the desired character encoding, such as `utf-8`. The `numCountBytes` is the size in bytes of the integer to represent the byte count. If 0, then a minimal number of bytes is used. If `bigEndian` is `True`, the byte count is appended in big endian byte ordering, otherwise little-ending byte ordering. The `str` is the string to be appended. The `charset` is the character encoding, such as `utf-8`, `utf-16`, `windows-1252`, etc.

Returns True for success, False for failure.

### BinData.AppendData

`Chilkat 11.7.0 · delphidll · BinData · AppendData · method · since 11.0.0`

```pascal
function CkBinData_AppendData(objHandle: HCkBinData;
    data: TBytes;
    numBytes: Integer): wordbool; stdcall;
```

**Full documentation for this method (same in every language):** [Passing Binary Data Between Chilkat and Delphi](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/chilkat_delphi_binary_array.md)

Appends binary data to the current contents.

Returns True for success, False for failure.

### BinData.AppendEncoded

`Chilkat 11.7.0 · delphidll · BinData · AppendEncoded · method · since 9.5.0.51`

```pascal
function CkBinData_AppendEncoded(objHandle: HCkBinData;
    encData: PWideChar;
    encoding: PWideChar): wordbool; stdcall;
```

Appends encoded binary data to the current data. The `encoding` may be `Base64`, `modBase64`, `base64Url`, `Base32`, `Base58`, `QP` (for quoted-printable), `URL` (for url-encoding), `Hex`, or any of the encodings found at [Chilkat Binary Encodings List](https://www.chilkatsoft.com/binary_encodings.asp).

Returns True for success, False for failure.

### BinData.AppendEncodedSb

`Chilkat 11.7.0 · delphidll · BinData · AppendEncodedSb · method · since 9.5.0.62`

```pascal
function CkBinData_AppendEncodedSb(objHandle: HCkBinData;
    sb: HCkStringBuilder;
    encoding: PWideChar): wordbool; stdcall;
```

Decodes the contents of `sb` and appends the decoded bytes to this object. The `encoding` may be `Base64`, `modBase64`, `base64Url`, `Base32`, `Base58`, `QP` (for quoted-printable), `URL` (for url-encoding), `Hex`, or any of the encodings found at [Chilkat Binary Encodings List](https://www.chilkatsoft.com/binary_encodings.asp).

Returns True for success, False for failure.

### BinData.AppendInt2

`Chilkat 11.7.0 · delphidll · BinData · AppendInt2 · method · since 9.5.0.77`

```pascal
function CkBinData_AppendInt2(objHandle: HCkBinData;
    value: Integer;
    littleEndian: wordbool): wordbool; stdcall;
```

Appends a 16-bit integer (2 bytes). If `littleEndian` is `True`, then the integer bytes are appended in little-endian byte order, otherwise big-endian byte order is used.

Returns True for success, False for failure.

### BinData.AppendInt4

`Chilkat 11.7.0 · delphidll · BinData · AppendInt4 · method · since 9.5.0.77`

```pascal
function CkBinData_AppendInt4(objHandle: HCkBinData;
    value: Integer;
    littleEndian: wordbool): wordbool; stdcall;
```

Appends a 32-bit integer (4 bytes). If `littleEndian` is `True`, then the integer bytes are appended in little-endian byte order, otherwise big-endian byte order is used.

Returns True for success, False for failure.

### BinData.AppendPadded

`Chilkat 11.7.0 · delphidll · BinData · AppendPadded · method · since 9.5.0.80`

```pascal
function CkBinData_AppendPadded(objHandle: HCkBinData;
    str: PWideChar;
    charset: PWideChar;
    padWithSpace: wordbool;
    fieldLen: Integer): wordbool; stdcall;
```

Appends a string to this object, padded to the `fieldLen` with NULL or SPACE chars. If `padWithSpace` is `True`, then SPACE chars are used and the string is not null-terminated. If `fieldLen` is `False`, then null bytes are used. The `charset` controls the byte representation to use, such as `utf-8`.

Note: This call will always append a total number of bytes equal to `fieldLen`. If the `str` is longer than `fieldLen`, the method returns `False` to indicate failure and nothing is appended.

Returns True for success, False for failure.

### BinData.AppendSb

`Chilkat 11.7.0 · delphidll · BinData · AppendSb · method · since 9.5.0.62`

```pascal
function CkBinData_AppendSb(objHandle: HCkBinData;
    sb: HCkStringBuilder;
    charset: PWideChar): wordbool; stdcall;
```

Appends the contents of a StringBuilder to this object.

Returns True for success, False for failure.

### BinData.AppendString

`Chilkat 11.7.0 · delphidll · BinData · AppendString · method · since 9.5.0.62`

```pascal
function CkBinData_AppendString(objHandle: HCkBinData;
    str: PWideChar;
    charset: PWideChar): wordbool; stdcall;
```

Appends a string to this object. (This does not append the BOM. If a BOM is required, the AppendBom method can be called to append the appropriate BOM.)

Returns True for success, False for failure.

### BinData.ByteSwap

`Chilkat 11.7.0 · delphidll · BinData · ByteSwap · method · since 11.0.0`

```pascal
procedure CkBinData_ByteSwap(objHandle: HCkBinData;
    size: Integer) stdcall;
```

Does either 16-bit or 32-bit byte swapping of the entire contents. If `size` equals 16, then swaps in 2 bytes (e.g., 0x1234 → 0x3412). If `size` equals 32, then swaps 4 bytes (e.g., 0x12345678 → 0x78563412)

### BinData.CharsetConvert

`Chilkat 11.7.0 · delphidll · BinData · CharsetConvert · method · since 11.0.0`

```pascal
function CkBinData_CharsetConvert(objHandle: HCkBinData;
    fromCharset: PWideChar;
    toCharset: PWideChar;
    allOrNone: wordbool): wordbool; stdcall;
```

This method converts the character encoding of an object's contents from one format to another, such as from Windows-1252 to UTF-8. The `allOrNone` parameter determines error handling for unrepresentable bytes. If `allOrNone` is `True`, the object's contents remain unchanged when errors occur. If `False`, error bytes are discarded. The method returns `True` if successful and `False` if errors occur.

Returns True for success, False for failure.

### BinData.Clear

`Chilkat 11.7.0 · delphidll · BinData · Clear · method · since 9.5.0.51`

```pascal
function CkBinData_Clear(objHandle: HCkBinData): wordbool; stdcall;
```

Clears the contents.

Returns True for success, False for failure.

### BinData.ContentsEqual

`Chilkat 11.7.0 · delphidll · BinData · ContentsEqual · method · since 9.5.0.62`

```pascal
function CkBinData_ContentsEqual(objHandle: HCkBinData;
    binData: HCkBinData): wordbool; stdcall;
```

Return `True` if the contents of this object equals the contents of `binData`.

### BinData.FindString

`Chilkat 11.7.0 · delphidll · BinData · FindString · method · since 9.5.0.85`

```pascal
function CkBinData_FindString(objHandle: HCkBinData;
    str: PWideChar;
    startIdx: Integer;
    charset: PWideChar): Integer; stdcall;
```

Return the index where the first occurrence of `str` is found. Return -1 if not found. The `startIdx` indicates the byte index where the search begins. The `charset` specifies the byte representation of `str` that is to be searched. For example, it can be `utf-8`, `windows-1252`, `ansi`, `utf-16`, etc.

### BinData.GetByte

`Chilkat 11.7.0 · delphidll · BinData · GetByte · method · since 9.5.0.92`

```pascal
function CkBinData_GetByte(objHandle: HCkBinData;
    index: Integer): Integer; stdcall;
```

Returns the value of the byte at the given `index`. The returned value is an integer from 0 to 255.

### BinData.GetData

`Chilkat 11.7.0 · delphidll · BinData · GetData · method · since 11.0.0`

```pascal
function CkBinData_GetData(objHandle: HCkBinData): Pointer; stdcall;
```

**Full documentation for this method (same in every language):** [Passing Binary Data Between Chilkat and Delphi](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/chilkat_delphi_binary_array.md)

Retrieves the binary data contained within the object.

Returns `nil` on failure

### BinData.GetDataChunk

`Chilkat 11.7.0 · delphidll · BinData · GetDataChunk · method · since 11.0.0`

```pascal
function CkBinData_GetDataChunk(objHandle: HCkBinData;
    offset: Integer;
    numBytes: Integer): Pointer; stdcall;
```

**Full documentation for this method (same in every language):** [Passing Binary Data Between Chilkat and Delphi](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/chilkat_delphi_binary_array.md)

Retrieves a chunk of the binary data contained within the object.

Returns `nil` on failure

### BinData.GetEncoded

`Chilkat 11.7.0 · delphidll · BinData · GetEncoded · method · since 9.5.0.51`

```pascal
function CkBinData_GetEncoded(objHandle: HCkBinData;
    encoding: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkBinData__getEncoded(objHandle: HCkBinData;
    encoding: PWideChar): PWideChar; stdcall;
```

Retrieves the binary data as an encoded string. The `encoding` may be `Base64`, `modBase64`, `base64Url`, `Base32`, `Base58`, `QP` (for quoted-printable), `URL` (for url-encoding), `Hex`, or any of the encodings found at [Chilkat Binary Encodings List](https://www.chilkatsoft.com/binary_encodings.asp).

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### BinData.GetEncodedChunk

`Chilkat 11.7.0 · delphidll · BinData · GetEncodedChunk · method · since 9.5.0.51`

```pascal
function CkBinData_GetEncodedChunk(objHandle: HCkBinData;
    offset: Integer;
    numBytes: Integer;
    encoding: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkBinData__getEncodedChunk(objHandle: HCkBinData;
    offset: Integer;
    numBytes: Integer;
    encoding: PWideChar): PWideChar; stdcall;
```

Retrieves a chunk of the binary data and returns it in encoded form. The `encoding` may be `Base64`, `modBase64`, `base64Url`, `Base32`, `Base58`, `QP` (for quoted-printable), `URL` (for url-encoding), `Hex`, or any of the encodings found at [Chilkat Binary Encodings List](https://www.chilkatsoft.com/binary_encodings.asp).

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### BinData.GetEncodedSb

`Chilkat 11.7.0 · delphidll · BinData · GetEncodedSb · method · since 9.5.0.64`

```pascal
function CkBinData_GetEncodedSb(objHandle: HCkBinData;
    encoding: PWideChar;
    sb: HCkStringBuilder): wordbool; stdcall;
```

Writes the encoded data to a StringBuilder. The `encoding` may be `Base64`, `modBase64`, `base64Url`, `Base32`, `Base58`, `QP` (for quoted-printable), `URL` (for url-encoding), `Hex`, or any of the encodings found at [Chilkat Binary Encodings List](https://www.chilkatsoft.com/binary_encodings.asp).

Returns True for success, False for failure.

### BinData.GetHash

`Chilkat 11.7.0 · delphidll · BinData · GetHash · method · since 9.5.0.91`

```pascal
function CkBinData_GetHash(objHandle: HCkBinData;
    algorithm: PWideChar;
    encoding: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkBinData__getHash(objHandle: HCkBinData;
    algorithm: PWideChar;
    encoding: PWideChar): PWideChar; stdcall;
```

Returns the hash of the contents of this object. The `algorithm` is the hash algorithm, and can be `sha1`, `sha256`, `sha384`, `sha512`, `sha3-224`, `sha3-256`, `sha3-384`, `sha3-512`, `md2`, `md5`, `ripemd128`, `ripemd160`,`ripemd256`, or `ripemd320`. The `encoding` can be `base64`, `modBase64`, `base64Url`, `base32`, `base58`, `qp` (for quoted-printable), `url` (for url-encoding), `hex`, `hexLower`, or any of the encodings found at [Chilkat Binary Encodings List](https://www.chilkatsoft.com/binary_encodings.asp).

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### BinData.GetInt2

`Chilkat 11.7.0 · delphidll · BinData · GetInt2 · method · since 9.5.0.88`

```pascal
function CkBinData_GetInt2(objHandle: HCkBinData;
    index: Integer;
    littleEndian: wordbool): Integer; stdcall;
```

Returns the value of the 16-bit signed integer stored in big-endian or little-endian byte ordering at the given index.

### BinData.GetInt4

`Chilkat 11.7.0 · delphidll · BinData · GetInt4 · method · since 9.5.0.88`

```pascal
function CkBinData_GetInt4(objHandle: HCkBinData;
    index: Integer;
    littleEndian: wordbool): Integer; stdcall;
```

Returns the value of the 32-bit signed integer stored in big-endian or little-endian byte ordering at the given index.

### BinData.GetString

`Chilkat 11.7.0 · delphidll · BinData · GetString · method · since 9.5.0.67`

```pascal
function CkBinData_GetString(objHandle: HCkBinData;
    charset: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkBinData__getString(objHandle: HCkBinData;
    charset: PWideChar): PWideChar; stdcall;
```

Interprets the bytes according to `charset` and returns the string. The `charset` can be `utf-8`, `utf-16`, `ansi`, `iso-8859-*`, `windows-125*`, or any of the supported character encodings listed in the link below.

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

See also:

- [Chilkat Supported Character Encodings](http://cknotes.com/chilkat-charsets-character-encodings-supported/)

### BinData.GetTextChunk

`Chilkat 11.7.0 · delphidll · BinData · GetTextChunk · method · since 9.5.0.85`

```pascal
function CkBinData_GetTextChunk(objHandle: HCkBinData;
    startIdx: Integer;
    numBytes: Integer;
    charset: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkBinData__getTextChunk(objHandle: HCkBinData;
    startIdx: Integer;
    numBytes: Integer;
    charset: PWideChar): PWideChar; stdcall;
```

Returns `numBytes` bytes starting at `startIdx`. The bytes are interpreted according to `charset` (for example, `utf-8`, `ansi`, `utf-16`, `windows-1252`, etc.)

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### BinData.GetUInt2

`Chilkat 11.7.0 · delphidll · BinData · GetUInt2 · method · since 9.5.0.88`

```pascal
function CkBinData_GetUInt2(objHandle: HCkBinData;
    index: Integer;
    littleEndian: wordbool): LongWord; stdcall;
```

Returns the value of the 16-bit unsigned integer stored in big-endian or little-endian byte ordering at the given index.

### BinData.GetUInt4

`Chilkat 11.7.0 · delphidll · BinData · GetUInt4 · method · since 9.5.0.88`

```pascal
function CkBinData_GetUInt4(objHandle: HCkBinData;
    index: Integer;
    littleEndian: wordbool): LongWord; stdcall;
```

Returns the value of the 32-bit unsigned integer stored in big-endian or little-endian byte ordering at the given index.

### BinData.IsValidUtf8

`Chilkat 11.7.0 · delphidll · BinData · IsValidUtf8 · method · since 10.1.0`

```pascal
function CkBinData_IsValidUtf8(objHandle: HCkBinData): wordbool; stdcall;
```

Returns `True` if this object contains valid utf-8 byte sequences. Any invalid byte sequence that is not valid utf-8 will cause this function to return `False`.

Returns True for success, False for failure.

### BinData.LoadEncoded

`Chilkat 11.7.0 · delphidll · BinData · LoadEncoded · method · since 9.5.0.51`

```pascal
function CkBinData_LoadEncoded(objHandle: HCkBinData;
    encData: PWideChar;
    encoding: PWideChar): wordbool; stdcall;
```

Loads binary data from an encoded string, replacing the current contents, if any. The `encoding` may be `Base64`, `modBase64`, `base64Url`, `Base32`, `Base58`, `QP` (for quoted-printable), `URL` (for url-encoding), `Hex`, or any of the encodings found at [Chilkat Binary Encodings List](https://www.chilkatsoft.com/binary_encodings.asp).

Returns True for success, False for failure.

### BinData.LoadFile

`Chilkat 11.7.0 · delphidll · BinData · LoadFile · method · since 9.5.0.51`

```pascal
function CkBinData_LoadFile(objHandle: HCkBinData;
    path: PWideChar): wordbool; stdcall;
```

Loads data from a file.

Returns True for success, False for failure.

### BinData.RemoveByteVal

`Chilkat 11.7.0 · delphidll · BinData · RemoveByteVal · method · since 9.5.0.90`

```pascal
procedure CkBinData_RemoveByteVal(objHandle: HCkBinData;
    value: Integer) stdcall;
```

Removes bytes having a specified value (0-255). For example, to remove all null bytes, pass 0 in `value`.

### BinData.RemoveChunk

`Chilkat 11.7.0 · delphidll · BinData · RemoveChunk · method · since 9.5.0.51`

```pascal
function CkBinData_RemoveChunk(objHandle: HCkBinData;
    offset: Integer;
    numBytes: Integer): wordbool; stdcall;
```

Removes a chunk of bytes from the binary data.

Returns True for success, False for failure.

### BinData.SecureClear

`Chilkat 11.7.0 · delphidll · BinData · SecureClear · method · since 9.5.0.67`

```pascal
function CkBinData_SecureClear(objHandle: HCkBinData): wordbool; stdcall;
```

Securely clears the contents by writing 0 bytes to the memory prior to deallocating the internal memory.

Returns True for success, False for failure.

### BinData.WriteAppendFile

`Chilkat 11.7.0 · delphidll · BinData · WriteAppendFile · method · since 9.5.0.91`

```pascal
function CkBinData_WriteAppendFile(objHandle: HCkBinData;
    path: PWideChar): wordbool; stdcall;
```

Appends the contents of this object to a file.

Returns True for success, False for failure.

### BinData.WriteFile

`Chilkat 11.7.0 · delphidll · BinData · WriteFile · method · since 9.5.0.62`

```pascal
function CkBinData_WriteFile(objHandle: HCkBinData;
    path: PWideChar): wordbool; stdcall;
```

Writes the contents to a file.

Returns True for success, False for failure.

## Deprecated members — do not use in new code

| Member | Kind | Deprecated in | Use instead |
|---|---|---|---|
| `AppendBinary` | method | before 11.6.1 | — |
| `GetBinary` | method | before 11.6.1 | — |
| `GetBinaryChunk` | method | before 11.6.1 | — |
| `LoadBinary` | method | before 11.6.1 | — |

## Related classes

[`StringBuilder`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/classes/StringBuilder.md)

