Change PayloadData to use ReadOnlyMemory<byte>.

This better expresses that the memory it wraps is non-null.

Author: bgrainger

src/MySqlConnector/Core/CommandExecutor.cs

@@ -57,11 +57,11 @@ public static async Task<DbDataReader> ExecuteReaderAsync(IReadOnlyList<IMySqlCo
 					Log.Warn("Session{0} query was interrupted", command.Connection.Session.Id);
 					throw new OperationCanceledException(cancellationToken);
 				}
-				catch (Exception ex) when (payload.ArraySegment.Count > 4_194_304 && (ex is SocketException || ex is IOException || ex is MySqlProtocolException))
+				catch (Exception ex) when (payload.Span.Length > 4_194_304 && (ex is SocketException || ex is IOException || ex is MySqlProtocolException))
 				{
 					// the default MySQL Server value for max_allowed_packet (in MySQL 5.7) is 4MiB: https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html#sysvar_max_allowed_packet
 					// use "decimal megabytes" (to round up) when creating the exception message
-					int megabytes = payload.ArraySegment.Count / 1_000_000;
+					int megabytes = payload.Span.Length / 1_000_000;
 					throw new MySqlException("Error submitting {0}MB packet; ensure 'max_allowed_packet' is greater than {0}MB.".FormatInvariant(megabytes), ex);
 				}
 			}

src/MySqlConnector/Core/ResultSet.cs

@@ -53,7 +53,7 @@ public async Task ReadResultSetHeaderAsync(IOBehavior ioBehavior)
 					var firstByte = payload.HeaderByte;
 					if (firstByte == OkPayload.Signature)
 					{
-						var ok = OkPayload.Create(payload.AsSpan(), Session.SupportsDeprecateEof, Session.SupportsSessionTrack);
+						var ok = OkPayload.Create(payload.Span, Session.SupportsDeprecateEof, Session.SupportsSessionTrack);
 						RecordsAffected = (RecordsAffected ?? 0) + ok.AffectedRowCount;
 						LastInsertId = unchecked((long) ok.LastInsertId);
 						WarningCount = ok.WarningCount;
@@ -73,7 +73,7 @@ public async Task ReadResultSetHeaderAsync(IOBehavior ioBehavior)
 						{
 							if (!Connection.AllowLoadLocalInfile)
 								throw new NotSupportedException("To use LOAD DATA LOCAL INFILE, set AllowLoadLocalInfile=true in the connection string. See https://fl.vu/mysql-load-data");
-							var localInfile = LocalInfilePayload.Create(payload.AsSpan());
+							var localInfile = LocalInfilePayload.Create(payload.Span);
 							if (!IsHostVerified(Connection)
 								&& !localInfile.FileName.StartsWith(MySqlBulkLoader.StreamPrefix, StringComparison.Ordinal))
 								throw new NotSupportedException("Use SourceStream or SslMode >= VerifyCA for LOAD DATA LOCAL INFILE. See https://fl.vu/mysql-load-data");
@@ -109,7 +109,7 @@ int ReadColumnCount(ReadOnlySpan<byte> span)
 								throw new MySqlException("Unexpected data at end of column_count packet; see https://github.com/mysql-net/MySqlConnector/issues/324");
 							return columnCount_;
 						}
-						var columnCount = ReadColumnCount(payload.AsSpan());
+						var columnCount = ReadColumnCount(payload.Span);
 
 						// reserve adequate space to hold a copy of all column definitions (but note that this can be resized below if we guess too small)
 						Utility.Resize(ref m_columnDefinitionPayloads, columnCount * 96);
@@ -120,23 +120,23 @@ int ReadColumnCount(ReadOnlySpan<byte> span)
 						for (var column = 0; column < ColumnDefinitions.Length; column++)
 						{
 							payload = await Session.ReceiveReplyAsync(ioBehavior, CancellationToken.None).ConfigureAwait(false);
-							var arraySegment = payload.ArraySegment;
+							var payloadLength = payload.Span.Length;
 
 							// 'Session.ReceiveReplyAsync' reuses a shared buffer; make a copy so that the column definitions can always be safely read at any future point
-							if (m_columnDefinitionPayloadUsedBytes + arraySegment.Count > m_columnDefinitionPayloads.Count)
-								Utility.Resize(ref m_columnDefinitionPayloads, m_columnDefinitionPayloadUsedBytes + arraySegment.Count);
-							Buffer.BlockCopy(arraySegment.Array, arraySegment.Offset, m_columnDefinitionPayloads.Array, m_columnDefinitionPayloadUsedBytes, arraySegment.Count);
+							if (m_columnDefinitionPayloadUsedBytes + payloadLength > m_columnDefinitionPayloads.Count)
+								Utility.Resize(ref m_columnDefinitionPayloads, m_columnDefinitionPayloadUsedBytes + payloadLength);
+							payload.Span.CopyTo(m_columnDefinitionPayloads.Array.AsSpan().Slice(m_columnDefinitionPayloadUsedBytes));
 
-							var columnDefinition = ColumnDefinitionPayload.Create(new ResizableArraySegment<byte>(m_columnDefinitionPayloads, m_columnDefinitionPayloadUsedBytes, arraySegment.Count));
+							var columnDefinition = ColumnDefinitionPayload.Create(new ResizableArraySegment<byte>(m_columnDefinitionPayloads, m_columnDefinitionPayloadUsedBytes, payloadLength));
 							ColumnDefinitions[column] = columnDefinition;
 							ColumnTypes[column] = TypeMapper.ConvertToMySqlDbType(columnDefinition, treatTinyAsBoolean: Connection.TreatTinyAsBoolean, guidFormat: Connection.GuidFormat);
-							m_columnDefinitionPayloadUsedBytes += arraySegment.Count;
+							m_columnDefinitionPayloadUsedBytes += payloadLength;
 						}
 
 						if (!Session.SupportsDeprecateEof)
 						{
 							payload = await Session.ReceiveReplyAsync(ioBehavior, CancellationToken.None).ConfigureAwait(false);
-							EofPayload.Create(payload.AsSpan());
+							EofPayload.Create(payload.Span);
 						}
 
 						if (ColumnDefinitions.Length == (Command?.OutParameters?.Count + 1) && ColumnDefinitions[0].Name == SingleCommandPayloadCreator.OutParameterSentinelColumnName)
@@ -245,7 +245,7 @@ static Row ScanRowAsyncRemainder(ResultSet this_, PayloadData payload, Row row_)
 			{
 				if (payload.HeaderByte == EofPayload.Signature)
 				{
-					var span = payload.AsSpan();
+					var span = payload.Span;
 					if (this_.Session.SupportsDeprecateEof && OkPayload.IsOk(span, this_.Session.SupportsDeprecateEof))
 					{
 						var ok = OkPayload.Create(span, this_.Session.SupportsDeprecateEof, this_.Session.SupportsSessionTrack);
@@ -270,7 +270,7 @@ static Row ScanRowAsyncRemainder(ResultSet this_, PayloadData payload, Row row_)
 						// 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
 						var isTextRow = false;
-						var reader = new ByteArrayReader(payload.AsSpan());
+						var reader = new ByteArrayReader(payload.Span);
 						var columnCount = 0;
 						while (reader.BytesRemaining > 0)
 						{
@@ -331,7 +331,7 @@ static Row ScanRowAsyncRemainder(ResultSet this_, PayloadData payload, Row row_)
 					}
 					row_ = isBinaryRow ? (Row) new BinaryRow(this_) : new TextRow(this_);
 				}
-				row_.SetData(payload.ArraySegment);
+				row_.SetData(payload.Memory);
 				this_.m_rowBuffered = row_;
 				this_.m_hasRows = true;
 				this_.BufferState = ResultSetState.ReadingRows;

src/MySqlConnector/Core/Row.cs

@@ -1,6 +1,7 @@
 #nullable disable
 using System;
 using System.IO;
+using System.Runtime.InteropServices;
 using MySql.Data.MySqlClient;
 using MySql.Data.Types;
 using MySqlConnector.Protocol;
@@ -11,23 +12,23 @@ namespace MySqlConnector.Core
 {
 	internal abstract class Row
 	{
-		public void SetData(ArraySegment<byte> data)
+		public void SetData(ReadOnlyMemory<byte> data)
 		{
 			m_data = data;
 			if (m_dataOffsets is null)
 			{
 				m_dataOffsets = new int[ResultSet.ColumnDefinitions.Length];
 				m_dataLengths = new int[ResultSet.ColumnDefinitions.Length];
 			}
-			GetDataOffsets(m_data.AsSpan(), m_dataOffsets, m_dataLengths);
+			GetDataOffsets(m_data.Span, m_dataOffsets, m_dataLengths);
 		}
 
 		public Row Clone()
 		{
 			var clonedRow = CloneCore();
-			var clonedData = new byte[m_data.Count];
-			Buffer.BlockCopy(m_data.Array, m_data.Offset, clonedData, 0, m_data.Count);
-			clonedRow.SetData(new ArraySegment<byte>(clonedData));
+			var clonedData = new byte[m_data.Length];
+			m_data.CopyTo(clonedData);
+			clonedRow.SetData(clonedData);
 			return clonedRow;
 		}
 
@@ -39,7 +40,7 @@ public object GetValue(int ordinal)
 			if (m_dataOffsets[ordinal] == -1)
 				return DBNull.Value;
 
-			var data = new ReadOnlySpan<byte>(m_data.Array, m_data.Offset + m_dataOffsets[ordinal], m_dataLengths[ordinal]);
+			var data = m_data.Slice(m_dataOffsets[ordinal], m_dataLengths[ordinal]).Span;
 			var columnDefinition = ResultSet.ColumnDefinitions[ordinal];
 			return GetValueCore(data, columnDefinition);
 		}
@@ -88,7 +89,8 @@ public long GetBytes(int ordinal, long dataOffset, byte[] buffer, int bufferOffs
 
 			var offset = (int) dataOffset;
 			var lengthToCopy = Math.Max(0, Math.Min(m_dataLengths[ordinal] - offset, length));
-			Buffer.BlockCopy(m_data.Array, m_data.Offset + m_dataOffsets[ordinal] + offset, buffer, bufferOffset, lengthToCopy);
+			if (lengthToCopy > 0)
+				m_data.Slice(m_dataOffsets[ordinal] + offset, lengthToCopy).Span.CopyTo(buffer.AsSpan().Slice(bufferOffset));
 			return lengthToCopy;
 		}
 
@@ -291,7 +293,9 @@ public DateTime GetDateTime(int ordinal)
 		public Stream GetStream(int ordinal)
 		{
 			CheckBinaryColumn(ordinal);
-			return new MemoryStream(m_data.Array, m_data.Offset + m_dataOffsets[ordinal], m_dataLengths[ordinal], false);
+			return (MemoryMarshal.TryGetArray(m_data, out var arraySegment)) ?
+				new MemoryStream(arraySegment.Array, arraySegment.Offset + m_dataOffsets[ordinal], m_dataLengths[ordinal], writable: false) :
+				throw new InvalidOperationException("Can't get underlying array.");
 		}
 
 		public string GetString(int ordinal) => (string) GetValue(ordinal);
@@ -405,7 +409,7 @@ private static void CheckBufferArguments<T>(long dataOffset, T[] buffer, int buf
 				throw new ArgumentException("bufferOffset + length cannot exceed buffer.Length", nameof(length));
 		}
 
-		ArraySegment<byte> m_data;
+		ReadOnlyMemory<byte> m_data;
 		int[] m_dataOffsets;
 		int[] m_dataLengths;
 	}