GH-41047: [C#] Address performance issue of reading from StringArray

csharp/src/Apache.Arrow/Arrays/StringArray.cs

@@ -26,6 +26,8 @@ public class StringArray: BinaryArray, IReadOnlyList<string>
     {
         public static readonly Encoding DefaultEncoding = Encoding.UTF8;
 
+        private Dictionary<Encoding, List<string>> materializedStringStore = new Dictionary<Encoding, List<string>>();
+
         public new class Builder : BuilderBase<StringArray, Builder>
         {
             public Builder() : base(StringType.Default) { }
@@ -75,6 +77,11 @@ public string GetString(int index, Encoding encoding = default)
         {
             encoding ??= DefaultEncoding;
 
+            if (materializedStringStore.TryGetValue(encoding, out List<string> materializedStrings))
+            {
+                return materializedStrings[index];
+            }
+
             ReadOnlySpan<byte> bytes = GetBytes(index, out bool isNull);
 
             if (isNull)
@@ -93,6 +100,30 @@ public string GetString(int index, Encoding encoding = default)
             }
         }
 
+        public void Materialize(Encoding encoding = default)
+        {
+            encoding ??= DefaultEncoding;
+
+            if (IsMaterialized(encoding))
+            {
+                return;
+            }
+
+            var stringStore = new List<string>(Length);
+            for (int i = 0; i < Length; i++)
+            {
+                stringStore.Add(GetString(i, encoding));
+            }
+
+            materializedStringStore[encoding] = stringStore;
+        }
+
+        public bool IsMaterialized(Encoding encoding = default)
+        {
+            encoding ??= DefaultEncoding;
+            return materializedStringStore.ContainsKey(encoding);
+        }
+
         int IReadOnlyCollection<string>.Count => Length;
 
         string IReadOnlyList<string>.this[int index] => GetString(index);

csharp/test/Apache.Arrow.Tests/StringArrayTests.cs

@@ -49,6 +49,37 @@ public void ReturnsAppendedValue(string firstValue, string secondValue)
                 // Assert
                 Assert.Equal(firstValue, retrievedValue);
             }
+
+            [Theory]
+            [InlineData(null, null)]
+            [InlineData(null, "")]
+            [InlineData(null, "value")]
+            [InlineData("", null)]
+            [InlineData("", "")]
+            [InlineData("", "value")]
+            [InlineData("value", null)]
+            [InlineData("value", "")]
+            [InlineData("value", "value")]
+            public void ReturnsAppendedValueMaterialize(string firstValue, string secondValue)
+            {
+                // Arrange
+                // Create an array with two elements. The second element being null,
+                // empty, or non-empty may influence the underlying BinaryArray
+                // storage such that retrieving an empty first element could result
+                // in an empty span or a 0-length span backed by storage.
+                var array = new StringArray.Builder()
+                    .Append(firstValue)
+                    .Append(secondValue)
+                    .Build();
+
+                // Act
+                array.Materialize();
+                var retrievedValue = array.GetString(0);
+
+                // Assert
+                Assert.True(array.IsMaterialized());
+                Assert.Equal(firstValue, retrievedValue);
+            }
         }
     }
 }