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
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
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
If you choose to implement your own ILockBytes
interface, you should consider providing custom marshaling by implementing
interface as part of your byte array object. The reason for this is that when
the OLE-provided implementations of IStorage
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
methods are called by the OLE-provided implementations of IStorage
, 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
||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
Software for Android Developers
- More information resources
Unix Manual Pages