pythonnet · filmor · Feb 14, 2021 · Feb 19, 2021
diff --git a/pythonnet/__init__.py b/pythonnet/__init__.py
@@ -63,7 +63,7 @@ def unload():
    global _RUNTIME
    if _LOADER_ASSEMBLY is not None:
        func = _LOADER_ASSEMBLY["Python.Runtime.Loader.Shutdown"]
-        if func(b"") != 0:
+        if func(b"full_shutdown") != 0:
            raise RuntimeError("Failed to call Python.NET shutdown")

    if _RUNTIME is not None:

diff --git a/src/runtime/classbase.cs b/src/runtime/classbase.cs
@@ -354,20 +354,16 @@ public static IntPtr tp_repr(IntPtr ob)
        public static void tp_dealloc(IntPtr ob)
        {
            ManagedType self = GetManagedObject(ob);
-            tp_clear(ob);
-            Runtime.PyObject_GC_UnTrack(self.pyHandle);
-            Runtime.PyObject_GC_Del(self.pyHandle);
+            RemoveObjectDict(ob);
+            Runtime.Py_CLEAR(ref self.tpHandle);
+            Runtime.PyObject_GC_UnTrack(ob);
+            Runtime.PyObject_GC_Del(ob);
            self.FreeGCHandle();
        }

        public static int tp_clear(IntPtr ob)
        {
-            ManagedType self = GetManagedObject(ob);
-            if (!self.IsTypeObject())
-            {
-                ClearObjectDict(ob);
-            }
-            self.tpHandle = IntPtr.Zero;
+            ClearObjectDict(ob);
            return 0;
        }


diff --git a/src/runtime/classmanager.cs b/src/runtime/classmanager.cs
@@ -5,6 +5,7 @@
 using System.Runtime.InteropServices;
 using System.Security;
 using System.Linq;
+using System.Diagnostics;

 namespace Python.Runtime
 {
@@ -270,7 +271,7 @@ private static void InitClassBase(Type type, ClassBase impl)

            // Finally, initialize the class __dict__ and return the object.
            var dict = new BorrowedReference(Marshal.ReadIntPtr(tp, TypeOffset.tp_dict));
-
+            Debug.Assert(!dict.IsNull);

            if (impl.dotNetMembers == null)
            {

diff --git a/src/runtime/extensiontype.cs b/src/runtime/extensiontype.cs
@@ -55,7 +55,7 @@ void SetupGc ()
        /// </summary>
        public static void FinalizeObject(ManagedType self)
        {
-            ClearObjectDict(self.pyHandle);
+            RemoveObjectDict(self.pyHandle);
            Runtime.PyObject_GC_Del(self.pyHandle);
            // Not necessary for decref of `tpHandle`.
            self.FreeGCHandle();

diff --git a/src/runtime/managedtype.cs b/src/runtime/managedtype.cs
@@ -243,6 +243,16 @@ protected virtual void OnSave(InterDomainContext context) { }
        protected virtual void OnLoad(InterDomainContext context) { }

        protected static void ClearObjectDict(IntPtr ob)
+        {
+            IntPtr dict = GetObjectDict(ob);
+            if (dict == IntPtr.Zero)
+            {
+                return;
+            }
+            Runtime.PyDict_Clear(dict);
+        }
+
+        protected static void RemoveObjectDict(IntPtr ob)
        {
            IntPtr dict = GetObjectDict(ob);
            if (dict == IntPtr.Zero)

diff --git a/src/runtime/metatype.cs b/src/runtime/metatype.cs
@@ -304,6 +304,12 @@ public static void tp_dealloc(IntPtr tp)
            NativeCall.Void_Call_1(op, tp);
        }

+        public static int tp_clear(IntPtr ob)
+        {
+            ClearObjectDict(ob);
+            return 0;
+        }
+
        private static IntPtr DoInstanceCheck(IntPtr tp, IntPtr args, bool checkType)
        {
            var cb = GetManagedObject(tp) as ClassBase;

diff --git a/src/runtime/methodobject.cs b/src/runtime/methodobject.cs
@@ -217,7 +217,7 @@ public static IntPtr tp_repr(IntPtr ob)
        {
            var self = (MethodObject)GetManagedObject(ob);
            self.ClearMembers();
-            ClearObjectDict(ob);
+            RemoveObjectDict(ob);
            self.Dealloc();
        }


diff --git a/src/runtime/runtime.cs b/src/runtime/runtime.cs
@@ -503,15 +503,19 @@ private static void PyDictTryDelItem(BorrowedReference dict, string key)
        private static void MoveClrInstancesOnwershipToPython()
        {
            var objs = ManagedType.GetManagedObjects();
-            var copyObjs = objs.ToArray();
-            foreach (var entry in copyObjs)
+            var copyObjs = new KeyValuePair<ManagedType, ManagedType.TrackTypes>[objs.Count];
            {
-                ManagedType obj = entry.Key;
-                if (!objs.ContainsKey(obj))
+                int i = 0;
+                foreach (var entry in objs)
                {
-                    System.Diagnostics.Debug.Assert(obj.gcHandle == default);
-                    continue;
+                    ManagedType obj = entry.Key;
+                    XIncref(obj.pyHandle);
+                    copyObjs[i++] = entry;
                }
+            }
+            foreach (var entry in copyObjs)
+            {
+                ManagedType obj = entry.Key;
                if (entry.Value == ManagedType.TrackTypes.Extension)
                {
                    obj.CallTypeClear();
@@ -522,11 +526,21 @@ private static void MoveClrInstancesOnwershipToPython()
                        PyObject_GC_Track(obj.pyHandle);
                    }
                }
-                if (obj.gcHandle.IsAllocated)
+            }
+            foreach (var entry in copyObjs)
+            {
+                ManagedType obj = entry.Key;
+                if (!objs.ContainsKey(obj))
+                {
+                    System.Diagnostics.Debug.Assert(obj.gcHandle == default);
+                    continue;
+                }
+                if (obj.RefCount > 1)
                {
-                    obj.gcHandle.Free();
+                    obj.FreeGCHandle();
+                    Marshal.WriteIntPtr(obj.pyHandle, ObjectOffset.magic(obj.tpHandle), IntPtr.Zero);
                }
-                obj.gcHandle = default;
+                XDecref(obj.pyHandle);
            }
            ManagedType.ClearTrackedObjects();
        }