Implement Array.Initialize in C#

src/coreclr/System.Private.CoreLib/src/System/Array.CoreCLR.cs

@@ -381,6 +381,7 @@ private unsafe bool IsValueOfElementType(object value)
         // if this is an array of value classes and that value class has a default constructor
         // then this calls this default constructor on every element in the value class array.
         // otherwise this is a no-op.  Generally this method is called automatically by the compiler
+        [RequiresUnreferencedCode("The parameterless constructor may be trimmed from the array element type.")]
         public unsafe void Initialize()
         {
             MethodTable* pArrayMT = RuntimeHelpers.GetMethodTable(this);
@@ -404,32 +405,27 @@ public unsafe void Initialize()
                 arrayType.GenericCache = cache;
             }
 
+            delegate*<ref byte, void> constructorFtn = cache.ConstructorEntrypoint;
             ref byte arrayRef = ref MemoryMarshal.GetArrayDataReference(this);
             nuint elementSize = pArrayMT->ComponentSize;
 
             for (int i = 0; i < Length; i++)
             {
-                cache.InvokeConstructor(ref arrayRef);
+                constructorFtn(ref arrayRef);
                 arrayRef = ref Unsafe.Add(ref arrayRef, elementSize);
             }
         }
 
         private sealed unsafe partial class ArrayInitializeCache
         {
-            private readonly delegate*<ref byte, void> _constructorEntrypoint;
+            internal readonly delegate*<ref byte, void> ConstructorEntrypoint;
 
             [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Array_GetElementConstructorEntrypoint")]
             private static partial delegate*<ref byte, void> GetElementConstructorEntrypoint(QCallTypeHandle arrayType);
 
             public ArrayInitializeCache(RuntimeType arrayType)
             {
-                _constructorEntrypoint = GetElementConstructorEntrypoint(new QCallTypeHandle(ref arrayType));
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void InvokeConstructor(ref byte thisAddress)
-            {
-                _constructorEntrypoint(ref thisAddress);
+                ConstructorEntrypoint = GetElementConstructorEntrypoint(new QCallTypeHandle(ref arrayType));
             }
         }
     }

src/coreclr/nativeaot/System.Private.CoreLib/src/System/Array.NativeAot.cs

@@ -107,12 +107,25 @@ private static void ValidateElementType(Type elementType)
                 throw new NotSupportedException(SR.NotSupported_OpenType);
         }
 
-        public void Initialize()
+        [RequiresUnreferencedCode("The parameterless constructor may be trimmed from the array element type.")]
+        public unsafe void Initialize()
         {
-            // This api is a nop unless the array element type is a value type with an explicit nullary constructor.
-            // Such a type could not be expressed in C# up until recently.
-            // TODO: Implement this
-            return;
+            EETypePtr pElementEEType = ElementEEType;
+            if (!pElementEEType.IsValueType)
+                return;
+
+            var constructorEntryPoint = (delegate*<ref byte, void>)RuntimeAugments.TypeLoaderCallbacks.TryGetDefaultConstructorForType(new RuntimeTypeHandle(pElementEEType));
+            if (constructorEntryPoint == null)
+                return;
+
+            ref byte arrayRef = ref MemoryMarshal.GetArrayDataReference(this);
+            nuint elementSize = ElementSize;
+
+            for (int i = 0; i < Length; i++)
+            {
+                constructorEntryPoint(ref arrayRef);
+                arrayRef = ref Unsafe.Add(ref arrayRef, elementSize);
+            }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/libraries/System.Reflection.MetadataLoadContext/tests/src/Tests/Type/TypeInvariants.cs

@@ -383,6 +383,13 @@ private static void TestTypeCommonInvariants(this Type type)
             const BindingFlags bf = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.FlattenHierarchy;
             foreach (MemberInfo mem in type.GetMember("*", MemberTypes.All, bf))
             {
+                // Workaround: Do not try to test Array.Initialize, since one of its locals is a function pointer.
+                // Delete this workaround when https://github.com/dotnet/runtime/issues/69273 is addressed.
+                if (mem.DeclaringType == mem.DeclaringType.Assembly.GetType("System.Array") && mem.Name == "Initialize")
+                {
+                    continue;
+                }
+
                 string s = mem.ToString();
                 Assert.Equal(type, mem.ReflectedType);
                 Type declaringType = mem.DeclaringType;

src/libraries/System.Runtime/tests/System/ArrayTests.cs

@@ -4447,7 +4447,6 @@ public static void MaxSizes()
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtimelab/issues/155", typeof(PlatformDetection), nameof(PlatformDetection.IsNativeAot))] // Array.Initialize
         public static void Array_Initialize()
         {
             var array = new StructWithDefaultConstructor[10, 10];

src/mono/System.Private.CoreLib/src/System/Array.Mono.cs

@@ -330,6 +330,7 @@ internal void InternalSetValue(object? value, nint index)
             SetValueImpl(value, (int)index);
         }
 
+        [RequiresUnreferencedCode("The parameterless constructor may be trimmed from the array element type.")]
         public void Initialize()
         {
             object arr = this;