Remove hungarian notation from Maybe* types

pythonnet · lostmsu · Jan 7, 2021 · Nov 9, 2020 · Nov 9, 2020 · Nov 18, 2020
commit 02fa245eed021c36ab211d7969766d5c871b2c5d
diff --git a/src/runtime/StateSerialization/MaybeMemberInfo.cs b/src/runtime/StateSerialization/MaybeMemberInfo.cs
@@ -11,8 +11,8 @@ internal struct MaybeMemberInfo<T> : ISerializable where T: MemberInfo
     {
         public static implicit operator MaybeMemberInfo<T> (T ob) => new MaybeMemberInfo<T>(ob);
 
-        string m_name;
-        MemberInfo m_info;
+        string name;
+        MemberInfo info;
 
         // As seen in ClassManager.GetClassInfo
         const BindingFlags k_flags = BindingFlags.Static |
@@ -23,62 +23,62 @@ public string DeletedMessage
         {
             get
             {
-                return $"The .NET {typeof(T)} {m_name} no longer exists";
+                return $"The .NET {typeof(T)} {name} no longer exists";
             }
         }
 
         public T Value
         {
             get
             {
-                if (m_info == null)
+                if (info == null)
                 {
                     throw new SerializationException(DeletedMessage);
                 }
-                return (T)m_info;
+                return (T)info;
             }
         }
 
-        public string Name {get{return m_name;}}
-        public bool Valid => m_info != null;
+        public string Name {get{return name;}}
+        public bool Valid => info != null;
 
         public override string ToString()
         {
-            return (m_info != null ? m_info.ToString() : $"missing type: {m_name}");
+            return (info != null ? info.ToString() : $"missing type: {name}");
         }
 
         public MaybeMemberInfo(T fi)
         {
-            m_info = fi;
-            m_name = m_info?.ToString();
+            info = fi;
+            name = info?.ToString();
         }
 
-        internal MaybeMemberInfo(SerializationInfo info, StreamingContext context)
+        internal MaybeMemberInfo(SerializationInfo serializationInfo, StreamingContext context)
         {
             // Assumption: name is always stored in "s"
-            m_name = info.GetString("s");
-            m_info = null;
+            name = serializationInfo.GetString("s");
+            info = null;
             try
             {
-                var tp = Type.GetType(info.GetString("t"));
+                var tp = Type.GetType(serializationInfo.GetString("t"));
                 if (tp != null)
                 {
-                    var field_name = info.GetString("f");
-                    m_info = tp.GetField(field_name, k_flags);
+                    var field_name = serializationInfo.GetString("f");
+                    info = tp.GetField(field_name, k_flags);
                 }
             }
             catch 
             {
             }
         }
 
-        public void GetObjectData(SerializationInfo info, StreamingContext context)
+        public void GetObjectData(SerializationInfo serializationInfo, StreamingContext context)
         {
-            info.AddValue("s", m_name);
+            serializationInfo.AddValue("s", name);
             if (Valid)
             {
-                info.AddValue("f", m_info.Name);
-                info.AddValue("t", m_info.ReflectedType.AssemblyQualifiedName);
+                serializationInfo.AddValue("f", info.Name);
+                serializationInfo.AddValue("t", info.ReflectedType.AssemblyQualifiedName);
             }
         }
     }

diff --git a/src/runtime/StateSerialization/MaybeMethodBase.cs b/src/runtime/StateSerialization/MaybeMethodBase.cs
@@ -11,8 +11,8 @@ internal struct MaybeMethodBase<T> : ISerializable where T: MethodBase
     {
         public static implicit operator MaybeMethodBase<T> (T ob) => new MaybeMethodBase<T>(ob);
 
-        string m_name;
-        MethodBase m_info;
+        string name;
+        MethodBase info;
         // As seen in ClassManager.GetClassInfo
         const BindingFlags k_flags = BindingFlags.Static |
                         BindingFlags.Instance |
@@ -22,72 +22,72 @@ public T Value
         {
             get
             {
-                if (m_info == null)
+                if (info == null)
                 {
-                    throw new SerializationException($"The .NET {typeof(T)} {m_name} no longer exists");
+                    throw new SerializationException($"The .NET {typeof(T)} {name} no longer exists");
                 }
-                return (T)m_info;
+                return (T)info;
             }
         }
 
-        public T UnsafeValue { get { return (T)m_info; } }
-        public string Name {get{return m_name;}}
-        public bool Valid => m_info != null;
+        public T UnsafeValue { get { return (T)info; } }
+        public string Name {get{return name;}}
+        public bool Valid => info != null;
 
         public override string ToString()
         {
-            return (m_info != null ? m_info.ToString() : $"missing method info: {m_name}");
+            return (info != null ? info.ToString() : $"missing method info: {name}");
         }
 
         public MaybeMethodBase(T mi)
         {
-            m_info = mi;
-            m_name = mi?.ToString();
+            info = mi;
+            name = mi?.ToString();
         }
 
-        internal MaybeMethodBase(SerializationInfo info, StreamingContext context)
+        internal MaybeMethodBase(SerializationInfo serializationInfo, StreamingContext context)
         {
-            m_name = info.GetString("s");
-            m_info = null;
+            name = serializationInfo.GetString("s");
+            info = null;
             try
             {
                 // Retrive the reflected type of the method;
-                var tp = Type.GetType(info.GetString("t"));
+                var tp = Type.GetType(serializationInfo.GetString("t"));
                 // Get the method's parameters types
-                var field_name = info.GetString("f");
-                var param = (string[])info.GetValue("p", typeof(string[]));
+                var field_name = serializationInfo.GetString("f");
+                var param = (string[])serializationInfo.GetValue("p", typeof(string[]));
                 Type[] types = new Type[param.Length];
                 for (int i = 0; i < param.Length; i++)
                 {
                     types[i] = Type.GetType(param[i]);
                 }
                 // Try to get the method
-                m_info = tp.GetMethod(field_name, k_flags, binder:null, types:types, modifiers:null);
+                info = tp.GetMethod(field_name, k_flags, binder:null, types:types, modifiers:null);
                 // Try again, may be a constructor
-                if (m_info == null && m_name.Contains(".ctor&quo
F438
t;))
+                if (info == null && name.Contains(".ctor"))
                 {
-                    m_info = tp.GetConstructor(k_flags, binder:null, types:types, modifiers:null);
+                    info = tp.GetConstructor(k_flags, binder:null, types:types, modifiers:null);
                 }
             }
             catch
             {
             }
         }
 
-        public void GetObjectData(SerializationInfo info, StreamingContext context)
+        public void GetObjectData(SerializationInfo serializationInfo, StreamingContext context)
         {
-            info.AddValue("s", m_name);
+            serializationInfo.AddValue("s", name);
             if (Valid)
             {
-                info.AddValue("f", m_info.Name);
-                info.AddValue("t", m_info.ReflectedType.AssemblyQualifiedName);
-                var p = m_info.GetParameters();
+                serializationInfo.AddValue("f", info.Name);
+                serializationInfo.AddValue("t", info.ReflectedType.AssemblyQualifiedName);
+                var p = info.GetParameters();
                 string[] types = new string[p.Length];
                 for (int i = 0; i < p.Length; i++)
                 {
                     types[i] = p[i].ParameterType.AssemblyQualifiedName;
                 }
-                info.AddValue("p", types, typeof(string[]));
+                serializationInfo.AddValue("p", types, typeof(string[]));
             }
         }
     }

diff --git a/src/runtime/StateSerialization/MaybeType.cs b/src/runtime/StateSerialization/MaybeType.cs
@@ -11,52 +11,52 @@ internal struct MaybeType : ISerializable
     {
         public static implicit operator MaybeType (Type ob) => new MaybeType(ob);
 
-        string m_name;
-        Type m_type;
+        string name;
+        Type type;
 
         public string DeletedMessage
         {
             get
             {
-                return $"The .NET Type {m_name} no longer exists";
+                return $"The .NET Type {name} no longer exists";
             }
         }
 
         public Type Value
         {
             get
             {
-                if (m_type == null)
+                if (type == null)
                 {
                     throw new SerializationException(DeletedMessage);
                 }
-                return m_type;
+                return type;
             }
         }
 
-        public string Name {get{return m_name;}}
-        public bool Valid => m_type != null;
+        public string Name {get{return name;}}
+        public bool Valid => type != null;
 
         public override string ToString()
         {
-            return (m_type != null ? m_type.ToString() : $"missing type: {m_name}");
+            return (type != null ? type.ToString() : $"missing type: {name}");
         }
 
         public MaybeType(Type tp)
         {
-            m_type = tp;
-            m_name = tp.AssemblyQualifiedName;
+            type = tp;
+            name = tp.AssemblyQualifiedName;
         }
 
-        private MaybeType(SerializationInfo info, StreamingContext context)
+        private MaybeType(SerializationInfo serializationInfo, StreamingContext context)
         {
-            m_name = (string)info.GetValue("n", typeof(string));
-            m_type = Type.GetType(m_name, throwOnError:false);
+            name = (string)serializationInfo.GetValue("n", typeof(string));
+            type = Type.GetType(name, throwOnError:false);
         }
 
-        public void GetObjectData(SerializationInfo info, StreamingContext context)
+        public void GetObjectData(SerializationInfo serializationInfo, StreamingContext context)
         {
-            info.AddValue("n", m_name);
+            serializationInfo.AddValue("n", name);
         }
     }
 }