| public static ReadBytes ( byte fromBuffer, int numberOfBytes, int readBitOffset, byte destination, int destinationByteOffset ) : void | ||
| fromBuffer | byte | |
| numberOfBytes | int | |
| readBitOffset | int | |
| destination | byte | |
| destinationByteOffset | int | |
| Результат | void | |
public unsafe void ReadBytes(byte *pBuffer, int offset, int numberOfBytes)
{
NetException.Assert(m_bitLength - m_readPosition + 7 >= (numberOfBytes * 8), c_readOverflowError);
NetBitWriter.ReadBytes(m_data, numberOfBytes, m_readPosition, pBuffer + offset, 0);
m_readPosition += (8 * numberOfBytes);
}
/// <summary>
/// Reads the specified number of bytes without advancing the read pointer
/// </summary>
public byte[] PeekBytes(int numberOfBytes)
{
NetException.Assert(m_bitLength - m_readPosition >= (numberOfBytes * 8), c_readOverflowError);
byte[] retval = new byte[numberOfBytes];
NetBitWriter.ReadBytes(m_data, numberOfBytes, m_readPosition, retval, 0);
return(retval);
}
/// <summary>
/// Reads the specified number of bytes without advancing the read pointer
/// </summary>
public void PeekBytes(byte[] into, int offset, int numberOfBytes)
{
NetException.Assert(m_bitLength - m_readPosition >= (numberOfBytes * 8), c_readOverflowError);
NetException.Assert(offset + numberOfBytes <= into.Length);
NetBitWriter.ReadBytes(m_data, numberOfBytes, m_readPosition, into, offset);
return;
}
/// <summary>
/// Reads the specified number of bytes without advancing the read pointer
/// </summary>
public Span <byte> PeekBytes(Span <byte> bytes)
{
var numberOfBytes = bytes.Length;
NetException.Assert(m_bitLength - m_readPosition >= (numberOfBytes * 8), c_readOverflowError);
NetBitWriter.ReadBytes(m_data, numberOfBytes, m_readPosition, bytes, 0);
return(bytes);
}
public void ReadBytes(byte[] into, int offset, int numberOfBytes)
{
Debug.Assert(m_bitLength - m_readPosition >= (numberOfBytes * 8), c_readOverflowError);
Debug.Assert(offset + numberOfBytes <= into.Length);
NetBitWriter.ReadBytes(Data, numberOfBytes, m_readPosition, into, offset);
m_readPosition += (8 * numberOfBytes);
return;
}
public byte[] ReadBytes(int numberOfBytes)
{
Debug.Assert(m_bitLength - m_readPosition >= (numberOfBytes * 8), c_readOverflowError);
byte[] retval = new byte[numberOfBytes];
NetBitWriter.ReadBytes(Data, numberOfBytes, m_readPosition, retval, 0);
m_readPosition += (8 * numberOfBytes);
return(retval);
}
/// <summary>
/// Reads the specified number of bytes and returns true for success
/// </summary>
public bool ReadBytes(int numberOfBytes, out byte[] result)
{
if (m_bitLength - m_readPosition + 7 < (numberOfBytes * 8))
{
result = null;
return(false);
}
result = new byte[numberOfBytes];
NetBitWriter.ReadBytes(m_data, numberOfBytes, m_readPosition, result, 0);
m_readPosition += (8 * numberOfBytes);
return(true);
}
/// <summary>
/// Reads the specified number of bits into a pre-allocated array.
/// </summary>
/// <param name="into">The destination array</param>
/// <param name="offset">The offset where to start writing in the destination array</param>
/// <param name="numberOfBits">The number of bits to read</param>
//[Obsolete("Use Span alternative instead with slicing.")]
public Span <byte> ReadBits(Span <byte> into, int offset, int numberOfBits)
{
NetException.Assert(m_bitLength - m_readPosition >= numberOfBits, c_readOverflowError);
NetException.Assert(offset + NetUtility.BytesToHoldBits(numberOfBits) <= into.Length);
int numberOfWholeBytes = numberOfBits / 8;
int extraBits = numberOfBits - (numberOfWholeBytes * 8);
NetBitWriter.ReadBytes(m_data, numberOfWholeBytes, m_readPosition, into, offset);
m_readPosition += (8 * numberOfWholeBytes);
if (extraBits > 0)
{
into[offset + numberOfWholeBytes] = ReadByte(extraBits);
}
return(into.Slice(offset, (numberOfBits + extraBits) >> 3));
}
public byte[] PeekBytes(int numberOfBytes)
{
byte[] retval = new byte[numberOfBytes];
NetBitWriter.ReadBytes(Data, numberOfBytes, m_readPosition, retval, 0);
return(retval);
}
