First pass

dotnet · tarekgh · Jul 19, 2022 · Apr 17, 2022 · Apr 17, 2022 · Apr 18, 2022
commit 871166ce3060edaeeef69e4c4a10084429df017c
diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/ConfigurationBinderTests.cs b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/ConfigurationBinderTests.cs
@@ -49,7 +49,13 @@ public string ReadOnly
                 get { return null; }
             }
 
+            public ISet<string> NonInstantiatedISet { get; set; } = null!;
+            public IDictionary<string, ISet<string>> NonInstantiatedDictionaryWithISet { get; set; } = null!;
+            public IDictionary<string, HashSet<string>> InstantiatedDictionaryWithHashSet { get; set; } =
+                new Dictionary<string, HashSet<string>>();
+
             public IEnumerable<string> NonInstantiatedIEnumerable { get; set; } = null!;
+            public ISet<string> InstantiatedISet { get; set; } = new HashSet<string>();
             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>();
@@ -478,6 +484,114 @@ public void CanBindNonInstantiatedIEnumerableWithItems()
             Assert.Equal("Yo2", options.NonInstantiatedIEnumerable.ElementAt(1));
         }
 
+        [Fact]
+        public void CanBindNonInstantiatedISet()
+        {
+            var dic = new Dictionary<string, string>
+            {
+                {"NonInstantiatedISet:0", "Yo1"},
+                {"NonInstantiatedISet:1", "Yo2"},
+            };
+            var configurationBuilder = new ConfigurationBuilder();
+            configurationBuilder.AddInMemoryCollection(dic);
+
+            var config = configurationBuilder.Build();
+
+            var options = config.Get<ComplexOptions>()!;
+
+            Assert.Equal(2, options.NonInstantiatedISet.Count());
+            Assert.Equal("Yo1", options.NonInstantiatedISet.ElementAt(0));
+            Assert.Equal("Yo2", options.NonInstantiatedISet.ElementAt(1));
+        }
+
+        [Fact]
+        public void CanBindNonInstantiatedDictionaryOfISet()
+        {
+            var dic = new Dictionary<string, string>
+            {
+                {"NonInstantiatedDictionaryWithISet:foo:0", "foo-1"},
+                {"NonInstantiatedDictionaryWithISet:foo:1", "foo-2"},
+                {"NonInstantiatedDictionaryWithISet:bar:0", "bar-1"},
+                {"NonInstantiatedDictionaryWithISet:bar:1", "bar-2"},
+            };
+            var configurationBuilder = new ConfigurationBuilder();
+            configurationBuilder.AddInMemoryCollection(dic);
+
+            var config = configurationBuilder.Build();
+
+            var options = config.Get<ComplexOptions>()!;
+
+            Assert.Equal(2, options.NonInstantiatedDictionaryWithISet.Count);
+            Assert.Equal("foo-1", options.NonInstantiatedDictionaryWithISet["foo"].ElementAt(0));
+            Assert.Equal("foo-2", options.NonInstantiatedDictionaryWithISet["foo"].ElementAt(1));
+            Assert.Equal("bar-1", options.NonInstantiatedDictionaryWithISet["bar"].ElementAt(0));
+            Assert.Equal("bar-2", options.NonInstantiatedDictionaryWithISet["bar"].ElementAt(1));
+        }
+
+        [Fact]
+        public void CanBindInstantiatedDictionaryOfISet()
+        {
+            var dic = new Dictionary<string, string>
+            {
+                {"InstantiatedDictionaryWithHashSet:foo:0", "foo-1"},
+                {"InstantiatedDictionaryWithHashSet:foo:1", "foo-2"},
+                {"InstantiatedDictionaryWithHashSet:bar:0", "bar-1"},
+                {"InstantiatedDictionaryWithHashSet:bar:1", "bar-2"},
+            };
+            var configurationBuilder = new ConfigurationBuilder();
+            configurationBuilder.AddInMemoryCollection(dic);
+
+            var config = configurationBuilder.Build();
+
+            var options = config.Get<ComplexOptions>()!;
+
+            Assert.Equal(2, options.InstantiatedDictionaryWithHashSet.Count);
+            Assert.Equal("foo-1", options.InstantiatedDictionaryWithHashSet["foo"].ElementAt(0));
+            Assert.Equal("foo-2", options.InstantiatedDictionaryWithHashSet["foo"].ElementAt(1));
+            Assert.Equal("bar-1", options.InstantiatedDictionaryWithHashSet["bar"].ElementAt(0));
+            Assert.Equal("bar-2", options.InstantiatedDictionaryWithHashSet["bar"].ElementAt(1));
+        }
+
+        [Fact]
+        public void CanBindInstantiatedISet()
+        {
+            var dic = new Dictionary<string, string>
+            {
+                {"InstantiatedISet:0", "Yo1"},
+                {"InstantiatedISet:1", "Yo2"},
+            };
+            var configurationBuilder = new ConfigurationBuilder();
+            configurationBuilder.AddInMemoryCollection(dic);
+
+            var config = configurationBuilder.Build();
+
+            var options = config.Get<ComplexOptions>()!;
+
+            Assert.Equal(2, options.InstantiatedISet.Count());
+            Assert.Equal("Yo1", options.InstantiatedISet.ElementAt(0));
+            Assert.Equal("Yo2", options.InstantiatedISet.ElementAt(1));
+        }
+
+        // [Fact]
+        // public void CanBindInstantiatedISet2()
+        // {
+        //     var dic = new Dictionary<string, string>
+        //     {
+        //         {"NonInstantiatedISet:0", "Yo1"},
+        //         {"NonInstantiatedISet:1", "Yo2"},
+        //     };
+        //     var configurationBuilder = new ConfigurationBuilder();
+        //     configurationBuilder.AddInMemoryCollection(dic);
+        //
+        //     var config = configurationBuilder.Build();
+        //
+        //     var options = config.Get<Steve>()!;
+        //
+        //     Assert.Equal(2, options.NonInstantiatedISet.Count());
+        //     Assert.Equal("Yo1", options.NonInstantiatedISet.ElementAt(0));
+        //     Assert.Equal("Yo2", options.NonInstantiatedISet.ElementAt(1));
+        // }
+
         [Fact]
         public void CanBindInstantiatedIEnumerableWithItems()
         {
@@ -1107,7 +1221,7 @@ public void BindCanSetNonPublicWhenSet(string property)
             var config = configurationBuilder.Build();
 
             var options = new ComplexOptions();
-            config.Bind(options, o => o.BindNonPublicProperties = true );
+            config.Bind(options, o => o.BindNonPublicProperties = true);
             Assert.Equal("stuff", options.GetType().GetTypeInfo().GetDeclaredProperty(property).GetValue(options));
         }
 

diff --git a/...es/Microsoft.Extensions.Configuration.Binder/tests/ConfigurationCollectionBindingTests.cs b/...es/Microsoft.Extensions.Configuration.Binder/tests/ConfigurationCollectionBindingTests.cs
@@ -581,6 +581,32 @@ public void AlreadyInitializedStringDictionaryBinding()
             Assert.Equal("val_3", options.AlreadyInitializedStringDictionaryInterface["ghi"]);
         }
 
+        [Fact]
+        public void AlreadyInitializedHashSetDictionaryBinding()
+        {
+            var input = new Dictionary<string, string>
+            {
+                {"AlreadyInitializedHashSetDictionary:123:0", "val_1"},
+                {"AlreadyInitializedHashSetDictionary:123:1", "val_2"},
+                {"AlreadyInitializedHashSetDictionary:123:2", "val_3"}
+            };
+
+            var configurationBuilder = new ConfigurationBuilder();
+            configurationBuilder.AddInMemoryCollection(input);
+            var config = configurationBuilder.Build();
+
+            var options = new OptionsWithDictionary();
+            config.Bind(options);
+
+            Assert.NotNull(options.AlreadyInitializedHashSetDictionary);
+            Assert.Equal(1, options.AlreadyInitializedHashSetDictionary.Count);
+
+            Assert.Equal("This was already here", options.AlreadyInitializedHashSetDictionary["123"].ElementAt(0));
+            Assert.Equal("val_1", options.AlreadyInitializedHashSetDictionary["123"].ElementAt(1));
+            Assert.Equal("val_2", options.AlreadyInitializedHashSetDictionary["123"].ElementAt(2));
+            Assert.Equal("val_3", options.AlreadyInitializedHashSetDictionary["123"].ElementAt(3));
+        }
+
         [Fact]
         public void CanOverrideExistingDictionaryKey()
         {
@@ -684,6 +710,36 @@ public void ListDictionary()
             Assert.Equal("def_2", options.ListDictionary["def"][2]);
         }
 
+        [Fact]
+        public void ISetDictionary()
+        {
+            var input = new Dictionary<string, string>
+            {
+                {"ISetDictionary:abc:0", "abc_0"},
+                {"ISetDictionary:abc:1", "abc_1"},
+                {"ISetDictionary:def:0", "def_0"},
+                {"ISetDictionary:def:1", "def_1"},
+                {"ISetDictionary:def:2", "def_2"}
+            };
+
+            var configurationBuilder = new ConfigurationBuilder();
+            configurationBuilder.AddInMemoryCollection(input);
+            var config = configurationBuilder.Build();
+
+            var options = new OptionsWithDictionary();
+            config.Bind(options);
+
+            Assert.Equal(2, options.ISetDictionary.Count);
+            Assert.Equal(2, options.ISetDictionary["abc"].Count);
+            Assert.Equal(3, options.ISetDictionary["def"].Count);
+
+            Assert.Equal("abc_0", options.ISetDictionary["abc"].ElementAt(0));
+            Assert.Equal("abc_1", options.ISetDictionary["abc"].ElementAt(1));
+            Assert.Equal("def_0", options.ISetDictionary["def"].ElementAt(0));
+            Assert.Equal("def_1", options.ISetDictionary["def"].ElementAt(1));
+            Assert.Equal("def_2", options.ISetDictionary["def"].ElementAt(2));
+        }
+
         [Fact]
         public void ListInNestedOptionBinding()
         {
@@ -1410,6 +1466,11 @@ public OptionsWithDictionary()
                 {
                     ["123"] = "This was already here"
                 };
+
+                AlreadyInitializedHashSetDictionary = new Dictionary<string, HashSet<string>>
+                {
+                    ["123"] = new HashSet<string>(new[] {"This was already here"})
+                };
             }
 
             public Dictionary<string, int> IntDictionary { get; set; }
@@ -1418,6 +1479,7 @@ public OptionsWithDictionary()
 
             public Dictionary<string, NestedOptions> ObjectDictionary { get; set; }
 
+            public Dictionary<string, ISet<string>> ISetDictionary { get; set; }
             public Dictionary<string, List<string>> ListDictionary { get; set; }
 
             public Dictionary<NestedOptions, string> NonStringKeyDictionary { get; set; }
@@ -1427,6 +1489,7 @@ public OptionsWithDictionary()
             public IDictionary<string, string> StringDictionaryInterface { get; set; }
 
             public IDictionary<string, string> AlreadyInitializedStringDictionaryInterface { get; set; }
+            public IDictionary<string, HashSet<string>> AlreadyInitializedHashSetDictionary { get; set; }
         }
 
         private class OptionsWithInterdependentProperties