replace seq.Slice(offset) with seq[offset..] (#182)

Gsantomaggio · web-flow · commit 656fcaa08791 · 2022-11-15T10:55:05.000+01:00
Improve the publish

- replace seq.Slice(offset) with seq[offset..]
- Add AggressiveInlining to the main send functions
- Add AggressiveInlining to write functions
- Tune the performance test increasing the messages buffer

Signed-off-by: Gabriele Santomaggio &lt;G.santomaggio@gmail.com&gt;
diff --git a/RabbitMQ.Stream.Client.PerfTest/Program.fs b/RabbitMQ.Stream.Client.PerfTest/Program.fs
@@ -37,6 +37,7 @@ let main argv =
         let producerConfig = RawProducerConfig(streamName,
                                             Reference = null,
                                             MaxInFlight = 10000,
+                                            MessagesBufferSize = 10000,
                                             ConfirmHandler = fun c -> confirmed <- confirmed + 1)
         let! producer = system.CreateRawProducer producerConfig
         //make producer available to metrics async
diff --git a/RabbitMQ.Stream.Client/AMQP/AmqpWireFormattingRead.cs b/RabbitMQ.Stream.Client/AMQP/AmqpWireFormattingRead.cs
@@ -182,7 +182,7 @@ internal static int ReadString(ref SequenceReader<byte> reader, out string value
                 case FormatCode.Sym32:
                 case FormatCode.Str32:
                     offset += WireFormatting.ReadInt32(ref reader, out var len);
-                    Span<byte> tempSpan32 = len <= 64 ? stackalloc byte[len] : new byte[len];
+                    var tempSpan32 = len <= 64 ? stackalloc byte[len] : new byte[len];
                     reader.TryCopyTo(tempSpan32);
                     reader.Advance(len);
                     value = Encoding.UTF8.GetString(tempSpan32);
diff --git a/RabbitMQ.Stream.Client/AMQP/AmqpWireFormattingWrite.cs b/RabbitMQ.Stream.Client/AMQP/AmqpWireFormattingWrite.cs
@@ -41,16 +41,16 @@ private static int WriteString(Span<byte> seq, string value)
             // Str8
             if (len <= byte.MaxValue)
             {
-                offset += WireFormatting.WriteByte(seq.Slice(offset), FormatCode.Str8);
-                offset += WireFormatting.WriteByte(seq.Slice(offset), (byte)len);
-                offset += s_encoding.GetBytes(value, seq.Slice(offset));
+                offset += WireFormatting.WriteByte(seq[offset..], FormatCode.Str8);
+                offset += WireFormatting.WriteByte(seq[offset..], (byte)len);
+                offset += s_encoding.GetBytes(value, seq[offset..]);
                 return offset;
             }
 
             // Str32
-            offset += WireFormatting.WriteByte(seq.Slice(offset), FormatCode.Str32);
-            offset += WireFormatting.WriteInt32(seq.Slice(offset), len);
-            offset += s_encoding.GetBytes(value, seq.Slice(offset));
+            offset += WireFormatting.WriteByte(seq[offset..], FormatCode.Str32);
+            offset += WireFormatting.WriteInt32(seq[offset..], len);
+            offset += s_encoding.GetBytes(value, seq[offset..]);
             return offset;
         }
 
@@ -64,13 +64,13 @@ private static int WriteUInt64(Span<byte> seq, ulong value)
             var offset = 0;
             if (value < 256)
             {
-                offset += WireFormatting.WriteByte(seq.Slice(offset), FormatCode.SmallUlong);
-                offset += WireFormatting.WriteByte(seq.Slice(offset), (byte)value);
+                offset += WireFormatting.WriteByte(seq[offset..], FormatCode.SmallUlong);
+                offset += WireFormatting.WriteByte(seq[offset..], (byte)value);
                 return offset;
             }
 
-            offset += WireFormatting.WriteByte(seq.Slice(offset), FormatCode.Ulong);
-            offset += WireFormatting.WriteUInt64(seq.Slice(offset), value);
+            offset += WireFormatting.WriteByte(seq[offset..], FormatCode.Ulong);
+            offset += WireFormatting.WriteUInt64(seq[offset..], value);
             return offset;
         }
 
@@ -83,13 +83,13 @@ private static int WriteUInt(Span<byte> seq, uint value)
                 case 0:
                     return WireFormatting.WriteByte(seq, FormatCode.Uint0);
                 case < 256:
-                    offset += WireFormatting.WriteByte(seq.Slice(offset), FormatCode.SmallUint);
-                    offset += WireFormatting.WriteByte(seq.Slice(offset), (byte)value);
+                    offset += WireFormatting.WriteByte(seq[offset..], FormatCode.SmallUint);
+                    offset += WireFormatting.WriteByte(seq[offset..], (byte)value);
                     return offset;
             }
 
-            offset += WireFormatting.WriteByte(seq.Slice(offset), FormatCode.Uint);
-            offset += WireFormatting.WriteUInt32(seq.Slice(offset), value);
+            offset += WireFormatting.WriteByte(seq[offset..], FormatCode.Uint);
+            offset += WireFormatting.WriteUInt32(seq[offset..], value);
             return offset;
         }
 
@@ -98,14 +98,14 @@ private static int WriteInt(Span<byte> seq, int value)
             var offset = 0;
             if (value is < 128 and >= -128)
             {
-                offset += WireFormatting.WriteByte(seq.Slice(offset), FormatCode.Smallint);
-                offset += WireFormatting.WriteByte(seq.Slice(offset), (byte)value);
+                offset += WireFormatting.WriteByte(seq[offset..], FormatCode.Smallint);
+                offset += WireFormatting.WriteByte(seq[offset..], (byte)value);
 
                 return offset;
             }
 
-            offset += WireFormatting.WriteByte(seq.Slice(offset), FormatCode.Int);
-            offset += WireFormatting.WriteInt32(seq.Slice(offset), value);
+            offset += WireFormatting.WriteByte(seq[offset..], FormatCode.Int);
+            offset += WireFormatting.WriteInt32(seq[offset..], value);
             return offset;
         }
 
@@ -114,14 +114,14 @@ private static int WriteInt64(Span<byte> seq, long value)
             var offset = 0;
             if (value is < 128 and >= -128)
             {
-                offset += WireFormatting.WriteByte(seq.Slice(offset), FormatCode.Smalllong);
-                offset += WireFormatting.WriteByte(seq.Slice(offset), (byte)value);
+                offset += WireFormatting.WriteByte(seq[offset..], FormatCode.Smalllong);
+                offset += WireFormatting.WriteByte(seq[offset..], (byte)value);
 
                 return offset;
             }
 
-            offset += WireFormatting.WriteByte(seq.Slice(offset), FormatCode.Long);
-            offset += WireFormatting.WriteInt64(seq.Slice(offset), value);
+            offset += WireFormatting.WriteByte(seq[offset..], FormatCode.Long);
+            offset += WireFormatting.WriteInt64(seq[offset..], value);
             return offset;
         }
 
@@ -138,60 +138,60 @@ private static int WriteBytes(Span<byte> seq, byte[] value)
             // List8
             if (len < 256)
             {
-                offset += WireFormatting.WriteByte(seq.Slice(offset), FormatCode.Vbin8);
-                offset += WireFormatting.WriteByte(seq.Slice(offset), (byte)len);
-                offset += WireFormatting.Write(seq.Slice(offset), new ReadOnlySequence<byte>(value));
+                offset += WireFormatting.WriteByte(seq[offset..], FormatCode.Vbin8);
+                offset += WireFormatting.WriteByte(seq[offset..], (byte)len);
+                offset += WireFormatting.Write(seq[offset..], new ReadOnlySequence<byte>(value));
                 return offset;
             }
 
             // List32
-            offset += WireFormatting.WriteByte(seq.Slice(offset), FormatCode.Vbin32);
-            offset += WireFormatting.WriteUInt32(seq.Slice(offset), (uint)len);
-            offset += WireFormatting.Write(seq.Slice(offset), new ReadOnlySequence<byte>(value));
+            offset += WireFormatting.WriteByte(seq[offset..], FormatCode.Vbin32);
+            offset += WireFormatting.WriteUInt32(seq[offset..], (uint)len);
+            offset += WireFormatting.Write(seq[offset..], new ReadOnlySequence<byte>(value));
             return offset;
         }
 
         private static int WriteUInt16(Span<byte> seq, ushort value)
         {
             var offset = WireFormatting.WriteByte(seq, FormatCode.Ushort);
-            offset += WireFormatting.WriteUInt16(seq.Slice(offset), value);
+            offset += WireFormatting.WriteUInt16(seq[offset..], value);
             return offset;
         }
 
         private static int WriteByte(Span<byte> seq, byte value)
         {
             var offset = WireFormatting.WriteByte(seq, FormatCode.Ubyte);
-            offset += WireFormatting.WriteByte(seq.Slice(offset), value);
+            offset += WireFormatting.WriteByte(seq[offset..], value);
             return offset;
         }
 
         private static int WriteSByte(Span<byte> seq, sbyte value)
         {
             var offset = WireFormatting.WriteByte(seq, FormatCode.Byte);
-            offset += WireFormatting.WriteByte(seq.Slice(offset), (byte)value);
+            offset += WireFormatting.WriteByte(seq[offset..], (byte)value);
             return offset;
         }
 
         private static int WriteFloat(Span<byte> seq, float value)
         {
             var offset = WireFormatting.WriteByte(seq, FormatCode.Float);
             var intFloat = BitConverter.SingleToInt32Bits(value);
-            offset += WireFormatting.WriteInt32(seq.Slice(offset), intFloat);
+            offset += WireFormatting.WriteInt32(seq[offset..], intFloat);
             return offset;
         }
 
         private static int WriteDouble(Span<byte> seq, double value)
         {
             var offset = WireFormatting.WriteByte(seq, FormatCode.Double);
             var intFloat = BitConverter.DoubleToInt64Bits(value);
-            offset += WireFormatting.WriteInt64(seq.Slice(offset), intFloat);
+            offset += WireFormatting.WriteInt64(seq[offset..], intFloat);
             return offset;
         }
 
         private static int WriteIn16(Span<byte> seq, short value)
         {
             var offset = WireFormatting.WriteByte(seq, FormatCode.Short);
-            offset += WireFormatting.WriteInt16(seq.Slice(offset), value);
+            offset += WireFormatting.WriteInt16(seq[offset..], value);
             return offset;
         }
 
@@ -204,7 +204,7 @@ private static int WriteTimestamp(Span<byte> seq, DateTime value)
         {
             var offset = WireFormatting.WriteByte(seq, FormatCode.Timestamp);
             var unixTime = ((DateTimeOffset)value).ToUnixTimeMilliseconds();
-            offset += WireFormatting.WriteUInt64(seq.Slice(offset), (ulong)unixTime);
+            offset += WireFormatting.WriteUInt64(seq[offset..], (ulong)unixTime);
             return offset;
         }
 
diff --git a/RabbitMQ.Stream.Client/AMQP/Data.cs b/RabbitMQ.Stream.Client/AMQP/Data.cs
@@ -32,16 +32,16 @@ public int Write(Span<byte> span)
             var offset = DescribedFormatCode.Write(span, DescribedFormatCode.ApplicationData);
             if (data.Length <= byte.MaxValue)
             {
-                offset += WireFormatting.WriteByte(span.Slice(offset), FormatCode.Vbin8); //binary marker
-                offset += WireFormatting.WriteByte(span.Slice(offset), (byte)data.Length); //length
+                offset += WireFormatting.WriteByte(span[offset..], FormatCode.Vbin8); //binary marker
+                offset += WireFormatting.WriteByte(span[offset..], (byte)data.Length); //length
             }
             else
             {
-                offset += WireFormatting.WriteByte(span.Slice(offset), FormatCode.Vbin32); //binary marker
-                offset += WireFormatting.WriteUInt32(span.Slice(offset), (uint)data.Length); //length
+                offset += WireFormatting.WriteByte(span[offset..], FormatCode.Vbin32); //binary marker
+                offset += WireFormatting.WriteUInt32(span[offset..], (uint)data.Length); //length
             }
 
-            offset += WireFormatting.Write(span.Slice(offset), data);
+            offset += WireFormatting.Write(span[offset..], data);
             return offset;
         }
 
diff --git a/RabbitMQ.Stream.Client/AMQP/DescribedFormatCode.cs b/RabbitMQ.Stream.Client/AMQP/DescribedFormatCode.cs
@@ -15,6 +15,9 @@ public static class DescribedFormatCode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static byte Read(ref SequenceReader<byte> reader)
         {
+            // DescribedFormatCode in this case we need to read 
+            // only the last byte form the header to get the format code
+            // the first can be ignored but it is necessary to read them
             reader.TryRead(out _);
             reader.TryRead(out _);
             reader.TryRead(out var formatCode);
diff --git a/RabbitMQ.Stream.Client/AMQP/Map.cs b/RabbitMQ.Stream.Client/AMQP/Map.cs
@@ -72,15 +72,15 @@ public int Size
         public int Write(Span<byte> span)
         {
             var offset = DescribedFormatCode.Write(span, MapDataCode);
-            offset += WireFormatting.WriteByte(span.Slice(offset), FormatCode.Map32);
-            offset += WireFormatting.WriteUInt32(span.Slice(offset), (uint)MapSize()); // MapSize 
-            offset += WireFormatting.WriteUInt32(span.Slice(offset), (uint)Count * 2); // pair values
+            offset += WireFormatting.WriteByte(span[offset..], FormatCode.Map32);
+            offset += WireFormatting.WriteUInt32(span[offset..], (uint)MapSize()); // MapSize 
+            offset += WireFormatting.WriteUInt32(span[offset..], (uint)Count * 2); // pair values
             foreach (var (key, value) in this)
             {
                 if (!IsNullOrEmptyString(key))
                 {
-                    offset += AmqpWireFormatting.WriteAny(span.Slice(offset), key);
-                    offset += AmqpWireFormatting.WriteAny(span.Slice(offset), value);
+                    offset += AmqpWireFormatting.WriteAny(span[offset..], key);
+                    offset += AmqpWireFormatting.WriteAny(span[offset..], value);
                 }
             }
 
diff --git a/RabbitMQ.Stream.Client/AMQP/Properties.cs b/RabbitMQ.Stream.Client/AMQP/Properties.cs
@@ -132,22 +132,22 @@ public int Size
         public int Write(Span<byte> span)
         {
             var offset = DescribedFormatCode.Write(span, DescribedFormatCode.MessageProperties);
-            offset += WireFormatting.WriteByte(span.Slice(offset), FormatCode.List32);
-            offset += WireFormatting.WriteUInt32(span.Slice(offset), (uint)PropertySize()); // PropertySize 
-            offset += WireFormatting.WriteUInt32(span.Slice(offset), 13); // field numbers
-            offset += AmqpWireFormatting.WriteAny(span.Slice(offset), MessageId);
-            offset += AmqpWireFormatting.WriteAny(span.Slice(offset), UserId);
-            offset += AmqpWireFormatting.WriteAny(span.Slice(offset), To);
-            offset += AmqpWireFormatting.WriteAny(span.Slice(offset), Subject);
-            offset += AmqpWireFormatting.WriteAny(span.Slice(offset), ReplyTo);
-            offset += AmqpWireFormatting.WriteAny(span.Slice(offset), CorrelationId);
-            offset += AmqpWireFormatting.WriteAny(span.Slice(offset), ContentType);
-            offset += AmqpWireFormatting.WriteAny(span.Slice(offset), ContentEncoding);
-            offset += AmqpWireFormatting.WriteAny(span.Slice(offset), AbsoluteExpiryTime);
-            offset += AmqpWireFormatting.WriteAny(span.Slice(offset), CreationTime);
-            offset += AmqpWireFormatting.WriteAny(span.Slice(offset), GroupId);
-            offset += AmqpWireFormatting.WriteAny(span.Slice(offset), GroupSequence);
-            offset += AmqpWireFormatting.WriteAny(span.Slice(offset), ReplyToGroupId);
+            offset += WireFormatting.WriteByte(span[offset..], FormatCode.List32);
+            offset += WireFormatting.WriteUInt32(span[offset..], (uint)PropertySize()); // PropertySize 
+            offset += WireFormatting.WriteUInt32(span[offset..], 13); // field numbers
+            offset += AmqpWireFormatting.WriteAny(span[offset..], MessageId);
+            offset += AmqpWireFormatting.WriteAny(span[offset..], UserId);
+            offset += AmqpWireFormatting.WriteAny(span[offset..], To);
+            offset += AmqpWireFormatting.WriteAny(span[offset..], Subject);
+            offset += AmqpWireFormatting.WriteAny(span[offset..], ReplyTo);
+            offset += AmqpWireFormatting.WriteAny(span[offset..], CorrelationId);
+            offset += AmqpWireFormatting.WriteAny(span[offset..], ContentType);
+            offset += AmqpWireFormatting.WriteAny(span[offset..], ContentEncoding);
+            offset += AmqpWireFormatting.WriteAny(span[offset..], AbsoluteExpiryTime);
+            offset += AmqpWireFormatting.WriteAny(span[offset..], CreationTime);
+            offset += AmqpWireFormatting.WriteAny(span[offset..], GroupId);
+            offset += AmqpWireFormatting.WriteAny(span[offset..], GroupSequence);
+            offset += AmqpWireFormatting.WriteAny(span[offset..], ReplyToGroupId);
             return offset;
         }
     }
diff --git a/RabbitMQ.Stream.Client/Message.cs b/RabbitMQ.Stream.Client/Message.cs
@@ -46,20 +46,20 @@ public int Write(Span<byte> span)
             var offset = 0;
             if (Properties != null)
             {
-                offset += Properties.Write(span.Slice(offset));
+                offset += Properties.Write(span[offset..]);
             }
 
             if (ApplicationProperties != null)
             {
-                offset += ApplicationProperties.Write(span.Slice(offset));
+                offset += ApplicationProperties.Write(span[offset..]);
             }
 
             if (Annotations != null)
             {
-                offset += Annotations.Write(span.Slice(offset));
+                offset += Annotations.Write(span[offset..]);
             }
 
-            offset += Data.Write(span.Slice(offset));
+            offset += Data.Write(span[offset..]);
             return offset;
         }
 
diff --git a/RabbitMQ.Stream.Client/MetaData.cs b/RabbitMQ.Stream.Client/MetaData.cs
@@ -39,13 +39,13 @@ public int Write(Span<byte> span)
         {
             var command = (ICommand)this;
             var offset = WireFormatting.WriteUInt16(span, Key);
-            offset += WireFormatting.WriteUInt16(span.Slice(offset), command.Version);
-            offset += WireFormatting.WriteUInt32(span.Slice(offset), correlationId);
+            offset += WireFormatting.WriteUInt16(span[offset..], command.Version);
+            offset += WireFormatting.WriteUInt32(span[offset..], correlationId);
             // map
-            offset += WireFormatting.WriteInt32(span.Slice(offset), streams.Count());
+            offset += WireFormatting.WriteInt32(span[offset..], streams.Count());
             foreach (var s in streams)
             {
-                offset += WireFormatting.WriteString(span.Slice(offset), s);
+                offset += WireFormatting.WriteString(span[offset..], s);
             }
 
             return offset;
diff --git a/RabbitMQ.Stream.Client/Publish.cs b/RabbitMQ.Stream.Client/Publish.cs
@@ -40,17 +40,17 @@ public Publish(byte publisherId, List<(ulong, Message)> messages)
         public int Write(Span<byte> span)
         {
             var offset = WireFormatting.WriteUInt16(span, Key);
-            offset += WireFormatting.WriteUInt16(span.Slice(offset), Version);
-            offset += WireFormatting.WriteByte(span.Slice(offset), publisherId);
+            offset += WireFormatting.WriteUInt16(span[offset..], Version);
+            offset += WireFormatting.WriteByte(span[offset..], publisherId);
             // this assumes we never write an empty publish frame
-            offset += WireFormatting.WriteInt32(span.Slice(offset), MessageCount);
+            offset += WireFormatting.WriteInt32(span[offset..], MessageCount);
             foreach (var (publishingId, msg) in messages)
             {
-                offset += WireFormatting.WriteUInt64(span.Slice(offset), publishingId);
+                offset += WireFormatting.WriteUInt64(span[offset..], publishingId);
                 // this only write "simple" messages, we assume msg is just the binary body
                 // not stream encoded data
-                offset += WireFormatting.WriteUInt32(span.Slice(offset), (uint)msg.Size);
-                offset += msg.Write(span.Slice(offset));
+                offset += WireFormatting.WriteUInt32(span[offset..], (uint)msg.Size);
+                offset += msg.Write(span[offset..]);
             }
 
             return offset;
diff --git a/RabbitMQ.Stream.Client/RawProducer.cs b/RabbitMQ.Stream.Client/RawProducer.cs
@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Channels;
 using System.Threading.Tasks;
@@ -221,6 +222,7 @@ public bool IsOpen()
             return !_disposed && !_client.IsClosed;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public async ValueTask Send(ulong publishingId, Message message)
         {
             await SemaphoreWait();
@@ -235,9 +237,11 @@ public async ValueTask Send(ulong publishingId, Message message)
             }
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private async Task ProcessBuffer()
         {
             var messages = new List<(ulong, Message)>(_config.MessagesBufferSize);
+
             while (await _messageBuffer.Reader.WaitToReadAsync().ConfigureAwait(false))
             {
                 while (_messageBuffer.Reader.TryRead(out var msg))
diff --git a/RabbitMQ.Stream.Client/Subscribe.cs b/RabbitMQ.Stream.Client/Subscribe.cs
diff --git a/RabbitMQ.Stream.Client/WireFormatting.cs b/RabbitMQ.Stream.Client/WireFormatting.cs

Original file line number	Diff line number	Diff line change
`@@ -41,16 +41,16 @@ private static int WriteString(Span<byte> seq, string value)`
`41`	`41`	`// Str8`
`42`	`42`	`if (len <= byte.MaxValue)`
`43`	`43`	`{`
`44`		`- offset += WireFormatting.WriteByte(seq.Slice(offset), FormatCode.Str8);`
`45`		`- offset += WireFormatting.WriteByte(seq.Slice(offset), (byte)len);`
`46`		`- offset += s_encoding.GetBytes(value, seq.Slice(offset));`
	`44`	`+ offset += WireFormatting.WriteByte(seq[offset..], FormatCode.Str8);`
	`45`	`+ offset += WireFormatting.WriteByte(seq[offset..], (byte)len);`
	`46`	`+ offset += s_encoding.GetBytes(value, seq[offset..]);`
`47`	`47`	`return offset;`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`// Str32`
`51`		`- offset += WireFormatting.WriteByte(seq.Slice(offset), FormatCode.Str32);`
`52`		`- offset += WireFormatting.WriteInt32(seq.Slice(offset), len);`
`53`		`- offset += s_encoding.GetBytes(value, seq.Slice(offset));`
	`51`	`+ offset += WireFormatting.WriteByte(seq[offset..], FormatCode.Str32);`
	`52`	`+ offset += WireFormatting.WriteInt32(seq[offset..], len);`
	`53`	`+ offset += s_encoding.GetBytes(value, seq[offset..]);`
`54`	`54`	`return offset;`
`55`	`55`	`}`
`56`	`56`
`@@ -64,13 +64,13 @@ private static int WriteUInt64(Span<byte> seq, ulong value)`
`64`	`64`	`var offset = 0;`
`65`	`65`	`if (value < 256)`
`66`	`66`	`{`
`67`		`- offset += WireFormatting.WriteByte(seq.Slice(offset), FormatCode.SmallUlong);`
`68`		`- offset += WireFormatting.WriteByte(seq.Slice(offset), (byte)value);`
	`67`	`+ offset += WireFormatting.WriteByte(seq[offset..], FormatCode.SmallUlong);`
	`68`	`+ offset += WireFormatting.WriteByte(seq[offset..], (byte)value);`
`69`	`69`	`return offset;`
`70`	`70`	`}`
`71`	`71`
`72`		`- offset += WireFormatting.WriteByte(seq.Slice(offset), FormatCode.Ulong);`
`73`		`- offset += WireFormatting.WriteUInt64(seq.Slice(offset), value);`
	`72`	`+ offset += WireFormatting.WriteByte(seq[offset..], FormatCode.Ulong);`
	`73`	`+ offset += WireFormatting.WriteUInt64(seq[offset..], value);`
`74`	`74`	`return offset;`
`75`	`75`	`}`
`76`	`76`
`@@ -83,13 +83,13 @@ private static int WriteUInt(Span<byte> seq, uint value)`
`83`	`83`	`case 0:`
`84`	`84`	`return WireFormatting.WriteByte(seq, FormatCode.Uint0);`
`85`	`85`	`case < 256:`
`86`		`- offset += WireFormatting.WriteByte(seq.Slice(offset), FormatCode.SmallUint);`
`87`		`- offset += WireFormatting.WriteByte(seq.Slice(offset), (byte)value);`
	`86`	`+ offset += WireFormatting.WriteByte(seq[offset..], FormatCode.SmallUint);`
	`87`	`+ offset += WireFormatting.WriteByte(seq[offset..], (byte)value);`
`88`	`88`	`return offset;`
`89`	`89`	`}`
`90`	`90`
`91`		`- offset += WireFormatting.WriteByte(seq.Slice(offset), FormatCode.Uint);`
`92`		`- offset += WireFormatting.WriteUInt32(seq.Slice(offset), value);`
	`91`	`+ offset += WireFormatting.WriteByte(seq[offset..], FormatCode.Uint);`
	`92`	`+ offset += WireFormatting.WriteUInt32(seq[offset..], value);`
`93`	`93`	`return offset;`
`94`	`94`	`}`
`95`	`95`
`@@ -98,14 +98,14 @@ private static int WriteInt(Span<byte> seq, int value)`
`98`	`98`	`var offset = 0;`
`99`	`99`	`if (value is < 128 and >= -128)`
`100`	`100`	`{`
`101`		`- offset += WireFormatting.WriteByte(seq.Slice(offset), FormatCode.Smallint);`
`102`		`- offset += WireFormatting.WriteByte(seq.Slice(offset), (byte)value);`
	`101`	`+ offset += WireFormatting.WriteByte(seq[offset..], FormatCode.Smallint);`
	`102`	`+ offset += WireFormatting.WriteByte(seq[offset..], (byte)value);`
`103`	`103`
`104`	`104`	`return offset;`
`105`	`105`	`}`
`106`	`106`
`107`		`- offset += WireFormatting.WriteByte(seq.Slice(offset), FormatCode.Int);`
`108`		`- offset += WireFormatting.WriteInt32(seq.Slice(offset), value);`
	`107`	`+ offset += WireFormatting.WriteByte(seq[offset..], FormatCode.Int);`
	`108`	`+ offset += WireFormatting.WriteInt32(seq[offset..], value);`
`109`	`109`	`return offset;`
`110`	`110`	`}`
`111`	`111`
`@@ -114,14 +114,14 @@ private static int WriteInt64(Span<byte> seq, long value)`
`114`	`114`	`var offset = 0;`
`115`	`115`	`if (value is < 128 and >= -128)`
`116`	`116`	`{`
`117`		`- offset += WireFormatting.WriteByte(seq.Slice(offset), FormatCode.Smalllong);`
`118`		`- offset += WireFormatting.WriteByte(seq.Slice(offset), (byte)value);`
	`117`	`+ offset += WireFormatting.WriteByte(seq[offset..], FormatCode.Smalllong);`
	`118`	`+ offset += WireFormatting.WriteByte(seq[offset..], (byte)value);`
`119`	`119`
`120`	`120`	`return offset;`
`121`	`121`	`}`
`122`	`122`
`123`		`- offset += WireFormatting.WriteByte(seq.Slice(offset), FormatCode.Long);`
`124`		`- offset += WireFormatting.WriteInt64(seq.Slice(offset), value);`
	`123`	`+ offset += WireFormatting.WriteByte(seq[offset..], FormatCode.Long);`
	`124`	`+ offset += WireFormatting.WriteInt64(seq[offset..], value);`
`125`	`125`	`return offset;`
`126`	`126`	`}`
`127`	`127`
`@@ -138,60 +138,60 @@ private static int WriteBytes(Span<byte> seq, byte[] value)`
`138`	`138`	`// List8`
`139`	`139`	`if (len < 256)`
`140`	`140`	`{`
`141`		`- offset += WireFormatting.WriteByte(seq.Slice(offset), FormatCode.Vbin8);`
`142`		`- offset += WireFormatting.WriteByte(seq.Slice(offset), (byte)len);`
`143`		`- offset += WireFormatting.Write(seq.Slice(offset), new ReadOnlySequence<byte>(value));`
	`141`	`+ offset += WireFormatting.WriteByte(seq[offset..], FormatCode.Vbin8);`
	`142`	`+ offset += WireFormatting.WriteByte(seq[offset..], (byte)len);`
	`143`	`+ offset += WireFormatting.Write(seq[offset..], new ReadOnlySequence<byte>(value));`
`144`	`144`	`return offset;`
`145`	`145`	`}`
`146`	`146`
`147`	`147`	`// List32`
`148`		`- offset += WireFormatting.WriteByte(seq.Slice(offset), FormatCode.Vbin32);`
`149`		`- offset += WireFormatting.WriteUInt32(seq.Slice(offset), (uint)len);`
`150`		`- offset += WireFormatting.Write(seq.Slice(offset), new ReadOnlySequence<byte>(value));`
	`148`	`+ offset += WireFormatting.WriteByte(seq[offset..], FormatCode.Vbin32);`
	`149`	`+ offset += WireFormatting.WriteUInt32(seq[offset..], (uint)len);`
	`150`	`+ offset += WireFormatting.Write(seq[offset..], new ReadOnlySequence<byte>(value));`
`151`	`151`	`return offset;`
`152`	`152`	`}`
`153`	`153`
`154`	`154`	`private static int WriteUInt16(Span<byte> seq, ushort value)`
`155`	`155`	`{`
`156`	`156`	`var offset = WireFormatting.WriteByte(seq, FormatCode.Ushort);`
`157`		`- offset += WireFormatting.WriteUInt16(seq.Slice(offset), value);`
	`157`	`+ offset += WireFormatting.WriteUInt16(seq[offset..], value);`
`158`	`158`	`return offset;`
`159`	`159`	`}`
`160`	`160`
`161`	`161`	`private static int WriteByte(Span<byte> seq, byte value)`
`162`	`162`	`{`
`163`	`163`	`var offset = WireFormatting.WriteByte(seq, FormatCode.Ubyte);`
`164`		`- offset += WireFormatting.WriteByte(seq.Slice(offset), value);`
	`164`	`+ offset += WireFormatting.WriteByte(seq[offset..], value);`
`165`	`165`	`return offset;`
`166`	`166`	`}`
`167`	`167`
`168`	`168`	`private static int WriteSByte(Span<byte> seq, sbyte value)`
`169`	`169`	`{`
`170`	`170`	`var offset = WireFormatting.WriteByte(seq, FormatCode.Byte);`
`171`		`- offset += WireFormatting.WriteByte(seq.Slice(offset), (byte)value);`
	`171`	`+ offset += WireFormatting.WriteByte(seq[offset..], (byte)value);`
`172`	`172`	`return offset;`
`173`	`173`	`}`
`174`	`174`
`175`	`175`	`private static int WriteFloat(Span<byte> seq, float value)`
`176`	`176`	`{`
`177`	`177`	`var offset = WireFormatting.WriteByte(seq, FormatCode.Float);`
`178`	`178`	`var intFloat = BitConverter.SingleToInt32Bits(value);`
`179`		`- offset += WireFormatting.WriteInt32(seq.Slice(offset), intFloat);`
	`179`	`+ offset += WireFormatting.WriteInt32(seq[offset..], intFloat);`
`180`	`180`	`return offset;`
`181`	`181`	`}`
`182`	`182`
`183`	`183`	`private static int WriteDouble(Span<byte> seq, double value)`
`184`	`184`	`{`
`185`	`185`	`var offset = WireFormatting.WriteByte(seq, FormatCode.Double);`
`186`	`186`	`var intFloat = BitConverter.DoubleToInt64Bits(value);`
`187`		`- offset += WireFormatting.WriteInt64(seq.Slice(offset), intFloat);`
	`187`	`+ offset += WireFormatting.WriteInt64(seq[offset..], intFloat);`
`188`	`188`	`return offset;`
`189`	`189`	`}`
`190`	`190`
`191`	`191`	`private static int WriteIn16(Span<byte> seq, short value)`
`192`	`192`	`{`
`193`	`193`	`var offset = WireFormatting.WriteByte(seq, FormatCode.Short);`
`194`		`- offset += WireFormatting.WriteInt16(seq.Slice(offset), value);`
	`194`	`+ offset += WireFormatting.WriteInt16(seq[offset..], value);`
`195`	`195`	`return offset;`
`196`	`196`	`}`
`197`	`197`
`@@ -204,7 +204,7 @@ private static int WriteTimestamp(Span<byte> seq, DateTime value)`
`204`	`204`	`{`
`205`	`205`	`var offset = WireFormatting.WriteByte(seq, FormatCode.Timestamp);`
`206`	`206`	`var unixTime = ((DateTimeOffset)value).ToUnixTimeMilliseconds();`
`207`		`- offset += WireFormatting.WriteUInt64(seq.Slice(offset), (ulong)unixTime);`
	`207`	`+ offset += WireFormatting.WriteUInt64(seq[offset..], (ulong)unixTime);`
`208`	`208`	`return offset;`
`209`	`209`	`}`
`210`	`210`
Original file line number	Diff line number	Diff line change
`@@ -32,16 +32,16 @@ public int Write(Span<byte> span)`
`32`	`32`	`var offset = DescribedFormatCode.Write(span, DescribedFormatCode.ApplicationData);`
`33`	`33`	`if (data.Length <= byte.MaxValue)`
`34`	`34`	`{`
`35`		`- offset += WireFormatting.WriteByte(span.Slice(offset), FormatCode.Vbin8); //binary marker`
`36`		`- offset += WireFormatting.WriteByte(span.Slice(offset), (byte)data.Length); //length`
	`35`	`+ offset += WireFormatting.WriteByte(span[offset..], FormatCode.Vbin8); //binary marker`
	`36`	`+ offset += WireFormatting.WriteByte(span[offset..], (byte)data.Length); //length`
`37`	`37`	`}`
`38`	`38`	`else`
`39`	`39`	`{`
`40`		`- offset += WireFormatting.WriteByte(span.Slice(offset), FormatCode.Vbin32); //binary marker`
`41`		`- offset += WireFormatting.WriteUInt32(span.Slice(offset), (uint)data.Length); //length`
	`40`	`+ offset += WireFormatting.WriteByte(span[offset..], FormatCode.Vbin32); //binary marker`
	`41`	`+ offset += WireFormatting.WriteUInt32(span[offset..], (uint)data.Length); //length`
`42`	`42`	`}`
`43`	`43`
`44`		`- offset += WireFormatting.Write(span.Slice(offset), data);`
	`44`	`+ offset += WireFormatting.Write(span[offset..], data);`
`45`	`45`	`return offset;`
`46`	`46`	`}`
`47`	`47`
Original file line number	Diff line number	Diff line change
`@@ -72,15 +72,15 @@ public int Size`
`72`	`72`	`public int Write(Span<byte> span)`
`73`	`73`	`{`
`74`	`74`	`var offset = DescribedFormatCode.Write(span, MapDataCode);`
`75`		`- offset += WireFormatting.WriteByte(span.Slice(offset), FormatCode.Map32);`
`76`		`- offset += WireFormatting.WriteUInt32(span.Slice(offset), (uint)MapSize()); // MapSize`
`77`		`- offset += WireFormatting.WriteUInt32(span.Slice(offset), (uint)Count * 2); // pair values`
	`75`	`+ offset += WireFormatting.WriteByte(span[offset..], FormatCode.Map32);`
	`76`	`+ offset += WireFormatting.WriteUInt32(span[offset..], (uint)MapSize()); // MapSize`
	`77`	`+ offset += WireFormatting.WriteUInt32(span[offset..], (uint)Count * 2); // pair values`
`78`	`78`	`foreach (var (key, value) in this)`
`79`	`79`	`{`
`80`	`80`	`if (!IsNullOrEmptyString(key))`
`81`	`81`	`{`
`82`		`- offset += AmqpWireFormatting.WriteAny(span.Slice(offset), key);`
`83`		`- offset += AmqpWireFormatting.WriteAny(span.Slice(offset), value);`
	`82`	`+ offset += AmqpWireFormatting.WriteAny(span[offset..], key);`
	`83`	`+ offset += AmqpWireFormatting.WriteAny(span[offset..], value);`
`84`	`84`	`}`
`85`	`85`	`}`
`86`	`86`
Original file line number	Diff line number	Diff line change
`@@ -46,20 +46,20 @@ public int Write(Span<byte> span)`
`46`	`46`	`var offset = 0;`
`47`	`47`	`if (Properties != null)`
`48`	`48`	`{`
`49`		`- offset += Properties.Write(span.Slice(offset));`
	`49`	`+ offset += Properties.Write(span[offset..]);`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`if (ApplicationProperties != null)`
`53`	`53`	`{`
`54`		`- offset += ApplicationProperties.Write(span.Slice(offset));`
	`54`	`+ offset += ApplicationProperties.Write(span[offset..]);`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`if (Annotations != null)`
`58`	`58`	`{`
`59`		`- offset += Annotations.Write(span.Slice(offset));`
	`59`	`+ offset += Annotations.Write(span[offset..]);`
`60`	`60`	`}`
`61`	`61`
`62`		`- offset += Data.Write(span.Slice(offset));`
	`62`	`+ offset += Data.Write(span[offset..]);`
`63`	`63`	`return offset;`
`64`	`64`	`}`
`65`	`65`
Original file line number	Diff line number	Diff line change
`@@ -39,13 +39,13 @@ public int Write(Span<byte> span)`
`39`	`39`	`{`
`40`	`40`	`var command = (ICommand)this;`
`41`	`41`	`var offset = WireFormatting.WriteUInt16(span, Key);`
`42`		`- offset += WireFormatting.WriteUInt16(span.Slice(offset), command.Version);`
`43`		`- offset += WireFormatting.WriteUInt32(span.Slice(offset), correlationId);`
	`42`	`+ offset += WireFormatting.WriteUInt16(span[offset..], command.Version);`
	`43`	`+ offset += WireFormatting.WriteUInt32(span[offset..], correlationId);`
`44`	`44`	`// map`
`45`		`- offset += WireFormatting.WriteInt32(span.Slice(offset), streams.Count());`
	`45`	`+ offset += WireFormatting.WriteInt32(span[offset..], streams.Count());`
`46`	`46`	`foreach (var s in streams)`
`47`	`47`	`{`
`48`		`- offset += WireFormatting.WriteString(span.Slice(offset), s);`
	`48`	`+ offset += WireFormatting.WriteString(span[offset..], s);`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`return offset;`