SystemEx.IO.CacheStream< TCache > Class Template Reference

A Stream wrapper around a Cache instance.
Provides sequential read/write access to a cache, including endian‑aware primitive serialization, range operations, and chunked asynchronous copy methods.
Seeking is supported only through the underlying cache. More...

Inheritance diagram for SystemEx.IO.CacheStream< TCache >:

Collaboration diagram for SystemEx.IO.CacheStream< TCache >:

Public Member Functions
	CacheStream (TCache cache)
	Creates a new stream wrapper for the specified cache.
override void	CopyTo (Stream destination, int bufferSize)
	Copies the contents of this stream to another stream using the specified buffer size.
virtual void	WriteTo (Stream stream)
	Writes the entire cache content to another stream.
override void	Flush ()
	Flushes the stream. No‑op for cache streams.
override int	Read (byte[] buffer, int offset, int count)
	Reads bytes from the cache into the specified buffer.
override void	Write (byte[] buffer, int offset, int count)
	Writes bytes from the buffer into the cache.
override long	Seek (long offset, SeekOrigin origin)
	Moves the cache position using the specified origin and offset.
override void	SetLength (long value)
int	Write (char value)
int	Write (byte value)
int	Write (uint value, Endian endian)
int	Write (int value, Endian endian)
int	Write (short value, Endian endian)
int	Write (ushort value, Endian endian)
int	Write (long value, Endian endian)
int	Write (ulong value, Endian endian)
int	Write (float value, Endian endian)
int	Write (double value, Endian endian)
uint	ReadUInt (Endian endian)
int	ReadInt (Endian endian)
short	ReadShort (Endian endian)
ushort	ReadUShort (Endian endian)
long	ReadLong (Endian endian)
ulong	ReadULong (Endian endian)
char	ReadChar (ulong position)
float	ReadFloat (Endian endian)
double	ReadDouble (Endian endian)
ulong	WriteRange (byte[] data)
ulong	WriteRange (ulong iend, byte[] data)
byte?[]	ReadRange (uint count)
byte[]	ToArray ()
	Returns the entire cache content as a byte array.
virtual Task	WriteAsync (ICache src, CancellationToken cancellationToken=default)
	Asynchronously copies the contents of a source cache into this stream's cache using fixed‑size chunks. Supports cancellation and lock checking.
virtual Task< ICache >	ReadAsync (ICache dest, CancellationToken cancellationToken=default)
	Asynchronously reads the contents of this stream's cache into another cache using fixed‑size chunks. Supports cancellation and lock checking.

Properties
override long	Position [get, set]
	Gets or sets the current position within the cache.
override bool	CanRead [get]
	Indicates whether the stream supports reading.
override bool	CanSeek [get]
	Indicates whether the stream supports seeking. Always true for CacheStream<TCache>.
override bool	CanWrite [get]
	Indicates whether the stream supports writing.
override long	Length [get]
	Gets the length of the underlying cache.
int	Written [get, set]
	Gets the number of bytes written by the last write operation.
ulong	LongLength [get]
	Gets the LongLength of the underlying cache.
bool	IsEmpty [get]

Detailed Description

A Stream wrapper around a Cache instance.
Provides sequential read/write access to a cache, including endian‑aware primitive serialization, range operations, and chunked asynchronous copy methods.
Seeking is supported only through the underlying cache.

Template Parameters

TCache

The cache type used as the backing store. Must derive from Cache.

Type Constraints

TCache

:

Cache

Member Function Documentation

CacheStream()

SystemEx.IO.CacheStream< TCache >.CacheStream

(

TCache

cache

)

Creates a new stream wrapper for the specified cache.

                                         {
            m_cache = cache;
        }

Here is the caller graph for this function:

CopyTo()

override void SystemEx.IO.CacheStream< TCache >.CopyTo	(	Stream	destination,
		int	bufferSize )

Copies the contents of this stream to another stream using the specified buffer size.

                                                                        {
            if ( GetType() != typeof(ICache) ) {
                if ( !m_cache.CanRead ) throw new InvalidOperationException("is Locked");
                base.CopyTo(destination, bufferSize);
            } else {
                base.CopyTo(destination, bufferSize);
            }
        }

Flush()

override void SystemEx.IO.CacheStream< TCache >.Flush

(

)

Flushes the stream. No‑op for cache streams.

                                     {
            return;
        }

Read()

override int SystemEx.IO.CacheStream< TCache >.Read	(	byte[]	buffer,
		int	offset,
		int	count )

Reads bytes from the cache into the specified buffer.

                                                                       {
            if ( !CanRead ) return 0;
            return m_cache.Read(buffer, offset, count);
        }

ReadAsync()

virtual Task< ICache > SystemEx.IO.CacheStream< TCache >.ReadAsync ( ICache dest, CancellationToken cancellationToken = default )

virtual

Asynchronously reads the contents of this stream's cache into another cache using fixed‑size chunks.
Supports cancellation and lock checking.

                                                                                                        {
            if ( !m_cache.CanRead ) throw new InvalidOperationException("src is Locked");
            if ( !dest.CanWrite ) throw new InvalidOperationException("dest is Locked");
 
            if ( cancellationToken.IsCancellationRequested )
                return Task.FromCanceled<ICache>(cancellationToken);
 
            try {
                const int CHUNK = 64 * 1024; // 64 KiB
                ulong total = (ulong)m_cache.Length;
                ulong pos = 0;
 
                while ( pos < total ) {
                    if ( cancellationToken.IsCancellationRequested )
                        return Task.FromCanceled<ICache>(cancellationToken);
 
                    int toRead = (int)System.Math.Min((ulong)CHUNK, total - pos);
                    byte[]? chunk = m_cache.ReadRange(pos, (uint)toRead);
 
                    if ( chunk == null || chunk.Length == 0 )
                        break;
 
                    dest.WriteRange(pos, chunk);
                    pos += (ulong)chunk.Length;
                }
 
                return Task.FromResult(dest);
            } catch ( OperationCanceledException oce ) {
                return Task.FromCanceled<ICache>(oce.CancellationToken);
            } catch ( Exception ex ) {
                return Task.FromException<ICache>(ex);
            }
        }

Here is the call graph for this function:

ReadChar()

char SystemEx.IO.CacheStream< TCache >.ReadChar

(

ulong

position

)

=> m_cache.ReadChar((ulong)Position);

ReadDouble()

double SystemEx.IO.CacheStream< TCache >.ReadDouble

(

Endian

endian

)

=> m_cache.ReadDouble((ulong)Position, endian);

ReadFloat()

float SystemEx.IO.CacheStream< TCache >.ReadFloat

(

Endian

endian

)

=> m_cache.ReadFloat((ulong)Position, endian);

ReadInt()

int SystemEx.IO.CacheStream< TCache >.ReadInt

(

Endian

endian

)

=> m_cache.ReadInt((ulong)Position, endian);

ReadLong()

long SystemEx.IO.CacheStream< TCache >.ReadLong

(

Endian

endian

)

=> m_cache.ReadLong((ulong)Position, endian);

ReadRange()

byte?[] SystemEx.IO.CacheStream< TCache >.ReadRange

(

uint

count

)

            => m_cache.ReadRange((ulong)Position, count);

ReadShort()

short SystemEx.IO.CacheStream< TCache >.ReadShort

(

Endian

endian

)

=> m_cache.ReadShort((ulong)Position, endian);

ReadUInt()

uint SystemEx.IO.CacheStream< TCache >.ReadUInt

(

Endian

endian

)

=> m_cache.ReadUInt((ulong)Position, endian);

ReadULong()

ulong SystemEx.IO.CacheStream< TCache >.ReadULong

(

Endian

endian

)

=> m_cache.ReadULong((ulong)Position, endian);

ReadUShort()

ushort SystemEx.IO.CacheStream< TCache >.ReadUShort

(

Endian

endian

)

=> m_cache.ReadUShort((ulong)Position, endian);

Seek()

override long SystemEx.IO.CacheStream< TCache >.Seek	(	long	offset,
		SeekOrigin	origin )

Moves the cache position using the specified origin and offset.

                                                                  {
            return (long)m_cache.Seek(origin, (int)offset);
        }

SetLength()

override void SystemEx.IO.CacheStream< TCache >.SetLength

(

long

value

)

                                                   {
           
        }

ToArray()

byte[] SystemEx.IO.CacheStream< TCache >.ToArray

(

)

Returns the entire cache content as a byte array.

=> m_cache.ToArray();

Here is the caller graph for this function:

Write() [1/11]

int SystemEx.IO.CacheStream< TCache >.Write

(

byte

value

)

=> m_cache.Write((byte)value);

Write() [2/11]

override void SystemEx.IO.CacheStream< TCache >.Write	(	byte[]	buffer,
		int	offset,
		int	count )

Writes bytes from the buffer into the cache.

                                                                         {
            if ( !CanWrite ) { Written = 0; return; }
            Written = m_cache.Write(buffer, offset, count);
        }

Write() [3/11]

int SystemEx.IO.CacheStream< TCache >.Write

(

char

value

)

=> m_cache.Write((byte)value);

Write() [4/11]

int SystemEx.IO.CacheStream< TCache >.Write	(	double	value,
		Endian	endian )

                                                      {
            byte[] _buffer = value.ToBytes(endian);
            return m_cache.Write(_buffer, 0, _buffer.Length);
        }

Write() [5/11]

int SystemEx.IO.CacheStream< TCache >.Write	(	float	value,
		Endian	endian )

                                                     {
            byte[] _buffer = value.ToBytes(endian);
            return m_cache.Write(_buffer, 0, _buffer.Length);
        }

Write() [6/11]

int SystemEx.IO.CacheStream< TCache >.Write	(	int	value,
		Endian	endian )

                                                   {
            byte[] _buffer = value.ToBytes(endian);
            return m_cache.Write(_buffer, 0, _buffer.Length);
        }

Write() [7/11]

int SystemEx.IO.CacheStream< TCache >.Write	(	long	value,
		Endian	endian )

                                                    {
            byte[] _buffer = value.ToBytes(endian);
            return m_cache.Write(_buffer, 0, _buffer.Length);
        }

Write() [8/11]

int SystemEx.IO.CacheStream< TCache >.Write	(	short	value,
		Endian	endian )

                                                     {
            byte[] _buffer = value.ToBytes(endian);
            return m_cache.Write(_buffer, 0, _buffer.Length);
        }

Write() [9/11]

int SystemEx.IO.CacheStream< TCache >.Write	(	uint	value,
		Endian	endian )

                                                    {
            byte[] _buffer = value.ToBytes(endian);
            return m_cache.Write(_buffer, 0, _buffer.Length);
        }

Write() [10/11]

int SystemEx.IO.CacheStream< TCache >.Write	(	ulong	value,
		Endian	endian )

                                                     {
            byte[] _buffer = value.ToBytes(endian);
            return m_cache.Write(_buffer, 0, _buffer.Length);
        }

Write() [11/11]

int SystemEx.IO.CacheStream< TCache >.Write	(	ushort	value,
		Endian	endian )

                                                      {
            byte[] _buffer = value.ToBytes(endian);
            return m_cache.Write(_buffer, 0, _buffer.Length);
        }

WriteAsync()

virtual Task SystemEx.IO.CacheStream< TCache >.WriteAsync ( ICache src, CancellationToken cancellationToken = default )

virtual

Asynchronously copies the contents of a source cache into this stream's cache using fixed‑size chunks.
Supports cancellation and lock checking.

                                                                                                {
            if ( !m_cache.CanWrite ) throw new InvalidOperationException("dest is Locked");
            if ( !src.CanRead ) throw new InvalidOperationException("src is Locked");
 
            if ( cancellationToken.IsCancellationRequested )
                return Task.FromCanceled(cancellationToken);
 
            try {
                const int CHUNK = 64 * 1024; // 64 KiB
                ulong total = (ulong)src.Length;
                ulong pos = 0;
 
                while ( pos < total ) {
                    if ( cancellationToken.IsCancellationRequested )
                        return Task.FromCanceled(cancellationToken);
 
                    int toRead = (int)System.Math.Min((ulong)CHUNK, total - pos);
                    byte[]? chunk = src.ReadRange(pos, (uint)toRead);
 
                    if ( chunk == null || chunk.Length == 0 )
                        break;
 
                    m_cache.WriteRange(pos, chunk);
                    pos += (ulong)chunk.Length;
                }
 
                return Task.CompletedTask;
            } catch ( OperationCanceledException oce ) {
                return Task.FromCanceled(oce.CancellationToken);
            } catch ( Exception ex ) {
                return Task.FromException(ex);
            }
        }

Here is the call graph for this function:

WriteRange() [1/2]

ulong SystemEx.IO.CacheStream< TCache >.WriteRange

(

byte[]

data

)

        => m_cache.WriteRange((ulong)Position, data);

WriteRange() [2/2]

ulong SystemEx.IO.CacheStream< TCache >.WriteRange	(	ulong	iend,
		byte[]	data )

            => m_cache.WriteRange((ulong)Position, iend, data);

WriteTo()

virtual void SystemEx.IO.CacheStream< TCache >.WriteTo ( Stream stream )

virtual

Writes the entire cache content to another stream.

                                                   {
            if ( !m_cache.CanRead ) throw new InvalidOperationException("src is Locked");
            if ( stream.GetType() != typeof(ICache) ) {
                CacheStream<TCache> _x = (CacheStream<TCache>)stream;
 
                if ( !_x.CanWrite ) throw new InvalidOperationException("is Locked");
                _x.WriteRange(0, ToArray());
 
            } else {
                stream.Write(ToArray());
            }
 
        }

Here is the call graph for this function:

Property Documentation

CanRead

override bool SystemEx.IO.CacheStream< TCache >.CanRead

get

Indicates whether the stream supports reading.

CanSeek

override bool SystemEx.IO.CacheStream< TCache >.CanSeek

get

Indicates whether the stream supports seeking.
Always true for CacheStream<TCache>.

CanWrite

override bool SystemEx.IO.CacheStream< TCache >.CanWrite

get

Indicates whether the stream supports writing.

Length

override long SystemEx.IO.CacheStream< TCache >.Length

get

Gets the length of the underlying cache.

LongLength

ulong SystemEx.IO.CacheStream< TCache >.LongLength

get

Gets the LongLength of the underlying cache.

Position

override long SystemEx.IO.CacheStream< TCache >.Position

getset

Gets or sets the current position within the cache.

                                      { 
            get => (long)m_cache.Position; 
            set => m_cache.SetSavePosition((ulong)value); 
        }

Written

int SystemEx.IO.CacheStream< TCache >.Written

getset

Gets the number of bytes written by the last write operation.

{ get; internal set; }

---

The documentation for this class was generated from the following file:

• CachStream.cs