Merge pull request #851 from stebet/netstandardBinaryPrimitives

michaelklishin · web-flow · commit 29f78bf2c0e0 · 2020-05-26T14:53:28.000+03:00
Adding BinaryPrimitives support for NETSTANDARD targets
diff --git a/projects/Apigen/apigen/Apigen.cs b/projects/Apigen/apigen/Apigen.cs
@@ -935,8 +935,8 @@ public void EmitMethodArgumentReader()
         {
             EmitLine("    internal override Client.Impl.MethodBase DecodeMethodFrom(ReadOnlyMemory<byte> memory)");
             EmitLine("    {");
-            EmitLine("      ushort classId = Util.NetworkOrderDeserializer.ReadUInt16(memory);");
-            EmitLine("      ushort methodId = Util.NetworkOrderDeserializer.ReadUInt16(memory.Slice(2));");
+            EmitLine("      ushort classId = Util.NetworkOrderDeserializer.ReadUInt16(memory.Span);");
+            EmitLine("      ushort methodId = Util.NetworkOrderDeserializer.ReadUInt16(memory.Slice(2).Span);");
             EmitLine("      Client.Impl.MethodBase result = DecodeMethodFrom(classId, methodId);");
             EmitLine("      if(result != null)");
             EmitLine("      {");
diff --git a/projects/RabbitMQ.Client/client/impl/CommandAssembler.cs b/projects/RabbitMQ.Client/client/impl/CommandAssembler.cs
@@ -89,7 +89,7 @@ public Command HandleFrame(in InboundFrame f)
                     {
                         throw new UnexpectedFrameException(f.Type);
                     }
-                    m_header = m_protocol.DecodeContentHeaderFrom(NetworkOrderDeserializer.ReadUInt16(f.Payload));
+                    m_header = m_protocol.DecodeContentHeaderFrom(NetworkOrderDeserializer.ReadUInt16(f.Payload.Span));
                     ulong totalBodyBytes = m_header.ReadFrom(f.Payload.Slice(2));
                     if (totalBodyBytes > MaxArrayOfBytesSize)
                     {
diff --git a/projects/RabbitMQ.Client/client/impl/ContentHeaderBase.cs b/projects/RabbitMQ.Client/client/impl/ContentHeaderBase.cs
@@ -70,7 +70,7 @@ public virtual object Clone()
         internal ulong ReadFrom(ReadOnlyMemory<byte> memory)
         {
             // Skipping the first two bytes since they arent used (weight - not currently used)
-            ulong bodySize = NetworkOrderDeserializer.ReadUInt64(memory.Slice(2));
+            ulong bodySize = NetworkOrderDeserializer.ReadUInt64(memory.Slice(2).Span);
             ContentHeaderPropertyReader reader = new ContentHeaderPropertyReader(memory.Slice(10));
             ReadPropertiesFrom(ref reader);
             return bodySize;
@@ -83,8 +83,8 @@ internal ulong ReadFrom(ReadOnlyMemory<byte> memory)
 
         internal int WriteTo(Memory<byte> memory, ulong bodySize)
         {
-            NetworkOrderSerializer.WriteUInt16(memory, ZERO); // Weight - not used
-            NetworkOrderSerializer.WriteUInt64(memory.Slice(2), bodySize);
+            NetworkOrderSerializer.WriteUInt16(memory.Span, ZERO); // Weight - not used
+            NetworkOrderSerializer.WriteUInt64(memory.Slice(2).Span, bodySize);
 
             ContentHeaderPropertyWriter writer = new ContentHeaderPropertyWriter(memory.Slice(10));
             WritePropertiesTo(ref writer);
diff --git a/projects/RabbitMQ.Client/client/impl/ContentHeaderPropertyReader.cs b/projects/RabbitMQ.Client/client/impl/ContentHeaderPropertyReader.cs
@@ -84,21 +84,21 @@ public void ReadFlagWord()
             {
                 throw new MalformedFrameException("Attempted to read flag word when none advertised");
             }
-            m_flagWord = NetworkOrderDeserializer.ReadUInt16(_memory.Slice(_memoryOffset));
+            m_flagWord = NetworkOrderDeserializer.ReadUInt16(_memory.Slice(_memoryOffset).Span);
             _memoryOffset += 2;
             m_bitCount = 0;
         }
 
         public uint ReadLong()
         {
-            uint result = NetworkOrderDeserializer.ReadUInt32(_memory.Slice(_memoryOffset));
+            uint result = NetworkOrderDeserializer.ReadUInt32(_memory.Slice(_memoryOffset).Span);
             _memoryOffset += 4;
             return result;
         }
 
         public ulong ReadLonglong()
         {
-            ulong result = NetworkOrderDeserializer.ReadUInt64(_memory.Slice(_memoryOffset));
+            ulong result = NetworkOrderDeserializer.ReadUInt64(_memory.Slice(_memoryOffset).Span);
             _memoryOffset += 8;
             return result;
         }
@@ -130,7 +130,7 @@ public bool ReadPresence()
 
         public ushort ReadShort()
         {
-            ushort result = NetworkOrderDeserializer.ReadUInt16(_memory.Slice(_memoryOffset));
+            ushort result = NetworkOrderDeserializer.ReadUInt16(_memory.Slice(_memoryOffset).Span);
             _memoryOffset += 2;
             return result;
         }
diff --git a/projects/RabbitMQ.Client/client/impl/ContentHeaderPropertyWriter.cs b/projects/RabbitMQ.Client/client/impl/ContentHeaderPropertyWriter.cs
@@ -127,7 +127,7 @@ public void WriteTimestamp(AmqpTimestamp val)
 
         private void EmitFlagWord(bool continuationBit)
         {
-            NetworkOrderSerializer.WriteUInt16(Memory.Slice(Offset), (ushort)(continuationBit ? (_flagWord | 1) : _flagWord));
+            NetworkOrderSerializer.WriteUInt16(Memory.Slice(Offset).Span, (ushort)(continuationBit ? (_flagWord | 1) : _flagWord));
             Offset += 2;
             _flagWord = 0;
             _bitCount = 0;
diff --git a/projects/RabbitMQ.Client/client/impl/Frame.cs b/projects/RabbitMQ.Client/client/impl/Frame.cs
@@ -70,7 +70,7 @@ internal override int GetMinimumPayloadBufferSize()
         internal override int WritePayload(Memory<byte> memory)
         {
             // write protocol class id (2 bytes)
-            NetworkOrderSerializer.WriteUInt16(memory, _header.ProtocolClassId);
+            NetworkOrderSerializer.WriteUInt16(memory.Span, _header.ProtocolClassId);
             // write header (X bytes)
             int bytesWritten = _header.WriteTo(memory.Slice(2), (ulong)_bodyLength);
             return 2 + bytesWritten;
@@ -115,8 +115,8 @@ internal override int GetMinimumPayloadBufferSize()
 
         internal override int WritePayload(Memory<byte> memory)
         {
-            NetworkOrderSerializer.WriteUInt16(memory, _method.ProtocolClassId);
-            NetworkOrderSerializer.WriteUInt16(memory.Slice(2), _method.ProtocolMethodId);
+            NetworkOrderSerializer.WriteUInt16(memory.Span, _method.ProtocolClassId);
+            NetworkOrderSerializer.WriteUInt16(memory.Slice(2).Span, _method.ProtocolMethodId);
             var argWriter = new MethodArgumentWriter(memory.Slice(4));
             _method.WriteArgumentsTo(ref argWriter);
             argWriter.Flush();
@@ -151,9 +151,9 @@ public OutboundFrame(FrameType type, int channel) : base(type, channel)
         internal void WriteTo(Memory<byte> memory)
         {
             memory.Span[0] = (byte)Type;
-            NetworkOrderSerializer.WriteUInt16(memory.Slice(1), (ushort)Channel);
+            NetworkOrderSerializer.WriteUInt16(memory.Slice(1).Span, (ushort)Channel);
             int bytesWritten = WritePayload(memory.Slice(7));
-            NetworkOrderSerializer.WriteUInt32(memory.Slice(3), (uint)bytesWritten);
+            NetworkOrderSerializer.WriteUInt32(memory.Slice(3).Span, (uint)bytesWritten);
             memory.Span[bytesWritten + 7] = Constants.FrameEnd;
             ByteCount = bytesWritten + 8;
         }
diff --git a/projects/RabbitMQ.Client/client/impl/MethodArgumentReader.cs b/projects/RabbitMQ.Client/client/impl/MethodArgumentReader.cs
@@ -82,15 +82,15 @@ public byte[] ReadContent()
         public uint ReadLong()
         {
             ClearBits();
-            uint result = NetworkOrderDeserializer.ReadUInt32(_memory.Slice(_memoryOffset));
+            uint result = NetworkOrderDeserializer.ReadUInt32(_memory.Slice(_memoryOffset).Span);
             _memoryOffset += 4;
             return result;
         }
 
         public ulong ReadLonglong()
         {
             ClearBits();
-            ulong result = NetworkOrderDeserializer.ReadUInt64(_memory.Slice(_memoryOffset));
+            ulong result = NetworkOrderDeserializer.ReadUInt64(_memory.Slice(_memoryOffset).Span);
             _memoryOffset += 8;
             return result;
         }
@@ -112,7 +112,7 @@ public byte ReadOctet()
         public ushort ReadShort()
         {
             ClearBits();
-            ushort result = NetworkOrderDeserializer.ReadUInt16(_memory.Slice(_memoryOffset));
+            ushort result = NetworkOrderDeserializer.ReadUInt16(_memory.Slice(_memoryOffset).Span);
             _memoryOffset += 2;
             return result;
         }
diff --git a/projects/RabbitMQ.Client/client/impl/WireFormatting.cs b/projects/RabbitMQ.Client/client/impl/WireFormatting.cs
@@ -96,7 +96,7 @@ public static void DecimalToAmqp(decimal value, out byte scale, out int mantissa
         public static IList ReadArray(ReadOnlyMemory<byte> memory, out int bytesRead)
         {
             IList array = new List<object>();
-            long arrayLength = NetworkOrderDeserializer.ReadUInt32(memory);
+            long arrayLength = NetworkOrderDeserializer.ReadUInt32(memory.Span);
             bytesRead = 4;
             while (bytesRead - 4 < arrayLength)
             {
@@ -111,7 +111,7 @@ public static IList ReadArray(ReadOnlyMemory<byte> memory, out int bytesRead)
         public static decimal ReadDecimal(ReadOnlyMemory<byte> memory)
         {
             byte scale = memory.Span[0];
-            uint unsignedMantissa = NetworkOrderDeserializer.ReadUInt32(memory.Slice(1));
+            uint unsignedMantissa = NetworkOrderDeserializer.ReadUInt32(memory.Slice(1).Span);
             return AmqpToDecimal(scale, unsignedMantissa);
         }
 
@@ -127,10 +127,10 @@ public static object ReadFieldValue(ReadOnlyMemory<byte> memory, out int bytesRe
                     return result;
                 case 'I':
                     bytesRead += 4;
-                    return NetworkOrderDeserializer.ReadInt32(slice);
+                    return NetworkOrderDeserializer.ReadInt32(slice.Span);
                 case 'i':
                     bytesRead += 4;
-                    return NetworkOrderDeserializer.ReadUInt32(slice);
+                    return NetworkOrderDeserializer.ReadUInt32(slice.Span);
                 case 'D':
                     bytesRead += 5;
                     return ReadDecimal(slice);
@@ -153,16 +153,16 @@ public static object ReadFieldValue(ReadOnlyMemory<byte> memory, out int bytesRe
                     return (sbyte)slice.Span[0];
                 case 'd':
                     bytesRead += 8;
-                    return NetworkOrderDeserializer.ReadDouble(slice);
+                    return NetworkOrderDeserializer.ReadDouble(slice.Span);
                 case 'f':
                     bytesRead += 4;
-                    return NetworkOrderDeserializer.ReadSingle(slice);
+                    return NetworkOrderDeserializer.ReadSingle(slice.Span);
                 case 'l':
                     bytesRead += 8;
-                    return NetworkOrderDeserializer.ReadInt64(slice);
+                    return NetworkOrderDeserializer.ReadInt64(slice.Span);
                 case 's':
                     bytesRead += 2;
-                    return NetworkOrderDeserializer.ReadInt16(slice);
+                    return NetworkOrderDeserializer.ReadInt16(slice.Span);
                 case 't':
                     bytesRead += 1;
                     return slice.Span[0] != 0;
@@ -179,7 +179,7 @@ public static object ReadFieldValue(ReadOnlyMemory<byte> memory, out int bytesRe
 
         public static byte[] ReadLongstr(ReadOnlyMemory<byte> memory)
         {
-            int byteCount = (int)NetworkOrderDeserializer.ReadUInt32(memory);
+            int byteCount = (int)NetworkOrderDeserializer.ReadUInt32(memory.Span);
             if (byteCount > int.MaxValue)
             {
                 throw new SyntaxErrorException($"Long string too long; byte length={byteCount}, max={int.MaxValue}");
@@ -211,7 +211,7 @@ public static string ReadShortstr(ReadOnlyMemory<byte> memory, out int bytesRead
         public static IDictionary<string, object> ReadTable(ReadOnlyMemory<byte> memory, out int bytesRead)
         {
             IDictionary<string, object> table = new Dictionary<string, object>();
-            long tableLength = NetworkOrderDeserializer.ReadUInt32(memory);
+            long tableLength = NetworkOrderDeserializer.ReadUInt32(memory.Span);
             bytesRead = 4;
             while ((bytesRead - 4) < tableLength)
             {
@@ -231,7 +231,7 @@ public static IDictionary<string, object> ReadTable(ReadOnlyMemory<byte> memory,
 
         public static AmqpTimestamp ReadTimestamp(ReadOnlyMemory<byte> memory)
         {
-            ulong stamp = NetworkOrderDeserializer.ReadUInt64(memory);
+            ulong stamp = NetworkOrderDeserializer.ReadUInt64(memory.Span);
             // 0-9 is afaict silent on the signedness of the timestamp.
             // See also MethodArgumentWriter.WriteTimestamp and AmqpTimestamp itself
             return new AmqpTimestamp((long)stamp);
@@ -241,7 +241,7 @@ public static int WriteArray(Memory<byte> memory, IList val)
         {
             if (val == null)
             {
-                NetworkOrderSerializer.WriteUInt32(memory, 0);
+                NetworkOrderSerializer.WriteUInt32(memory.Span, 0);
                 return 4;
             }
             else
@@ -252,7 +252,7 @@ public static int WriteArray(Memory<byte> memory, IList val)
                     bytesWritten += WriteFieldValue(memory.Slice(4 + bytesWritten), entry); ;
                 }
 
-                NetworkOrderSerializer.WriteUInt32(memory, (uint)bytesWritten);
+                NetworkOrderSerializer.WriteUInt32(memory.Span, (uint)bytesWritten);
                 return 4 + bytesWritten;
             }
         }
@@ -296,7 +296,7 @@ public static int WriteFieldValue(Memory<byte> memory, object value)
                     if (MemoryMarshal.TryGetArray(memory, out ArraySegment<byte> segment))
                     {
                         int bytesWritten = Encoding.UTF8.GetBytes(val, 0, val.Length, segment.Array, segment.Offset +  5);
-                        NetworkOrderSerializer.WriteUInt32(slice, (uint)bytesWritten);
+                        NetworkOrderSerializer.WriteUInt32(slice.Span, (uint)bytesWritten);
                         return 5 + bytesWritten;
                     }
 
@@ -306,11 +306,11 @@ public static int WriteFieldValue(Memory<byte> memory, object value)
                     return 1 + WriteLongstr(slice, val);
                 case int val:
                     memory.Span[0] = (byte)'I';
-                    NetworkOrderSerializer.WriteInt32(slice, val);
+                    NetworkOrderSerializer.WriteInt32(slice.Span, val);
                     return 5;
                 case uint val:
                     memory.Span[0] = (byte)'i';
-                    NetworkOrderSerializer.WriteUInt32(slice, val);
+                    NetworkOrderSerializer.WriteUInt32(slice.Span, val);
                     return 5;
                 case decimal val:
                     memory.Span[0] = (byte)'D';
@@ -334,19 +334,19 @@ public static int WriteFieldValue(Memory<byte> memory, object value)
                     return 2;
                 case double val:
                     memory.Span[0] = (byte)'d';
-                    NetworkOrderSerializer.WriteDouble(slice, val);
+                    NetworkOrderSerializer.WriteDouble(slice.Span, val);
                     return 9;
                 case float val:
                     memory.Span[0] = (byte)'f';
-                    NetworkOrderSerializer.WriteSingle(slice, val);
+                    NetworkOrderSerializer.WriteSingle(slice.Span, val);
                     return 5;
                 case long val:
                     memory.Span[0] = (byte)'l';
-                    NetworkOrderSerializer.WriteInt64(slice, val);
+                    NetworkOrderSerializer.WriteInt64(slice.Span, val);
                     return 9;
                 case short val:
                     memory.Span[0] = (byte)'s';
-                    NetworkOrderSerializer.WriteInt16(slice, val);
+                    NetworkOrderSerializer.WriteInt16(slice.Span, val);
                     return 3;
                 case bool val:
                     memory.Span[0] = (byte)'t';
@@ -399,13 +399,13 @@ public static int GetFieldValueByteCount(object value)
 
         public static int WriteLong(Memory<byte> memory, uint val)
         {
-            NetworkOrderSerializer.WriteUInt32(memory, val);
+            NetworkOrderSerializer.WriteUInt32(memory.Span, val);
             return 4;
         }
 
         public static int WriteLonglong(Memory<byte> memory, ulong val)
         {
-            NetworkOrderSerializer.WriteUInt64(memory, val);
+            NetworkOrderSerializer.WriteUInt64(memory.Span, val);
             return 8;
         }
 
@@ -423,7 +423,7 @@ public static int WriteLongstr(Memory<byte> memory, byte[] val, int index, int c
 
         public static int WriteShort(Memory<byte> memory, ushort val)
         {
-            NetworkOrderSerializer.WriteUInt16(memory, val);
+            NetworkOrderSerializer.WriteUInt16(memory.Span, val);
             return 2;
         }
 
@@ -448,7 +448,7 @@ public static int WriteTable(Memory<byte> memory, IDictionary val)
         {
             if (val == null)
             {
-                NetworkOrderSerializer.WriteUInt32(memory, 0);
+                NetworkOrderSerializer.WriteUInt32(memory.Span, 0);
                 return 4;
             }
             else
@@ -462,7 +462,7 @@ public static int WriteTable(Memory<byte> memory, IDictionary val)
                     bytesWritten += WriteFieldValue(slice.Slice(bytesWritten), entry.Value);
                 }
 
-                NetworkOrderSerializer.WriteUInt32(memory, (uint)bytesWritten);
+                NetworkOrderSerializer.WriteUInt32(memory.Span, (uint)bytesWritten);
                 return 4 + bytesWritten;
             }
         }
@@ -471,7 +471,7 @@ public static int WriteTable(Memory<byte> memory, IDictionary<string, object> va
         {
             if (val == null)
             {
-                NetworkOrderSerializer.WriteUInt32(memory, 0);
+                NetworkOrderSerializer.WriteUInt32(memory.Span, 0);
                 return 4;
             }
             else
@@ -485,7 +485,7 @@ public static int WriteTable(Memory<byte> memory, IDictionary<string, object> va
                     bytesWritten += WriteFieldValue(slice.Slice(bytesWritten), entry.Value);
                 }
 
-                NetworkOrderSerializer.WriteUInt32(memory, (uint)bytesWritten);
+                NetworkOrderSerializer.WriteUInt32(memory.Span, (uint)bytesWritten);
                 return 4 + bytesWritten;
             }
         }
diff --git a/projects/RabbitMQ.Client/util/NetworkOrderDeserializer.cs b/projects/RabbitMQ.Client/util/NetworkOrderDeserializer.cs
diff --git a/projects/RabbitMQ.Client/util/NetworkOrderSerializer.cs b/projects/RabbitMQ.Client/util/NetworkOrderSerializer.cs

Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ public Command HandleFrame(in InboundFrame f)`
`89`	`89`	`{`
`90`	`90`	`throw new UnexpectedFrameException(f.Type);`
`91`	`91`	`}`
`92`		`- m_header = m_protocol.DecodeContentHeaderFrom(NetworkOrderDeserializer.ReadUInt16(f.Payload));`
	`92`	`+ m_header = m_protocol.DecodeContentHeaderFrom(NetworkOrderDeserializer.ReadUInt16(f.Payload.Span));`
`93`	`93`	`ulong totalBodyBytes = m_header.ReadFrom(f.Payload.Slice(2));`
`94`	`94`	`if (totalBodyBytes > MaxArrayOfBytesSize)`
`95`	`95`	`{`
Original file line number	Diff line number	Diff line change
`@@ -84,21 +84,21 @@ public void ReadFlagWord()`
`84`	`84`	`{`
`85`	`85`	`throw new MalformedFrameException("Attempted to read flag word when none advertised");`
`86`	`86`	`}`
`87`		`- m_flagWord = NetworkOrderDeserializer.ReadUInt16(_memory.Slice(_memoryOffset));`
	`87`	`+ m_flagWord = NetworkOrderDeserializer.ReadUInt16(_memory.Slice(_memoryOffset).Span);`
`88`	`88`	`_memoryOffset += 2;`
`89`	`89`	`m_bitCount = 0;`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`public uint ReadLong()`
`93`	`93`	`{`
`94`		`- uint result = NetworkOrderDeserializer.ReadUInt32(_memory.Slice(_memoryOffset));`
	`94`	`+ uint result = NetworkOrderDeserializer.ReadUInt32(_memory.Slice(_memoryOffset).Span);`
`95`	`95`	`_memoryOffset += 4;`
`96`	`96`	`return result;`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`public ulong ReadLonglong()`
`100`	`100`	`{`
`101`		`- ulong result = NetworkOrderDeserializer.ReadUInt64(_memory.Slice(_memoryOffset));`
	`101`	`+ ulong result = NetworkOrderDeserializer.ReadUInt64(_memory.Slice(_memoryOffset).Span);`
`102`	`102`	`_memoryOffset += 8;`
`103`	`103`	`return result;`
`104`	`104`	`}`
`@@ -130,7 +130,7 @@ public bool ReadPresence()`
`130`	`130`
`131`	`131`	`public ushort ReadShort()`
`132`	`132`	`{`
`133`		`- ushort result = NetworkOrderDeserializer.ReadUInt16(_memory.Slice(_memoryOffset));`
	`133`	`+ ushort result = NetworkOrderDeserializer.ReadUInt16(_memory.Slice(_memoryOffset).Span);`
`134`	`134`	`_memoryOffset += 2;`
`135`	`135`	`return result;`
`136`	`136`	`}`
Original file line number	Diff line number	Diff line change
`@@ -127,7 +127,7 @@ public void WriteTimestamp(AmqpTimestamp val)`
`127`	`127`
`128`	`128`	`private void EmitFlagWord(bool continuationBit)`
`129`	`129`	`{`
`130`		`- NetworkOrderSerializer.WriteUInt16(Memory.Slice(Offset), (ushort)(continuationBit ? (_flagWord \| 1) : _flagWord));`
	`130`	`+ NetworkOrderSerializer.WriteUInt16(Memory.Slice(Offset).Span, (ushort)(continuationBit ? (_flagWord \| 1) : _flagWord));`
`131`	`131`	`Offset += 2;`
`132`	`132`	`_flagWord = 0;`
`133`	`133`	`_bitCount = 0;`
Original file line number	Diff line number	Diff line change
`@@ -82,15 +82,15 @@ public byte[] ReadContent()`
`82`	`82`	`public uint ReadLong()`
`83`	`83`	`{`
`84`	`84`	`ClearBits();`
`85`		`- uint result = NetworkOrderDeserializer.ReadUInt32(_memory.Slice(_memoryOffset));`
	`85`	`+ uint result = NetworkOrderDeserializer.ReadUInt32(_memory.Slice(_memoryOffset).Span);`
`86`	`86`	`_memoryOffset += 4;`
`87`	`87`	`return result;`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`public ulong ReadLonglong()`
`91`	`91`	`{`
`92`	`92`	`ClearBits();`
`93`		`- ulong result = NetworkOrderDeserializer.ReadUInt64(_memory.Slice(_memoryOffset));`
	`93`	`+ ulong result = NetworkOrderDeserializer.ReadUInt64(_memory.Slice(_memoryOffset).Span);`
`94`	`94`	`_memoryOffset += 8;`
`95`	`95`	`return result;`
`96`	`96`	`}`
`@@ -112,7 +112,7 @@ public byte ReadOctet()`
`112`	`112`	`public ushort ReadShort()`
`113`	`113`	`{`
`114`	`114`	`ClearBits();`
`115`		`- ushort result = NetworkOrderDeserializer.ReadUInt16(_memory.Slice(_memoryOffset));`
	`115`	`+ ushort result = NetworkOrderDeserializer.ReadUInt16(_memory.Slice(_memoryOffset).Span);`
`116`	`116`	`_memoryOffset += 2;`
`117`	`117`	`return result;`
`118`	`118`	`}`
Original file line number	Diff line number	Diff line change
`@@ -96,7 +96,7 @@ public static void DecimalToAmqp(decimal value, out byte scale, out int mantissa`
`96`	`96`	`public static IList ReadArray(ReadOnlyMemory<byte> memory, out int bytesRead)`
`97`	`97`	`{`
`98`	`98`	`IList array = new List<object>();`
`99`		`- long arrayLength = NetworkOrderDeserializer.ReadUInt32(memory);`
	`99`	`+ long arrayLength = NetworkOrderDeserializer.ReadUInt32(memory.Span);`
`100`	`100`	`bytesRead = 4;`
`101`	`101`	`while (bytesRead - 4 < arrayLength)`
`102`	`102`	`{`
`@@ -111,7 +111,7 @@ public static IList ReadArray(ReadOnlyMemory<byte> memory, out int bytesRead)`
`111`	`111`	`public static decimal ReadDecimal(ReadOnlyMemory<byte> memory)`
`112`	`112`	`{`
`113`	`113`	`byte scale = memory.Span[0];`
`114`		`- uint unsignedMantissa = NetworkOrderDeserializer.ReadUInt32(memory.Slice(1));`
	`114`	`+ uint unsignedMantissa = NetworkOrderDeserializer.ReadUInt32(memory.Slice(1).Span);`
`115`	`115`	`return AmqpToDecimal(scale, unsignedMantissa);`
`116`	`116`	`}`
`117`	`117`
`@@ -127,10 +127,10 @@ public static object ReadFieldValue(ReadOnlyMemory<byte> memory, out int bytesRe`
`127`	`127`	`return result;`
`128`	`128`	`case 'I':`
`129`	`129`	`bytesRead += 4;`
`130`		`- return NetworkOrderDeserializer.ReadInt32(slice);`
	`130`	`+ return NetworkOrderDeserializer.ReadInt32(slice.Span);`
`131`	`131`	`case 'i':`
`132`	`132`	`bytesRead += 4;`
`133`		`- return NetworkOrderDeserializer.ReadUInt32(slice);`
	`133`	`+ return NetworkOrderDeserializer.ReadUInt32(slice.Span);`
`134`	`134`	`case 'D':`
`135`	`135`	`bytesRead += 5;`
`136`	`136`	`return ReadDecimal(slice);`
`@@ -153,16 +153,16 @@ public static object ReadFieldValue(ReadOnlyMemory<byte> memory, out int bytesRe`
`153`	`153`	`return (sbyte)slice.Span[0];`
`154`	`154`	`case 'd':`
`155`	`155`	`bytesRead += 8;`
`156`		`- return NetworkOrderDeserializer.ReadDouble(slice);`
	`156`	`+ return NetworkOrderDeserializer.ReadDouble(slice.Span);`
`157`	`157`	`case 'f':`
`158`	`158`	`bytesRead += 4;`
`159`		`- return NetworkOrderDeserializer.ReadSingle(slice);`
	`159`	`+ return NetworkOrderDeserializer.ReadSingle(slice.Span);`
`160`	`160`	`case 'l':`
`161`	`161`	`bytesRead += 8;`
`162`		`- return NetworkOrderDeserializer.ReadInt64(slice);`
	`162`	`+ return NetworkOrderDeserializer.ReadInt64(slice.Span);`
`163`	`163`	`case 's':`
`164`	`164`	`bytesRead += 2;`
`165`		`- return NetworkOrderDeserializer.ReadInt16(slice);`
	`165`	`+ return NetworkOrderDeserializer.ReadInt16(slice.Span);`
`166`	`166`	`case 't':`
`167`	`167`	`bytesRead += 1;`
`168`	`168`	`return slice.Span[0] != 0;`
`@@ -179,7 +179,7 @@ public static object ReadFieldValue(ReadOnlyMemory<byte> memory, out int bytesRe`
`179`	`179`
`180`	`180`	`public static byte[] ReadLongstr(ReadOnlyMemory<byte> memory)`
`181`	`181`	`{`
`182`		`- int byteCount = (int)NetworkOrderDeserializer.ReadUInt32(memory);`
	`182`	`+ int byteCount = (int)NetworkOrderDeserializer.ReadUInt32(memory.Span);`
`183`	`183`	`if (byteCount > int.MaxValue)`
`184`	`184`	`{`
`185`	`185`	`throw new SyntaxErrorException($"Long string too long; byte length={byteCount}, max={int.MaxValue}");`
`@@ -211,7 +211,7 @@ public static string ReadShortstr(ReadOnlyMemory<byte> memory, out int bytesRead`
`211`	`211`	`public static IDictionary<string, object> ReadTable(ReadOnlyMemory<byte> memory, out int bytesRead)`
`212`	`212`	`{`
`213`	`213`	`IDictionary<string, object> table = new Dictionary<string, object>();`
`214`		`- long tableLength = NetworkOrderDeserializer.ReadUInt32(memory);`
	`214`	`+ long tableLength = NetworkOrderDeserializer.ReadUInt32(memory.Span);`
`215`	`215`	`bytesRead = 4;`
`216`	`216`	`while ((bytesRead - 4) < tableLength)`
`217`	`217`	`{`
`@@ -231,7 +231,7 @@ public static IDictionary<string, object> ReadTable(ReadOnlyMemory<byte> memory,`
`231`	`231`
`232`	`232`	`public static AmqpTimestamp ReadTimestamp(ReadOnlyMemory<byte> memory)`
`233`	`233`	`{`
`234`		`- ulong stamp = NetworkOrderDeserializer.ReadUInt64(memory);`
	`234`	`+ ulong stamp = NetworkOrderDeserializer.ReadUInt64(memory.Span);`
`235`	`235`	`// 0-9 is afaict silent on the signedness of the timestamp.`
`236`	`236`	`// See also MethodArgumentWriter.WriteTimestamp and AmqpTimestamp itself`
`237`	`237`	`return new AmqpTimestamp((long)stamp);`
`@@ -241,7 +241,7 @@ public static int WriteArray(Memory<byte> memory, IList val)`
`241`	`241`	`{`
`242`	`242`	`if (val == null)`
`243`	`243`	`{`
`244`		`- NetworkOrderSerializer.WriteUInt32(memory, 0);`
	`244`	`+ NetworkOrderSerializer.WriteUInt32(memory.Span, 0);`
`245`	`245`	`return 4;`
`246`	`246`	`}`
`247`	`247`	`else`
`@@ -252,7 +252,7 @@ public static int WriteArray(Memory<byte> memory, IList val)`
`252`	`252`	`bytesWritten += WriteFieldValue(memory.Slice(4 + bytesWritten), entry); ;`
`253`	`253`	`}`
`254`	`254`
`255`		`- NetworkOrderSerializer.WriteUInt32(memory, (uint)bytesWritten);`
	`255`	`+ NetworkOrderSerializer.WriteUInt32(memory.Span, (uint)bytesWritten);`
`256`	`256`	`return 4 + bytesWritten;`
`257`	`257`	`}`
`258`	`258`	`}`
`@@ -296,7 +296,7 @@ public static int WriteFieldValue(Memory<byte> memory, object value)`
`296`	`296`	`if (MemoryMarshal.TryGetArray(memory, out ArraySegment<byte> segment))`
`297`	`297`	`{`
`298`	`298`	`int bytesWritten = Encoding.UTF8.GetBytes(val, 0, val.Length, segment.Array, segment.Offset + 5);`
`299`		`- NetworkOrderSerializer.WriteUInt32(slice, (uint)bytesWritten);`
	`299`	`+ NetworkOrderSerializer.WriteUInt32(slice.Span, (uint)bytesWritten);`
`300`	`300`	`return 5 + bytesWritten;`
`301`	`301`	`}`
`302`	`302`
`@@ -306,11 +306,11 @@ public static int WriteFieldValue(Memory<byte> memory, object value)`
`306`	`306`	`return 1 + WriteLongstr(slice, val);`
`307`	`307`	`case int val:`
`308`	`308`	`memory.Span[0] = (byte)'I';`
`309`		`- NetworkOrderSerializer.WriteInt32(slice, val);`
	`309`	`+ NetworkOrderSerializer.WriteInt32(slice.Span, val);`
`310`	`310`	`return 5;`
`311`	`311`	`case uint val:`
`312`	`312`	`memory.Span[0] = (byte)'i';`
`313`		`- NetworkOrderSerializer.WriteUInt32(slice, val);`
	`313`	`+ NetworkOrderSerializer.WriteUInt32(slice.Span, val);`
`314`	`314`	`return 5;`
`315`	`315`	`case decimal val:`
`316`	`316`	`memory.Span[0] = (byte)'D';`
`@@ -334,19 +334,19 @@ public static int WriteFieldValue(Memory<byte> memory, object value)`
`334`	`334`	`return 2;`
`335`	`335`	`case double val:`
`336`	`336`	`memory.Span[0] = (byte)'d';`
`337`		`- NetworkOrderSerializer.WriteDouble(slice, val);`
	`337`	`+ NetworkOrderSerializer.WriteDouble(slice.Span, val);`
`338`	`338`	`return 9;`
`339`	`339`	`case float val:`
`340`	`340`	`memory.Span[0] = (byte)'f';`
`341`		`- NetworkOrderSerializer.WriteSingle(slice, val);`
	`341`	`+ NetworkOrderSerializer.WriteSingle(slice.Span, val);`
`342`	`342`	`return 5;`
`343`	`343`	`case long val:`
`344`	`344`	`memory.Span[0] = (byte)'l';`
`345`		`- NetworkOrderSerializer.WriteInt64(slice, val);`
	`345`	`+ NetworkOrderSerializer.WriteInt64(slice.Span, val);`
`346`	`346`	`return 9;`
`347`	`347`	`case short val:`
`348`	`348`	`memory.Span[0] = (byte)'s';`
`349`		`- NetworkOrderSerializer.WriteInt16(slice, val);`
	`349`	`+ NetworkOrderSerializer.WriteInt16(slice.Span, val);`
`350`	`350`	`return 3;`
`351`	`351`	`case bool val:`
`352`	`352`	`memory.Span[0] = (byte)'t';`
`@@ -399,13 +399,13 @@ public static int GetFieldValueByteCount(object value)`
`399`	`399`
`400`	`400`	`public static int WriteLong(Memory<byte> memory, uint val)`
`401`	`401`	`{`
`402`		`- NetworkOrderSerializer.WriteUInt32(memory, val);`
	`402`	`+ NetworkOrderSerializer.WriteUInt32(memory.Span, val);`
`403`	`403`	`return 4;`
`404`	`404`	`}`
`405`	`405`
`406`	`406`	`public static int WriteLonglong(Memory<byte> memory, ulong val)`
`407`	`407`	`{`
`408`		`- NetworkOrderSerializer.WriteUInt64(memory, val);`
	`408`	`+ NetworkOrderSerializer.WriteUInt64(memory.Span, val);`
`409`	`409`	`return 8;`
`410`	`410`	`}`
`411`	`411`
`@@ -423,7 +423,7 @@ public static int WriteLongstr(Memory<byte> memory, byte[] val, int index, int c`
`423`	`423`
`424`	`424`	`public static int WriteShort(Memory<byte> memory, ushort val)`
`425`	`425`	`{`
`426`		`- NetworkOrderSerializer.WriteUInt16(memory, val);`
	`426`	`+ NetworkOrderSerializer.WriteUInt16(memory.Span, val);`
`427`	`427`	`return 2;`
`428`	`428`	`}`
`429`	`429`
`@@ -448,7 +448,7 @@ public static int WriteTable(Memory<byte> memory, IDictionary val)`
`448`	`448`	`{`
`449`	`449`	`if (val == null)`
`450`	`450`	`{`
`451`		`- NetworkOrderSerializer.WriteUInt32(memory, 0);`
	`451`	`+ NetworkOrderSerializer.WriteUInt32(memory.Span, 0);`
`452`	`452`	`return 4;`
`453`	`453`	`}`
`454`	`454`	`else`
`@@ -462,7 +462,7 @@ public static int WriteTable(Memory<byte> memory, IDictionary val)`
`462`	`462`	`bytesWritten += WriteFieldValue(slice.Slice(bytesWritten), entry.Value);`
`463`	`463`	`}`
`464`	`464`
`465`		`- NetworkOrderSerializer.WriteUInt32(memory, (uint)bytesWritten);`
	`465`	`+ NetworkOrderSerializer.WriteUInt32(memory.Span, (uint)bytesWritten);`
`466`	`466`	`return 4 + bytesWritten;`
`467`	`467`	`}`
`468`	`468`	`}`
`@@ -471,7 +471,7 @@ public static int WriteTable(Memory<byte> memory, IDictionary<string, object> va`
`471`	`471`	`{`
`472`	`472`	`if (val == null)`
`473`	`473`	`{`
`474`		`- NetworkOrderSerializer.WriteUInt32(memory, 0);`
	`474`	`+ NetworkOrderSerializer.WriteUInt32(memory.Span, 0);`
`475`	`475`	`return 4;`
`476`	`476`	`}`
`477`	`477`	`else`
`@@ -485,7 +485,7 @@ public static int WriteTable(Memory<byte> memory, IDictionary<string, object> va`
`485`	`485`	`bytesWritten += WriteFieldValue(slice.Slice(bytesWritten), entry.Value);`
`486`	`486`	`}`
`487`	`487`
`488`		`- NetworkOrderSerializer.WriteUInt32(memory, (uint)bytesWritten);`
	`488`	`+ NetworkOrderSerializer.WriteUInt32(memory.Span, (uint)bytesWritten);`
`489`	`489`	`return 4 + bytesWritten;`
`490`	`490`	`}`
`491`	`491`	`}`