spanification of WireFormatting & Reader/Writer

bollhals · bollhals · commit d0d30327869b · 2020-06-02T21:50:29.000+02:00
diff --git a/projects/Apigen/apigen/Apigen.cs b/projects/Apigen/apigen/Apigen.cs
@@ -952,14 +952,14 @@ public void EmitClassMethodImplementations(AmqpClass c)
 
         public void EmitMethodArgumentReader()
         {
-            EmitLine("    internal override Client.Impl.MethodBase DecodeMethodFrom(ReadOnlyMemory<byte> memory)");
+            EmitLine("    internal override Client.Impl.MethodBase DecodeMethodFrom(ReadOnlySpan<byte> span)");
             EmitLine("    {");
-            EmitLine("      ushort classId = Util.NetworkOrderDeserializer.ReadUInt16(memory.Span);");
-            EmitLine("      ushort methodId = Util.NetworkOrderDeserializer.ReadUInt16(memory.Slice(2).Span);");
+            EmitLine("      ushort classId = Util.NetworkOrderDeserializer.ReadUInt16(span);");
+            EmitLine("      ushort methodId = Util.NetworkOrderDeserializer.ReadUInt16(span.Slice(2));");
             EmitLine("      Client.Impl.MethodBase result = DecodeMethodFrom(classId, methodId);");
             EmitLine("      if(result != null)");
             EmitLine("      {");
-            EmitLine("        Client.Impl.MethodArgumentReader reader = new Client.Impl.MethodArgumentReader(memory.Slice(4));");
+            EmitLine("        Client.Impl.MethodArgumentReader reader = new Client.Impl.MethodArgumentReader(span.Slice(4));");
             EmitLine("        result.ReadArgumentsFrom(ref reader);");
             EmitLine("        return result;");
             EmitLine("      }");
diff --git a/projects/RabbitMQ.Client/client/impl/CommandAssembler.cs b/projects/RabbitMQ.Client/client/impl/CommandAssembler.cs
@@ -81,16 +81,18 @@ public Command HandleFrame(in InboundFrame f)
                     {
                         throw new UnexpectedFrameException(f.Type);
                     }
-                    m_method = m_protocol.DecodeMethodFrom(f.Payload);
+                    m_method = m_protocol.DecodeMethodFrom(f.Payload.Span);
                     m_state = m_method.HasContent ? AssemblyState.ExpectingContentHeader : AssemblyState.Complete;
                     return CompletedCommand();
                 case AssemblyState.ExpectingContentHeader:
                     if (!f.IsHeader())
                     {
                         throw new UnexpectedFrameException(f.Type);
                     }
-                    m_header = m_protocol.DecodeContentHeaderFrom(NetworkOrderDeserializer.ReadUInt16(f.Payload.Span));
-                    ulong totalBodyBytes = m_header.ReadFrom(f.Payload.Slice(2));
+
+                    ReadOnlySpan<byte> span = f.Payload.Span;
+                    m_header = m_protocol.DecodeContentHeaderFrom(NetworkOrderDeserializer.ReadUInt16(span));
+                    ulong totalBodyBytes = m_header.ReadFrom(span.Slice(2));
                     if (totalBodyBytes > MaxArrayOfBytesSize)
                     {
                         throw new UnexpectedFrameException(f.Type);
diff --git a/projects/RabbitMQ.Client/client/impl/ContentHeaderBase.cs b/projects/RabbitMQ.Client/client/impl/ContentHeaderBase.cs
@@ -67,11 +67,11 @@ public virtual object Clone()
         ///<summary>
         /// Fill this instance from the given byte buffer stream.
         ///</summary>
-        internal ulong ReadFrom(ReadOnlyMemory<byte> memory)
+        internal ulong ReadFrom(ReadOnlySpan<byte> span)
         {
             // Skipping the first two bytes since they arent used (weight - not currently used)
-            ulong bodySize = NetworkOrderDeserializer.ReadUInt64(memory.Slice(2).Span);
-            ContentHeaderPropertyReader reader = new ContentHeaderPropertyReader(memory.Slice(10));
+            ulong bodySize = NetworkOrderDeserializer.ReadUInt64(span.Slice(2));
+            ContentHeaderPropertyReader reader = new ContentHeaderPropertyReader(span.Slice(10));
             ReadPropertiesFrom(ref reader);
             return bodySize;
         }
@@ -81,13 +81,12 @@ internal ulong ReadFrom(ReadOnlyMemory<byte> memory)
 
         private const ushort ZERO = 0;
 
-        internal int WriteTo(Memory<byte> memory, ulong bodySize)
+        internal int WriteTo(Span<byte> span, ulong bodySize)
         {
-            var span = memory.Span;
             NetworkOrderSerializer.WriteUInt16(span, ZERO); // Weight - not used
             NetworkOrderSerializer.WriteUInt64(span.Slice(2), bodySize);
 
-            ContentHeaderPropertyWriter writer = new ContentHeaderPropertyWriter(memory.Slice(10));
+            ContentHeaderPropertyWriter writer = new ContentHeaderPropertyWriter(span.Slice(10));
             WritePropertiesTo(ref writer);
             return 10 + writer.Offset;
         }
diff --git a/projects/RabbitMQ.Client/client/impl/ContentHeaderPropertyReader.cs b/projects/RabbitMQ.Client/client/impl/ContentHeaderPropertyReader.cs
@@ -50,19 +50,16 @@ internal ref struct ContentHeaderPropertyReader
         private const int StartBitMask = 0b1000_0000_0000_0000;
         private const int EndBitMask = 0b0000_0000_0000_0001;
 
-        private readonly ReadOnlyMemory<byte> _memory;
         private readonly ReadOnlySpan<byte> _span;
         private int _offset;
         private int _bitMask;
         private int _bits;
         
         private ReadOnlySpan<byte> Span => _span.Slice(_offset);
-        private ReadOnlyMemory<byte> Memory => _memory.Slice(_offset);
 
-        public ContentHeaderPropertyReader(ReadOnlyMemory<byte> memory)
+        public ContentHeaderPropertyReader(ReadOnlySpan<byte> span)
         {
-            _memory = memory;
-            _span = memory.Span;
+            _span = span;
             _offset = 0;
             _bitMask = EndBitMask; // force a flag read
             _bits = 1; // just the continuation bit
@@ -141,15 +138,15 @@ public ushort ReadShort()
 
         public string ReadShortstr()
         {
-            string result = WireFormatting.ReadShortstr(Memory, out int bytesRead);
+            string result = WireFormatting.ReadShortstr(Span, out int bytesRead);
             _offset += bytesRead;
             return result;
         }
 
         /// <returns>A type of <seealso cref="System.Collections.Generic.IDictionary{TKey,TValue}"/>.</returns>
         public Dictionary<string, object> ReadTable()
         {
-            Dictionary<string, object> result = WireFormatting.ReadTable(Memory, out int bytesRead);
+            Dictionary<string, object> result = WireFormatting.ReadTable(Span, out int bytesRead);
             _offset += bytesRead;
             return result;
         }
diff --git a/projects/RabbitMQ.Client/client/impl/ContentHeaderPropertyWriter.cs b/projects/RabbitMQ.Client/client/impl/ContentHeaderPropertyWriter.cs
@@ -50,7 +50,6 @@ internal ref struct ContentHeaderPropertyWriter
         private const ushort StartBitMask = 0b1000_0000_0000_0000;
         private const ushort EndBitMask = 0b0000_0000_0000_0001;
 
-        private readonly Memory<byte> _memory;
         private readonly Span<byte> _span;
         private int _offset;
         private ushort _bitAccumulator;
@@ -59,12 +58,10 @@ internal ref struct ContentHeaderPropertyWriter
         public int Offset => _offset;
 
         private Span<byte> Span => _span.Slice(_offset);
-        private Memory<byte> Memory => _memory.Slice(_offset);
 
-        public ContentHeaderPropertyWriter(Memory<byte> memory)
+        public ContentHeaderPropertyWriter(Span<byte> span)
         {
-            _memory = memory;
-            _span = _memory.Span;
+            _span = span;
             _offset = 0;
             _bitAccumulator = 0;
             _bitMask = StartBitMask;
@@ -124,12 +121,12 @@ public void WriteShort(ushort val)
 
         public void WriteShortstr(string val)
         {
-            _offset += WireFormatting.WriteShortstr(Memory, val);
+            _offset += WireFormatting.WriteShortstr(Span, val);
         }
 
         public void WriteTable(IDictionary<string, object> val)
         {
-            _offset += WireFormatting.WriteTable(Memory, val);
+            _offset += WireFormatting.WriteTable(Span, val);
         }
 
         public void WriteTimestamp(AmqpTimestamp val)
diff --git a/projects/RabbitMQ.Client/client/impl/Frame.cs b/projects/RabbitMQ.Client/client/impl/Frame.cs
@@ -66,12 +66,12 @@ internal override int GetMinimumPayloadBufferSize()
             return 2 + _header.GetRequiredBufferSize();
         }
 
-        internal override int WritePayload(Memory<byte> memory)
+        internal override int WritePayload(Span<byte> span)
         {
             // write protocol class id (2 bytes)
-            NetworkOrderSerializer.WriteUInt16(memory.Span, _header.ProtocolClassId);
+            NetworkOrderSerializer.WriteUInt16(span, _header.ProtocolClassId);
             // write header (X bytes)
-            int bytesWritten = _header.WriteTo(memory.Slice(2), (ulong)_bodyLength);
+            int bytesWritten = _header.WriteTo(span.Slice(2), (ulong)_bodyLength);
             return bytesWritten + 2;
         }
     }
@@ -90,9 +90,9 @@ internal override int GetMinimumPayloadBufferSize()
             return _body.Length;
         }
 
-        internal override int WritePayload(Memory<byte> memory)
+        internal override int WritePayload(Span<byte> span)
         {
-            _body.CopyTo(memory);
+            _body.Span.CopyTo(span);
             return _body.Length;
         }
     }
@@ -112,12 +112,11 @@ internal override int GetMinimumPayloadBufferSize()
             return 4 + _method.GetRequiredBufferSize();
         }
 
-        internal override int WritePayload(Memory<byte> memory)
+        internal override int WritePayload(Span<byte> span)
         {
-            var span = memory.Span;
             NetworkOrderSerializer.WriteUInt16(span, _method.ProtocolClassId);
             NetworkOrderSerializer.WriteUInt16(span.Slice(2), _method.ProtocolMethodId);
-            var argWriter = new MethodArgumentWriter(memory.Slice(4));
+            var argWriter = new MethodArgumentWriter(span.Slice(4));
             _method.WriteArgumentsTo(ref argWriter);
             return 4 + argWriter.Offset;
         }
@@ -134,7 +133,7 @@ internal override int GetMinimumPayloadBufferSize()
             return 0;
         }
 
-        internal override int WritePayload(Memory<byte> memory)
+        internal override int WritePayload(Span<byte> span)
         {
             return 0;
         }
@@ -151,17 +150,16 @@ protected OutboundFrame(FrameType type, int channel)
             Channel = channel;
         }
 
-        internal void WriteTo(Memory<byte> memory)
+        internal void WriteTo(Span<byte> span)
         {
-            var span = memory.Span;
             span[0] = (byte)Type;
             NetworkOrderSerializer.WriteUInt16(span.Slice(1), (ushort)Channel);
-            int bytesWritten = WritePayload(memory.Slice(7));
+            int bytesWritten = WritePayload(span.Slice(7));
             NetworkOrderSerializer.WriteUInt32(span.Slice(3), (uint)bytesWritten);
             span[bytesWritten + 7] = Constants.FrameEnd;
         }
 
-        internal abstract int WritePayload(Memory<byte> memory);
+        internal abstract int WritePayload(Span<byte> span);
         internal abstract int GetMinimumPayloadBufferSize();
         internal int GetMinimumBufferSize()
         {
diff --git a/projects/RabbitMQ.Client/client/impl/MainSession.cs b/projects/RabbitMQ.Client/client/impl/MainSession.cs
@@ -84,7 +84,7 @@ public override void HandleFrame(in InboundFrame frame)
 
             if (!_closeServerInitiated && frame.IsMethod())
             {
-                MethodBase method = Connection.Protocol.DecodeMethodFrom(frame.Payload);
+                MethodBase method = Connection.Protocol.DecodeMethodFrom(frame.Payload.Span);
                 if ((method.ProtocolClassId == _closeClassId)
                     && (method.ProtocolMethodId == _closeMethodId))
                 {
diff --git a/projects/RabbitMQ.Client/client/impl/MethodArgumentReader.cs b/projects/RabbitMQ.Client/client/impl/MethodArgumentReader.cs
@@ -47,19 +47,16 @@ namespace RabbitMQ.Client.Impl
 {
     internal ref struct MethodArgumentReader
     {
-        private readonly ReadOnlyMemory<byte> _memory;
         private readonly ReadOnlySpan<byte> _span;
         private int _offset;
         private int _bitMask;
         private int _bits;
         
         private ReadOnlySpan<byte> Span => _span.Slice(_offset);
-        private ReadOnlyMemory<byte> Memory => _memory.Slice(_offset);
 
-        public MethodArgumentReader(ReadOnlyMemory<byte> memory)
+        public MethodArgumentReader(ReadOnlySpan<byte> span)
         {
-            _memory = memory;
-            _span = memory.Span;
+            _span = span;
             _offset = 0;
             _bitMask = 0;
             _bits = 0;
@@ -119,14 +116,14 @@ public ushort ReadShort()
 
         public string ReadShortstr()
         {
-            string result = WireFormatting.ReadShortstr(Memory, out int bytesRead);
+            string result = WireFormatting.ReadShortstr(Span, out int bytesRead);
             _offset += bytesRead;
             return result;
         }
 
         public Dictionary<string, object> ReadTable()
         {
-            Dictionary<string, object> result = WireFormatting.ReadTable(Memory, out int bytesRead);
+            Dictionary<string, object> result = WireFormatting.ReadTable(Span, out int bytesRead);
             _offset += bytesRead;
             return result;
         }
diff --git a/projects/RabbitMQ.Client/client/impl/MethodArgumentWriter.cs b/projects/RabbitMQ.Client/client/impl/MethodArgumentWriter.cs
@@ -46,7 +46,6 @@ namespace RabbitMQ.Client.Impl
 {
     internal ref struct MethodArgumentWriter
     {
-        private readonly Memory<byte> _memory;
         private readonly Span<byte> _span;
         private int _offset;
         private int _bitAccumulator;
@@ -55,12 +54,10 @@ internal ref struct MethodArgumentWriter
         public int Offset => _offset;
 
         private Span<byte> Span => _span.Slice(_offset);
-        private Memory<byte> Memory => _memory.Slice(_offset);
 
-        public MethodArgumentWriter(Memory<byte> memory)
+        public MethodArgumentWriter(Span<byte> span)
         {
-            _memory = memory;
-            _span = memory.Span;
+            _span = span;
             _offset = 0;
             _bitAccumulator = 0;
             _bitMask = 1;
@@ -117,17 +114,17 @@ public void WriteShort(ushort val)
 
         public void WriteShortstr(string val)
         {
-            _offset += WireFormatting.WriteShortstr(Memory, val);
+            _offset += WireFormatting.WriteShortstr(Span, val);
         }
 
         public void WriteTable(IDictionary val)
         {
-            _offset += WireFormatting.WriteTable(Memory, val);
+            _offset += WireFormatting.WriteTable(Span, val);
         }
 
         public void WriteTable(IDictionary<string, object> val)
         {
-            _offset += WireFormatting.WriteTable(Memory, val);
+            _offset += WireFormatting.WriteTable(Span, val);
         }
 
         public void WriteTimestamp(AmqpTimestamp val)
diff --git a/projects/RabbitMQ.Client/client/impl/ProtocolBase.cs b/projects/RabbitMQ.Client/client/impl/ProtocolBase.cs
@@ -106,7 +106,7 @@ public void CreateConnectionClose(ushort reasonCode,
         }
 
         internal abstract ContentHeaderBase DecodeContentHeaderFrom(ushort classId);
-        internal abstract MethodBase DecodeMethodFrom(ReadOnlyMemory<byte> reader);
+        internal abstract MethodBase DecodeMethodFrom(ReadOnlySpan<byte> reader);
 
         public override bool Equals(object obj)
         {
diff --git a/projects/RabbitMQ.Client/client/impl/QuiescingSession.cs b/projects/RabbitMQ.Client/client/impl/QuiescingSession.cs
@@ -59,7 +59,7 @@ public override void HandleFrame(in InboundFrame frame)
         {
             if (frame.IsMethod())
             {
-                MethodBase method = Connection.Protocol.DecodeMethodFrom(frame.Payload);
+                MethodBase method = Connection.Protocol.DecodeMethodFrom(frame.Payload.Span);
                 if ((method.ProtocolClassId == ClassConstants.Channel)
                     && (method.ProtocolMethodId == ChannelMethodConstants.CloseOk))
                 {
diff --git a/projects/RabbitMQ.Client/client/impl/SocketFrameHandler.cs b/projects/RabbitMQ.Client/client/impl/SocketFrameHandler.cs
@@ -252,8 +252,7 @@ public async Task WriteFrameImpl()
                 {
                     int bufferSize = frame.GetMinimumBufferSize();
                     byte[] memoryArray = ArrayPool<byte>.Shared.Rent(bufferSize);
-                    Memory<byte> slice = new Memory<byte>(memoryArray, 0, bufferSize);
-                    frame.WriteTo(slice);
+                    frame.WriteTo(new Span<byte>(memoryArray, 0, bufferSize));
                     _writer.Write(memoryArray, 0, bufferSize);
                     ArrayPool<byte>.Shared.Return(memoryArray);
                 }
diff --git a/projects/RabbitMQ.Client/client/impl/WireFormatting.cs b/projects/RabbitMQ.Client/client/impl/WireFormatting.cs
diff --git a/projects/Unit/TestBasicProperties.cs b/projects/Unit/TestBasicProperties.cs
diff --git a/projects/Unit/TestFieldTableFormatting.cs b/projects/Unit/TestFieldTableFormatting.cs

Original file line number	Diff line number	Diff line change
`@@ -81,16 +81,18 @@ public Command HandleFrame(in InboundFrame f)`
`81`	`81`	`{`
`82`	`82`	`throw new UnexpectedFrameException(f.Type);`
`83`	`83`	`}`
`84`		`- m_method = m_protocol.DecodeMethodFrom(f.Payload);`
	`84`	`+ m_method = m_protocol.DecodeMethodFrom(f.Payload.Span);`
`85`	`85`	`m_state = m_method.HasContent ? AssemblyState.ExpectingContentHeader : AssemblyState.Complete;`
`86`	`86`	`return CompletedCommand();`
`87`	`87`	`case AssemblyState.ExpectingContentHeader:`
`88`	`88`	`if (!f.IsHeader())`
`89`	`89`	`{`
`90`	`90`	`throw new UnexpectedFrameException(f.Type);`
`91`	`91`	`}`
`92`		`- m_header = m_protocol.DecodeContentHeaderFrom(NetworkOrderDeserializer.ReadUInt16(f.Payload.Span));`
`93`		`- ulong totalBodyBytes = m_header.ReadFrom(f.Payload.Slice(2));`
	`92`	`+`
	`93`	`+ ReadOnlySpan<byte> span = f.Payload.Span;`
	`94`	`+ m_header = m_protocol.DecodeContentHeaderFrom(NetworkOrderDeserializer.ReadUInt16(span));`
	`95`	`+ ulong totalBodyBytes = m_header.ReadFrom(span.Slice(2));`
`94`	`96`	`if (totalBodyBytes > MaxArrayOfBytesSize)`
`95`	`97`	`{`
`96`	`98`	`throw new UnexpectedFrameException(f.Type);`
Original file line number	Diff line number	Diff line change
`@@ -66,12 +66,12 @@ internal override int GetMinimumPayloadBufferSize()`
`66`	`66`	`return 2 + _header.GetRequiredBufferSize();`
`67`	`67`	`}`
`68`	`68`
`69`		`- internal override int WritePayload(Memory<byte> memory)`
	`69`	`+ internal override int WritePayload(Span<byte> span)`
`70`	`70`	`{`
`71`	`71`	`// write protocol class id (2 bytes)`
`72`		`- NetworkOrderSerializer.WriteUInt16(memory.Span, _header.ProtocolClassId);`
	`72`	`+ NetworkOrderSerializer.WriteUInt16(span, _header.ProtocolClassId);`
`73`	`73`	`// write header (X bytes)`
`74`		`- int bytesWritten = _header.WriteTo(memory.Slice(2), (ulong)_bodyLength);`
	`74`	`+ int bytesWritten = _header.WriteTo(span.Slice(2), (ulong)_bodyLength);`
`75`	`75`	`return bytesWritten + 2;`
`76`	`76`	`}`
`77`	`77`	`}`
`@@ -90,9 +90,9 @@ internal override int GetMinimumPayloadBufferSize()`
`90`	`90`	`return _body.Length;`
`91`	`91`	`}`
`92`	`92`
`93`		`- internal override int WritePayload(Memory<byte> memory)`
	`93`	`+ internal override int WritePayload(Span<byte> span)`
`94`	`94`	`{`
`95`		`- _body.CopyTo(memory);`
	`95`	`+ _body.Span.CopyTo(span);`
`96`	`96`	`return _body.Length;`
`97`	`97`	`}`
`98`	`98`	`}`
`@@ -112,12 +112,11 @@ internal override int GetMinimumPayloadBufferSize()`
`112`	`112`	`return 4 + _method.GetRequiredBufferSize();`
`113`	`113`	`}`
`114`	`114`
`115`		`- internal override int WritePayload(Memory<byte> memory)`
	`115`	`+ internal override int WritePayload(Span<byte> span)`
`116`	`116`	`{`
`117`		`- var span = memory.Span;`
`118`	`117`	`NetworkOrderSerializer.WriteUInt16(span, _method.ProtocolClassId);`
`119`	`118`	`NetworkOrderSerializer.WriteUInt16(span.Slice(2), _method.ProtocolMethodId);`
`120`		`- var argWriter = new MethodArgumentWriter(memory.Slice(4));`
	`119`	`+ var argWriter = new MethodArgumentWriter(span.Slice(4));`
`121`	`120`	`_method.WriteArgumentsTo(ref argWriter);`
`122`	`121`	`return 4 + argWriter.Offset;`
`123`	`122`	`}`
`@@ -134,7 +133,7 @@ internal override int GetMinimumPayloadBufferSize()`
`134`	`133`	`return 0;`
`135`	`134`	`}`
`136`	`135`
`137`		`- internal override int WritePayload(Memory<byte> memory)`
	`136`	`+ internal override int WritePayload(Span<byte> span)`
`138`	`137`	`{`
`139`	`138`	`return 0;`
`140`	`139`	`}`
`@@ -151,17 +150,16 @@ protected OutboundFrame(FrameType type, int channel)`
`151`	`150`	`Channel = channel;`
`152`	`151`	`}`
`153`	`152`
`154`		`- internal void WriteTo(Memory<byte> memory)`
	`153`	`+ internal void WriteTo(Span<byte> span)`
`155`	`154`	`{`
`156`		`- var span = memory.Span;`
`157`	`155`	`span[0] = (byte)Type;`
`158`	`156`	`NetworkOrderSerializer.WriteUInt16(span.Slice(1), (ushort)Channel);`
`159`		`- int bytesWritten = WritePayload(memory.Slice(7));`
	`157`	`+ int bytesWritten = WritePayload(span.Slice(7));`
`160`	`158`	`NetworkOrderSerializer.WriteUInt32(span.Slice(3), (uint)bytesWritten);`
`161`	`159`	`span[bytesWritten + 7] = Constants.FrameEnd;`
`162`	`160`	`}`
`163`	`161`
`164`		`- internal abstract int WritePayload(Memory<byte> memory);`
	`162`	`+ internal abstract int WritePayload(Span<byte> span);`
`165`	`163`	`internal abstract int GetMinimumPayloadBufferSize();`
`166`	`164`	`internal int GetMinimumBufferSize()`
`167`	`165`	`{`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ public override void HandleFrame(in InboundFrame frame)`
`84`	`84`
`85`	`85`	`if (!_closeServerInitiated && frame.IsMethod())`
`86`	`86`	`{`
`87`		`- MethodBase method = Connection.Protocol.DecodeMethodFrom(frame.Payload);`
	`87`	`+ MethodBase method = Connection.Protocol.DecodeMethodFrom(frame.Payload.Span);`
`88`	`88`	`if ((method.ProtocolClassId == _closeClassId)`
`89`	`89`	`&& (method.ProtocolMethodId == _closeMethodId))`
`90`	`90`	`{`
Original file line number	Diff line number	Diff line change
`@@ -47,19 +47,16 @@ namespace RabbitMQ.Client.Impl`
`47`	`47`	`{`
`48`	`48`	`internal ref struct MethodArgumentReader`
`49`	`49`	`{`
`50`		`- private readonly ReadOnlyMemory<byte> _memory;`
`51`	`50`	`private readonly ReadOnlySpan<byte> _span;`
`52`	`51`	`private int _offset;`
`53`	`52`	`private int _bitMask;`
`54`	`53`	`private int _bits;`
`55`	`54`
`56`	`55`	`private ReadOnlySpan<byte> Span => _span.Slice(_offset);`
`57`		`- private ReadOnlyMemory<byte> Memory => _memory.Slice(_offset);`
`58`	`56`
`59`		`- public MethodArgumentReader(ReadOnlyMemory<byte> memory)`
	`57`	`+ public MethodArgumentReader(ReadOnlySpan<byte> span)`
`60`	`58`	`{`
`61`		`- _memory = memory;`
`62`		`- _span = memory.Span;`
	`59`	`+ _span = span;`
`63`	`60`	`_offset = 0;`
`64`	`61`	`_bitMask = 0;`
`65`	`62`	`_bits = 0;`
`@@ -119,14 +116,14 @@ public ushort ReadShort()`
`119`	`116`
`120`	`117`	`public string ReadShortstr()`
`121`	`118`	`{`
`122`		`- string result = WireFormatting.ReadShortstr(Memory, out int bytesRead);`
	`119`	`+ string result = WireFormatting.ReadShortstr(Span, out int bytesRead);`
`123`	`120`	`_offset += bytesRead;`
`124`	`121`	`return result;`
`125`	`122`	`}`
`126`	`123`
`127`	`124`	`public Dictionary<string, object> ReadTable()`
`128`	`125`	`{`
`129`		`- Dictionary<string, object> result = WireFormatting.ReadTable(Memory, out int bytesRead);`
	`126`	`+ Dictionary<string, object> result = WireFormatting.ReadTable(Span, out int bytesRead);`
`130`	`127`	`_offset += bytesRead;`
`131`	`128`	`return result;`
`132`	`129`	`}`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,6 @@ namespace RabbitMQ.Client.Impl`
`46`	`46`	`{`
`47`	`47`	`internal ref struct MethodArgumentWriter`
`48`	`48`	`{`
`49`		`- private readonly Memory<byte> _memory;`
`50`	`49`	`private readonly Span<byte> _span;`
`51`	`50`	`private int _offset;`
`52`	`51`	`private int _bitAccumulator;`
`@@ -55,12 +54,10 @@ internal ref struct MethodArgumentWriter`
`55`	`54`	`public int Offset => _offset;`
`56`	`55`
`57`	`56`	`private Span<byte> Span => _span.Slice(_offset);`
`58`		`- private Memory<byte> Memory => _memory.Slice(_offset);`
`59`	`57`
`60`		`- public MethodArgumentWriter(Memory<byte> memory)`
	`58`	`+ public MethodArgumentWriter(Span<byte> span)`
`61`	`59`	`{`
`62`		`- _memory = memory;`
`63`		`- _span = memory.Span;`
	`60`	`+ _span = span;`
`64`	`61`	`_offset = 0;`
`65`	`62`	`_bitAccumulator = 0;`
`66`	`63`	`_bitMask = 1;`
`@@ -117,17 +114,17 @@ public void WriteShort(ushort val)`
`117`	`114`
`118`	`115`	`public void WriteShortstr(string val)`
`119`	`116`	`{`
`120`		`- _offset += WireFormatting.WriteShortstr(Memory, val);`
	`117`	`+ _offset += WireFormatting.WriteShortstr(Span, val);`
`121`	`118`	`}`
`122`	`119`
`123`	`120`	`public void WriteTable(IDictionary val)`
`124`	`121`	`{`
`125`		`- _offset += WireFormatting.WriteTable(Memory, val);`
	`122`	`+ _offset += WireFormatting.WriteTable(Span, val);`
`126`	`123`	`}`
`127`	`124`
`128`	`125`	`public void WriteTable(IDictionary<string, object> val)`
`129`	`126`	`{`
`130`		`- _offset += WireFormatting.WriteTable(Memory, val);`
	`127`	`+ _offset += WireFormatting.WriteTable(Span, val);`
`131`	`128`	`}`
`132`	`129`
`133`	`130`	`public void WriteTimestamp(AmqpTimestamp val)`
Original file line number	Diff line number	Diff line change
`@@ -106,7 +106,7 @@ public void CreateConnectionClose(ushort reasonCode,`
`106`	`106`	`}`
`107`	`107`
`108`	`108`	`internal abstract ContentHeaderBase DecodeContentHeaderFrom(ushort classId);`
`109`		`- internal abstract MethodBase DecodeMethodFrom(ReadOnlyMemory<byte> reader);`
	`109`	`+ internal abstract MethodBase DecodeMethodFrom(ReadOnlySpan<byte> reader);`
`110`	`110`
`111`	`111`	`public override bool Equals(object obj)`
`112`	`112`	`{`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ public override void HandleFrame(in InboundFrame frame)`
`59`	`59`	`{`
`60`	`60`	`if (frame.IsMethod())`
`61`	`61`	`{`
`62`		`- MethodBase method = Connection.Protocol.DecodeMethodFrom(frame.Payload);`
	`62`	`+ MethodBase method = Connection.Protocol.DecodeMethodFrom(frame.Payload.Span);`
`63`	`63`	`if ((method.ProtocolClassId == ClassConstants.Channel)`
`64`	`64`	`&& (method.ProtocolMethodId == ChannelMethodConstants.CloseOk))`
`65`	`65`	`{`
Original file line number	Diff line number	Diff line change
`@@ -252,8 +252,7 @@ public async Task WriteFrameImpl()`
`252`	`252`	`{`
`253`	`253`	`int bufferSize = frame.GetMinimumBufferSize();`
`254`	`254`	`byte[] memoryArray = ArrayPool<byte>.Shared.Rent(bufferSize);`
`255`		`- Memory<byte> slice = new Memory<byte>(memoryArray, 0, bufferSize);`
`256`		`- frame.WriteTo(slice);`
	`255`	`+ frame.WriteTo(new Span<byte>(memoryArray, 0, bufferSize));`
`257`	`256`	`_writer.Write(memoryArray, 0, bufferSize);`
`258`	`257`	`ArrayPool<byte>.Shared.Return(memoryArray);`
`259`	`258`	`}`