CachedFileStream Class

public class CachedFileStream : Stream

Public Class CachedFileStream
	Inherits Stream

public ref class CachedFileStream : public Stream

Gemstone.IO.CachedFileStream = function();

Type.createClass(
	'Gemstone.IO.CachedFileStream',
	Stream);

Inheritance

Object    MarshalByRefObject    Stream    CachedFileStream

This class was developed as a wrapper around FileStream with the same basic functionality. This stream treats the file as a collection of contiguous blocks which can be loaded into an in-memory lookup table to greatly improve seek times. This class generally performs significantly better than the standard FileStream class when maintaining multiple file pointers and frequently seeking back and forth between them. For an example of a good use-case, consider copying a list of serialized objects from one location in the file to another without loading the whole list into memory.

This class likely will not perform significantly better or worse than the standard FileStream when performing strictly sequential reads or writes. For an example of a bad use-case, consider reading a list of objects into memory or simply appending new data to the end of the file. In both of these cases, it may be better to use the standard FileStream for less memory overhead and more predictable flush behavior.

Blocks are loaded into memory as they are used (for read/write operations) and will be kept in memory for as long as possible. Blocks can only be flushed from the cache by decreasing the cache size or by accessing a non-cached block when the cache is already full. In these cases, a least recently used algorithm is executed to determine which blocks should be removed from the cache either to decrease the size of the cache or to make room for a new block.

Write operations are also cached such that they will not be committed to the file until the block is removed from the cache or a call to Flush has been made. This can have some additional implications as compared to the standard FileStream. For instance, write operations may not be committed to the file in the order in which they were executed. Users of this class will need to be judicious about when and how often they call Flush.

Reference