Tweaks for RPC Communication

InABox.Core/Serialization.cs

@@ -302,6 +302,9 @@ namespace InABox.Core
             return new Guid(reader.ReadBytes(16));
         }
 
+        private static bool MatchType<T1>(Type t) => typeof(T1) == t;
+        private static bool MatchType<T1,T2>(Type t) => (typeof(T1) == t) || (typeof(T2) == t);
+        
         /// <summary>
         /// Binary serialize a bunch of different types of values. <see cref="WriteBinaryValue(CoreBinaryWriter, Type, object?)"/> and
         /// <see cref="ReadBinaryValue(CoreBinaryReader, Type)"/> are inverses of each other.
@@ -319,15 +322,27 @@ namespace InABox.Core
         public static void WriteBinaryValue(this CoreBinaryWriter writer, Type type, object? value)
         {
             value ??= CoreUtils.GetDefault(type);
-            if (type == typeof(byte[]) && value is byte[] bArray)
+            
+            if (value == null)
             {
-                writer.Write(bArray.Length);
-                writer.Write(bArray);
+                if (MatchType<string>(type))
+                    writer.Write("");
+                else if (writer.Settings.IncludeNullables && typeof(IPackable).IsAssignableFrom(type))
+                    writer.Write(false);
+                else if (writer.Settings.IncludeNullables && typeof(ISerializeBinary).IsAssignableFrom(type))
+                    writer.Write(false);
+                else if (Nullable.GetUnderlyingType(type) is Type t)
+                    writer.Write(false);
+                else
+                    writer.Write(0);
             }
-            else if (type == typeof(byte[]) && value is null)
+            
+            else if (MatchType<byte[], object>(type) && value is byte[] bArray)
             {
-                writer.Write(0);
+                writer.Write(bArray.Length);
+                writer.Write(bArray);
             }
+            
             else if (type.IsArray && value is Array array)
             {
                 var elementType = type.GetElementType();
@@ -337,111 +352,78 @@ namespace InABox.Core
                     WriteBinaryValue(writer, elementType, val1);
                 }
             }
-            else if (type.IsArray && value is null)
-            {
-                writer.Write(0);
-            }
+            
             else if (type.IsEnum && value is Enum e)
             {
                 var underlyingType = type.GetEnumUnderlyingType();
                 WriteBinaryValue(writer, underlyingType, Convert.ChangeType(e, underlyingType));
             }
-            else if (type == typeof(bool) && value is bool b)
+            
+            else if (MatchType<bool, object>(type) && value is bool b)
             {
                 writer.Write(b);
             }
-            else if (type == typeof(string) && value is string str)
-            {
+            
+            else if (MatchType<string, object>(type) && value is string str)
                 writer.Write(str);
-            }
-            else if (type == typeof(string) && value is null)
-            {
-                writer.Write("");
-            }
-            else if (type == typeof(Guid) && value is Guid guid)
-            {
+
+            else if (MatchType<Guid, object>(type) && value is Guid guid)
                 writer.Write(guid);
-            }
-            else if (type == typeof(byte) && value is byte i8)
-            {
+            
+            
+            else if (MatchType<byte, object>(type) && value is byte i8)
                 writer.Write(i8);
-            }
-            else if (type == typeof(Int16) && value is Int16 i16)
-            {
+            
+            else if (MatchType<Int16, object>(type) && value is Int16 i16)
                 writer.Write(i16);
-            }
-            else if (type == typeof(Int32) && value is Int32 i32)
-            {
+            
+            else if (MatchType<Int32, object>(type) && value is Int32 i32)
                 writer.Write(i32);
-            }
-            else if (type == typeof(Int64) && value is Int64 i64)
-            {
+            
+            else if (MatchType<Int64, object>(type) && value is Int64 i64)
                 writer.Write(i64);
-            }
-            else if (type == typeof(float) && value is float f32)
-            {
+            
+            else if (MatchType<float, object>(type) && value is float f32)
                 writer.Write(f32);
-            }
-            else if (type == typeof(double) && value is double f64)
-            {
+            
+            else if (MatchType<double, object>(type) && value is double f64)
                 writer.Write(f64);
-            }
-            else if (type == typeof(DateTime) && value is DateTime date)
-            {
+            
+            else if (MatchType<DateTime, object>(type) && value is DateTime date)
                 writer.Write(date.Ticks);
-            }
-            else if (type == typeof(TimeSpan) && value is TimeSpan time)
-            {
+            
+            else if (MatchType<TimeSpan, object>(type) && value is TimeSpan time)
                 writer.Write(time.Ticks);
-            }
-            else if (type == typeof(LoggablePropertyAttribute))
-            {
-                writer.Write((value as LoggablePropertyAttribute)?.Format ?? "");
-            }
+            
+            else if (MatchType<LoggablePropertyAttribute, object>(type) && value is LoggablePropertyAttribute lpa)
+                writer.Write(lpa.Format ?? "");
+            
             else if (typeof(IPackable).IsAssignableFrom(type) && value is IPackable pack)
             {
                 if (writer.Settings.IncludeNullables)
-                {
                     writer.Write(true);
-                }
                 pack.Pack(writer);
             }
-            else if (writer.Settings.IncludeNullables && typeof(IPackable).IsAssignableFrom(type) && value is null)
-            {
-                writer.Write(false);
-            }
+            
             else if (typeof(ISerializeBinary).IsAssignableFrom(type) && value is ISerializeBinary binary)
             {
                 if (writer.Settings.IncludeNullables)
-                {
                     writer.Write(true);
-                }
                 binary.SerializeBinary(writer);
             }
-            else if (writer.Settings.IncludeNullables && typeof(ISerializeBinary).IsAssignableFrom(type) && value is null)
-            {
-                writer.Write(false);
-            }
+            
             else if (Nullable.GetUnderlyingType(type) is Type t)
             {
-                if (value == null)
-                {
-                    writer.Write(false);
-                }
-                else
-                {
-                    writer.Write(true);
-                    writer.WriteBinaryValue(t, value);
-                }
+                writer.Write(true);
+                writer.WriteBinaryValue(t, value);
             }
+            
             else if (value is UserProperty userprop)
-            {
-                 WriteBinaryValue(writer, userprop.Type, userprop.Value);
-            }
+                WriteBinaryValue(writer, userprop.Type, userprop.Value);
+            
             else
-            {
                 throw new Exception($"Invalid type; Target DataType is {type} and value DataType is {value?.GetType().ToString() ?? "null"}");
-            }
+            
         }
 
         public static void WriteBinaryValue<T>(this CoreBinaryWriter writer, T value)

InABox.Server/RPC/Handlers/Save.cs

@@ -12,7 +12,7 @@ namespace InABox.Rpc
             var user = CredentialsCache.ValidateAndRefresh(session.ID)
                 ?? throw new RpcException("User not found in Credentials Cache!", RpcError.UNAUTHENTICATED);
 
-            var response = new RpcSaveResult();
+            var response = new RpcSaveResult() { Type = parameters.Type };
             var entities = parameters.Items;
 
             var originals = new Dictionary<string, object>[entities.Length];