Add ResizableArray.

This allows an old array to be garbage-collected, instead of being kept alive by the existing ColumnDefinitionPayloads that were created.

Author: bgrainger

src/MySqlConnector/Core/ResultSet.cs

@@ -102,7 +102,7 @@ int ReadColumnCount(ArraySegment<byte> arraySegment)
 						var columnCount = ReadColumnCount(payload.ArraySegment);
 
 						// reserve adequate space to hold a copy of all column definitions (but note that this can be resized below if we guess too small)
-						Array.Resize(ref m_columnDefinitionPayloads, columnCount * 96);
+						Utility.Resize(ref m_columnDefinitionPayloads, columnCount * 96);
 
 						ColumnDefinitions = new ColumnDefinitionPayload[columnCount];
 						ColumnTypes = new MySqlDbType[columnCount];
@@ -115,11 +115,11 @@ int ReadColumnCount(ArraySegment<byte> arraySegment)
 							var arraySegment = payload.ArraySegment;
 
 							// '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.Length)
-								Array.Resize(ref m_columnDefinitionPayloads, Math.Max(m_columnDefinitionPayloadUsedBytes + arraySegment.Count, m_columnDefinitionPayloadUsedBytes * 2));
-							Buffer.BlockCopy(arraySegment.Array, arraySegment.Offset, m_columnDefinitionPayloads, m_columnDefinitionPayloadUsedBytes, arraySegment.Count);
+							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);
 
-							var columnDefinition = ColumnDefinitionPayload.Create(new ArraySegment<byte>(m_columnDefinitionPayloads, m_columnDefinitionPayloadUsedBytes, arraySegment.Count));
+							var columnDefinition = ColumnDefinitionPayload.Create(new ResizableArraySegment<byte>(m_columnDefinitionPayloads, m_columnDefinitionPayloadUsedBytes, arraySegment.Count));
 							ColumnDefinitions[column] = columnDefinition;
 							ColumnTypes[column] = TypeMapper.ConvertToMySqlDbType(columnDefinition, treatTinyAsBoolean: Connection.TreatTinyAsBoolean, guidFormat: Connection.GuidFormat);
 							m_columnDefinitionPayloadUsedBytes += arraySegment.Count;
@@ -344,7 +344,7 @@ public Row GetCurrentRow()
 		public int? RecordsAffected { get; private set; }
 		public ResultSetState State { get; private set; }
 
-		byte[] m_columnDefinitionPayloads;
+		ResizableArray<byte> m_columnDefinitionPayloads;
 		int m_columnDefinitionPayloadUsedBytes;
 		int[] m_dataLengths;
 		int[] m_dataOffsets;

src/MySqlConnector/Protocol/Payloads/ColumnDefinitionPayload.cs

@@ -17,13 +17,13 @@ public string Name
 			}
 		}
 
-		public CharacterSet CharacterSet { get; private set; }
+		public CharacterSet CharacterSet { get; }
 
-		public uint ColumnLength { get; private set; }
+		public uint ColumnLength { get; }
 
-		public ColumnType ColumnType { get; private set; }
+		public ColumnType ColumnType { get; }
 
-		public ColumnFlags ColumnFlags { get; private set; }
+		public ColumnFlags ColumnFlags { get; }
 
 		public string SchemaName
 		{
@@ -75,9 +75,9 @@ public string PhysicalName
 			}
 		}
 
-		public byte Decimals { get; private set; }
+		public byte Decimals { get; }
 
-		public static ColumnDefinitionPayload Create(ArraySegment<byte> arraySegment)
+		public static ColumnDefinitionPayload Create(ResizableArraySegment<byte> arraySegment)
 		{
 			var reader = new ByteArrayReader(arraySegment);
 			SkipLengthEncodedByteString(ref reader); // catalog
@@ -95,15 +95,7 @@ public static ColumnDefinitionPayload Create(ArraySegment<byte> arraySegment)
 			reader.ReadByte(0); // reserved byte 1
 			reader.ReadByte(0); // reserved byte 2
 
-			return new ColumnDefinitionPayload
-			{
-				OriginalData = arraySegment,
-				CharacterSet = characterSet,
-				ColumnLength = columnLength,
-				ColumnType = columnType,
-				ColumnFlags = columnFlags,
-				Decimals = decimals
-			};
+			return new ColumnDefinitionPayload(arraySegment, characterSet, columnLength, columnType, columnFlags, decimals);
 		}
 
 		private static void SkipLengthEncodedByteString(ref ByteArrayReader reader)
@@ -112,6 +104,16 @@ private static void SkipLengthEncodedByteString(ref ByteArrayReader reader)
 			reader.Offset += length;
 		}
 
+		private ColumnDefinitionPayload(ResizableArraySegment<byte> originalData, CharacterSet characterSet, uint columnLength, ColumnType columnType, ColumnFlags columnFlags, byte decimals)
+		{
+			OriginalData = originalData;
+			CharacterSet = characterSet;
+			ColumnLength = columnLength;
+			ColumnType = columnType;
+			ColumnFlags = columnFlags;
+			Decimals = decimals;
+		}
+
 		private void ReadNames()
 		{
 			var reader = new ByteArrayReader(OriginalData);
@@ -124,7 +126,7 @@ private void ReadNames()
 			m_readNames = true;
 		}
 
-		ArraySegment<byte> OriginalData { get; set; }
+		ResizableArraySegment<byte> OriginalData { get; }
 
 		bool m_readNames;
 		string m_name;

src/MySqlConnector/Utilities/ResizableArray.cs

@@ -0,0 +1,22 @@
+namespace MySqlConnector.Utilities
+{
+	/// <summary>
+	/// A wrapper around a resizable array. This type is intended to be used with <see cref="ResizableArraySegment{T}"/>.
+	/// </summary>
+	internal sealed class ResizableArray<T>
+	{
+		public T[] Array => m_array;
+		public int Count => m_array?.Length ?? 0;
+
+		/// <summary>
+		/// Do not call this method directly; use <see cref="Utility.Resize{T}"/>.
+		/// </summary>
+		internal void DoResize(int length)
+		{
+			if (m_array == null || length > m_array.Length)
+				System.Array.Resize(ref m_array, length);
+		}
+
+		T[] m_array;
+	}
+}

src/MySqlConnector/Utilities/ResizableArraySegment.cs

@@ -0,0 +1,23 @@
+using System;
+
+namespace MySqlConnector.Utilities
+{
+	/// <summary>
+	/// An <see cref="ArraySegment{T}"/> that supports having its underlying array reallocated and resized.
+	/// </summary>
+	internal struct ResizableArraySegment<T>
+	{
+		public ResizableArraySegment(ResizableArray<T> array, int offset, int count)
+		{
+			Array = array;
+			Offset = offset;
+			Count = count;
+		}
+
+		public ResizableArray<T> Array { get; }
+		public int Offset { get; }
+		public int Count { get; }
+
+		public static implicit operator ReadOnlySpan<T>(ResizableArraySegment<T> segment) => new ReadOnlySpan<T>(segment.Array.Array, segment.Offset, segment.Count);
+	}
+}

src/MySqlConnector/Utilities/Utility.cs

@@ -230,6 +230,17 @@ public static int FindNextIndex(ReadOnlySpan<byte> data, int offset, ReadOnlySpa
 			return -1;
 		}
 
+		/// <summary>
+		/// Resizes <paramref name="resizableArray"/> to hold at least <paramref name="newLength"/> items.
+		/// </summary>
+		/// <remarks><paramref name="resizableArray"/> may be <c>null</c>, in which case a new <see cref="ResizableArray{T}"/> will be allocated.</remarks>
+		public static void Resize<T>(ref ResizableArray<T> resizableArray, int newLength)
+		{
+			if (resizableArray == null)
+				resizableArray = new ResizableArray<T>();
+			resizableArray.DoResize(Math.Max(newLength, resizableArray.Count * 2));
+		}
+
 		public static TimeSpan ParseTimeSpan(ReadOnlySpan<byte> value)
 		{
 			var originalValue = value;