Fixes Binding to non-null IEnumerable doesn't work #36390

src/libraries/Microsoft.Extensions.Configuration.Binder/src/ConfigurationBinder.cs

@@ -2,8 +2,10 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.ComponentModel;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Reflection;
@@ -378,17 +380,27 @@ private static void BindProperty(PropertyInfo property, object instance, IConfig
                     {
                         BindCollection(instance, collectionInterface, config, options);
                     }
-                    // Something else
                     else
                     {
-                        BindNonScalar(config, instance, options);
+                        // See if its an IEnumerable
+                        collectionInterface = FindOpenGenericInterface(typeof(IEnumerable<>), type);
+                        if (collectionInterface != null)
+                        {
+                            instance = BindExistingCollection((IEnumerable)instance!, config, options);
+                        }
+                        // Something else
+                        else
+                        {
+                            BindNonScalar(config, instance, options);
+                        }
                     }
                 }
             }
 
             return instance;
         }
 
+
         private static object? CreateInstance([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)] Type type)
         {
             if (type.IsInterface || type.IsAbstract)
@@ -498,6 +510,41 @@ private static void BindCollection(
             }
         }
 
+        [RequiresUnreferencedCode("Cannot statically analyze what the element type is of the object collection so its members may be trimmed.")]
+        private static IEnumerable BindExistingCollection(IEnumerable source, IConfiguration config, BinderOptions options)
+        {
+            // find the interface that is IEnumerable<T>
+            Type type = source.GetType().GetInterface("IEnumerable`1", false)!;
+            Type elementType = type.GenericTypeArguments[0];
+            Type genericType = typeof(List<>).MakeGenericType(elementType);
+
+            IList newList = (IList)Activator.CreateInstance(genericType, source)!;
+
+            IConfigurationSection[] children = config.GetChildren().ToArray();
+
+            for (int i = 0; i < children.Length; i++)
+            {
+                try
+                {
+                    object? item = BindInstance(
+                        type: elementType,
+                        instance: null,
+                        config: children[i],
+                        options: options);
+
+                    if (item != null)
+                    {
+                        newList.Add(item);
+                    }
+                }
+                catch
+                {
+                }
+            }
+
+            return newList;
+        }
+
         [RequiresUnreferencedCode("Cannot statically analyze what the element type is of the Array so its members may be trimmed.")]
         private static Array BindArray(Array source, IConfiguration config, BinderOptions options)
         {

src/libraries/Microsoft.Extensions.Configuration.Binder/tests/ConfigurationBinderTests.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
+using System.Linq;
 using System.Reflection;
 using Xunit;
 
@@ -47,6 +48,11 @@ public string ReadOnly
             {
                 get { return null; }
             }
+
+            public IEnumerable<string> NonInstantiatedIEnumerable { get; set; } = null!;
+            public IEnumerable<string> InstantiatedIEnumerable { get; set; } = new List<string>();
+            public ICollection<string> InstantiatedICollection { get; set; } = new List<string>();
+            public IReadOnlyCollection<string> InstantiatedIReadOnlyCollection { get; set; } = new List<string>();
         }
 
         public class NestedOptions
@@ -220,6 +226,107 @@ public void CanBindConfigurationKeyNameAttributes()
             Assert.Equal("Yo", options.NamedProperty);
         }
 
+        [Fact]
+        public void CanBindNonInstantiatedIEnumerableWithItems()
+        {
+            var dic = new Dictionary<string, string>
+            {
+                {"NonInstantiatedIEnumerable:0", "Yo1"},
+                {"NonInstantiatedIEnumerable:1", "Yo2"},
+            };
+            var configurationBuilder = new ConfigurationBuilder();
+            configurationBuilder.AddInMemoryCollection(dic);
+
+            var config = configurationBuilder.Build();
+
+            var options = config.Get<ComplexOptions>()!;
+
+            Assert.Equal(2, options.NonInstantiatedIEnumerable.Count());
+            Assert.Equal("Yo1", options.NonInstantiatedIEnumerable.ElementAt(0));
+            Assert.Equal("Yo2", options.NonInstantiatedIEnumerable.ElementAt(1));
+        }
+
+        [Fact]
+        public void CanBindInstantiatedIEnumerableWithItems()
+        {
+            var dic = new Dictionary<string, string>
+            {
+                {"InstantiatedIEnumerable:0", "Yo1"},
+                {"InstantiatedIEnumerable:1", "Yo2"},
+            };
+            var configurationBuilder = new ConfigurationBuilder();
+            configurationBuilder.AddInMemoryCollection(dic);
+
+            var config = configurationBuilder.Build();
+
+            var options = config.Get<ComplexOptions>()!;
+
+            Assert.Equal(2, options.InstantiatedIEnumerable.Count());
+            Assert.Equal("Yo1", options.InstantiatedIEnumerable.ElementAt(0));
+            Assert.Equal("Yo2", options.InstantiatedIEnumerable.ElementAt(1));
+        }
+
+        [Fact]
+        public void CanBindInstantiatedICollectionWithItems()
+        {
+            var dic = new Dictionary<string, string>
+            {
+                {"InstantiatedICollection:0", "Yo1"},
+                {"InstantiatedICollection:1", "Yo2"},
+            };
+            var configurationBuilder = new ConfigurationBuilder();
+            configurationBuilder.AddInMemoryCollection(dic);
+
+            var config = configurationBuilder.Build();
+
+            var options = config.Get<ComplexOptions>()!;
+
+            Assert.Equal(2, options.InstantiatedICollection.Count());
+            Assert.Equal("Yo1", options.InstantiatedICollection.ElementAt(0));
+            Assert.Equal("Yo2", options.InstantiatedICollection.ElementAt(1));
+        }
+
+        [Fact]
+        public void CanBindInstantiatedIReadOnlyCollectionWithItems()
+        {
+            var dic = new Dictionary<string, string>
+            {
+                {"InstantiatedIReadOnlyCollection:0", "Yo1"},
+                {"InstantiatedIReadOnlyCollection:1", "Yo2"},
+            };
+            var configurationBuilder = new ConfigurationBuilder();
+            configurationBuilder.AddInMemoryCollection(dic);
+
+            var config = configurationBuilder.Build();
+
+            var options = config.Get<ComplexOptions>()!;
+
+            Assert.Equal(2, options.InstantiatedIReadOnlyCollection.Count);
+            Assert.Equal("Yo1", options.InstantiatedIReadOnlyCollection.ElementAt(0));
+            Assert.Equal("Yo2", options.InstantiatedIReadOnlyCollection.ElementAt(1));
+        }
+
+        [Fact]
+        public void CanBindInstantiatedIEnumerableWithNullItems()
+        {
+            var dic = new Dictionary<string, string>
+            {
+                {"InstantiatedIEnumerable:0", null},
+                {"InstantiatedIEnumerable:1", "Yo1"},
+                {"InstantiatedIEnumerable:2", "Yo2"},
+            };
+            var configurationBuilder = new ConfigurationBuilder();
+            configurationBuilder.AddInMemoryCollection(dic);
+
+            var config = configurationBuilder.Build();
+
+            var options = config.Get<ComplexOptions>()!;
+
+            Assert.Equal(2, options.InstantiatedIEnumerable.Count());
+            Assert.Equal("Yo1", options.InstantiatedIEnumerable.ElementAt(0));
+            Assert.Equal("Yo2", options.InstantiatedIEnumerable.ElementAt(1));
+        }
+
         [Fact]
         public void EmptyStringIsNullable()
         {