devNotes 11-16-2016 Demo Path – How to Present

// Open the file
using (var stream = new FileStream("/path/to/file", FileMode.Open))
{
	// Compute how many values the file has
	var numValues = stream.Length / sizeof(ushort);
 
	// Allocate an array to hold all those values
	var readValues = new ushort[numValues];
 
	// Open a reader to make reading those values easy
	using (var reader = new BinaryReader(stream))
	{
		// Read all the values
		for (var i = 0; i < numValues; ++i)
		{
			readValues[i] = reader.ReadUInt16();
		}
	}
}

var numBytesRead = myFileStream.Read(myBuffer, offsetIntoMyBuffer, numBytesToRead);

public override int Read([In] [Out] byte[] array, int offset, int count)
{
	if (this.handle == MonoIO.InvalidHandle)
	{
		throw new ObjectDisposedException("Stream has been closed");
	}
	if (array == null)
	{
		throw new ArgumentNullException("array");
	}
	if (!this.CanRead)
	{
		throw new NotSupportedException("Stream does not support reading");
	}
	int num = array.Length;
	if (offset < 0)
	{
		throw new ArgumentOutOfRangeException("offset", "< 0");
	}
	if (count < 0)
	{
		throw new ArgumentOutOfRangeException("count", "< 0");
	}
	if (offset > num)
	{
		throw new ArgumentException("destination offset is beyond array size");
	}
	if (offset > num - count)
	{
		throw new ArgumentException("Reading would overrun buffer");
	}
	if (this.async)
	{
		IAsyncResult asyncResult = this.BeginRead(array, offset, count, null, null);
		return this.EndRead(asyncResult);
	}
	return this.ReadInternal(array, offset, count);
}

private int ReadInternal(byte[] dest, int offset, int count)
{
	int num = 0;
	int num2 = this.ReadSegment(dest, offset, count);
	num += num2;
	count -= num2;
	if (count == 0)
	{
		return num;
	}
	if (count > this.buf_size)
	{
		this.FlushBuffer();
		num2 = this.ReadData(this.handle, dest, offset + num, count);
		this.buf_start += (long)num2;
	}
	else
	{
		this.RefillBuffer();
		num2 = this.ReadSegment(dest, offset + num, count);
	}
	return num + num2;
}

private int ReadSegment(byte[] dest, int dest_offset, int count)
{
	if (count > this.buf_length - this.buf_offset)
	{
		count = this.buf_length - this.buf_offset;
	}
	if (count > 0)
	{
		Buffer.BlockCopy(this.buf, this.buf_offset, dest, dest_offset, count);
		this.buf_offset += count;
	}
	return count;
}

public static void BlockCopy(Array src, int srcOffset, Array dst, int dstOffset, int count)
{
	if (src == null)
	{
		throw new ArgumentNullException("src");
	}
	if (dst == null)
	{
		throw new ArgumentNullException("dst");
	}
	if (srcOffset < 0)
	{
		throw new ArgumentOutOfRangeException("srcOffset", Locale.GetText("Non-negative number required."));
	}
	if (dstOffset < 0)
	{
		throw new ArgumentOutOfRangeException("dstOffset", Locale.GetText("Non-negative number required."));
	}
	if (count < 0)
	{
		throw new ArgumentOutOfRangeException("count", Locale.GetText("Non-negative number required."));
	}
	if (!Buffer.BlockCopyInternal(src, srcOffset, dst, dstOffset, count) && (srcOffset > Buffer.ByteLength(src) - count || dstOffset > Buffer.ByteLength(dst) - count))
	{
		throw new ArgumentException(Locale.GetText("Offset and length were out of bounds for the array or count is greater than the number of elements from index to the end of the source collection."));
	}
}

[MethodImpl(MethodImplOptions.InternalCall)]
internal static extern bool BlockCopyInternal(Array src, int src_offset, Array dest, int dest_offset, int count);
 
public static int ByteLength(Array array)
{
	if (array == null)
	{
		throw new ArgumentNullException("array");
	}
	int num = Buffer.ByteLengthInternal(array);
	if (num < 0)
	{
		throw new ArgumentException(Locale.GetText("Object must be an array of primitives."));
	}
	return num;
}
 
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern int ByteLengthInternal(Array array);

[CLSCompliant(false)]
public virtual ushort ReadUInt16()
{
	this.FillBuffer(2);
	return (ushort)((int)this.m_buffer[0] | (int)this.m_buffer[1] << 8);
}
 
protected virtual void FillBuffer(int numBytes)
{
	if (this.m_disposed)
	{
		throw new ObjectDisposedException("BinaryReader", "Cannot read from a closed BinaryReader.");
	}
	if (this.m_stream == null)
	{
		throw new IOException("Stream is invalid");
	}
	this.CheckBuffer(numBytes);
	int num;
	for (int i = 0; i < numBytes; i += num)
	{
		num = this.m_stream.Read(this.m_buffer, i, numBytes - i);
		if (num == 0)
		{
			throw new EndOfStreamException();
		}
	}
}
 
private void CheckBuffer(int length)
{
	if (this.m_buffer.Length <= length)
	{
		byte[] array = new byte[length];
		Buffer.BlockCopyInternal(this.m_buffer, 0, array, 0, this.m_buffer.Length);
		this.m_buffer = array;
	}
}

// Allocate an array to hold all the values
var numValues = FileSize / sizeof(ushort);
var readValues = new ushort[numValues];
 
// Keep reading while there's more data
while (bufferedReader.FillBuffer())
{
	// Read as many values as we can from the reader's buffer
	var readValsIndex = 0;
	for (
		var numReads = bufferedReader.NumBytesAvailable / sizeof(ushort);
		numReads > 0;
		--numReads
	)
	{
		readValues[readValsIndex++] = bufferedReader.ReadUInt16();
	}
}

public ushort ReadUInt16()
{
	var val = (ushort)((int)buffer[bufferOffset] | (int)buffer[bufferOffset+1] << 8);
	bufferOffset += 2;
	return val;
}

using System;
using System.IO;
 
using UnityEngine;
 
public class BufferedBinaryReader : IDisposable
{
	private readonly Stream stream;
	private readonly byte[] buffer;
	private readonly int bufferSize;
	private int bufferOffset;
	private int numBufferedBytes;
 
	public BufferedBinaryReader(Stream stream, int bufferSize)
	{
		this.stream = stream;
		this.bufferSize = bufferSize;
		buffer = new byte[bufferSize];
		bufferOffset = bufferSize;
	}
 
	public int NumBytesAvailable { get { return Math.Max(0, numBufferedBytes - bufferOffset); } }
 
	public bool FillBuffer()
	{
		var numBytesUnread = bufferSize - bufferOffset;
		var numBytesToRead = bufferSize - numBytesUnread;
		bufferOffset = 0;
		numBufferedBytes = numBytesUnread;
		if (numBytesUnread > 0)
		{
			Buffer.BlockCopy(buffer, numBytesToRead, buffer, 0, numBytesUnread);
		}
		while (numBytesToRead > 0)
		{
			var numBytesRead = stream.Read(buffer, numBytesUnread, numBytesToRead);
			if (numBytesRead == 0)
			{
				return false;
			}
			numBufferedBytes += numBytesRead;
			numBytesToRead -= numBytesRead;
			numBytesUnread += numBytesRead;
		}
		return true;
	}
 
	public ushort ReadUInt16()
	{
		var val = (ushort)((int)buffer[bufferOffset] | (int)buffer[bufferOffset+1] << 8);
		bufferOffset += 2;
		return val;
	}
 
	public void Dispose()
	{
		stream.Close();
	}
}
 
public class TestScript : MonoBehaviour
{
	private const int FileSize = 10 * 1024 * 1024;
 
	void Start()
	{
		var path = Path.Combine(Application.persistentDataPath, "bigfile.dat");
		try
		{
			File.WriteAllBytes(path, new byte[FileSize]);
			TestFileStream(path);
			TestBinaryReaders(path);
		}
		finally
		{
			File.Delete(path);
		}
	}
 
	private void TestFileStream(string path)
	{
		using (var stream = new FileStream(path, FileMode.Open))
		{
			var stopwatch = System.Diagnostics.Stopwatch.StartNew();
			var readBytes = new byte[FileSize];
			var log = "Read Size,Time\n";
			foreach (var readSize in new[]{ 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096 })
			{
				stream.Position = 0;
				stopwatch.Reset();
				stopwatch.Start();
				var offset = 0;
				do
				{
					offset += stream.Read(readBytes, offset, Math.Min(readSize, FileSize - offset));
				}
				while (offset < FileSize);
				var time = stopwatch.ElapsedMilliseconds;
				log += readSize + "," + time + "\n";
			}
			Debug.Log(log);
		}
	}
 
	private void TestBinaryReaders(string path)
	{
		using (var stream = new FileStream(path, FileMode.Open))
		{
			var stopwatch = System.Diagnostics.Stopwatch.StartNew();
			var log = "Reader,Time\n";
			var numValues = FileSize / sizeof(ushort);
			var readValues = new ushort[numValues];
			var reader = new BinaryReader(stream);
			stopwatch.Reset();
			stopwatch.Start();
			for (var i = 0; i < numValues; ++i)
			{
				readValues[i] = reader.ReadUInt16();
			}
			var time = stopwatch.ElapsedMilliseconds;
			log += "BinaryReader," + time + "\n";
 
			stream.Position = 0;
			var bufferedReader = new BufferedBinaryReader(stream, 4096);
			stopwatch.Reset();
			stopwatch.Start();
			while (bufferedReader.FillBuffer())
			{
				var readValsIndex = 0;
				for (
					var numReads = bufferedReader.NumBytesAvailable / sizeof(ushort);
					numReads > 0;
					--numReads
				)
				{
					readValues[readValsIndex++] = bufferedReader.ReadUInt16();
				}
			}
			time = stopwatch.ElapsedMilliseconds;
			log += "BufferedBinaryReader," + time + "\n";
			Debug.Log(log);
		}
	}
}