ILockBytes

The ILockBytes interface provides a byte array object used by the OLE-provided implementation of compound files. Its methods manipulate the byte array object that provides the physical storage for the root storage object of a compound file. The byte array for an ILockBytes implementation is backed by some physical storage, such as a disk file, global memory, or a database; and the ILockBytes implementation hides the details of accessing the physical storage.

When to Implement

OLE provides an implementation of the ILockBytes interface for its compound files. The OLE-provided ILockBytes interface presents a byte array stored in a physical disk file.

Most applications will never implement the ILockBytes interface. Instead, applications will typically call the StgCreateDocfile function to create a root storage object (in this case, an IStorage instance backed by a specified disk file); and this function internally creates an instance of the OLE-provided, file-based ILockBytes implementation.

OLE also provides a memory-based ILockBytes implementation (see CreateILockBytesOnHGlobal).

It is possible for an application to provide its own ILockBytes implementation. For example, a database application might want to implement an ILockBytes backed by the storage of its relational tables. However, it is strongly recommended that you use the OLE-provided implementations. For a discussion of the advantages of using the OLE implementations rather than creating your own, see the StgCreateDocfileOnILockBytes API function.

If you choose to implement your own ILockBytes interface, you should consider providing custom marshaling by implementing the IMarshal interface as part of your byte array object. The reason for this is that when the OLE-provided implementations of IStorage and IStream are marshaled to another process, their ILockBytes interface pointers are also marshaled to the other process. The default marshaling mechanism creates a proxy ILockBytes that transmits method calls back to the original LockBytes object. Custom marshaling can improve efficiency by creating a remote LockBytes object that can access the byte array directly.

When to Use

The ILockBytes methods are called by the OLE-provided implementations of IStorage and IStream, so application programmers do not need to call ILockBytes methods. If you write your own ILockBytes implementation, you can use the StgCreateDocfileOnILockBytes function to create an IStorage backed by your ILockBytes.

Methods in Vtable Order

IUnknown Methods	Description
QueryInterface	Returns pointers to supported interfaces.
AddRef	Increments the reference count.
Release	Decrements the reference count.

ILockBytes Methods	Description
ReadAt	Reads a specified number of bytes starting at a specified offset from the beginning of the byte array.
WriteAt	Writes a specified number of bytes to a specified location in the byte array.
Flush	Ensures that any internal buffers maintained by the ILockBytes implementation are written out to the backing storage.
SetSize	Changes the size of the byte array.
LockRegion	Restricts access to a specified range of bytes in the byte array.
UnlockRegion	Removes the access restriction on a range of bytes previously restricted with ILockBytes::LockRegion.
Stat	Retrieves a STATSTG structure for this byte array object.

Software for developers

Delphi Components
.Net Components
Software for Android Developers

More information resources

MegaDetailed.Net
Unix Manual Pages
Delphi Examples

Databases for Amazon shops developers

Amazon Categories Database
Browse Nodes Database