Rename unnecessary parameter aliases.

bgrainger · bgrainger · commit 052f18854379 · 2021-02-05T07:18:40.000-08:00
With an earlier C# version, local methods couldn't have the same parameter names as locals in the outer scope.
diff --git a/src/MySqlConnector/Core/ResultSet.cs b/src/MySqlConnector/Core/ResultSet.cs
@@ -236,7 +236,7 @@ public async Task<bool> ReadAsync(IOBehavior ioBehavior, CancellationToken cance
 				? new ValueTask<Row?>(ScanRowAsyncRemainder(this, payloadValueTask.Result, row))
 				: new ValueTask<Row?>(ScanRowAsyncAwaited(this, payloadValueTask.AsTask(), row, cancellationToken));
 
-			static async Task<Row?> ScanRowAsyncAwaited(ResultSet this_, Task<PayloadData> payloadTask, Row? row_, CancellationToken token)
+			static async Task<Row?> ScanRowAsyncAwaited(ResultSet resultSet, Task<PayloadData> payloadTask, Row? row, CancellationToken token)
 			{
 				PayloadData payloadData;
 				try
@@ -245,37 +245,37 @@ public async Task<bool> ReadAsync(IOBehavior ioBehavior, CancellationToken cance
 				}
 				catch (MySqlException ex)
 				{
-					this_.BufferState = this_.State = ResultSetState.NoMoreData;
+					resultSet.BufferState = resultSet.State = ResultSetState.NoMoreData;
 					if (ex.ErrorCode == MySqlErrorCode.QueryInterrupted && token.IsCancellationRequested)
 						throw new OperationCanceledException(ex.Message, ex, token);
 					throw;
 				}
-				return ScanRowAsyncRemainder(this_, payloadData, row_);
+				return ScanRowAsyncRemainder(resultSet, payloadData, row);
 			}
 
-			static Row? ScanRowAsyncRemainder(ResultSet this_, PayloadData payload, Row? row_)
+			static Row? ScanRowAsyncRemainder(ResultSet resultSet, PayloadData payload, Row? row)
 			{
 				if (payload.HeaderByte == EofPayload.Signature)
 				{
 					var span = payload.Span;
-					if (this_.Session.SupportsDeprecateEof && OkPayload.IsOk(span, this_.Session.SupportsDeprecateEof))
+					if (resultSet.Session.SupportsDeprecateEof && OkPayload.IsOk(span, resultSet.Session.SupportsDeprecateEof))
 					{
-						var ok = OkPayload.Create(span, this_.Session.SupportsDeprecateEof, this_.Session.SupportsSessionTrack);
-						this_.BufferState = (ok.ServerStatus & ServerStatus.MoreResultsExist) == 0 ? ResultSetState.NoMoreData : ResultSetState.HasMoreData;
+						var ok = OkPayload.Create(span, resultSet.Session.SupportsDeprecateEof, resultSet.Session.SupportsSessionTrack);
+						resultSet.BufferState = (ok.ServerStatus & ServerStatus.MoreResultsExist) == 0 ? ResultSetState.NoMoreData : ResultSetState.HasMoreData;
 						return null;
 					}
-					if (!this_.Session.SupportsDeprecateEof && EofPayload.IsEof(payload))
+					if (!resultSet.Session.SupportsDeprecateEof && EofPayload.IsEof(payload))
 					{
 						var eof = EofPayload.Create(span);
-						this_.BufferState = (eof.ServerStatus & ServerStatus.MoreResultsExist) == 0 ? ResultSetState.NoMoreData : ResultSetState.HasMoreData;
+						resultSet.BufferState = (eof.ServerStatus & ServerStatus.MoreResultsExist) == 0 ? ResultSetState.NoMoreData : ResultSetState.HasMoreData;
 						return null;
 					}
 				}
 
-				if (row_ is null)
+				if (row is null)
 				{
 					bool isBinaryRow = false;
-					if (payload.HeaderByte == 0 && !this_.Connection.IgnorePrepare)
+					if (payload.HeaderByte == 0 && !resultSet.Connection.IgnorePrepare)
 					{
 						// this might be a binary row, but it might also be a text row whose first column is zero bytes long; try reading
 						// the row as a series of length-encoded values (the text format) to see if this might plausibly be a text row
@@ -328,7 +328,7 @@ public async Task<bool> ReadAsync(IOBehavior ioBehavior, CancellationToken cance
 							reader.Offset += length;
 							columnCount++;
 
-							if (columnCount == this_.ColumnDefinitions!.Length)
+							if (columnCount == resultSet.ColumnDefinitions!.Length)
 							{
 								// if we used up all the bytes reading exactly 'ColumnDefinitions' length-encoded columns, then assume this is a text row
 								if (reader.BytesRemaining == 0)
@@ -339,12 +339,12 @@ public async Task<bool> ReadAsync(IOBehavior ioBehavior, CancellationToken cance
 
 						isBinaryRow = !isTextRow;
 					}
-					row_ = isBinaryRow ? (Row) new BinaryRow(this_) : new TextRow(this_);
+					row = isBinaryRow ? (Row) new BinaryRow(resultSet) : new TextRow(resultSet);
 				}
-				row_.SetData(payload.Memory);
-				this_.m_hasRows = true;
-				this_.BufferState = ResultSetState.ReadingRows;
-				return row_;
+				row.SetData(payload.Memory);
+				resultSet.m_hasRows = true;
+				resultSet.BufferState = ResultSetState.ReadingRows;
+				return row;
 			}
 		}
 
diff --git a/src/MySqlConnector/Core/ServerSession.cs b/src/MySqlConnector/Core/ServerSession.cs
@@ -1449,13 +1449,13 @@ private async Task GetRealServerDetailsAsync(IOBehavior ioBehavior, Cancellation
 
 				// first (and only) row
 				payload = await ReceiveReplyAsync(ioBehavior, CancellationToken.None).ConfigureAwait(false);
-				static void ReadRow(ReadOnlySpan<byte> span, out int? connectionId_, out byte[]? serverVersion_)
+				static void ReadRow(ReadOnlySpan<byte> span, out int? connectionId, out byte[]? serverVersion)
 				{
 					var reader = new ByteArrayReader(span);
 					var length = reader.ReadLengthEncodedIntegerOrNull();
-					connectionId_ = (length != -1 && Utf8Parser.TryParse(reader.ReadByteString(length), out int id, out _)) ? id : default(int?);
+					connectionId = (length != -1 && Utf8Parser.TryParse(reader.ReadByteString(length), out int id, out _)) ? id : default(int?);
 					length = reader.ReadLengthEncodedIntegerOrNull();
-					serverVersion_ = length != -1 ? reader.ReadByteString(length).ToArray() : null;
+					serverVersion = length != -1 ? reader.ReadByteString(length).ToArray() : null;
 				}
 				ReadRow(payload.Span, out var connectionId, out var serverVersion);
 
diff --git a/src/MySqlConnector/Protocol/Serialization/ProtocolUtility.cs b/src/MySqlConnector/Protocol/Serialization/ProtocolUtility.cs
@@ -408,8 +408,8 @@ private static ValueTask<Packet> ReadPacketAsync(BufferedByteReader bufferedByte
 				return ReadPacketAfterHeader(headerBytesTask.Result, bufferedByteReader, byteHandler, getNextSequenceNumber, protocolErrorBehavior, ioBehavior);
 			return AddContinuation(headerBytesTask, bufferedByteReader, byteHandler, getNextSequenceNumber, protocolErrorBehavior, ioBehavior);
 
-			static async ValueTask<Packet> AddContinuation(ValueTask<ArraySegment<byte>> headerBytes_, BufferedByteReader bufferedByteReader_, IByteHandler byteHandler_, Func<int> getNextSequenceNumber_, ProtocolErrorBehavior protocolErrorBehavior_, IOBehavior ioBehavior_) =>
-				await ReadPacketAfterHeader(await headerBytes_.ConfigureAwait(false), bufferedByteReader_, byteHandler_, getNextSequenceNumber_, protocolErrorBehavior_, ioBehavior_).ConfigureAwait(false);
+			static async ValueTask<Packet> AddContinuation(ValueTask<ArraySegment<byte>> headerBytes, BufferedByteReader bufferedByteReader, IByteHandler byteHandler, Func<int> getNextSequenceNumber, ProtocolErrorBehavior protocolErrorBehavior, IOBehavior ioBehavior) =>
+				await ReadPacketAfterHeader(await headerBytes.ConfigureAwait(false), bufferedByteReader, byteHandler, getNextSequenceNumber, protocolErrorBehavior, ioBehavior).ConfigureAwait(false);
 		}
 
 		private static ValueTask<Packet> ReadPacketAfterHeader(ReadOnlySpan<byte> headerBytes, BufferedByteReader bufferedByteReader, IByteHandler byteHandler, Func<int> getNextSequenceNumber, ProtocolErrorBehavior protocolErrorBehavior, IOBehavior ioBehavior)
@@ -433,8 +433,8 @@ private static ValueTask<Packet> ReadPacketAfterHeader(ReadOnlySpan<byte> header
 				return CreatePacketFromPayload(payloadBytesTask.Result, payloadLength, protocolErrorBehavior, packetOutOfOrderException);
 			return AddContinuation(payloadBytesTask, payloadLength, protocolErrorBehavior, packetOutOfOrderException);
 
-			static async ValueTask<Packet> AddContinuation(ValueTask<ArraySegment<byte>> payloadBytesTask_, int payloadLength_, ProtocolErrorBehavior protocolErrorBehavior_, Exception? packetOutOfOrderException_) =>
-				await CreatePacketFromPayload(await payloadBytesTask_.ConfigureAwait(false), payloadLength_, protocolErrorBehavior_, packetOutOfOrderException_).ConfigureAwait(false);
+			static async ValueTask<Packet> AddContinuation(ValueTask<ArraySegment<byte>> payloadBytesTask, int payloadLength, ProtocolErrorBehavior protocolErrorBehavior, Exception? packetOutOfOrderException) =>
+				await CreatePacketFromPayload(await payloadBytesTask.ConfigureAwait(false), payloadLength, protocolErrorBehavior, packetOutOfOrderException).ConfigureAwait(false);
 		}
 
 		private static ValueTask<Packet> CreatePacketFromPayload(ArraySegment<byte> payloadBytes, int payloadLength, ProtocolErrorBehavior protocolErrorBehavior, Exception? exception)
@@ -474,11 +474,11 @@ private static ValueTask<ArraySegment<byte>> DoReadPayloadAsync(BufferedByteRead
 
 			return AddContinuation(readPacketTask, bufferedByteReader, byteHandler, getNextSequenceNumber, previousPayloads, protocolErrorBehavior, ioBehavior);
 
-			static async ValueTask<ArraySegment<byte>> AddContinuation(ValueTask<Packet> readPacketTask_, BufferedByteReader bufferedByteReader_, IByteHandler byteHandler_, Func<int> getNextSequenceNumber_, ArraySegmentHolder<byte> previousPayloads_, ProtocolErrorBehavior protocolErrorBehavior_, IOBehavior ioBehavior_)
+			static async ValueTask<ArraySegment<byte>> AddContinuation(ValueTask<Packet> readPacketTask, BufferedByteReader bufferedByteReader, IByteHandler byteHandler, Func<int> getNextSequenceNumber, ArraySegmentHolder<byte> previousPayloads, ProtocolErrorBehavior protocolErrorBehavior, IOBehavior ioBehavior)
 			{
-				var packet = await readPacketTask_.ConfigureAwait(false);
-				var resultTask = HasReadPayload(previousPayloads_, packet, protocolErrorBehavior_, out var result_) ? result_ :
-					DoReadPayloadAsync(bufferedByteReader_, byteHandler_, getNextSequenceNumber_, previousPayloads_, protocolErrorBehavior_, ioBehavior_);
+				var packet = await readPacketTask.ConfigureAwait(false);
+				var resultTask = HasReadPayload(previousPayloads, packet, protocolErrorBehavior, out var result) ? result :
+					DoReadPayloadAsync(bufferedByteReader, byteHandler, getNextSequenceNumber, previousPayloads, protocolErrorBehavior, ioBehavior);
 				return await resultTask.ConfigureAwait(false);
 			}
 		}
@@ -515,12 +515,12 @@ public static ValueTask<int> WritePayloadAsync(IByteHandler byteHandler, Func<in
 			return payload.Length <= MaxPacketSize ? WritePacketAsync(byteHandler, getNextSequenceNumber(), payload, ioBehavior) :
 				WritePayloadAsyncAwaited(byteHandler, getNextSequenceNumber, payload, ioBehavior);
 
-			static async ValueTask<int> WritePayloadAsyncAwaited(IByteHandler byteHandler_, Func<int> getNextSequenceNumber_, ReadOnlyMemory<byte> payload_, IOBehavior ioBehavior_)
+			static async ValueTask<int> WritePayloadAsyncAwaited(IByteHandler byteHandler, Func<int> getNextSequenceNumber, ReadOnlyMemory<byte> payload, IOBehavior ioBehavior)
 			{
-				for (var bytesSent = 0; bytesSent < payload_.Length; bytesSent += MaxPacketSize)
+				for (var bytesSent = 0; bytesSent < payload.Length; bytesSent += MaxPacketSize)
 				{
-					var contents = payload_.Slice(bytesSent, Math.Min(MaxPacketSize, payload_.Length - bytesSent));
-					await WritePacketAsync(byteHandler_, getNextSequenceNumber_(), contents, ioBehavior_).ConfigureAwait(false);
+					var contents = payload.Slice(bytesSent, Math.Min(MaxPacketSize, payload.Length - bytesSent));
+					await WritePacketAsync(byteHandler, getNextSequenceNumber(), contents, ioBehavior).ConfigureAwait(false);
 				}
 				return 0;
 			}
@@ -541,10 +541,10 @@ private static ValueTask<int> WritePacketAsync(IByteHandler byteHandler, int seq
 			}
 			return WritePacketAsyncAwaited(task, buffer);
 
-			static async ValueTask<int> WritePacketAsyncAwaited(ValueTask<int> task_, byte[] buffer_)
+			static async ValueTask<int> WritePacketAsyncAwaited(ValueTask<int> task, byte[] buffer)
 			{
-				await task_.ConfigureAwait(false);
-				ArrayPool<byte>.Shared.Return(buffer_);
+				await task.ConfigureAwait(false);
+				ArrayPool<byte>.Shared.Return(buffer);
 				return 0;
 			}
 		}
diff --git a/src/MySqlConnector/Protocol/Serialization/StreamByteHandler.cs b/src/MySqlConnector/Protocol/Serialization/StreamByteHandler.cs
@@ -27,14 +27,14 @@ public ValueTask<int> ReadBytesAsync(Memory<byte> buffer, IOBehavior ioBehavior)
 				m_stream.CanTimeout ? DoReadBytesSync(buffer) :
 				DoReadBytesSyncOverAsync(buffer);
 
-			ValueTask<int> DoReadBytesSync(Memory<byte> buffer_)
+			ValueTask<int> DoReadBytesSync(Memory<byte> buffer)
 			{
 				m_stream.ReadTimeout = RemainingTimeout == Constants.InfiniteTimeout ? Timeout.Infinite : RemainingTimeout;
 				var startTime = RemainingTimeout == Constants.InfiniteTimeout ? 0 : Environment.TickCount;
 				int bytesRead;
 				try
 				{
-					bytesRead = m_stream.Read(buffer_);
+					bytesRead = m_stream.Read(buffer);
 				}
 				catch (Exception ex)
 				{
@@ -47,27 +47,27 @@ ValueTask<int> DoReadBytesSync(Memory<byte> buffer_)
 				return new ValueTask<int>(bytesRead);
 			}
 
-			ValueTask<int> DoReadBytesSyncOverAsync(Memory<byte> buffer_)
+			ValueTask<int> DoReadBytesSyncOverAsync(Memory<byte> buffer)
 			{
 				try
 				{
 					// handle timeout by setting a timer to close the stream in the background
-					return new ValueTask<int>(DoReadBytesAsync(buffer_).GetAwaiter().GetResult());
+					return new ValueTask<int>(DoReadBytesAsync(buffer).GetAwaiter().GetResult());
 				}
 				catch (Exception ex)
 				{
 					return ValueTaskExtensions.FromException<int>(ex);
 				}
 			}
 
-			async Task<int> DoReadBytesAsync(Memory<byte> buffer_)
+			async Task<int> DoReadBytesAsync(Memory<byte> buffer)
 			{
 				var startTime = RemainingTimeout == Constants.InfiniteTimeout ? 0 : Environment.TickCount;
 				var timerId = RemainingTimeout == Constants.InfiniteTimeout ? 0 : TimerQueue.Instance.Add(RemainingTimeout, m_closeStream);
 				int bytesRead;
 				try
 				{
-					bytesRead = await m_stream.ReadAsync(buffer_).ConfigureAwait(false);
+					bytesRead = await m_stream.ReadAsync(buffer).ConfigureAwait(false);
 				}
 				catch (Exception ex) when (ex is ObjectDisposedException or IOException)
 				{
@@ -104,9 +104,9 @@ public ValueTask<int> WriteBytesAsync(ReadOnlyMemory<byte> data, IOBehavior ioBe
 				return ValueTaskExtensions.FromException<int>(ex);
 			}
 
-			async Task<int> DoWriteBytesAsync(ReadOnlyMemory<byte> data_)
+			async Task<int> DoWriteBytesAsync(ReadOnlyMemory<byte> data)
 			{
-				await m_stream.WriteAsync(data_).ConfigureAwait(false);
+				await m_stream.WriteAsync(data).ConfigureAwait(false);
 				return 0;
 			}
 		}

Original file line number	Diff line number	Diff line change
`@@ -236,7 +236,7 @@ public async Task<bool> ReadAsync(IOBehavior ioBehavior, CancellationToken cance`
`236`	`236`	`? new ValueTask<Row?>(ScanRowAsyncRemainder(this, payloadValueTask.Result, row))`
`237`	`237`	`: new ValueTask<Row?>(ScanRowAsyncAwaited(this, payloadValueTask.AsTask(), row, cancellationToken));`
`238`	`238`
`239`		`- static async Task<Row?> ScanRowAsyncAwaited(ResultSet this_, Task<PayloadData> payloadTask, Row? row_, CancellationToken token)`
	`239`	`+ static async Task<Row?> ScanRowAsyncAwaited(ResultSet resultSet, Task<PayloadData> payloadTask, Row? row, CancellationToken token)`
`240`	`240`	`{`
`241`	`241`	`PayloadData payloadData;`
`242`	`242`	`try`
`@@ -245,37 +245,37 @@ public async Task<bool> ReadAsync(IOBehavior ioBehavior, CancellationToken cance`
`245`	`245`	`}`
`246`	`246`	`catch (MySqlException ex)`
`247`	`247`	`{`
`248`		`- this_.BufferState = this_.State = ResultSetState.NoMoreData;`
	`248`	`+ resultSet.BufferState = resultSet.State = ResultSetState.NoMoreData;`
`249`	`249`	`if (ex.ErrorCode == MySqlErrorCode.QueryInterrupted && token.IsCancellationRequested)`
`250`	`250`	`throw new OperationCanceledException(ex.Message, ex, token);`
`251`	`251`	`throw;`
`252`	`252`	`}`
`253`		`- return ScanRowAsyncRemainder(this_, payloadData, row_);`
	`253`	`+ return ScanRowAsyncRemainder(resultSet, payloadData, row);`
`254`	`254`	`}`
`255`	`255`
`256`		`- static Row? ScanRowAsyncRemainder(ResultSet this_, PayloadData payload, Row? row_)`
	`256`	`+ static Row? ScanRowAsyncRemainder(ResultSet resultSet, PayloadData payload, Row? row)`
`257`	`257`	`{`
`258`	`258`	`if (payload.HeaderByte == EofPayload.Signature)`
`259`	`259`	`{`
`260`	`260`	`var span = payload.Span;`
`261`		`- if (this_.Session.SupportsDeprecateEof && OkPayload.IsOk(span, this_.Session.SupportsDeprecateEof))`
	`261`	`+ if (resultSet.Session.SupportsDeprecateEof && OkPayload.IsOk(span, resultSet.Session.SupportsDeprecateEof))`
`262`	`262`	`{`
`263`		`- var ok = OkPayload.Create(span, this_.Session.SupportsDeprecateEof, this_.Session.SupportsSessionTrack);`
`264`		`- this_.BufferState = (ok.ServerStatus & ServerStatus.MoreResultsExist) == 0 ? ResultSetState.NoMoreData : ResultSetState.HasMoreData;`
	`263`	`+ var ok = OkPayload.Create(span, resultSet.Session.SupportsDeprecateEof, resultSet.Session.SupportsSessionTrack);`
	`264`	`+ resultSet.BufferState = (ok.ServerStatus & ServerStatus.MoreResultsExist) == 0 ? ResultSetState.NoMoreData : ResultSetState.HasMoreData;`
`265`	`265`	`return null;`
`266`	`266`	`}`
`267`		`- if (!this_.Session.SupportsDeprecateEof && EofPayload.IsEof(payload))`
	`267`	`+ if (!resultSet.Session.SupportsDeprecateEof && EofPayload.IsEof(payload))`
`268`	`268`	`{`
`269`	`269`	`var eof = EofPayload.Create(span);`
`270`		`- this_.BufferState = (eof.ServerStatus & ServerStatus.MoreResultsExist) == 0 ? ResultSetState.NoMoreData : ResultSetState.HasMoreData;`
	`270`	`+ resultSet.BufferState = (eof.ServerStatus & ServerStatus.MoreResultsExist) == 0 ? ResultSetState.NoMoreData : ResultSetState.HasMoreData;`
`271`	`271`	`return null;`
`272`	`272`	`}`
`273`	`273`	`}`
`274`	`274`
`275`		`- if (row_ is null)`
	`275`	`+ if (row is null)`
`276`	`276`	`{`
`277`	`277`	`bool isBinaryRow = false;`
`278`		`- if (payload.HeaderByte == 0 && !this_.Connection.IgnorePrepare)`
	`278`	`+ if (payload.HeaderByte == 0 && !resultSet.Connection.IgnorePrepare)`
`279`	`279`	`{`
`280`	`280`	`// this might be a binary row, but it might also be a text row whose first column is zero bytes long; try reading`
`281`	`281`	`// the row as a series of length-encoded values (the text format) to see if this might plausibly be a text row`
`@@ -328,7 +328,7 @@ public async Task<bool> ReadAsync(IOBehavior ioBehavior, CancellationToken cance`
`328`	`328`	`reader.Offset += length;`
`329`	`329`	`columnCount++;`
`330`	`330`
`331`		`- if (columnCount == this_.ColumnDefinitions!.Length)`
	`331`	`+ if (columnCount == resultSet.ColumnDefinitions!.Length)`
`332`	`332`	`{`
`333`	`333`	`// if we used up all the bytes reading exactly 'ColumnDefinitions' length-encoded columns, then assume this is a text row`
`334`	`334`	`if (reader.BytesRemaining == 0)`
`@@ -339,12 +339,12 @@ public async Task<bool> ReadAsync(IOBehavior ioBehavior, CancellationToken cance`
`339`	`339`
`340`	`340`	`isBinaryRow = !isTextRow;`
`341`	`341`	`}`
`342`		`- row_ = isBinaryRow ? (Row) new BinaryRow(this_) : new TextRow(this_);`
	`342`	`+ row = isBinaryRow ? (Row) new BinaryRow(resultSet) : new TextRow(resultSet);`
`343`	`343`	`}`
`344`		`- row_.SetData(payload.Memory);`
`345`		`- this_.m_hasRows = true;`
`346`		`- this_.BufferState = ResultSetState.ReadingRows;`
`347`		`- return row_;`
	`344`	`+ row.SetData(payload.Memory);`
	`345`	`+ resultSet.m_hasRows = true;`
	`346`	`+ resultSet.BufferState = ResultSetState.ReadingRows;`
	`347`	`+ return row;`
`348`	`348`	`}`
`349`	`349`	`}`
`350`	`350`
Original file line number	Diff line number	Diff line change
`@@ -408,8 +408,8 @@ private static ValueTask<Packet> ReadPacketAsync(BufferedByteReader bufferedByte`
`408`	`408`	`return ReadPacketAfterHeader(headerBytesTask.Result, bufferedByteReader, byteHandler, getNextSequenceNumber, protocolErrorBehavior, ioBehavior);`
`409`	`409`	`return AddContinuation(headerBytesTask, bufferedByteReader, byteHandler, getNextSequenceNumber, protocolErrorBehavior, ioBehavior);`
`410`	`410`
`411`		`- static async ValueTask<Packet> AddContinuation(ValueTask<ArraySegment<byte>> headerBytes_, BufferedByteReader bufferedByteReader_, IByteHandler byteHandler_, Func<int> getNextSequenceNumber_, ProtocolErrorBehavior protocolErrorBehavior_, IOBehavior ioBehavior_) =>`
`412`		`- await ReadPacketAfterHeader(await headerBytes_.ConfigureAwait(false), bufferedByteReader_, byteHandler_, getNextSequenceNumber_, protocolErrorBehavior_, ioBehavior_).ConfigureAwait(false);`
	`411`	`+ static async ValueTask<Packet> AddContinuation(ValueTask<ArraySegment<byte>> headerBytes, BufferedByteReader bufferedByteReader, IByteHandler byteHandler, Func<int> getNextSequenceNumber, ProtocolErrorBehavior protocolErrorBehavior, IOBehavior ioBehavior) =>`
	`412`	`+ await ReadPacketAfterHeader(await headerBytes.ConfigureAwait(false), bufferedByteReader, byteHandler, getNextSequenceNumber, protocolErrorBehavior, ioBehavior).ConfigureAwait(false);`
`413`	`413`	`}`
`414`	`414`
`415`	`415`	`private static ValueTask<Packet> ReadPacketAfterHeader(ReadOnlySpan<byte> headerBytes, BufferedByteReader bufferedByteReader, IByteHandler byteHandler, Func<int> getNextSequenceNumber, ProtocolErrorBehavior protocolErrorBehavior, IOBehavior ioBehavior)`
`@@ -433,8 +433,8 @@ private static ValueTask<Packet> ReadPacketAfterHeader(ReadOnlySpan<byte> header`
`433`	`433`	`return CreatePacketFromPayload(payloadBytesTask.Result, payloadLength, protocolErrorBehavior, packetOutOfOrderException);`
`434`	`434`	`return AddContinuation(payloadBytesTask, payloadLength, protocolErrorBehavior, packetOutOfOrderException);`
`435`	`435`
`436`		`- static async ValueTask<Packet> AddContinuation(ValueTask<ArraySegment<byte>> payloadBytesTask_, int payloadLength_, ProtocolErrorBehavior protocolErrorBehavior_, Exception? packetOutOfOrderException_) =>`
`437`		`- await CreatePacketFromPayload(await payloadBytesTask_.ConfigureAwait(false), payloadLength_, protocolErrorBehavior_, packetOutOfOrderException_).ConfigureAwait(false);`
	`436`	`+ static async ValueTask<Packet> AddContinuation(ValueTask<ArraySegment<byte>> payloadBytesTask, int payloadLength, ProtocolErrorBehavior protocolErrorBehavior, Exception? packetOutOfOrderException) =>`
	`437`	`+ await CreatePacketFromPayload(await payloadBytesTask.ConfigureAwait(false), payloadLength, protocolErrorBehavior, packetOutOfOrderException).ConfigureAwait(false);`
`438`	`438`	`}`
`439`	`439`
`440`	`440`	`private static ValueTask<Packet> CreatePacketFromPayload(ArraySegment<byte> payloadBytes, int payloadLength, ProtocolErrorBehavior protocolErrorBehavior, Exception? exception)`
`@@ -474,11 +474,11 @@ private static ValueTask<ArraySegment<byte>> DoReadPayloadAsync(BufferedByteRead`
`474`	`474`
`475`	`475`	`return AddContinuation(readPacketTask, bufferedByteReader, byteHandler, getNextSequenceNumber, previousPayloads, protocolErrorBehavior, ioBehavior);`
`476`	`476`
`477`		`- static async ValueTask<ArraySegment<byte>> AddContinuation(ValueTask<Packet> readPacketTask_, BufferedByteReader bufferedByteReader_, IByteHandler byteHandler_, Func<int> getNextSequenceNumber_, ArraySegmentHolder<byte> previousPayloads_, ProtocolErrorBehavior protocolErrorBehavior_, IOBehavior ioBehavior_)`
	`477`	`+ static async ValueTask<ArraySegment<byte>> AddContinuation(ValueTask<Packet> readPacketTask, BufferedByteReader bufferedByteReader, IByteHandler byteHandler, Func<int> getNextSequenceNumber, ArraySegmentHolder<byte> previousPayloads, ProtocolErrorBehavior protocolErrorBehavior, IOBehavior ioBehavior)`
`478`	`478`	`{`
`479`		`- var packet = await readPacketTask_.ConfigureAwait(false);`
`480`		`- var resultTask = HasReadPayload(previousPayloads_, packet, protocolErrorBehavior_, out var result_) ? result_ :`
`481`		`- DoReadPayloadAsync(bufferedByteReader_, byteHandler_, getNextSequenceNumber_, previousPayloads_, protocolErrorBehavior_, ioBehavior_);`
	`479`	`+ var packet = await readPacketTask.ConfigureAwait(false);`
	`480`	`+ var resultTask = HasReadPayload(previousPayloads, packet, protocolErrorBehavior, out var result) ? result :`
	`481`	`+ DoReadPayloadAsync(bufferedByteReader, byteHandler, getNextSequenceNumber, previousPayloads, protocolErrorBehavior, ioBehavior);`
`482`	`482`	`return await resultTask.ConfigureAwait(false);`
`483`	`483`	`}`
`484`	`484`	`}`
`@@ -515,12 +515,12 @@ public static ValueTask<int> WritePayloadAsync(IByteHandler byteHandler, Func<in`
`515`	`515`	`return payload.Length <= MaxPacketSize ? WritePacketAsync(byteHandler, getNextSequenceNumber(), payload, ioBehavior) :`
`516`	`516`	`WritePayloadAsyncAwaited(byteHandler, getNextSequenceNumber, payload, ioBehavior);`
`517`	`517`
`518`		`- static async ValueTask<int> WritePayloadAsyncAwaited(IByteHandler byteHandler_, Func<int> getNextSequenceNumber_, ReadOnlyMemory<byte> payload_, IOBehavior ioBehavior_)`
	`518`	`+ static async ValueTask<int> WritePayloadAsyncAwaited(IByteHandler byteHandler, Func<int> getNextSequenceNumber, ReadOnlyMemory<byte> payload, IOBehavior ioBehavior)`
`519`	`519`	`{`
`520`		`- for (var bytesSent = 0; bytesSent < payload_.Length; bytesSent += MaxPacketSize)`
	`520`	`+ for (var bytesSent = 0; bytesSent < payload.Length; bytesSent += MaxPacketSize)`
`521`	`521`	`{`
`522`		`- var contents = payload_.Slice(bytesSent, Math.Min(MaxPacketSize, payload_.Length - bytesSent));`
`523`		`- await WritePacketAsync(byteHandler_, getNextSequenceNumber_(), contents, ioBehavior_).ConfigureAwait(false);`
	`522`	`+ var contents = payload.Slice(bytesSent, Math.Min(MaxPacketSize, payload.Length - bytesSent));`
	`523`	`+ await WritePacketAsync(byteHandler, getNextSequenceNumber(), contents, ioBehavior).ConfigureAwait(false);`
`524`	`524`	`}`
`525`	`525`	`return 0;`
`526`	`526`	`}`
`@@ -541,10 +541,10 @@ private static ValueTask<int> WritePacketAsync(IByteHandler byteHandler, int seq`
`541`	`541`	`}`
`542`	`542`	`return WritePacketAsyncAwaited(task, buffer);`
`543`	`543`
`544`		`- static async ValueTask<int> WritePacketAsyncAwaited(ValueTask<int> task_, byte[] buffer_)`
	`544`	`+ static async ValueTask<int> WritePacketAsyncAwaited(ValueTask<int> task, byte[] buffer)`
`545`	`545`	`{`
`546`		`- await task_.ConfigureAwait(false);`
`547`		`- ArrayPool<byte>.Shared.Return(buffer_);`
	`546`	`+ await task.ConfigureAwait(false);`
	`547`	`+ ArrayPool<byte>.Shared.Return(buffer);`
`548`	`548`	`return 0;`
`549`	`549`	`}`
`550`	`550`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,14 +27,14 @@ public ValueTask<int> ReadBytesAsync(Memory<byte> buffer, IOBehavior ioBehavior)`
`27`	`27`	`m_stream.CanTimeout ? DoReadBytesSync(buffer) :`
`28`	`28`	`DoReadBytesSyncOverAsync(buffer);`
`29`	`29`
`30`		`- ValueTask<int> DoReadBytesSync(Memory<byte> buffer_)`
	`30`	`+ ValueTask<int> DoReadBytesSync(Memory<byte> buffer)`
`31`	`31`	`{`
`32`	`32`	`m_stream.ReadTimeout = RemainingTimeout == Constants.InfiniteTimeout ? Timeout.Infinite : RemainingTimeout;`
`33`	`33`	`var startTime = RemainingTimeout == Constants.InfiniteTimeout ? 0 : Environment.TickCount;`
`34`	`34`	`int bytesRead;`
`35`	`35`	`try`
`36`	`36`	`{`
`37`		`- bytesRead = m_stream.Read(buffer_);`
	`37`	`+ bytesRead = m_stream.Read(buffer);`
`38`	`38`	`}`
`39`	`39`	`catch (Exception ex)`
`40`	`40`	`{`
`@@ -47,27 +47,27 @@ ValueTask<int> DoReadBytesSync(Memory<byte> buffer_)`
`47`	`47`	`return new ValueTask<int>(bytesRead);`
`48`	`48`	`}`
`49`	`49`
`50`		`- ValueTask<int> DoReadBytesSyncOverAsync(Memory<byte> buffer_)`
	`50`	`+ ValueTask<int> DoReadBytesSyncOverAsync(Memory<byte> buffer)`
`51`	`51`	`{`
`52`	`52`	`try`
`53`	`53`	`{`
`54`	`54`	`// handle timeout by setting a timer to close the stream in the background`
`55`		`- return new ValueTask<int>(DoReadBytesAsync(buffer_).GetAwaiter().GetResult());`
	`55`	`+ return new ValueTask<int>(DoReadBytesAsync(buffer).GetAwaiter().GetResult());`
`56`	`56`	`}`
`57`	`57`	`catch (Exception ex)`
`58`	`58`	`{`
`59`	`59`	`return ValueTaskExtensions.FromException<int>(ex);`
`60`	`60`	`}`
`61`	`61`	`}`
`62`	`62`
`63`		`- async Task<int> DoReadBytesAsync(Memory<byte> buffer_)`
	`63`	`+ async Task<int> DoReadBytesAsync(Memory<byte> buffer)`
`64`	`64`	`{`
`65`	`65`	`var startTime = RemainingTimeout == Constants.InfiniteTimeout ? 0 : Environment.TickCount;`
`66`	`66`	`var timerId = RemainingTimeout == Constants.InfiniteTimeout ? 0 : TimerQueue.Instance.Add(RemainingTimeout, m_closeStream);`
`67`	`67`	`int bytesRead;`
`68`	`68`	`try`
`69`	`69`	`{`
`70`		`- bytesRead = await m_stream.ReadAsync(buffer_).ConfigureAwait(false);`
	`70`	`+ bytesRead = await m_stream.ReadAsync(buffer).ConfigureAwait(false);`
`71`	`71`	`}`
`72`	`72`	`catch (Exception ex) when (ex is ObjectDisposedException or IOException)`
`73`	`73`	`{`
`@@ -104,9 +104,9 @@ public ValueTask<int> WriteBytesAsync(ReadOnlyMemory<byte> data, IOBehavior ioBe`
`104`	`104`	`return ValueTaskExtensions.FromException<int>(ex);`
`105`	`105`	`}`
`106`	`106`
`107`		`- async Task<int> DoWriteBytesAsync(ReadOnlyMemory<byte> data_)`
	`107`	`+ async Task<int> DoWriteBytesAsync(ReadOnlyMemory<byte> data)`
`108`	`108`	`{`
`109`		`- await m_stream.WriteAsync(data_).ConfigureAwait(false);`
	`109`	`+ await m_stream.WriteAsync(data).ConfigureAwait(false);`
`110`	`110`	`return 0;`
`111`	`111`	`}`
`112`	`112`	`}`