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/embed_tests/Python.EmbeddingTest.csproj b/src/embed_tests/Python.EmbeddingTest.csproj
@@ -2,6 +2,7 @@
 
   <PropertyGroup>
     <TargetFrameworks>net472;netcoreapp3.1</TargetFrameworks>
+    <LangVersion>9.0</LangVersion>
     <AssemblyOriginatorKeyFile>..\pythonnet.snk</AssemblyOriginatorKeyFile>
     <SignAssembly>true</SignAssembly>
   </PropertyGroup>

diff --git a/src/embed_tests/TestClass.cs b/src/embed_tests/TestClass.cs
@@ -0,0 +1,78 @@
+using System;
+using System.Runtime.InteropServices;
+
+using NUnit.Framework;
+
+using Python.Runtime;
+
+using PyRuntime = Python.Runtime.Runtime;
+
+namespace Python.EmbeddingTest
+{
+    public class TestClass
+    {
+        public class MyClass
+        {
+        }
+
+        [OneTimeSetUp]
+        public void SetUp()
+        {
+            PythonEngine.Initialize();
+        }
+
+        [OneTimeTearDown]
+        public void Dispose()
+        {
+            PythonEngine.Shutdown();
+        }
+
+        [Test]
+        public void WeakRefForClrObject()
+        {
+            var obj = new MyClass();
+            using var scope = Py.CreateScope();
+            scope.Set("clr_obj", obj);
+            scope.Exec(@"
+import weakref
+ref = weakref.ref(clr_obj)
+");
+            using PyObject pyobj = scope.Get("clr_obj");
+            ValidateAttachedGCHandle(obj, pyobj.Handle);
+        }
+
+        [Test]
+        public void WeakRefForSubClass()
+        {
+            using (var scope = Py.CreateScope())
+            {
+                scope.Exec(@"
+from Python.EmbeddingTest import TestClass
+import weakref
+
+class Sub(TestClass.MyClass):
+    pass
+
+obj = Sub()
+ref = weakref.ref(obj)
+");
+                using (PyObject pyobj = scope.Get("obj"))
+                {
+                    IntPtr op = pyobj.Handle;
+                    IntPtr type = PyRuntime.PyObject_TYPE(op);
+                    IntPtr clrHandle = Marshal.ReadIntPtr(op, ObjectOffset.magic(type));
+                    var clobj = (CLRObject)GCHandle.FromIntPtr(clrHandle).Target;
+                    Assert.IsTrue(clobj.inst is MyClass);
+                }
+            }
+        }
+
+        private static void ValidateAttachedGCHandle(object obj, IntPtr op)
+        {
+            IntPtr type = PyRuntime.PyObject_TYPE(op);
+            IntPtr clrHandle = Marshal.ReadIntPtr(op, ObjectOffset.magic(type));
+            var clobj = (CLRObject)GCHandle.FromIntPtr(clrHandle).Target;
+            Assert.True(ReferenceEquals(clobj.inst, obj));
+        }
+    }
+}
diff --git a/src/runtime/classbase.cs b/src/runtime/classbase.cs
@@ -1,9 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Runtime.InteropServices;
-using System.Runtime.Serialization;
 
 namespace Python.Runtime
 {
@@ -354,44 +352,39 @@ 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);
+            if (Runtime.PyType_SUPPORTS_WEAKREFS(Runtime.PyObject_TYPE(ob)))
+            {
+                Runtime.PyObject_ClearWeakRefs(ob);
+            }
+            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;
         }
 
         protected override void OnSave(InterDomainContext context)
         {
             base.OnSave(context);
-            if (pyHandle != tpHandle)
-            {
-                IntPtr dict = GetObjectDict(pyHandle);
-                Runtime.XIncref(dict);
-                context.Storage.AddValue("dict", dict);
-            }
+            IntPtr dict = GetObjectDict(pyHandle);
+            Runtime.XIncref(dict);
+            Runtime.XIncref(tpHandle);
+            context.Storage.AddValue("dict", dict);
         }
 
         protected override void OnLoad(InterDomainContext context)
         {
             base.OnLoad(context);
-            if (pyHandle != tpHandle)
-            {
-                IntPtr dict = context.Storage.GetValue<IntPtr>("dict");
-                SetObjectDict(pyHandle, dict);
-            }
+            IntPtr dict = context.Storage.GetValue<IntPtr>("dict");
+            SetObjectDict(pyHandle, dict);
             gcHandle = AllocGCHandle();
-            Marshal.WriteIntPtr(pyHandle, TypeOffset.magic(), (IntPtr)gcHandle);
+            Marshal.WriteIntPtr(pyHandle, ObjectOffset.magic(tpHandle), (IntPtr)gcHandle);
         }
 
 

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/clrobject.cs b/src/runtime/clrobject.cs
@@ -30,10 +30,6 @@ internal CLRObject(object ob, IntPtr tp)
             tpHandle = tp;
             pyHandle = py;
             inst = ob;
-
-            // Fix the BaseException args (and __cause__ in case of Python 3)
-            // slot if wrapping a CLR exception
-            Exceptions.SetArgsAndCause(py);
         }
 
         protected CLRObject()
@@ -49,7 +45,7 @@ static CLRObject GetInstance(object ob, IntPtr pyType)
         static CLRObject GetInstance(object ob)
         {
             ClassBase cc = ClassManager.GetClass(ob.GetType());
-            return GetInstance(ob, cc.tpHandle);
+            return GetInstance(ob, cc.pyHandle);
         }
 
         internal static NewReference GetInstHandle(object ob, BorrowedReference pyType)
@@ -67,7 +63,7 @@ internal static IntPtr GetInstHandle(object ob, IntPtr pyType)
         internal static IntPtr GetInstHandle(object ob, Type type)
         {
             ClassBase cc = ClassManager.GetClass(type);
-            CLRObject co = GetInstance(ob, cc.tpHandle);
+            CLRObject co = GetInstance(ob, cc.pyHandle);
             return co.pyHandle;
         }
 

diff --git a/src/runtime/exceptions.cs b/src/runtime/exceptions.cs
@@ -85,6 +85,13 @@ internal static Exception ToException(IntPtr ob)
             }
             return Runtime.PyUnicode_FromString(message);
         }
+
+        public static int tp_init(IntPtr ob, IntPtr args, IntPtr kwds)
+        {
+            Exceptions.SetArgsAndCause(ob);
+            return 0;
+        }
+
     }
 
     /// <summary>
@@ -180,16 +187,23 @@ internal static void SetArgsAndCause(IntPtr ob)
                 args = Runtime.PyTuple_New(0);
             }
 
-            Marshal.WriteIntPtr(ob, ExceptionOffset.args, args);
-
+            int baseOffset = OriginalObjectOffsets.Size;
+            Runtime.Py_SETREF(ob, baseOffset + ExceptionOffset.args, args);
+
             if (e.InnerException != null)
             {
-                // Note: For an AggregateException, InnerException is only the first of the InnerExceptions.
-                IntPtr cause = CLRObject.GetInstHandle(e.InnerException);
-                Marshal.WriteIntPtr(ob, ExceptionOffset.cause, cause);
+                IntPtr cause = GetExceptHandle(e.InnerException);
+                Runtime.Py_SETREF(ob, baseOffset + ExceptionOffset.cause, cause);
             }
         }
 
+        internal static IntPtr GetExceptHandle(Exception e)
+        {
+            IntPtr op = CLRObject.GetInstHandle(e);
+            SetArgsAndCause(op);
+            return op;
+        }
+
         /// <summary>
         /// Shortcut for (pointer == NULL) -&gt; throw PythonException
         /// </summary>
@@ -289,7 +303,7 @@ public static void SetError(Exception e)
                 return;
             }
 
-            IntPtr op = CLRObject.GetInstHandle(e);
+            IntPtr op = GetExceptHandle(e);
             IntPtr etype = Runtime.PyObject_GetAttr(op, PyIdentifier.__class__);
             Runtime.PyErr_SetObject(new BorrowedReference(etype), new BorrowedReference(op));
             Runtime.XDecref(etype);

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();