Prototype complete InterpreterEntry serialization

UIX/Microsoft/Iris/Debug/Data/InterpreterEntry.cs

@@ -1,11 +1,15 @@
-using System;
+using Microsoft.Iris.Markup;
+using System;
 using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.Serialization;
 
 namespace Microsoft.Iris.Debug.Data;
 
+[Serializable]
 public class InterpreterEntry
 {
-    public InterpreterEntry(object opCode, params OpCodeArgument[] args)
+    public InterpreterEntry(OpCode opCode, params OpCodeArgument[] args)
     {
         OpCode = opCode;
 
@@ -15,22 +19,25 @@ public class InterpreterEntry
             Arguments = new List<OpCodeArgument>();
     }
 
-    public object OpCode { get; }
+    public OpCode OpCode { get; }
     public IList<OpCodeArgument> Arguments { get; }
     public IList<object> ReturnValues { get; } = new List<object>();
 
     public override string ToString()
     {
-        return $"{OpCode}({string.Join(", ", Arguments)}) -> [{ReturnValues}]";
+        return $"{OpCode}({string.Join(", ", Arguments)}) -> [{string.Join(", ", ReturnValues)}]";
     }
 }
 
-public class OpCodeArgument
+[Serializable]
+public class OpCodeArgument : ISerializable
 {
     public string Name { get; set; }
     public Type Type { get; set; }
     public object Value { get; set; }
 
+    protected bool CanSerializeValue => Value is ISerializable;
+
     public OpCodeArgument(string name, Type type, object value)
     {
         Name = name;
@@ -38,5 +45,23 @@ public class OpCodeArgument
         Value = value;
     }
 
+    protected OpCodeArgument(SerializationInfo info, StreamingContext context)
+    {
+        Name = info.GetString(nameof(Name));
+        Type = Type.GetType(info.GetString(nameof(Type)), false);
+
+        bool canSerializeValue = info.GetBoolean(nameof(CanSerializeValue));
+        Type valueSerializeType = canSerializeValue ? Type : typeof(string);
+        Value = info.GetValue(nameof(Value), valueSerializeType);
+    }
+
     public override string ToString() => $"{Type} {Value}";
+
+    public void GetObjectData(SerializationInfo info, StreamingContext context)
+    {
+        info.AddValue(nameof(Name), Name);
+        info.AddValue(nameof(Type), Type.FullName);
+        info.AddValue(nameof(CanSerializeValue), CanSerializeValue);
+        info.AddValue(nameof(Value), CanSerializeValue ? Value : Value.ToString());
+    }
 }

UIX/Microsoft/Iris/Debug/ZmqDebuggerClient.cs

@@ -2,6 +2,8 @@
 using NetMQ;
 using NetMQ.Sockets;
 using System;
+using System.IO;
+using System.Runtime.Serialization.Formatters.Binary;
 using System.Text;
 
 namespace Microsoft.Iris.Debug;
@@ -34,8 +36,11 @@ public class ZmqDebuggerClient : IDebuggerClient, IDisposable
             switch (type)
             {
                 case DebuggerMessageType.InterpreterOpCode:
-                    string entry = Encoding.Unicode.GetString(bytes);
-                    InterpreterStep?.Invoke(this, null);
+                    {
+                        using MemoryStream stream = new(bytes);
+                        var entry = (InterpreterEntry)new BinaryFormatter().Deserialize(stream);
+                        InterpreterStep?.Invoke(this, entry);
+                    }
                     break;
 
                 case DebuggerMessageType.DispatcherStep:
@@ -46,7 +51,7 @@ public class ZmqDebuggerClient : IDebuggerClient, IDisposable
         }
     }
 
-    private DebuggerMessageType RecieveDebuggerMessage(SubscriberSocket socket, out byte[] bytes)
+    private static DebuggerMessageType RecieveDebuggerMessage(SubscriberSocket socket, out byte[] bytes)
     {
         var frames = socket.ReceiveMultipartBytes(2);
 

UIX/Microsoft/Iris/Debug/ZmqDebuggerServer.cs

@@ -1,6 +1,8 @@
 using NetMQ;
 using NetMQ.Sockets;
 using System;
+using System.IO;
+using System.Runtime.Serialization.Formatters.Binary;
 using System.Text;
 
 namespace Microsoft.Iris.Debug;
@@ -22,7 +24,10 @@ internal class ZmqDebuggerServer : IDebuggerServer, IDisposable
 
     public void LogInterpreterOpCode(object context, Data.InterpreterEntry entry)
     {
-        SendDebuggerMessage(DebuggerMessageType.InterpreterOpCode, entry.ToString());
+        using MemoryStream entryStream = new();
+        new BinaryFormatter().Serialize(entryStream, entry);
+
+        SendDebuggerMessage(DebuggerMessageType.InterpreterOpCode, entryStream.ToArray());
     }
 
     public void LogDispatcher(string message)