928 lines
29 KiB
C#
928 lines
29 KiB
C#
using System;
|
||
using System.IO;
|
||
using System.Text;
|
||
|
||
namespace 电子展板.Utility
|
||
{
|
||
public class ByteArrayStream : Stream
|
||
{
|
||
private byte[] _buffer;
|
||
private int _position;
|
||
private int _length;
|
||
private int _capacity;
|
||
private Encoding _defaultEncoding = Encoding.UTF8;
|
||
|
||
// 默认编码方式（用于字符串读写）
|
||
public Encoding DefaultEncoding
|
||
{
|
||
get => _defaultEncoding;
|
||
set => _defaultEncoding = value ?? throw new ArgumentNullException(nameof(value));
|
||
}
|
||
|
||
// 构造函数：创建指定初始容量的流
|
||
public ByteArrayStream(int initialCapacity = 4096)
|
||
{
|
||
if (initialCapacity < 0)
|
||
throw new ArgumentOutOfRangeException(nameof(initialCapacity));
|
||
|
||
_capacity = initialCapacity;
|
||
_buffer = new byte[initialCapacity];
|
||
_position = 0;
|
||
_length = 0;
|
||
}
|
||
|
||
// 构造函数：从现有字节数组创建流
|
||
public ByteArrayStream(byte[] buffer)
|
||
{
|
||
if (buffer == null)
|
||
throw new ArgumentNullException(nameof(buffer));
|
||
|
||
_buffer = buffer;
|
||
_capacity = buffer.Length;
|
||
_length = buffer.Length;
|
||
_position = 0;
|
||
}
|
||
|
||
// 指示当前流是否支持读取
|
||
public override bool CanRead => true;
|
||
|
||
// 指示当前流是否支持查找
|
||
public override bool CanSeek => true;
|
||
|
||
// 指示当前流是否支持写入
|
||
public override bool CanWrite => true;
|
||
|
||
// 获取流的长度
|
||
public override long Length => _length;
|
||
|
||
// 获取或设置当前流中的位置
|
||
public override long Position
|
||
{
|
||
get => _position;
|
||
set
|
||
{
|
||
if (value < 0 || value > _length)
|
||
throw new ArgumentOutOfRangeException(nameof(value));
|
||
_position = (int)value;
|
||
}
|
||
}
|
||
|
||
// 确保有足够的容量
|
||
private void EnsureCapacity(int required)
|
||
{
|
||
if (required <= _capacity) return;
|
||
|
||
// 每次扩容为当前容量的2倍或所需容量（取较大值）
|
||
int newCapacity = Math.Max(_capacity * 2, required);
|
||
byte[] newBuffer = new byte[newCapacity];
|
||
Array.Copy(_buffer, newBuffer, _length);
|
||
_buffer = newBuffer;
|
||
_capacity = newCapacity;
|
||
}
|
||
|
||
public override void Flush()
|
||
{
|
||
// 内存流无需实际刷新
|
||
}
|
||
|
||
public override int Read(byte[] buffer, int offset, int count)
|
||
{
|
||
if (buffer == null)
|
||
throw new ArgumentNullException(nameof(buffer));
|
||
if (offset < 0)
|
||
throw new ArgumentOutOfRangeException(nameof(offset));
|
||
if (count < 0)
|
||
throw new ArgumentOutOfRangeException(nameof(count));
|
||
if (offset + count > buffer.Length)
|
||
throw new ArgumentException("偏移量和计数的总和超过缓冲区长度");
|
||
|
||
int bytesToRead = Math.Min(count, _length - _position);
|
||
if (bytesToRead > 0)
|
||
{
|
||
Array.Copy(_buffer, _position, buffer, offset, bytesToRead);
|
||
_position += bytesToRead;
|
||
}
|
||
return bytesToRead;
|
||
}
|
||
|
||
public override long Seek(long offset, SeekOrigin origin)
|
||
{
|
||
long newPosition;
|
||
switch (origin)
|
||
{
|
||
case SeekOrigin.Begin:
|
||
newPosition = offset;
|
||
break;
|
||
case SeekOrigin.Current:
|
||
newPosition = _position + offset;
|
||
break;
|
||
case SeekOrigin.End:
|
||
newPosition = _length + offset;
|
||
break;
|
||
default:
|
||
throw new ArgumentOutOfRangeException(nameof(origin));
|
||
}
|
||
|
||
if (newPosition < 0 || newPosition > _length)
|
||
throw new IOException("seek 位置无效");
|
||
|
||
_position = (int)newPosition;
|
||
return _position;
|
||
}
|
||
|
||
public override void SetLength(long value)
|
||
{
|
||
if (value < 0 || value > int.MaxValue)
|
||
throw new ArgumentOutOfRangeException(nameof(value));
|
||
|
||
int newLength = (int)value;
|
||
EnsureCapacity(newLength);
|
||
_length = newLength;
|
||
|
||
if (_position > newLength)
|
||
_position = newLength;
|
||
}
|
||
|
||
public override void Write(byte[] buffer, int offset, int count)
|
||
{
|
||
if (buffer == null)
|
||
throw new ArgumentNullException(nameof(buffer));
|
||
if (offset < 0)
|
||
throw new ArgumentOutOfRangeException(nameof(offset));
|
||
if (count < 0)
|
||
throw new ArgumentOutOfRangeException(nameof(count));
|
||
if (offset + count > buffer.Length)
|
||
throw new ArgumentException("偏移量和计数的总和超过缓冲区长度");
|
||
|
||
if (count == 0) return;
|
||
|
||
int newPosition = _position + count;
|
||
if (newPosition > _length)
|
||
{
|
||
EnsureCapacity(newPosition);
|
||
_length = newPosition;
|
||
}
|
||
|
||
Array.Copy(buffer, offset, _buffer, _position, count);
|
||
_position = newPosition;
|
||
}
|
||
|
||
#region 基础数据类型读写方法 - 完整实现
|
||
|
||
/// <summary>
|
||
/// 读取一个字节
|
||
/// </summary>
|
||
public new byte ReadByte()
|
||
{
|
||
if (_position >= _length)
|
||
throw new EndOfStreamException("已到达流的末尾");
|
||
|
||
return _buffer[_position++];
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入一个字节
|
||
/// </summary>
|
||
public new void WriteByte(byte value)
|
||
{
|
||
EnsureCapacity(_position + 1);
|
||
|
||
if (_position == _length)
|
||
_length++;
|
||
|
||
_buffer[_position++] = value;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取16位有符号整数（小端字节序）
|
||
/// </summary>
|
||
public short ReadInt16()
|
||
{
|
||
return ReadInt16(Endianness.LittleEndian);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取16位有符号整数
|
||
/// </summary>
|
||
public short ReadInt16(Endianness endianness)
|
||
{
|
||
byte[] bytes = ReadBytes(2);
|
||
if (NeedReverse(endianness))
|
||
Array.Reverse(bytes);
|
||
|
||
return BitConverter.ToInt16(bytes, 0);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入16位有符号整数（小端字节序）
|
||
/// </summary>
|
||
public void WriteInt16(short value)
|
||
{
|
||
WriteInt16(value, Endianness.LittleEndian);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入16位有符号整数
|
||
/// </summary>
|
||
public void WriteInt16(short value, Endianness endianness)
|
||
{
|
||
byte[] bytes = BitConverter.GetBytes(value);
|
||
if (NeedReverse(endianness))
|
||
Array.Reverse(bytes);
|
||
|
||
Write(bytes, 0, bytes.Length);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取16位无符号整数（小端字节序）
|
||
/// </summary>
|
||
public ushort ReadUInt16()
|
||
{
|
||
return ReadUInt16(Endianness.LittleEndian);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取16位无符号整数
|
||
/// </summary>
|
||
public ushort ReadUInt16(Endianness endianness)
|
||
{
|
||
byte[] bytes = ReadBytes(2);
|
||
if (NeedReverse(endianness))
|
||
Array.Reverse(bytes);
|
||
|
||
return BitConverter.ToUInt16(bytes, 0);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入16位无符号整数（小端字节序）
|
||
/// </summary>
|
||
public void WriteUInt16(ushort value)
|
||
{
|
||
WriteUInt16(value, Endianness.LittleEndian);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入16位无符号整数
|
||
/// </summary>
|
||
public void WriteUInt16(ushort value, Endianness endianness)
|
||
{
|
||
byte[] bytes = BitConverter.GetBytes(value);
|
||
if (NeedReverse(endianness))
|
||
Array.Reverse(bytes);
|
||
|
||
Write(bytes, 0, bytes.Length);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取32位有符号整数（小端字节序）
|
||
/// </summary>
|
||
public int ReadInt32()
|
||
{
|
||
return ReadInt32(Endianness.LittleEndian);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取32位有符号整数
|
||
/// </summary>
|
||
public int ReadInt32(Endianness endianness)
|
||
{
|
||
byte[] bytes = ReadBytes(4);
|
||
if (NeedReverse(endianness))
|
||
Array.Reverse(bytes);
|
||
|
||
return BitConverter.ToInt32(bytes, 0);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入32位有符号整数（小端字节序）
|
||
/// </summary>
|
||
public void WriteInt32(int value)
|
||
{
|
||
WriteInt32(value, Endianness.LittleEndian);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入32位有符号整数
|
||
/// </summary>
|
||
public void WriteInt32(int value, Endianness endianness)
|
||
{
|
||
byte[] bytes = BitConverter.GetBytes(value);
|
||
if (NeedReverse(endianness))
|
||
Array.Reverse(bytes);
|
||
|
||
Write(bytes, 0, bytes.Length);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取32位无符号整数（小端字节序）
|
||
/// </summary>
|
||
public uint ReadUInt32()
|
||
{
|
||
return ReadUInt32(Endianness.LittleEndian);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取32位无符号整数
|
||
/// </summary>
|
||
public uint ReadUInt32(Endianness endianness)
|
||
{
|
||
byte[] bytes = ReadBytes(4);
|
||
if (NeedReverse(endianness))
|
||
Array.Reverse(bytes);
|
||
|
||
return BitConverter.ToUInt32(bytes, 0);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入32位无符号整数（小端字节序）
|
||
/// </summary>
|
||
public void WriteUInt32(uint value)
|
||
{
|
||
WriteUInt32(value, Endianness.LittleEndian);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入32位无符号整数
|
||
/// </summary>
|
||
public void WriteUInt32(uint value, Endianness endianness)
|
||
{
|
||
byte[] bytes = BitConverter.GetBytes(value);
|
||
if (NeedReverse(endianness))
|
||
Array.Reverse(bytes);
|
||
|
||
Write(bytes, 0, bytes.Length);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取64位有符号整数（小端字节序）
|
||
/// </summary>
|
||
public long ReadInt64()
|
||
{
|
||
return ReadInt64(Endianness.LittleEndian);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取64位有符号整数
|
||
/// </summary>
|
||
public long ReadInt64(Endianness endianness)
|
||
{
|
||
byte[] bytes = ReadBytes(8);
|
||
if (NeedReverse(endianness))
|
||
Array.Reverse(bytes);
|
||
|
||
return BitConverter.ToInt64(bytes, 0);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入64位有符号整数（小端字节序）
|
||
/// </summary>
|
||
public void WriteInt64(long value)
|
||
{
|
||
WriteInt64(value, Endianness.LittleEndian);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入64位有符号整数
|
||
/// </summary>
|
||
public void WriteInt64(long value, Endianness endianness)
|
||
{
|
||
byte[] bytes = BitConverter.GetBytes(value);
|
||
if (NeedReverse(endianness))
|
||
Array.Reverse(bytes);
|
||
|
||
Write(bytes, 0, bytes.Length);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取64位无符号整数（小端字节序）
|
||
/// </summary>
|
||
public ulong ReadUInt64()
|
||
{
|
||
return ReadUInt64(Endianness.LittleEndian);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取64位无符号整数
|
||
/// </summary>
|
||
public ulong ReadUInt64(Endianness endianness)
|
||
{
|
||
byte[] bytes = ReadBytes(8);
|
||
if (NeedReverse(endianness))
|
||
Array.Reverse(bytes);
|
||
|
||
return BitConverter.ToUInt64(bytes, 0);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入64位无符号整数（小端字节序）
|
||
/// </summary>
|
||
public void WriteUInt64(ulong value)
|
||
{
|
||
WriteUInt64(value, Endianness.LittleEndian);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入64位无符号整数
|
||
/// </summary>
|
||
public void WriteUInt64(ulong value, Endianness endianness)
|
||
{
|
||
byte[] bytes = BitConverter.GetBytes(value);
|
||
if (NeedReverse(endianness))
|
||
Array.Reverse(bytes);
|
||
|
||
Write(bytes, 0, bytes.Length);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取单精度浮点数（小端字节序）
|
||
/// </summary>
|
||
public float ReadFloat()
|
||
{
|
||
return ReadFloat(Endianness.LittleEndian);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取单精度浮点数
|
||
/// </summary>
|
||
public float ReadFloat(Endianness endianness)
|
||
{
|
||
byte[] bytes = ReadBytes(4);
|
||
if (NeedReverse(endianness))
|
||
Array.Reverse(bytes);
|
||
|
||
return BitConverter.ToSingle(bytes, 0);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入单精度浮点数（小端字节序）
|
||
/// </summary>
|
||
public void WriteFloat(float value)
|
||
{
|
||
WriteFloat(value, Endianness.LittleEndian);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入单精度浮点数
|
||
/// </summary>
|
||
public void WriteFloat(float value, Endianness endianness)
|
||
{
|
||
byte[] bytes = BitConverter.GetBytes(value);
|
||
if (NeedReverse(endianness))
|
||
Array.Reverse(bytes);
|
||
|
||
Write(bytes, 0, bytes.Length);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取双精度浮点数（小端字节序）
|
||
/// </summary>
|
||
public double ReadDouble()
|
||
{
|
||
return ReadDouble(Endianness.LittleEndian);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取双精度浮点数
|
||
/// </summary>
|
||
public double ReadDouble(Endianness endianness)
|
||
{
|
||
byte[] bytes = ReadBytes(8);
|
||
if (NeedReverse(endianness))
|
||
Array.Reverse(bytes);
|
||
|
||
return BitConverter.ToDouble(bytes, 0);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入双精度浮点数（小端字节序）
|
||
/// </summary>
|
||
public void WriteDouble(double value)
|
||
{
|
||
WriteDouble(value, Endianness.LittleEndian);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入双精度浮点数
|
||
/// </summary>
|
||
public void WriteDouble(double value, Endianness endianness)
|
||
{
|
||
byte[] bytes = BitConverter.GetBytes(value);
|
||
if (NeedReverse(endianness))
|
||
Array.Reverse(bytes);
|
||
|
||
Write(bytes, 0, bytes.Length);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取布尔值（1字节，0表示false，非0表示true）
|
||
/// </summary>
|
||
public bool ReadBoolean()
|
||
{
|
||
return ReadByte() != 0;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入布尔值（1字节，0表示false，1表示true）
|
||
/// </summary>
|
||
public void WriteBoolean(bool value)
|
||
{
|
||
WriteByte(value ? (byte)1 : (byte)0);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取字符（小端字节序）
|
||
/// </summary>
|
||
public char ReadChar()
|
||
{
|
||
return ReadChar(Endianness.LittleEndian);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取字符
|
||
/// </summary>
|
||
public char ReadChar(Endianness endianness)
|
||
{
|
||
byte[] bytes = ReadBytes(2);
|
||
if (NeedReverse(endianness))
|
||
Array.Reverse(bytes);
|
||
|
||
return BitConverter.ToChar(bytes, 0);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入字符（小端字节序）
|
||
/// </summary>
|
||
public void WriteChar(char value)
|
||
{
|
||
WriteChar(value, Endianness.LittleEndian);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入字符
|
||
/// </summary>
|
||
public void WriteChar(char value, Endianness endianness)
|
||
{
|
||
byte[] bytes = BitConverter.GetBytes(value);
|
||
if (NeedReverse(endianness))
|
||
Array.Reverse(bytes);
|
||
|
||
Write(bytes, 0, bytes.Length);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取十进制数（小端字节序）
|
||
/// </summary>
|
||
public decimal ReadDecimal()
|
||
{
|
||
return ReadDecimal(Endianness.LittleEndian);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取十进制数
|
||
/// </summary>
|
||
public decimal ReadDecimal(Endianness endianness)
|
||
{
|
||
int[] bits = new int[4];
|
||
for (int i = 0; i < 4; i++)
|
||
{
|
||
bits[i] = ReadInt32(endianness);
|
||
}
|
||
return new decimal(bits);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入十进制数（小端字节序）
|
||
/// </summary>
|
||
public void WriteDecimal(decimal value)
|
||
{
|
||
WriteDecimal(value, Endianness.LittleEndian);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入十进制数
|
||
/// </summary>
|
||
public void WriteDecimal(decimal value, Endianness endianness)
|
||
{
|
||
int[] bits = decimal.GetBits(value);
|
||
foreach (int bit in bits)
|
||
{
|
||
WriteInt32(bit, endianness);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取指定长度的字节数组
|
||
/// </summary>
|
||
public byte[] ReadBytes(int count)
|
||
{
|
||
if (count < 0)
|
||
throw new ArgumentOutOfRangeException(nameof(count));
|
||
if (_position + count > _length)
|
||
throw new EndOfStreamException("没有足够的字节可供读取");
|
||
|
||
byte[] result = new byte[count];
|
||
Array.Copy(_buffer, _position, result, 0, count);
|
||
_position += count;
|
||
return result;
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 字符串读写方法
|
||
|
||
/// <summary>
|
||
/// 读取以null结尾的字符串（C风格字符串）
|
||
/// </summary>
|
||
public string ReadNullTerminatedString()
|
||
{
|
||
return ReadNullTerminatedString(DefaultEncoding);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取以null结尾的字符串（C风格字符串）
|
||
/// </summary>
|
||
public string ReadNullTerminatedString(Encoding encoding)
|
||
{
|
||
if (encoding == null)
|
||
throw new ArgumentNullException(nameof(encoding));
|
||
|
||
int startPos = _position;
|
||
|
||
// 查找null终止符
|
||
while (_position < _length && _buffer[_position] != 0)
|
||
{
|
||
_position++;
|
||
}
|
||
|
||
int byteCount = _position - startPos;
|
||
string result = encoding.GetString(_buffer, startPos, byteCount);
|
||
|
||
// 跳过null终止符
|
||
if (_position < _length)
|
||
{
|
||
_position++;
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入以null结尾的字符串（C风格字符串）
|
||
/// </summary>
|
||
public void WriteNullTerminatedString(string value)
|
||
{
|
||
WriteNullTerminatedString(value, DefaultEncoding);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入以null结尾的字符串（C风格字符串）
|
||
/// </summary>
|
||
public void WriteNullTerminatedString(string value, Encoding encoding)
|
||
{
|
||
if (value == null)
|
||
throw new ArgumentNullException(nameof(value));
|
||
if (encoding == null)
|
||
throw new ArgumentNullException(nameof(encoding));
|
||
|
||
byte[] bytes = encoding.GetBytes(value);
|
||
Write(bytes, 0, bytes.Length);
|
||
WriteByte(0); // 写入null终止符
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取前缀长度的字符串（先读取长度，再读取内容）
|
||
/// 使用Int32作为长度前缀
|
||
/// </summary>
|
||
public string ReadLengthPrefixedString()
|
||
{
|
||
return ReadLengthPrefixedString(DefaultEncoding, Endianness.LittleEndian);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取前缀长度的字符串（先读取长度，再读取内容）
|
||
/// 使用Int32作为长度前缀
|
||
/// </summary>
|
||
public string ReadLengthPrefixedString(Encoding encoding, Endianness endianness)
|
||
{
|
||
return ReadLengthPrefixedString<int>(encoding, endianness);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取前缀长度的字符串（先读取长度，再读取内容）
|
||
/// 支持指定长度类型（Int16, Int32, Int64等）
|
||
/// </summary>
|
||
public string ReadLengthPrefixedString<TLength>(Encoding encoding, Endianness endianness)
|
||
where TLength : struct, IConvertible
|
||
{
|
||
if (encoding == null)
|
||
throw new ArgumentNullException(nameof(encoding));
|
||
|
||
// 读取长度前缀
|
||
TLength lengthValue = Read<TLength>(endianness);
|
||
int length = Convert.ToInt32(lengthValue);
|
||
|
||
if (length < 0)
|
||
throw new IOException("字符串长度不能为负数");
|
||
|
||
byte[] bytes = ReadBytes(length);
|
||
return encoding.GetString(bytes);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入前缀长度的字符串（先写入长度，再写入内容）
|
||
/// 使用Int32作为长度前缀
|
||
/// </summary>
|
||
public void WriteLengthPrefixedString(string value)
|
||
{
|
||
WriteLengthPrefixedString(value, DefaultEncoding, Endianness.LittleEndian);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入前缀长度的字符串（先写入长度，再写入内容）
|
||
/// 使用Int32作为长度前缀
|
||
/// </summary>
|
||
public void WriteLengthPrefixedString(string value, Encoding encoding, Endianness endianness)
|
||
{
|
||
WriteLengthPrefixedString<int>(value, encoding, endianness);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入前缀长度的字符串（先写入长度，再写入内容）
|
||
/// 支持指定长度类型（Int16, Int32, Int64等）
|
||
/// </summary>
|
||
public void WriteLengthPrefixedString<TLength>(string value, Encoding encoding, Endianness endianness)
|
||
where TLength : struct, IConvertible
|
||
{
|
||
if (value == null)
|
||
throw new ArgumentNullException(nameof(value));
|
||
if (encoding == null)
|
||
throw new ArgumentNullException(nameof(encoding));
|
||
|
||
byte[] bytes = encoding.GetBytes(value);
|
||
|
||
// 检查长度是否在指定类型范围内
|
||
TLength lengthValue = (TLength)Convert.ChangeType(bytes.Length, typeof(TLength));
|
||
|
||
// 写入长度前缀和字符串内容
|
||
Write<TLength>(lengthValue, endianness);
|
||
Write(bytes, 0, bytes.Length);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取固定长度的字符串
|
||
/// </summary>
|
||
public string ReadFixedLengthString(int byteCount)
|
||
{
|
||
return ReadFixedLengthString(byteCount, DefaultEncoding);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 读取固定长度的字符串
|
||
/// </summary>
|
||
public string ReadFixedLengthString(int byteCount, Encoding encoding)
|
||
{
|
||
if (byteCount < 0)
|
||
throw new ArgumentOutOfRangeException(nameof(byteCount));
|
||
if (encoding == null)
|
||
throw new ArgumentNullException(nameof(encoding));
|
||
|
||
byte[] bytes = ReadBytes(byteCount);
|
||
return encoding.GetString(bytes);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入固定长度的字符串，不足则填充，超出则截断
|
||
/// </summary>
|
||
public void WriteFixedLengthString(string value, int byteCount)
|
||
{
|
||
WriteFixedLengthString(value, byteCount, DefaultEncoding, (byte)0);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 写入固定长度的字符串，不足则填充，超出则截断
|
||
/// </summary>
|
||
public void WriteFixedLengthString(string value, int byteCount, Encoding encoding, byte paddingByte)
|
||
{
|
||
if (byteCount < 0)
|
||
throw new ArgumentOutOfRangeException(nameof(byteCount));
|
||
if (encoding == null)
|
||
throw new ArgumentNullException(nameof(encoding));
|
||
if (value == null)
|
||
value = string.Empty;
|
||
|
||
// 获取字符串的字节表示
|
||
byte[] originalBytes = encoding.GetBytes(value);
|
||
|
||
// 创建目标字节数组
|
||
byte[] targetBytes = new byte[byteCount];
|
||
|
||
if (paddingByte != 0)
|
||
{
|
||
// // 填充默认值
|
||
for (int i = 0; i < byteCount; i++)
|
||
targetBytes[i] = paddingByte;
|
||
}
|
||
// 复制字节，超出部分截断
|
||
int copyLength = Math.Min(originalBytes.Length, byteCount);
|
||
Array.Copy(originalBytes, targetBytes, copyLength);
|
||
|
||
Write(targetBytes, 0, targetBytes.Length);
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 泛型读写方法
|
||
|
||
/// <summary>
|
||
/// 泛型读取方法（小端字节序）
|
||
/// </summary>
|
||
public T Read<T>() where T : struct
|
||
{
|
||
return Read<T>(Endianness.LittleEndian);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 泛型读取方法
|
||
/// </summary>
|
||
public T Read<T>(Endianness endianness) where T : struct
|
||
{
|
||
Type type = typeof(T);
|
||
|
||
if (type == typeof(byte)) return (T)(object)ReadByte();
|
||
if (type == typeof(short)) return (T)(object)ReadInt16(endianness);
|
||
if (type == typeof(ushort)) return (T)(object)ReadUInt16(endianness);
|
||
if (type == typeof(int)) return (T)(object)ReadInt32(endianness);
|
||
if (type == typeof(uint)) return (T)(object)ReadUInt32(endianness);
|
||
if (type == typeof(long)) return (T)(object)ReadInt64(endianness);
|
||
if (type == typeof(ulong)) return (T)(object)ReadUInt64(endianness);
|
||
if (type == typeof(float)) return (T)(object)ReadFloat(endianness);
|
||
if (type == typeof(double)) return (T)(object)ReadDouble(endianness);
|
||
if (type == typeof(bool)) return (T)(object)ReadBoolean();
|
||
if (type == typeof(char)) return (T)(object)ReadChar(endianness);
|
||
if (type == typeof(decimal)) return (T)(object)ReadDecimal(endianness);
|
||
|
||
throw new NotSupportedException($"不支持的类型: {type.Name}");
|
||
}
|
||
|
||
/// <summary>
|
||
/// 泛型写入方法（小端字节序）
|
||
/// </summary>
|
||
public void Write<T>(T value) where T : struct
|
||
{
|
||
Write(value, Endianness.LittleEndian);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 泛型写入方法
|
||
/// </summary>
|
||
public void Write<T>(T value, Endianness endianness) where T : struct
|
||
{
|
||
Type type = typeof(T);
|
||
|
||
if (type == typeof(byte)) { WriteByte((byte)(object)value); return; }
|
||
if (type == typeof(short)) { WriteInt16((short)(object)value, endianness); return; }
|
||
if (type == typeof(ushort)) { WriteUInt16((ushort)(object)value, endianness); return; }
|
||
if (type == typeof(int)) { WriteInt32((int)(object)value, endianness); return; }
|
||
if (type == typeof(uint)) { WriteUInt32((uint)(object)value, endianness); return; }
|
||
if (type == typeof(long)) { WriteInt64((long)(object)value, endianness); return; }
|
||
if (type == typeof(ulong)) { WriteUInt64((ulong)(object)value, endianness); return; }
|
||
if (type == typeof(float)) { WriteFloat((float)(object)value, endianness); return; }
|
||
if (type == typeof(double)) { WriteDouble((double)(object)value, endianness); return; }
|
||
if (type == typeof(bool)) { WriteBoolean((bool)(object)value); return; }
|
||
if (type == typeof(char)) { WriteChar((char)(object)value, endianness); return; }
|
||
if (type == typeof(decimal)) { WriteDecimal((decimal)(object)value, endianness); return; }
|
||
|
||
throw new NotSupportedException($"不支持的类型: {type.Name}");
|
||
}
|
||
|
||
#endregion
|
||
|
||
/// <summary>
|
||
/// 将流内容转换为字节数组
|
||
/// </summary>
|
||
public byte[] ToByteArray()
|
||
{
|
||
byte[] result = new byte[_length];
|
||
Array.Copy(_buffer, result, _length);
|
||
return result;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 辅助方法：判断是否需要反转字节顺序
|
||
/// </summary>
|
||
private bool NeedReverse(Endianness endianness)
|
||
{
|
||
return (endianness == Endianness.BigEndian && BitConverter.IsLittleEndian) ||
|
||
(endianness == Endianness.LittleEndian && !BitConverter.IsLittleEndian);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 字节序枚举
|
||
/// </summary>
|
||
public enum Endianness
|
||
{
|
||
LittleEndian, // 小端字节序
|
||
BigEndian // 大端字节序
|
||
}
|
||
} |