Use single cached reference for C# enum values in Python

Make C# enums work as singletons in Python so that the `is` identity comparison operator works for C# enums as well.

Author: jhonabreul

src/embed_tests/EnumTests.cs

@@ -418,7 +418,82 @@ def operation2():
 
             Assert.AreEqual(expectedResult, module.InvokeMethod("operation1").As<bool>());
             Assert.AreEqual(invertedOperationExpectedResult, module.InvokeMethod("operation2").As<bool>());
+        }
+
+        private static IEnumerable<TestCaseData> IdentityComparisonTestCases
+        {
+            get
+            {
+                var enumValues = Enum.GetValues<VerticalDirection>();
+                foreach (var enumValue1 in enumValues)
+                {
+                    foreach (var enumValue2 in enumValues)
+                    {
+                        if (enumValue2 != enumValue1)
+                        {
+                            yield return new TestCaseData(enumValue1, enumValue2);
+                        }
+                    }
+                }
+            }
+        }
+
+        [TestCaseSource(nameof(IdentityComparisonTestCases))]
+        public void CSharpEnumsAreSingletonsInPthonAndIdentityComparisonWorks(VerticalDirection enumValue1, VerticalDirection enumValue2)
+        {
+            var enumValue1Str = $"{nameof(EnumTests)}.{nameof(VerticalDirection)}.{enumValue1}";
+            var enumValue2Str = $"{nameof(EnumTests)}.{nameof(VerticalDirection)}.{enumValue2}";
+            using var _ = Py.GIL();
+            var module = PyModule.FromString("TESTTTT", $@"
+from clr import AddReference
+AddReference(""Python.EmbeddingTest"")
+
+from Python.EmbeddingTest import *
+
+def are_same1():
+    return {enumValue1Str} is {enumValue1Str}
+
+def are_same2():
+    enum_value = {enumValue1Str}
+    return enum_value is {enumValue1Str}
+
+def are_same3():
+    enum_value = {enumValue1Str}
+    return {enumValue1Str} is enum_value
+
+def are_same4():
+    enum_value1 = {enumValue1Str}
+    enum_value2 = {enumValue1Str}
+    return enum_value1 is enum_value2
+
+def are_not_same1():
+    return {enumValue1Str} is not {enumValue2Str}
+
+def are_not_same2():
+    enum_value = {enumValue1Str}
+    return enum_value is not {enumValue2Str}
+
+def are_not_same3():
+    enum_value = {enumValue2Str}
+    return {enumValue1Str} is not enum_value
+
+def are_not_same4():
+    enum_value1 = {enumValue1Str}
+    enum_value2 = {enumValue2Str}
+    return enum_value1 is not enum_value2
+
+
+");
+
+            Assert.IsTrue(module.InvokeMethod("are_same1").As<bool>());
+            Assert.IsTrue(module.InvokeMethod("are_same2").As<bool>());
+            Assert.IsTrue(module.InvokeMethod("are_same3").As<bool>());
+            Assert.IsTrue(module.InvokeMethod("are_same4").As<bool>());
 
+            Assert.IsTrue(module.InvokeMethod("are_not_same1").As<bool>());
+            Assert.IsTrue(module.InvokeMethod("are_not_same2").As<bool>());
+            Assert.IsTrue(module.InvokeMethod("are_not_same3").As<bool>());
+            Assert.IsTrue(module.InvokeMethod("are_not_same4").As<bool>());
         }
     }
 }

src/runtime/Converter.cs

@@ -18,6 +18,13 @@ namespace Python.Runtime
     [SuppressUnmanagedCodeSecurity]
     internal class Converter
     {
+        /// <summary>
+        /// We use a cache of the enum values references so that we treat them as singletons in Python.
+        /// We just try to mimic Python enums behavior, since Python enum values are singletons,
+        /// so the `is` identity comparison operator works for C# enums as well.
+        /// </summary>
+
+        private static readonly Dictionary<Type, Dictionary<object, PyObject>> _enumCache = new();
         private Converter()
         {
         }
@@ -228,7 +235,18 @@ internal static NewReference ToPython(object? value, Type type)
 
             if (type.IsEnum)
             {
-                return CLRObject.GetReference(value, type);
+                if (!_enumCache.TryGetValue(type, out var cache))
+                {
+                    cache = new();
+                    _enumCache[type] = cache;
+                }
+
+                if (!cache.TryGetValue(value, out var cachedValue))
+                {
+                    cache[value] = cachedValue = CLRObject.GetReference(value, type).MoveToPyObject();
+                }
+
+                return cachedValue.NewReferenceOrNull();
             }
 
             // it the type is a python subclass of a managed type then return the