Upgrade to latest version of ConfigurationBinder class as of .net 8 (#1143)

* Upgrade to latest version of ConfigurationBinder class as of .net 8

added files

* Added new comment for ThrowHelper

* removed line

* correct the test names

* more name fixes

* removed charcter

* Code comments

* Re-added the throwhelper using ArgumentNullException.ThowIfNull() method

* renamed file

* Fix from codereview

* added link

* Exclude from code coverage (MS code)

Author: helto4real

src/AppModel/NetDaemon.AppModel.Tests/Config/ConfigurationBinderTests.cs

@@ -22,39 +22,42 @@ public void TestAddYamlConfigGetsSettingsCorrectly()
     }
 
     [Fact]
-    public void TestWhenInitIEnumerableThrowsException()
+    public void TestWhenInitIEnumerableShouldCorrectHaveCount()
     {
         // ARRANGE
         // ACT
         // CHECK
-        Assert.Throws<InvalidOperationException>(() => GetObjectFromSection<CollectionBindingFaultyIEnumerableTestClass>("TestCollections"));
+        var config = GetObjectFromSection<CollectionBindingIEnumerableWithInitTestClass>("TestCollections");
+        config!.SomeEnumerable.Should().HaveCount(2);
     }
 
     [Fact]
-    public void TestWhenInitIReadOnlyListThrowsException()
+    public void TestWhenInitIReadOnlyListShouldHaveCorrectCount()
     {
         // ARRANGE
         // ACT
         // CHECK
-        Assert.Throws<InvalidOperationException>(() => GetObjectFromSection<CollectionBindingFaultyIReadOnlyListTestClass>("TestCollections"));
+        var config = GetObjectFromSection<CollectionBindingIReadOnlyListWithInitTestClass>("TestCollections");
+        config!.SomeReadOnlyList.Should().HaveCount(2);
     }
 
     [Fact]
-    public void TestWhenInitIReadOnlyCollectionThrowsException()
+    public void TestWhenInitIReadOnlyCollectionShouldHaveCorrectCount()
     {
         // ARRANGE
         // ACT
         // CHECK
-        Assert.Throws<InvalidOperationException>(() => GetObjectFromSection<CollectionBindingFaultyIReadOnlyCollectionTestClass>("TestCollections"));
+        var config = GetObjectFromSection<CollectionBindingIReadOnlyCollectionWithInitTestClass>("TestCollections");
+        config!.SomeReadOnlyCollection.Should().HaveCount(2);
     }
 
     [Fact]
-    public void TestWhenInitIReadOnlyDictionaryThrowsException()
+    public void TestWhenInitIReadOnlyDictionaryShouldHaveCount()
     {
         // ARRANGE
         // ACT
-        Assert.Throws<InvalidOperationException>(() =>
-            GetObjectFromSection<CollectionBindingFaultyIReadOnlyDictionaryTestClass>("TestCollections"));
+        var config = GetObjectFromSection<CollectionBindingIReadOnlyDictionaryWithInitTestClass>("TestCollections");
+        config!.SomeReadOnlyDictionary.Should().HaveCount(2);
         // CHECK
     }
 
@@ -141,6 +144,17 @@ public void TestAddYamlConfigBadClassShouldThrowException()
         GetObjectFromSection<IDictionary<int, int>>("TestCollections").Should().BeEmpty();
     }
 
+    [Fact]
+    public void TestAddYamlConfigGetsEnumWithUnderlyingTypeCorrectly()
+    {
+        // ARRANGE
+        // ACT
+        var config = GetObjectFromSection<IEnumerable<TestShortEnum>>("AnotherTestShortEnum");
+        // CHECK
+        config!.Should().HaveCount(2);
+        Enum.GetUnderlyingType(config!.First().GetType()).Should().Be(typeof(ushort));
+    }
+
     private static T? GetObjectFromSection<T>(string sectionName)
     {
         var providerMock = new Mock<IServiceProvider>();
@@ -161,6 +175,12 @@ internal enum TestEnum
         Enum2
     }
 
+    internal enum TestShortEnum : ushort
+    {
+        Enum1,
+        Enum2
+    }
+
     #region -- failing class declarations --
 
     internal abstract class AbstractShouldNotSerialize
@@ -196,23 +216,25 @@ public record CollectionBindingTestClass
     public IDictionary<string, string>? SomeDictionary { get; init; }
 }
 
-public record CollectionBindingFaultyIEnumerableTestClass
+public record CollectionBindingIEnumerableWithInitTestClass
 {
     public IEnumerable<string>? SomeEnumerable { get; init; } = new List<string>();
 }
 
-public record CollectionBindingFaultyIReadOnlyListTestClass
+public record CollectionBindingIReadOnlyListWithInitTestClass
 {
     public IReadOnlyList<string>? SomeReadOnlyList { get; init; } = new List<string>();
 }
 
-public record CollectionBindingFaultyIReadOnlyCollectionTestClass
+public record CollectionBindingIReadOnlyCollectionWithInitTestClass
 {
     public IReadOnlyCollection<string>? SomeReadOnlyCollection { get; init; } = new List<string>();
 }
 
-public record CollectionBindingFaultyIReadOnlyDictionaryTestClass
+public record CollectionBindingIReadOnlyDictionaryWithInitTestClass
 {
     public IReadOnlyDictionary<string, string>? SomeReadOnlyDictionary { get; init; } =
         new Dictionary<string, string>();
 }
+
+

src/AppModel/NetDaemon.AppModel.Tests/Config/Fixtures/CollectionTestsFixture.yaml

@@ -51,4 +51,8 @@ AnotherTestArray:
 
 AnotherTestEnum:
   - Enum1
-  - Enum2
+  - Enum2
+
+AnotherTestShortEnum:
+  - Enum1
+  - Enum2

src/AppModel/NetDaemon.AppModel/Internal/Config/BindingPoint.cs

@@ -0,0 +1,75 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+
+namespace NetDaemon.AppModel.Internal.Config;
+
+[ExcludeFromCodeCoverage]
+internal sealed class BindingPoint
+{
+    private readonly Func<object?>? _initialValueProvider;
+    private object? _initialValue;
+    private object? _setValue;
+    private bool _valueSet;
+
+    public BindingPoint(object? initialValue = null, bool isReadOnly = false)
+    {
+        _initialValue = initialValue;
+        IsReadOnly = isReadOnly;
+    }
+
+    public BindingPoint(Func<object?> initialValueProvider, bool isReadOnly)
+    {
+        _initialValueProvider = initialValueProvider;
+        IsReadOnly = isReadOnly;
+    }
+
+    public bool IsReadOnly { get; }
+
+    public bool HasNewValue
+    {
+        get
+        {
+            if (IsReadOnly)
+            {
+                return false;
+            }
+
+            if (_valueSet)
+            {
+                return true;
+            }
+
+            // When binding mutable value types, even if we didn't explicitly set a new value
+            // We still end up editing a copy of that value and therefore should treat it as
+            // a new value that needs to be written back to the parent object.
+            return _initialValue?.GetType() is { } initialValueType
+                && initialValueType.IsValueType
+                // Skipping primitive value types isn't strictly necessary but avoids us needing
+                // to update the parent object in a very common case (certainly more common than
+                // mutable structs). We'll still do a "wasted" update for non-primitive immutable structs.
+                && !initialValueType.IsPrimitive;
+        }
+    }
+
+    public object? Value => _valueSet ? _setValue : _initialValue ??= _initialValueProvider?.Invoke();
+
+    public void SetValue(object? newValue)
+    {
+        Debug.Assert(!IsReadOnly);
+        Debug.Assert(!_valueSet);
+        _setValue = newValue;
+        _valueSet = true;
+    }
+
+    public void TrySetValue(object? newValue)
+    {
+        if (!IsReadOnly)
+        {
+            SetValue(newValue);
+        }
+    }
+}