Add __len__ and __contains__ to IDictionary that defines ContainsKey

Author: jhonabreul

src/embed_tests/ClassManagerTests.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
@@ -1003,6 +1004,132 @@ def call(instance):
         }
 
         #endregion
+
+        private static TestCaseData[] IDictionaryContainsTestCases => new TestCaseData[]
+        {
+            new(typeof(TestDictionary<string, string>)),
+            new(typeof(Dictionary<string, string>)),
+        };
+
+        [TestCaseSource(nameof(IDictionaryContainsTestCases))]
+        public void IDictionaryContainsMethodIsBound(Type dictType)
+        {
+            using var _ = Py.GIL();
+
+            var module = PyModule.FromString("IDictionaryContainsMethodIsBound", $@"
+from clr import AddReference
+AddReference(""Python.EmbeddingTest"")
+
+from Python.EmbeddingTest import *
+
+def contains(dictionary, key):
+    return key in dictionary
+");
+
+            using var contains = module.GetAttr("contains");
+
+            var dictionary = (Activator.CreateInstance(dictType) as IDictionary)!;
+            var key1 = "key1";
+            dictionary.Add(key1, "value1");
+
+            using var pyDictionary = dictionary.ToPython();
+            using var pyKey1 = key1.ToPython();
+
+            var result = contains.Invoke(pyDictionary, pyKey1).As<bool>();
+            Assert.IsTrue(result);
+
+            using var pyKey2 = "key2".ToPython();
+            result = contains.Invoke(pyDictionary, pyKey2).As<bool>();
+            Assert.IsFalse(result);
+        }
+
+        [TestCaseSource(nameof(IDictionaryContainsTestCases))]
+        public void CanCheckIfNoneIsInDictionary(Type dictType)
+        {
+            using var _ = Py.GIL();
+
+            var module = PyModule.FromString("CanCheckIfNoneIsInDictionary", $@"
+from clr import AddReference
+AddReference(""Python.EmbeddingTest"")
+
+from Python.EmbeddingTest import *
+
+def contains(dictionary, key):
+    return key in dictionary
+");
+
+            using var contains = module.GetAttr("contains");
+
+            var dictionary = (Activator.CreateInstance(dictType) as IDictionary)!;
+            dictionary.Add("key1", "value1");
+
+            using var pyDictionary = dictionary.ToPython();
+
+            var result = false;
+            Assert.DoesNotThrow(() => result = contains.Invoke(pyDictionary, PyObject.None).As<bool>());
+            Assert.IsFalse(result);
+        }
+
+        public class TestDictionary<TValue, TKey> : IDictionary
+        {
+            private readonly Dictionary<TValue, TKey> _data = new();
+
+            public object this[object key] { get => ((IDictionary)_data)[key]; set => ((IDictionary)_data)[key] = value; }
+
+            public bool IsFixedSize => ((IDictionary)_data).IsFixedSize;
+
+            public bool IsReadOnly => ((IDictionary)_data).IsReadOnly;
+
+            public ICollection Keys => ((IDictionary)_data).Keys;
+
+            public ICollection Values => ((IDictionary)_data).Values;
+
+            public int Count => ((ICollection)_data).Count;
+
+            public bool IsSynchronized => ((ICollection)_data).IsSynchronized;
+
+            public object SyncRoot => ((ICollection)_data).SyncRoot;
+
+            public void Add(object key, object value)
+            {
+                ((IDictionary)_data).Add(key, value);
+            }
+
+            public void Clear()
+            {
+                ((IDictionary)_data).Clear();
+            }
+
+            public bool Contains(object key)
+            {
+                return ((IDictionary)_data).Contains(key);
+            }
+
+            public void CopyTo(Array array, int index)
+            {
+                ((ICollection)_data).CopyTo(array, index);
+            }
+
+            public IDictionaryEnumerator GetEnumerator()
+            {
+                return ((IDictionary)_data).GetEnumerator();
+            }
+
+            public void Remove(object key)
+            {
+                ((IDictionary)_data).Remove(key);
+            }
+
+            IEnumerator IEnumerable.GetEnumerator()
+            {
+                return ((IEnumerable)_data).GetEnumerator();
+            }
+
+            public bool ContainsKey(TKey key)
+            {
+                return Contains(key);
+            }
+        }
     }
 
     public class NestedTestParent

src/runtime/ClassManager.cs

@@ -180,6 +180,11 @@ internal static ClassBase CreateClass(Type type)
                 impl = new ArrayObject(type);
             }
 
+            else if (type.IsDictionary())
+            {
+                impl = new DictionaryObject(type);
+            }
+
             else if (type.IsKeyValuePairEnumerable())
             {
                 impl = new KeyValuePairEnumerableObject(type);

src/runtime/Types/DictionaryObject.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections;
+using System.Linq;
+
+namespace Python.Runtime
+{
+    /// <summary>
+    /// Implements a Python type for managed IDictionary (dictionaries).
+    /// This type is essentially the same as a ClassObject, except that it provides
+    /// sequence semantics to support natural dictionary usage (__contains__ and __len__)
+    /// from Python.
+    /// </summary>
+    internal class DictionaryObject : KeyValuePairEnumerableObject
+    {
+        internal DictionaryObject(Type tp) : base(tp)
+        {
+        }
+    }
+
+    public static class DictionaryObjectExtension
+    {
+        public static bool IsDictionary(this Type type)
+        {
+            var iDictionaryType = typeof(IDictionary);
+            return type.GetInterfaces().Contains(iDictionaryType) && DictionaryObject.VerifyMethodRequirements(type);
+        }
+    }
+}

src/runtime/Types/KeyValuePairEnumerableObject.cs

@@ -77,6 +77,13 @@ public static int sq_contains(BorrowedReference ob, BorrowedReference v)
                     $"invalid parameter type for sq_contains: should be {Converter.GetTypeByAlias(v)}, found {parameters[0].ParameterType}");
             }
 
+            // If the argument is None, we return false. Python allows using None as key,
+            // but C# doesn't and will throw, so we shortcut here
+            if (arg == null)
+            {
+                return 0;
+            }
+
             return (bool)methodInfo.Invoke(self, new[] { arg }) ? 1 : 0;
         }
     }