StreamMemory

StreamMemory creates memory access to a stream.

// Create stream
Stream stream = new MemoryStream();
// Create memory access
using IMemory<byte> memory = new StreamMemory(stream);
// Write data
memory.Count = 1024;
for (int i = 0; i < memory.Count; i++) memory[i] = (byte)i;
// Flush to stream (not needed for MemoryStream)
memory.Flush();

.AttachDisposable() attaches disposable object to be disposed along with memory (Extension method from Avalache.Utilities).

// Create stream
Stream stream = new MemoryStream();
// Create memory access
using IMemory<byte> memory = new StreamMemory(stream).AttachDisposable(stream);
// Write data
memory.Count = 1024;
for (int i = 0; i < memory.Count; i++) memory[i] = (byte)i;
// Flush to stream (not needed for MemoryStream)
memory.Flush();

Concurrency

.Synchronized() decorates with mutex locking for concurrent thread use.

// Create stream
Stream stream = new MemoryStream();
// Create memory access
using IMemory<byte> memory = new StreamMemory(stream).AttachDisposable(stream).Synchronized();
// Write data
Parallel.For(0, 1024, (int i) => memory.Add((byte)i));
// Flush to stream (not needed for MemoryStream)
memory.Flush();

.Synchronized(mLock) decorates with specific monitor object.

// Create synchronization object
object mLock = new();
// Create stream
Stream stream = new MemoryStream();
// Create memory access
using IMemory<byte> memory = new StreamMemory(stream).AttachDisposable(stream).Synchronized(mLock);
// Write data
Parallel.For(0, 1024, (int i) => memory.Add((byte)i));
// Flush to stream (not really needed for MemoryStream)
memory.Flush();

Full Example

Full example

using Avalanche.Memory;
using Avalanche.Utilities;

public class streammemory
{
    public static void Run()
    {
        {
            // <01>
            // Create stream
            Stream stream = new MemoryStream();
            // Create memory access
            using IMemory<byte> memory = new StreamMemory(stream);
            // Write data
            memory.Count = 1024;
            for (int i = 0; i < memory.Count; i++) memory[i] = (byte)i;
            // Flush to stream (not needed for MemoryStream)
            memory.Flush();
            // </01>
        }
        {
            // <02>
            // Create stream
            Stream stream = new MemoryStream();
            // Create memory access
            using IMemory<byte> memory = new StreamMemory(stream).AttachDisposable(stream);
            // Write data
            memory.Count = 1024;
            for (int i = 0; i < memory.Count; i++) memory[i] = (byte)i;
            // Flush to stream (not needed for MemoryStream)
            memory.Flush();
            // </02>
        }
        {
            // <11>
            // Create stream
            Stream stream = new MemoryStream();
            // Create memory access
            using IMemory<byte> memory = new StreamMemory(stream).AttachDisposable(stream).Synchronized();
            // Write data
            Parallel.For(0, 1024, (int i) => memory.Add((byte)i));
            // Flush to stream (not needed for MemoryStream)
            memory.Flush();
            // </11>
        }
        {
            // <12>
            // Create synchronization object
            object mLock = new();
            // Create stream
            Stream stream = new MemoryStream();
            // Create memory access
            using IMemory<byte> memory = new StreamMemory(stream).AttachDisposable(stream).Synchronized(mLock);
            // Write data
            Parallel.For(0, 1024, (int i) => memory.Add((byte)i));
            // Flush to stream (not really needed for MemoryStream)
            memory.Flush();
            // </12>
        }
    }
}