Implement .As<T>, add some notification tests

Realm/Realm/DatabaseTypes/RealmValue.cs

@@ -789,13 +789,17 @@ public T AsRealmObject<T>()
             where T : class, IRealmObjectBase
             => Type == RealmValueType.Null ? null : AsRealmObject<T>();
 
+        // TODO (ni): add docs
         public T AsMappedObject<T>()
             where T : class, IMappedObject
         {
             EnsureType("dictionary", RealmValueType.Dictionary);
-            throw new NotImplementedException();
+            var result = Activator.CreateInstance<T>();
+            result.SetBackingStorage(_dictionaryValue!);
+            return result;
         }
 
+        // TODO (ni): add docs
         public T? AsNullableMappedObject<T>()
             where T : class, IMappedObject
             => Type == RealmValueType.Null ? null : AsMappedObject<T>();
@@ -815,12 +819,17 @@ public T As<T>()
 
             if (typeof(IMappedObject).IsAssignableFrom(typeof(T)))
             {
-                return Type switch
+                switch (Type)
                 {
-                    RealmValueType.Null => Operator.Convert<T>(null)!,
-                    RealmValueType.Dictionary => throw new NotImplementedException(),
-                    _ => throw new NotSupportedException($"Can't convert from {Type} to dictionary, which is the backing storage type for {typeof(T)}"),
-                };
+                    case RealmValueType.Null:
+                        return Operator.Convert<T>(null)!;
+                    case RealmValueType.Dictionary:
+                        var result = Activator.CreateInstance<T>()!;
+                        ((IMappedObject)result).SetBackingStorage(_dictionaryValue!);
+                        return result;
+                    default:
+                        throw new InvalidCastException($"Can't convert from {Type} to dictionary, which is the backing storage type for {typeof(T)}");
+                }
             }
 
             // This largely copies AsAny to avoid boxing the underlying value in an object

Realm/Realm/Extensions/CollectionExtensions.cs

@@ -557,6 +557,15 @@ public static async Task<IQueryable<T>> SubscribeAsync<T>(this IQueryable<T> que
         return query;
     }
 
+    // TODO (ni): add docs
+    public static T As<T>(this IDictionary<string, RealmValue> dict)
+        where T : IMappedObject
+    {
+        var result = Activator.CreateInstance<T>();
+        result.SetBackingStorage(dict);
+        return result;
+    }
+
     [EditorBrowsable(EditorBrowsableState.Never)]
     [SuppressMessage("StyleCop.CSharp.DocumentationRules", "SA1600:Elements should be documented",
         Justification = "This is only used by the weaver/source generated classes and should not be exposed to users.")]

Tests/Realm.Tests/Database/FlexibleSchemaPocTests.cs

@@ -16,8 +16,11 @@
 //
 ////////////////////////////////////////////////////////////////////////////
 
+using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using NUnit.Framework;
 
 namespace Realms.Tests.Database;
@@ -26,15 +29,45 @@ namespace Realms.Tests.Database;
 public partial class FlexibleSchemaPocTests : RealmInstanceTest
 {
     [Test]
-    public void ConvertDictionary_ToMappedType()
+    public void RealmValue_AsMappedType_ReturnsCorrectObject()
     {
-        // TODO: NI to get this to work
         AddData();
 
         var dogContainer = _realm.All<FlexibleSchemaPocContainer>().First(c => c.ContainedObjectType == nameof(Dog));
 
         var dog = dogContainer.MixedProperty.As<Dog>();
-        // var dogFromDict = dogContainer.MixedDict.As<Dog>();
+
+        // TODO: add assertions for the values
+        Assert.That(dog, Is.TypeOf<Dog>());
+
+        var dog2 = dogContainer.MixedProperty.AsMappedObject<Dog>();
+
+        // TODO: add assertions for the values
+        Assert.That(dog2, Is.TypeOf<Dog>());
+
+        var nullContainer = _realm.Write(() => _realm.Add(new FlexibleSchemaPocContainer("null")
+        {
+            MixedProperty = RealmValue.Null
+        }));
+
+        var nullDog = nullContainer.MixedProperty.As<Dog?>();
+        Assert.That(nullDog, Is.Null);
+
+        var nullDog2 = nullContainer.MixedProperty.AsNullableMappedObject<Dog>();
+        Assert.That(nullDog2, Is.Null);
+    }
+
+    [Test]
+    public void RealmValue_AsMappedType_WhenTypeIsIncorrect_Throws()
+    {
+        var intContainer = _realm.Write(() => _realm.Add(new FlexibleSchemaPocContainer("int")
+        {
+            MixedProperty = 5
+        }));
+
+        Assert.Throws<InvalidCastException>(() => intContainer.MixedProperty.As<Dog>());
+        Assert.Throws<InvalidCastException>(() => intContainer.MixedProperty.AsMappedObject<Dog>());
+        Assert.Throws<InvalidCastException>(() => intContainer.MixedProperty.AsNullableMappedObject<Dog>());
     }
 
     [Test]
@@ -59,6 +92,43 @@ public void AccessMappedTypeProperties_ReadsValuesFromBackingStorage()
         Assert.That(bird.CanFly, Is.True);
     }
 
+    [Test]
+    public void NotifyPropertyChanged_NotifiesForModifications()
+    {
+        AddData();
+
+        var dogContainer = _realm.All<FlexibleSchemaPocContainer>().First(c => c.ContainedObjectType == nameof(Dog));
+
+        var dog = dogContainer.MixedProperty.As<Dog>();
+        var changes = new List<PropertyChangedEventArgs>();
+        dog.PropertyChanged += (s, e) =>
+        {
+            Assert.That(s, Is.EqualTo(dog));
+            changes.Add(e);
+        };
+
+        _realm.Write(() =>
+        {
+            dogContainer.MixedProperty.AsDictionary()[nameof(Dog.BarkCount)] = 10;
+        });
+
+        _realm.Refresh();
+
+        Assert.That(changes.Count, Is.EqualTo(1));
+        Assert.That(changes[0].PropertyName, Is.EqualTo(nameof(Dog.BarkCount)));
+
+        _realm.Write(() =>
+        {
+            dogContainer.MixedProperty.AsDictionary()[nameof(Dog.BarkCount)] = 15;
+            dogContainer.MixedProperty.AsDictionary()[nameof(Dog.Name)] = "Fido III";
+        });
+        _realm.Refresh();
+
+        Assert.That(changes.Count, Is.EqualTo(3));
+        Assert.That(changes[1].PropertyName, Is.EqualTo(nameof(Dog.BarkCount)));
+        Assert.That(changes[2].PropertyName, Is.EqualTo(nameof(Dog.Name)));
+    }
+
     private void AddData()
     {
         _realm.Write(() =>
@@ -115,14 +185,77 @@ public partial class Dog : IMappedObject
     }
 
     // Generated
-    public partial class Dog
+    public partial class Dog : INotifyPropertyChanged
     {
         private IDictionary<string, RealmValue> _backingStorage = null!;
 
         public void SetBackingStorage(IDictionary<string, RealmValue> dictionary)
         {
             _backingStorage = dictionary;
         }
+
+        #region  INotifyPropertyChanged
+
+        private IDisposable? _notificationToken;
+
+        private event PropertyChangedEventHandler? _propertyChanged;
+
+        /// <inheritdoc />
+        public event PropertyChangedEventHandler? PropertyChanged
+        {
+            add
+            {
+                if (_propertyChanged == null)
+                {
+                    SubscribeForNotifications();
+                }
+
+                _propertyChanged += value;
+            }
+
+            remove
+            {
+                _propertyChanged -= value;
+
+                if (_propertyChanged == null)
+                {
+                    UnsubscribeFromNotifications();
+                }
+            }
+        }
+
+        partial void OnPropertyChanged(string? propertyName);
+
+        private void RaisePropertyChanged([CallerMemberName] string propertyName = "")
+        {
+            _propertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+            OnPropertyChanged(propertyName);
+        }
+
+        private void SubscribeForNotifications()
+        {
+            _notificationToken = _backingStorage.SubscribeForKeyNotifications((sender, changes) =>
+            {
+                if (changes == null)
+                {
+                    return;
+                }
+
+                foreach (var key in changes.ModifiedKeys)
+                {
+                    RaisePropertyChanged(key);
+                }
+
+                // TODO: what do we do with deleted/inserted keys
+            });
+        }
+
+        private void UnsubscribeFromNotifications()
+        {
+            _notificationToken?.Dispose();
+        }
+
+        #endregion
     }
 
     // User-defined
@@ -134,13 +267,76 @@ public partial class Bird : IMappedObject
     }
 
     // Generated
-    public partial class Bird
+    public partial class Bird : INotifyPropertyChanged
     {
         private IDictionary<string, RealmValue> _backingStorage = null!;
 
         public void SetBackingStorage(IDictionary<string, RealmValue> dictionary)
         {
             _backingStorage = dictionary;
         }
+
+        #region  INotifyPropertyChanged
+
+        private IDisposable? _notificationToken;
+
+        private event PropertyChangedEventHandler? _propertyChanged;
+
+        /// <inheritdoc />
+        public event PropertyChangedEventHandler? PropertyChanged
+        {
+            add
+            {
+                if (_propertyChanged == null)
+                {
+                    SubscribeForNotifications();
+                }
+
+                _propertyChanged += value;
+            }
+
+            remove
+            {
+                _propertyChanged -= value;
+
+                if (_propertyChanged == null)
+                {
+                    UnsubscribeFromNotifications();
+                }
+            }
+        }
+
+        partial void OnPropertyChanged(string? propertyName);
+
+        private void RaisePropertyChanged([CallerMemberName] string propertyName = "")
+        {
+            _propertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+            OnPropertyChanged(propertyName);
+        }
+
+        private void SubscribeForNotifications()
+        {
+            _notificationToken = _backingStorage.SubscribeForKeyNotifications((sender, changes) =>
+            {
+                if (changes == null)
+                {
+                    return;
+                }
+
+                foreach (var key in changes.ModifiedKeys)
+                {
+                    RaisePropertyChanged(key);
+                }
+
+                // TODO: what do we do with deleted/inserted keys
+            });
+        }
+
+        private void UnsubscribeFromNotifications()
+        {
+            _notificationToken?.Dispose();
+        }
+
+        #endregion
     }
 }