Allow changes in dictionaries to be synced with the managed code

Author: Mark Schareina

Source/Noesis.Javascript/JavascriptInterop.cpp

@@ -620,7 +620,18 @@ JavascriptInterop::Setter(Local<String> iName, Local<Value> iValue, const Proper
 	wstring name = (wchar_t*) *String::Value(JavascriptContext::GetCurrentIsolate(), iName);
 	Handle<External> external = Handle<External>::Cast(iInfo.Holder()->GetInternalField(0));
 	JavascriptExternal* wrapper = (JavascriptExternal*) external->Value();
-	
+
+	System::Object^ self = wrapper->GetObject();
+	System::Type^ type = self->GetType();
+	if (type->IsGenericType && type->GetInterface(System::Collections::Generic::IDictionary::typeid->Name) != nullptr)
+	{
+		// set property for c# dictionary object
+		System::Collections::Generic::IDictionary<System::String^, System::Object^>^ dict = (System::Collections::Generic::IDictionary<System::String^, System::Object^>^)self;
+		System::String^ key = gcnew System::String((wchar_t*)*String::Value(iName));
+		System::Object^ value = ConvertFromV8(iValue);
+		dict[key] = value;
+	}
+
 	// set property
 	iInfo.GetReturnValue().Set(wrapper->SetProperty(name, iValue));
 }

Tests/Noesis.Javascript.Tests/AccessorInterceptorTests.cs

@@ -1,6 +1,8 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using FluentAssertions;
 using System;
+using System.Collections.Generic;
+using Noesis.Javascript.Tests.Proxy;
 
 namespace Noesis.Javascript.Tests
 {
@@ -53,6 +55,27 @@ public void AccessingByIndexAPropertyInAManagedObject()
             _context.Run("myObject[99] == 'Value 99'").Should().BeOfType<bool>().Which.Should().BeTrue();
         }
 
+        class ClassWithDictionary
+        {
+            public JavaScriptDictionary<string, object> prop { get; set; }
+        }
+
+        [TestMethod]
+        public void AccessingDictionaryInManagedObject()
+        {
+            var dict = new Dictionary<string, object> { { "bar", "33" }, { "baz", true } };
+            ClassWithDictionary testObj = new ClassWithDictionary() { prop = new JavaScriptDictionary<string, object>(dict) };
+
+            _context.SetParameter("test", testObj);
+            var result = _context.Run(@"test.prop.foo = 42; test.prop.baz = false;");
+            var testObjResult = (ClassWithDictionary)_context.GetParameter("test");
+
+            testObjResult.prop.Count.Should().Be(3);
+            testObjResult.prop["foo"].Should().Be(42);
+            testObjResult.prop["bar"].Should().Be("33");
+            testObjResult.prop["baz"].Should().Be(false);
+        }
+
         class ClassWithProperty
         {
             public string MyProperty { get; set; }

Tests/Noesis.Javascript.Tests/Noesis.Javascript.Tests.csproj

@@ -92,6 +92,7 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="MultipleAppDomainsTest.cs" />
     <Compile Include="DateTest.cs" />
+    <Compile Include="Proxy\JavaScriptDictionary.cs" />
     <Compile Include="VersionStringTests.cs" />
   </ItemGroup>
   <ItemGroup>

Tests/Noesis.Javascript.Tests/Proxy/JavaScriptDictionary.cs

@@ -0,0 +1,115 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Noesis.Javascript.Tests.Proxy
+{
+    public class JavaScriptDictionary<K, V> : IDictionary<K, V>
+    {
+
+        public JavaScriptDictionary(IDictionary<K, V> dict)
+        {
+            realDict = dict;
+        }
+
+        private IDictionary<K, V> realDict;
+
+        public V this[K key]
+        {
+            get
+            {
+                return realDict[key];
+            }
+            set
+            {
+                realDict[key] = value;
+            }
+        }
+
+        public ICollection<K> Keys
+        {
+            get
+            {
+                return realDict.Keys;
+            }
+        }
+
+        public ICollection<V> Values
+        {
+            get
+            {
+                return realDict.Values;
+            }
+        }
+
+        public int Count
+        {
+            get
+            {
+                return realDict.Count;
+            }
+        }
+
+        public bool IsReadOnly
+        {
+            get
+            {
+                return realDict.IsReadOnly;
+            }
+        }
+
+        public void Add(K key, V value)
+        {
+            realDict.Add(key, value);
+        }
+
+        public void Add(KeyValuePair<K, V> item)
+        {
+            realDict.Add(item);
+        }
+
+        public void Clear()
+        {
+            realDict.Clear();
+        }
+
+        public bool Contains(KeyValuePair<K, V> item)
+        {
+            return realDict.Contains(item);
+        }
+
+        public bool ContainsKey(K key)
+        {
+            return realDict.ContainsKey(key);
+        }
+
+        public void CopyTo(KeyValuePair<K, V>[] array, int arrayIndex)
+        {
+            realDict.CopyTo(array, arrayIndex);
+        }
+
+        public IEnumerator<KeyValuePair<K, V>> GetEnumerator()
+        {
+            return realDict.GetEnumerator();
+        }
+
+        public bool Remove(K key)
+        {
+            return realDict.Remove(key);
+        }
+
+        public bool Remove(KeyValuePair<K, V> item)
+        {
+            return realDict.Remove(item);
+        }
+
+        public bool TryGetValue(K key, out V value)
+        {
+            return realDict.TryGetValue(key, out value);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return realDict.GetEnumerator();
+        }
+    }
+}