Make use of ReadExactly & ReadExactlyAsync.

Obsidian/Net/MinecraftStream.Reading.cs

@@ -20,7 +20,7 @@ public partial class MinecraftStream
     public byte ReadUnsignedByte()
     {
         Span<byte> buffer = stackalloc byte[1];
-        BaseStream.Read(buffer);
+        BaseStream.ReadExactly(buffer);
         return buffer[0];
     }
 
@@ -53,7 +53,7 @@ public async Task<bool> ReadBooleanAsync()
     public ushort ReadUnsignedShort()
     {
         Span<byte> buffer = stackalloc byte[2];
-        this.Read(buffer);
+        this.ReadExactly(buffer);
         return BinaryPrimitives.ReadUInt16BigEndian(buffer);
     }
 
@@ -68,89 +68,89 @@ public async Task<ushort> ReadUnsignedShortAsync()
     public short ReadShort()
     {
         Span<byte> buffer = stackalloc byte[2];
-        this.Read(buffer);
+        this.ReadExactly(buffer);
         return BinaryPrimitives.ReadInt16BigEndian(buffer);
     }
 
     public async Task<short> ReadShortAsync()
     {
         using var buffer = new RentedArray<byte>(sizeof(short));
-        await this.ReadAsync(buffer);
+        await this.ReadExactlyAsync(buffer);
         return BinaryPrimitives.ReadInt16BigEndian(buffer);
     }
 
     [ReadMethod]
     public int ReadInt()
     {
         Span<byte> buffer = stackalloc byte[4];
-        this.Read(buffer);
+        this.ReadExactly(buffer);
         return BinaryPrimitives.ReadInt32BigEndian(buffer);
     }
 
     public async Task<int> ReadIntAsync()
     {
         using var buffer = new RentedArray<byte>(sizeof(int));
-        await this.ReadAsync(buffer);
+        await this.ReadExactlyAsync(buffer);
         return BinaryPrimitives.ReadInt32BigEndian(buffer);
     }
 
     [ReadMethod]
     public long ReadLong()
     {
         Span<byte> buffer = stackalloc byte[8];
-        this.Read(buffer);
+        this.ReadExactly(buffer);
         return BinaryPrimitives.ReadInt64BigEndian(buffer);
     }
 
     public async Task<long> ReadLongAsync()
     {
         using var buffer = new RentedArray<byte>(sizeof(long));
-        await this.ReadAsync(buffer);
+        await this.ReadExactlyAsync(buffer);
         return BinaryPrimitives.ReadInt64BigEndian(buffer);
     }
 
     [ReadMethod]
     public ulong ReadUnsignedLong()
     {
         Span<byte> buffer = stackalloc byte[8];
-        this.Read(buffer);
+        this.ReadExactly(buffer);
         return BinaryPrimitives.ReadUInt64BigEndian(buffer);
     }
 
     public async Task<ulong> ReadUnsignedLongAsync()
     {
         using var buffer = new RentedArray<byte>(sizeof(ulong));
-        await this.ReadAsync(buffer);
+        await this.ReadExactlyAsync(buffer);
         return BinaryPrimitives.ReadUInt64BigEndian(buffer);
     }
 
     [ReadMethod]
     public float ReadFloat()
     {
         Span<byte> buffer = stackalloc byte[4];
-        this.Read(buffer);
+        this.ReadExactly(buffer);
         return BinaryPrimitives.ReadSingleBigEndian(buffer);
     }
 
     public async Task<float> ReadFloatAsync()
     {
         using var buffer = new RentedArray<byte>(sizeof(float));
-        await this.ReadAsync(buffer);
+        await this.ReadExactlyAsync(buffer);
         return BinaryPrimitives.ReadSingleBigEndian(buffer);
     }
 
     [ReadMethod]
     public double ReadDouble()
     {
         Span<byte> buffer = stackalloc byte[8];
-        this.Read(buffer);
+        this.ReadExactly(buffer);
         return BinaryPrimitives.ReadDoubleBigEndian(buffer);
     }
 
     public async Task<double> ReadDoubleAsync()
     {
         using var buffer = new RentedArray<byte>(sizeof(double));
-        await this.ReadAsync(buffer);
+        await this.ReadExactlyAsync(buffer);
         return BinaryPrimitives.ReadDoubleBigEndian(buffer);
     }
 
@@ -159,7 +159,7 @@ public string ReadString(int maxLength = 32767)
     {
         var length = ReadVarInt();
         var buffer = new byte[length];
-        this.Read(buffer, 0, length);
+        this.ReadExactly(buffer);
 
         var value = Encoding.UTF8.GetString(buffer);
         if (maxLength > 0 && value.Length > maxLength)
@@ -177,7 +177,7 @@ public async Task<string> ReadStringAsync(int maxLength = 32767)
         {
             buffer.Span.Reverse();
         }
-        await this.ReadAsync(buffer);
+        await this.ReadExactlyAsync(buffer);
 
         var value = Encoding.UTF8.GetString(buffer);
         if (maxLength > 0 && value.Length > maxLength)