Oct 18, 2023
diff --git a/src/runtime/ClassManager.cs b/src/runtime/ClassManager.cs
 using System.Diagnostics;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Security;

 using Python.Runtime.StateSerialization;
                                                             BindingFlags.Public |
                                                             BindingFlags.NonPublic;

        internal static Dictionary<MaybeType, ReflectedClrType> cache = new(capacity: 128);
        internal static Dictionary<MaybeType, ReflectedClrType> cache = new(
            capacity: 128, comparer: new MaybeTypeComparer()
        );
        private static readonly Type dtype;

        private ClassManager()
diff --git a/src/runtime/StateSerialization/MaybeType.cs b/src/runtime/StateSerialization/MaybeType.cs
 using System.Runtime.Serialization;
 using System.Runtime.Serialization.Formatters.Binary;
 using System.IO;
 using System.Collections.Generic;

 namespace Python.Runtime
 namespace Python.Runtime;

 [Serializable]
 internal struct MaybeType : ISerializable
 {
    [Serializable]
    internal struct MaybeType : ISerializable
    {
        public static implicit operator MaybeType (Type ob) => new(ob);
    public static implicit operator MaybeType (Type ob) => new(ob);

 // The AssemblyQualifiedName of the serialized Type
 const string SerializationName = "n";
 readonly string name;
 readonly Type type;
    // The AssemblyQualifiedName of the serialized Type
    const string SerializationName = "n";
    readonly string name;
    readonly Type type;

        public string DeletedMessage
    public string DeletedMessage
    {
        get
        {
            get
            {
                return $"The .NET Type {name} no longer exists";
            }
            return $"The .NET Type {name} no longer exists";
        }
    }

        public Type Value
    public Type Value
    {
        get
        {
 get
 if (type == null)
            {
                if (type == null)
                {
                    throw new SerializationException(DeletedMessage);
                }
                return type;
                throw new SerializationException(DeletedMessage);
            }
            return type;
        }
    }

 public string Name => name;
 public bool Valid => type != null;
    public string Name => name;
    public bool Valid => type != null;

 public override string ToString()
 {
 return (type != null ? type.ToString() : $"missing type: {name}");
 }
    public override string ToString()
    {
        return (type != null ? type.ToString() : $"missing type: {name}");
    }

 public MaybeType(Type tp)
 {
 type = tp;
 name = tp.AssemblyQualifiedName;
 }
    public MaybeType(Type tp)
    {
        type = tp;
        name = tp.AssemblyQualifiedName;
    }

 private MaybeType(SerializationInfo serializationInfo, StreamingContext context)
 {
 name = (string)serializationInfo.GetValue(SerializationName, typeof(string));
 type = Type.GetType(name, throwOnError:false);
 }
    private MaybeType(SerializationInfo serializationInfo, StreamingContext context)
    {
        name = (string)serializationInfo.GetValue(SerializationName, typeof(string));
        type = Type.GetType(name, throwOnError:false);
    }

        public void GetObjectData(SerializationInfo serializationInfo, StreamingContext context)
        {
            serializationInfo.AddValue(SerializationName, name);
        }
    public void GetObjectData(SerializationInfo serializationInfo, StreamingContext context)
    {
        serializationInfo.AddValue(SerializationName, name);
    }
 }

 [Serializable]
 internal class MaybeTypeComparer : IEqualityComparer<MaybeType>
 {
    public bool Equals (MaybeType lhs, MaybeType rhs) =>
        lhs.Name == rhs.Name;

    public int GetHashCode(MaybeType t) => (t.Name ?? "").GetHashCode();
 }
Original file line number	Diff line number	Diff line change
Expand Up		@@ -3,7 +3,6 @@
		using System.Diagnostics;
		using System.Linq;
		using System.Reflection;
		using System.Runtime.InteropServices;
		using System.Security;

		using Python.Runtime.StateSerialization;
Expand DownExpand Up		@@ -33,7 +32,9 @@ internal class ClassManager
		BindingFlags.Public \|
		BindingFlags.NonPublic;

		internal static Dictionary<MaybeType, ReflectedClrType> cache = new(capacity: 128);
		internal static Dictionary<MaybeType, ReflectedClrType> cache = new(
		capacity: 128, comparer: new MaybeTypeComparer()
		);
		private static readonly Type dtype;

		private ClassManager()
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -3,62 +3,71 @@
		using System.Runtime.Serialization;
		using System.Runtime.Serialization.Formatters.Binary;
		using System.IO;
		using System.Collections.Generic;

		namespace Python.Runtime
		namespace Python.Runtime;

		[Serializable]
		internal struct MaybeType : ISerializable
		{
		[Serializable]
		internal struct MaybeType : ISerializable
		{
		public static implicit operator MaybeType (Type ob) => new(ob);
		public static implicit operator MaybeType (Type ob) => new(ob);

		// The AssemblyQualifiedName of the serialized Type
		const string SerializationName = "n";
		readonly string name;
		readonly Type type;
		// The AssemblyQualifiedName of the serialized Type
		const string SerializationName = "n";
		readonly string name;
		readonly Type type;

		public string DeletedMessage
		public string DeletedMessage
		{
		get
		{
		get
		{
		return $"The .NET Type {name} no longer exists";
		}
		return $"The .NET Type {name} no longer exists";
		}
		}

		public Type Value
		public Type Value
		{
		get
		{
		get
		if (type == null)
		{
		if (type == null)
		{
		throw new SerializationException(DeletedMessage);
		}
		return type;
		throw new SerializationException(DeletedMessage);
		}
		return type;
		}
		}

		public string Name => name;
		public bool Valid => type != null;
		public string Name => name;
		public bool Valid => type != null;

		public override string ToString()
		{
		return (type != null ? type.ToString() : $"missing type: {name}");
		}
		public override string ToString()
		{
		return (type != null ? type.ToString() : $"missing type: {name}");
		}

		public MaybeType(Type tp)
		{
		type = tp;
		name = tp.AssemblyQualifiedName;
		}
		public MaybeType(Type tp)
		{
		type = tp;
		name = tp.AssemblyQualifiedName;
		}

		private MaybeType(SerializationInfo serializationInfo, StreamingContext context)
		{
		name = (string)serializationInfo.GetValue(SerializationName, typeof(string));
		type = Type.GetType(name, throwOnError:false);
		}
		private MaybeType(SerializationInfo serializationInfo, StreamingContext context)
		{
		name = (string)serializationInfo.GetValue(SerializationName, typeof(string));
		type = Type.GetType(name, throwOnError:false);
		}

		public void GetObjectData(SerializationInfo serializationInfo, StreamingContext context)
		{
		serializationInfo.AddValue(SerializationName, name);
		}
		public void GetObjectData(SerializationInfo serializationInfo, StreamingContext context)
		{
		serializationInfo.AddValue(SerializationName, name);
		}
		}

		[Serializable]
		internal class MaybeTypeComparer : IEqualityComparer<MaybeType>
		{
		public bool Equals (MaybeType lhs, MaybeType rhs) =>
		lhs.Name == rhs.Name;

		public int GetHashCode(MaybeType t) => (t.Name ?? "").GetHashCode();
		}