protected override void ProtectedImport(Stream stream, BufferManager bufferManager)
{
Encoding encoding = new UTF8Encoding(false);
byte[] lengthBuffer = new byte[4];
for (; ;)
{
if (stream.Read(lengthBuffer, 0, lengthBuffer.Length) != lengthBuffer.Length)
{
return;
}
int length = NetworkConverter.ToInt32(lengthBuffer);
byte id = (byte)stream.ReadByte();
using (RangeStream rangeStream = new RangeStream(stream, stream.Position, length, true))
{
if (id == (byte)SerializeId.Id)
{
byte[] buffer = new byte[rangeStream.Length];
rangeStream.Read(buffer, 0, buffer.Length);
this.Id = buffer;
}
else if (id == (byte)SerializeId.Name)
{
using (StreamReader reader = new StreamReader(rangeStream, encoding))
{
this.Name = reader.ReadToEnd();
}
}
}
}
}
private static Stream AddHash(Stream stream)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
try
{
var targetStream = new RangeStream(stream, true);
BufferStream metadataStream = new BufferStream(_bufferManager);
metadataStream.WriteByte((byte)ConvertHashAlgorithm.Sha256);
targetStream.Seek(0, SeekOrigin.Begin);
var hash = Sha256.ComputeHash(targetStream);
BufferStream hashStream = new BufferStream(_bufferManager);
hashStream.Write(hash, 0, hash.Length);
return(new UniteStream(metadataStream, targetStream, hashStream));
}
catch (Exception e)
{
throw new ArgumentException(e.Message, e);
}
}
private static Stream RemoveType(Stream stream, string type)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
Encoding encoding = new UTF8Encoding(false);
byte[] lengthBuffer = new byte[4];
if (stream.Read(lengthBuffer, 0, lengthBuffer.Length) != lengthBuffer.Length)
{
throw new FormatException();
}
int length = NetworkConverter.ToInt32(lengthBuffer);
using (RangeStream rangeStream = new RangeStream(stream, stream.Position, length, true))
{
using (StreamReader reader = new StreamReader(rangeStream, encoding))
{
if (type != reader.ReadToEnd())
{
throw new FormatException();
}
}
}
return(new RangeStream(stream, true));
}
protected override void ProtectedImport(Stream stream, BufferManager bufferManager)
{
using (DeadlockMonitor.Lock(this.ThisLock))
{
Encoding encoding = new UTF8Encoding(false);
byte[] lengthBuffer = new byte[4];
for (; ;)
{
if (stream.Read(lengthBuffer, 0, lengthBuffer.Length) != lengthBuffer.Length)
{
return;
}
int length = NetworkConverter.ToInt32(lengthBuffer);
byte id = (byte)stream.ReadByte();
using (RangeStream rangeStream = new RangeStream(stream, stream.Position, length, true))
{
if (id == (byte)SerializeId.CommandMessage)
{
this.CommandMessages.Add(CommandMessage.Import(rangeStream, bufferManager));
}
}
}
}
}
private static Stream RemoveHash(Stream stream)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
int type = (int)Varint.GetUInt64(stream);
if (type == (int)ConvertHashAlgorithm.Sha256)
{
var value = new byte[32];
stream.Read(value, 0, value.Length);
var dataStream = new RangeStream(stream, true);
if (!Unsafe.Equals(value, Sha256.Compute(new WrapperStream(dataStream))))
{
throw new ArgumentException("Hash");
}
dataStream.Seek(0, SeekOrigin.Begin);
return(dataStream);
}
else
{
throw new NotSupportedException();
}
}
private void Pull(object state)
{
Thread.CurrentThread.Name = "Pull";
try
{
Stopwatch sw = new Stopwatch();
for (; ;)
{
if (_disposed)
{
throw new ObjectDisposedException(this.GetType().FullName);
}
sw.Restart();
if (_protocolVersion == ProtocolVersion.Version1)
{
using (Stream stream = _connection.Receive(_receiveTimeSpan))
{
if (stream.Length == 0)
{
continue;
}
byte type = (byte)stream.ReadByte();
using (Stream stream2 = new RangeStream(stream, 1, stream.Length - 1, true))
{
var message = CommandsMessage.Import(stream2, _bufferManager);
this.OnPullMessagesEvent(new MessagesEventArgs()
{
Messages = message.CommandMessages
});
}
}
}
else
{
throw new ConnectionManagerException();
}
sw.Stop();
if (sw.ElapsedMilliseconds < 1000)
{
Thread.Sleep(1000 - (int)sw.ElapsedMilliseconds);
}
}
}
catch (Exception)
{
if (!_disposed)
{
this.OnClose(new EventArgs());
}
}
}
private static string ToBase64String(Stream stream)
{
using (var targetStream = new RangeStream(stream, true))
using (var safeBuffer = _bufferManager.CreateSafeBuffer((int)targetStream.Length))
{
targetStream.Seek(0, SeekOrigin.Begin);
targetStream.Read(safeBuffer.Value, 0, (int)targetStream.Length);
return(NetworkConverter.ToBase64UrlString(safeBuffer.Value, 0, (int)targetStream.Length));
}
}
protected override void ProtectedImport(Stream stream, BufferManager bufferManager, int count)
{
lock (this.ThisLock)
{
for (; ;)
{
byte id;
{
byte[] idBuffer = new byte[1];
if (stream.Read(idBuffer, 0, idBuffer.Length) != idBuffer.Length)
{
return;
}
id = idBuffer[0];
}
int length;
{
byte[] lengthBuffer = new byte[4];
if (stream.Read(lengthBuffer, 0, lengthBuffer.Length) != lengthBuffer.Length)
{
return;
}
length = NetworkConverter.ToInt32(lengthBuffer);
}
using (RangeStream rangeStream = new RangeStream(stream, stream.Position, length, true))
{
if (id == (byte)SerializeId.Key)
{
this.Keys.Add(Key.Import(rangeStream, bufferManager));
}
else if (id == (byte)SerializeId.CorrectionAlgorithm)
{
this.CorrectionAlgorithm = (CorrectionAlgorithm)Enum.Parse(typeof(CorrectionAlgorithm), ItemUtilities.GetString(rangeStream));
}
else if (id == (byte)SerializeId.InformationLength)
{
this.InformationLength = ItemUtilities.GetInt(rangeStream);
}
else if (id == (byte)SerializeId.BlockLength)
{
this.BlockLength = ItemUtilities.GetInt(rangeStream);
}
else if (id == (byte)SerializeId.Length)
{
this.Length = ItemUtilities.GetLong(rangeStream);
}
}
}
}
}
protected override void ProtectedImport(Stream stream, BufferManager bufferManager, int count)
{
lock (this.ThisLock)
{
for (; ;)
{
byte id;
{
byte[] idBuffer = new byte[1];
if (stream.Read(idBuffer, 0, idBuffer.Length) != idBuffer.Length)
{
return;
}
id = idBuffer[0];
}
int length;
{
byte[] lengthBuffer = new byte[4];
if (stream.Read(lengthBuffer, 0, lengthBuffer.Length) != lengthBuffer.Length)
{
return;
}
length = NetworkConverter.ToInt32(lengthBuffer);
}
using (RangeStream rangeStream = new RangeStream(stream, stream.Position, length, true))
{
if (id == (byte)SerializeId.KeyExchangeAlgorithm)
{
this.KeyExchangeAlgorithm = EnumEx <KeyExchangeAlgorithm> .Parse(ItemUtilities.GetString(rangeStream));
}
else if (id == (byte)SerializeId.KeyDerivationAlgorithm)
{
this.KeyDerivationAlgorithm = EnumEx <KeyDerivationAlgorithm> .Parse(ItemUtilities.GetString(rangeStream));
}
else if (id == (byte)SerializeId.CryptoAlgorithm)
{
this.CryptoAlgorithm = EnumEx <CryptoAlgorithm> .Parse(ItemUtilities.GetString(rangeStream));
}
else if (id == (byte)SerializeId.HashAlgorithm)
{
this.HashAlgorithm = EnumEx <HashAlgorithm> .Parse(ItemUtilities.GetString(rangeStream));
}
else if (id == (byte)SerializeId.SessionId)
{
this.SessionId = ItemUtilities.GetByteArray(rangeStream);
}
}
}
}
}
public void Can_count_lines_ranged()
{
const long expected = 10000L;
using var fixture = new FlatFileFixture((int)expected, Encoding.UTF8);
var range = new RangeStream(fixture.FileStream, 0, 5000);
var sw = Stopwatch.StartNew();
var lines = LineReader.CountLines(range, Encoding.UTF8);
Assert.True(lines < 150);
_console.WriteLine($"{lines} lines took {sw.Elapsed} to read.");
}
protected override void ProtectedImport(Stream stream, BufferManager bufferManager, int count)
{
for (; ;)
{
byte id;
{
byte[] idBuffer = new byte[1];
if (stream.Read(idBuffer, 0, idBuffer.Length) != idBuffer.Length)
{
return;
}
id = idBuffer[0];
}
int length;
{
byte[] lengthBuffer = new byte[4];
if (stream.Read(lengthBuffer, 0, lengthBuffer.Length) != lengthBuffer.Length)
{
return;
}
length = NetworkConverter.ToInt32(lengthBuffer);
}
using (RangeStream rangeStream = new RangeStream(stream, stream.Position, length, true))
{
if (id == (byte)SerializeId.Tag)
{
this.Tag = Chat.Import(rangeStream, bufferManager);
}
else if (id == (byte)SerializeId.CreationTime)
{
this.CreationTime = DateTime.ParseExact(ItemUtilities.GetString(rangeStream), "yyyy-MM-ddTHH:mm:ssZ", System.Globalization.DateTimeFormatInfo.InvariantInfo).ToUniversalTime();
}
else if (id == (byte)SerializeId.FormatType)
{
this.FormatType = (HypertextFormatType)Enum.Parse(typeof(HypertextFormatType), ItemUtilities.GetString(rangeStream));
}
else if (id == (byte)SerializeId.Hypertext)
{
this.Hypertext = ItemUtilities.GetString(rangeStream);
}
else if (id == (byte)SerializeId.Certificate)
{
this.Certificate = Certificate.Import(rangeStream, bufferManager);
}
}
}
}
protected override void ProtectedImport(Stream stream, BufferManager bufferManager)
{
using (DeadlockMonitor.Lock(this.ThisLock))
{
Encoding encoding = new UTF8Encoding(false);
byte[] lengthBuffer = new byte[4];
for (; ;)
{
if (stream.Read(lengthBuffer, 0, lengthBuffer.Length) != lengthBuffer.Length)
{
return;
}
int length = NetworkConverter.ToInt32(lengthBuffer);
byte id = (byte)stream.ReadByte();
using (RangeStream rangeStream = new RangeStream(stream, stream.Position, length, true))
{
if (id == (byte)SerializeId.Name)
{
using (StreamReader reader = new StreamReader(rangeStream, encoding))
{
this.Name = reader.ReadToEnd();
}
}
else if (id == (byte)SerializeId.State)
{
using (StreamReader reader = new StreamReader(rangeStream, encoding))
{
this.State = (ChannelState)Enum.Parse(typeof(ChannelState), reader.ReadToEnd());
}
}
else if (id == (byte)SerializeId.Manager)
{
byte[] buffer = new byte[rangeStream.Length];
rangeStream.Read(buffer, 0, buffer.Length);
this.Managers.Add(buffer);
}
else if (id == (byte)SerializeId.Member)
{
byte[] buffer = new byte[rangeStream.Length];
rangeStream.Read(buffer, 0, buffer.Length);
this.Members.Add(buffer);
}
}
}
}
}
protected override void ProtectedImport(Stream stream, BufferManager bufferManager, int count)
{
lock (this.ThisLock)
{
for (; ;)
{
byte id;
{
byte[] idBuffer = new byte[1];
if (stream.Read(idBuffer, 0, idBuffer.Length) != idBuffer.Length)
{
return;
}
id = idBuffer[0];
}
int length;
{
byte[] lengthBuffer = new byte[4];
if (stream.Read(lengthBuffer, 0, lengthBuffer.Length) != lengthBuffer.Length)
{
return;
}
length = NetworkConverter.ToInt32(lengthBuffer);
}
using (RangeStream rangeStream = new RangeStream(stream, stream.Position, length, true))
{
if (id == (byte)SerializeId.CreationTime)
{
this.CreationTime = DateTime.ParseExact(ItemUtilities.GetString(rangeStream), "yyyy-MM-ddTHH:mm:ssZ", System.Globalization.DateTimeFormatInfo.InvariantInfo).ToUniversalTime();
}
if (id == (byte)SerializeId.ExchangeKey)
{
this.ExchangeKey = ItemUtilities.GetByteArray(rangeStream);
}
if (id == (byte)SerializeId.ProtocolHash)
{
this.ProtocolHash = ItemUtilities.GetByteArray(rangeStream);
}
else if (id == (byte)SerializeId.Certificate)
{
this.Certificate = Certificate.Import(rangeStream, bufferManager);
}
}
}
}
}
protected override void ReadData(PsdReader reader, object userData)
{
if (this.IsDocument(reader) == true)
{
using (Stream stream = new RangeStream(reader.Stream, reader.Position, this.Length))
{
PsdDocument document = new InternalDocument();
document.Read(stream, reader.Resolver, reader.Uri);
Document = document;
}
}
else
{
Document = null;
}
}
public override void ReadValue(PsdReader reader, object userData, out FileHeaderSection value)
{
if (this.IsDocument(reader) == true)
{
using (Stream stream = new RangeStream(reader.Stream, reader.Position, this.Length))
using (PsdReader r = new PsdReader(stream, reader.Resolver, reader.Uri))
{
r.ReadDocumentHeader();
value = FileHeaderSectionReader.Read(r);
}
}
else
{
value = new FileHeaderSection();
}
}
public override void ReadValue(PsdReader reader, object userData, out PsdDocument value)
{
if (this.IsDocument(reader) == true)
{
using (Stream stream = new RangeStream(reader.Stream, reader.Position, this.Length))
{
PsdDocument document = new publicDocument();
document.Read(stream, reader.Resolver, reader.Uri);
value = document;
}
}
else
{
value = null;
}
}
protected override void ReadData(PsdReader reader, object userData)
{
if (this.IsDocument(reader) == true)
{
using (Stream stream = new RangeStream(reader.Stream, reader.Position, this.Length))
using (PsdReader reader2 = new PsdReader(stream, reader.Resolver, reader.Uri))
{
reader.ReadDocumentHeader();
fileHeaderSection = FileHeaderSection.Read(reader2);
}
}
else
{
fileHeaderSection = new FileHeaderSection();
}
}
public void seek()
{
MemoryStream memStream = new MemoryStream(testData, false);
memStream.Seek(testDataOffset, SeekOrigin.Current);
RangeStream rangeStream = new RangeStream(memStream, testDataLength);
Assert.AreEqual(testData[testDataOffset + 0], rangeStream.ReadByte());
rangeStream.Position += 2;
Assert.AreEqual(testData[testDataOffset + 3], rangeStream.ReadByte());
Assert.AreEqual(0, rangeStream.Seek(0, SeekOrigin.Begin));
Assert.AreEqual(testData[testDataOffset + 0], rangeStream.ReadByte());
Assert.AreEqual(2, rangeStream.Seek(1, SeekOrigin.Current));
Assert.AreEqual(testData[testDataOffset + 2], rangeStream.ReadByte());
Assert.AreEqual(1, rangeStream.Seek(-3, SeekOrigin.End));
Assert.AreEqual(testData[testDataOffset + 1], rangeStream.ReadByte());
}
public void write()
{
byte[] actual = testData.ToArray();
MemoryStream memStream = new MemoryStream(actual, true);
memStream.Seek(testDataOffset, SeekOrigin.Current);
RangeStream rangeStream = new RangeStream(memStream, 4, true);
byte[] expected = testData.ToArray();
expected[testDataOffset + 0] = 0x10;
expected[testDataOffset + 1] = 0x20;
expected[testDataOffset + 2] = 0x30;
expected[testDataOffset + 3] = 0x40;
rangeStream.Write(expected, testDataOffset, testDataLength);
Assert.AreEqual(expected, actual);
}
private static Stream RemoveHash(Stream stream)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
byte type = (byte)stream.ReadByte();
if (type == (byte)ConvertHashAlgorithm.Sha256)
{
Stream dataStream = null;
try
{
byte[] hash = new byte[32];
using (RangeStream hashStream = new RangeStream(stream, stream.Length - 32, 32, true))
{
hashStream.Read(hash, 0, hash.Length);
}
dataStream = new RangeStream(stream, 1, stream.Length - (1 + 32));
if (!Unsafe.Equals(hash, Sha256.ComputeHash(dataStream)))
{
throw new FormatException();
}
dataStream.Seek(0, SeekOrigin.Begin);
return(dataStream);
}
catch (Exception)
{
if (dataStream != null)
{
dataStream.Dispose();
}
throw;
}
}
throw new NotSupportedException();
}
protected override void ProtectedImport(Stream stream, BufferManager bufferManager, int count)
{
for (; ;)
{
byte id;
{
byte[] idBuffer = new byte[1];
if (stream.Read(idBuffer, 0, idBuffer.Length) != idBuffer.Length)
{
return;
}
id = idBuffer[0];
}
int length;
{
byte[] lengthBuffer = new byte[4];
if (stream.Read(lengthBuffer, 0, lengthBuffer.Length) != lengthBuffer.Length)
{
return;
}
length = NetworkConverter.ToInt32(lengthBuffer);
}
using (RangeStream rangeStream = new RangeStream(stream, stream.Position, length, true))
{
if (id == (byte)SerializeId.Nickname)
{
this.Nickname = ItemUtilities.GetString(rangeStream);
}
else if (id == (byte)SerializeId.DigitalSignatureAlgorithm)
{
this.DigitalSignatureAlgorithm = (DigitalSignatureAlgorithm)Enum.Parse(typeof(DigitalSignatureAlgorithm), ItemUtilities.GetString(rangeStream));
}
else if (id == (byte)SerializeId.PublicKey)
{
this.PublicKey = ItemUtilities.GetByteArray(rangeStream);
}
else if (id == (byte)SerializeId.PrivateKey)
{
this.PrivateKey = ItemUtilities.GetByteArray(rangeStream);
}
}
}
}
public void Read(Stream stream)
{
SectionId readSectionId;
UInt32 readSize, readVersion;
ReadHead(stream, out readSectionId, out readSize, out readVersion);
if (readSectionId != sectionId)
{
String msg = String.Format("Trying to read a \"{0}\" from a \"{1}\"", readSectionId, sectionId);
throw new InvalidDataException(msg);
}
version = readVersion;
RangeStream rangeStream = new RangeStream(stream, readSize, false, false);
readBody(rangeStream);
}
protected override void readBody(Stream stream)
{
SectionId structSectionId;
UInt32 structSize;
Section.ReadHead(new GatekeeperStream(stream), out structSectionId, out structSize, out structVersion);
if (structSectionId != SectionId.Struct)
{
throw new InvalidDataException("Struct list section does not contain struct section");
}
long oldPosition = stream.Position;
RangeStream structStream = new RangeStream(stream, structSize, false, false);
readStruct(structStream);
stream.Position = oldPosition + structSize;
base.readBody(stream);
}
public override void Send(System.IO.Stream stream, TimeSpan timeout, Information options)
{
if (_disposed)
{
throw new ObjectDisposedException(this.GetType().FullName);
}
if (!_connect)
{
throw new ConnectionException();
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (stream.Length == 0)
{
throw new ArgumentOutOfRangeException("stream");
}
lock (_sendLock)
{
using (RangeStream targetStream = new RangeStream(stream, stream.Position, stream.Length - stream.Position, true))
{
try
{
using (MemoryStream crcStream = new MemoryStream(Crc32_Castagnoli.ComputeHash(targetStream)))
using (Stream dataStream = new UniteStream(new WrapperStream(targetStream, true), crcStream))
{
_connection.Send(dataStream, timeout, options);
}
}
catch (ConnectionException e)
{
throw e;
}
catch (Exception e)
{
throw new ConnectionException(e.Message, e);
}
}
}
}
public void read()
{
MemoryStream memStream = new MemoryStream(testData, false);
memStream.Seek(testDataOffset, SeekOrigin.Current);
RangeStream rangeStream = new RangeStream(memStream, testDataLength);
byte[] part1 = new byte[3];
int part1Len = rangeStream.Read(part1, 0, 3);
Assert.AreEqual(3, part1Len);
Assert.AreEqual(0x01, part1[0]);
Assert.AreEqual(0x02, part1[1]);
Assert.AreEqual(0x03, part1[2]);
byte[] part2 = new byte[4];
int part2Len = rangeStream.Read(part2, 1, 3);
Assert.AreEqual(1, part2Len);
Assert.AreEqual(0x04, part2[1]);
}
public void Test_RangeStream()
{
using (MemoryStream memoryStream = new MemoryStream(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 }))
{
byte[] mbyte = new byte[4];
memoryStream.Seek(7, SeekOrigin.Begin);
memoryStream.Read(mbyte, 0, mbyte.Length);
memoryStream.Seek(5, SeekOrigin.Begin);
using (RangeStream rangeStream = new RangeStream(memoryStream, 7, 4))
{
Assert.AreEqual(memoryStream.Position, 7, "RangeStream #1");
Assert.AreEqual(rangeStream.Position, 0, "RangeStream #2");
byte[] rbyte = new byte[4];
rangeStream.Read(rbyte, 0, rbyte.Length);
Assert.AreEqual(rangeStream.Length, 4, "RangeStream #3");
Assert.IsTrue(CollectionUtilities.Equals(mbyte, rbyte), "RangeStream #4");
}
}
}
protected override void ProtectedImport(Stream stream, BufferManager bufferManager, int count)
{
for (; ;)
{
byte id;
{
byte[] idBuffer = new byte[1];
if (stream.Read(idBuffer, 0, idBuffer.Length) != idBuffer.Length)
{
return;
}
id = idBuffer[0];
}
int length;
{
byte[] lengthBuffer = new byte[4];
if (stream.Read(lengthBuffer, 0, lengthBuffer.Length) != lengthBuffer.Length)
{
return;
}
length = NetworkConverter.ToInt32(lengthBuffer);
}
using (RangeStream rangeStream = new RangeStream(stream, stream.Position, length, true))
{
if (id == (byte)SerializeId.Id)
{
this.Id = ItemUtilities.GetByteArray(rangeStream);
}
else if (id == (byte)SerializeId.Uri)
{
this.ProtectedUris.Add(ItemUtilities.GetString(rangeStream));
}
}
}
}
private static string ToBase64String(Stream stream)
{
using (var targetStream = new RangeStream(stream, true))
{
byte[] buffer = null;
try
{
buffer = _bufferManager.TakeBuffer((int)targetStream.Length);
targetStream.Seek(0, SeekOrigin.Begin);
targetStream.Read(buffer, 0, (int)targetStream.Length);
return(NetworkConverter.ToBase64UrlString(buffer, 0, (int)targetStream.Length));
}
finally
{
if (buffer != null)
{
_bufferManager.ReturnBuffer(buffer);
}
}
}
}
protected override void ProtectedImport(Stream stream, BufferManager bufferManager, int count)
{
lock (this.ThisLock)
{
for (; ;)
{
byte id;
{
byte[] idBuffer = new byte[1];
if (stream.Read(idBuffer, 0, idBuffer.Length) != idBuffer.Length)
{
return;
}
id = idBuffer[0];
}
int length;
{
byte[] lengthBuffer = new byte[4];
if (stream.Read(lengthBuffer, 0, lengthBuffer.Length) != lengthBuffer.Length)
{
return;
}
length = NetworkConverter.ToInt32(lengthBuffer);
}
using (RangeStream rangeStream = new RangeStream(stream, stream.Position, length, true))
{
if (id == (byte)SerializeId.Box)
{
this.Boxes.Add(Box.Import(rangeStream, bufferManager));
}
}
}
}
}
protected override void ProtectedImport(Stream stream, BufferManager bufferManager)
{
using (DeadlockMonitor.Lock(this.ThisLock))
{
Encoding encoding = new UTF8Encoding(false);
byte[] lengthBuffer = new byte[4];
for (; ;)
{
if (stream.Read(lengthBuffer, 0, lengthBuffer.Length) != lengthBuffer.Length)
{
return;
}
int length = NetworkConverter.ToInt32(lengthBuffer);
byte id = (byte)stream.ReadByte();
using (RangeStream rangeStream = new RangeStream(stream, stream.Position, length, true))
{
if (id == (byte)SerializeId.Command)
{
using (StreamReader reader = new StreamReader(rangeStream, encoding))
{
this.Command = reader.ReadToEnd();
}
}
else if (id == (byte)SerializeId.Content)
{
byte[] buff = new byte[(int)rangeStream.Length];
rangeStream.Read(buff, 0, buff.Length);
this.Content = new ArraySegment <byte>(buff, 0, (int)rangeStream.Length);
}
}
}
}
}
