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
Returns pointers to supported interfaces.
Increments the reference count.
Decrements the reference count.

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

Software for developers
Delphi Components
.Net Components
Software for Android Developers
More information resources
Unix Manual Pages
Delphi Examples
Databases for Amazon shops developers
Amazon Categories Database
Browse Nodes Database