Отправка подлинного объекта в двоичном виде

Author: EvilBeaver

src/OneScript.DebugProtocol/Internal/AutoPropertyExtensions.cs

@@ -0,0 +1,59 @@
+/*----------------------------------------------------------
+This Source Code Form is subject to the terms of the
+Mozilla Public License, v.2.0. If a copy of the MPL
+was not distributed with this file, You can obtain one
+at http://mozilla.org/MPL/2.0/.
+----------------------------------------------------------*/
+
+/*
+ * Based on https://gist.github.com/NickStrupat/39e659e53a7aa000b737
+ */
+
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+namespace OneScript.DebugProtocol.Internal
+{
+    internal static class AutoPropertyExtensions
+    {
+        private const string Prefix = "<";
+        private const string Suffix = ">k__BackingField";
+
+        private static string GetBackingFieldName(string propertyName) => $"{Prefix}{propertyName}{Suffix}";
+
+        private static string GetBaseClassPrefix(Type baseClass) => baseClass.Name + "+";
+
+        public static FieldInfo GetBackingField(this PropertyInfo propertyInfo)
+        {
+            if (propertyInfo == null)
+                throw new ArgumentNullException(nameof(propertyInfo));
+            if (!propertyInfo.CanRead || !propertyInfo.GetGetMethod(nonPublic: true)
+                    .IsDefined(typeof(CompilerGeneratedAttribute), inherit: true))
+                return null;
+
+            var backingFieldName = GetBackingFieldName(propertyInfo.Name);
+                        
+            var backingField =
+                propertyInfo.DeclaringType?.GetField(backingFieldName, BindingFlags.Instance | BindingFlags.NonPublic);
+            
+            if (backingField == null)
+                return null;
+            
+            if (!backingField.IsDefined(typeof(CompilerGeneratedAttribute), inherit: true))
+                return null;
+            return backingField;
+        }
+
+        public static string GetFieldSerializationName(this FieldInfo field, PropertyInfo property)
+        {
+            if (field.DeclaringType == property.ReflectedType)
+            {
+                return field.Name;
+            }
+            
+            // This is inherited prop
+            return GetBaseClassPrefix(field.DeclaringType) + field.Name;
+        }
+    }
+}

…Protocol/TcpServer/BinaryFormatWriter.cs …gProtocol/Internal/BinaryFormatWriter.cssrc/OneScript.DebugProtocol/TcpServer/BinaryFormatWriter.cs renamed to src/OneScript.DebugProtocol/Internal/BinaryFormatWriter.cs src/OneScript.DebugProtocol/TcpServer/BinaryFormatWriter.cs renamed to src/OneScript.DebugProtocol/Internal/BinaryFormatWriter.cs

@@ -7,9 +7,11 @@ This Source Code Form is subject to the terms of the
 
 using System;
 using System.IO;
+using System.Linq;
+using System.Reflection;
 using System.Text;
 
-namespace OneScript.DebugProtocol.TcpServer
+namespace OneScript.DebugProtocol.Internal
 {
     internal class BinaryFormatWriter : IDisposable
     {
@@ -22,35 +24,79 @@ public BinaryFormatWriter(Stream target)
 
         public void WriteHeader(int rootId, int headerId)
         {
-            _writer.Write((byte)0);
+            WriteRecordType(0);
             _writer.Write(rootId);
             _writer.Write(headerId);
             _writer.Write(1);
             _writer.Write(0);
         }
 
         public void WriteStringRecord(int objectId, string data)
+        {
+            WriteRecordType(6);
+            _writer.Write(objectId);
+            
+            WriteStringValue(data);
+        }
+
+        private void WriteStringValue(string data)
         {
             var bytes = Encoding.UTF8.GetBytes(data);
             if (bytes.Length > 127)
                 throw new ArgumentOutOfRangeException(nameof(data), "Length encoding not supported for strings more than 127 bytes");
-            
-            _writer.Write((byte)6);
-            _writer.Write(objectId);
+
             _writer.Write((byte)bytes.Length);
             _writer.Write(bytes, 0, bytes.Length);
         }
 
+        public void WriteLibrary(Assembly assembly, int libraryId)
+        {
+            WriteRecordType(12);
+            _writer.Write(libraryId);
+            WriteStringValue(assembly.GetName().Name);
+        }
+
+        public void WriteClassWithNoFields(Type type, int classId, int libraryId)
+        {
+            WriteRecordType(5);
+            
+            _writer.Write(classId);
+            WriteStringValue(type.FullName);
+            _writer.Write(0); // properties count
+            
+            _writer.Write(libraryId);
+        }
+
+        private void WriteObjectArray(int objectId, object[] arr)
+        {
+            if (arr.Length != 0)
+                throw new ArgumentException("Only empty arrays mapping supported");
+            
+            WriteRecordType(16);
+            _writer.Write(objectId);
+            _writer.Write(0);
+        }
+
+        private void WriteNull()
+        {
+            WriteRecordType(10);
+        }
+
         public void WriteEnd()
         {
-            _writer.Write((byte)11);
+            WriteRecordType(11);
         }
 
         public void Close()
         {
             Dispose();
         }
 
+        private void WriteRecordType(byte type)
+        {
+            _writer.Write(type);
+        }
+
         public void Dispose()
         {
             _writer.Flush();

src/OneScript.DebugProtocol/TcpServer/DefaultMessageServer.cs

@@ -85,6 +85,11 @@ private void RunCommandsLoop()
                     {
                         _serverStopped = true;
                     }
+                    catch (ThreadInterruptedException)
+                    {
+                        // Сервер принудительно остановлен
+                        _serverStopped = true;
+                    }
                     catch (Exception e)
                     {
                         var eventData = new CommunicationEventArgs
@@ -97,6 +102,8 @@ private void RunCommandsLoop()
                         OnError?.Invoke(this, eventData);
                     }
                 }
+                
+                _protocolChannel.Dispose();
             });
 
             _messageThread.IsBackground = true;
@@ -117,8 +124,8 @@ public void Stop()
 
             if (_messageThread?.IsAlive == true)
             {
-                _protocolChannel.Dispose();
                 _messageThread.Interrupt();
+                _protocolChannel.Dispose();
             }
         }
 

src/OneScript.DebugProtocol/TcpServer/FormatReconcileUtils.cs

@@ -7,6 +7,7 @@ This Source Code Form is subject to the terms of the
 using System;
 using System.IO;
 using System.Text;
+using OneScript.DebugProtocol.Internal;
 
 namespace OneScript.DebugProtocol.TcpServer
 {
@@ -19,12 +20,14 @@ public static class FormatReconcileUtils
         /// </summary>
         public static byte[] GetReconcileMagic()
         {
-            using (var memoryStream = new MemoryStream(128))
+            using (var memoryStream = new MemoryStream(256))
             {
                 using (var writer = new BinaryFormatWriter(memoryStream))
                 {
                     writer.WriteHeader(1, 1);
-                    writer.WriteStringRecord(1, "1C1C1C");
+                    writer.WriteLibrary(typeof(RpcCall).Assembly, 1);
+                    writer.WriteClassWithNoFields(typeof(RpcCall), 1, 1);
+                    //writer.WriteInstance(new object[]{Array.Empty<object>(), "$NonExistentMethod$", nameof(IDebuggerService)});
                     writer.WriteEnd();
                 }
 

src/Tests/VSCode.DebugAdapter.Tests/ReconcileForOlderVersionTests.cs

@@ -3,6 +3,7 @@
 using System.IO;
 using System.Runtime.Serialization.Formatters.Binary;
 using FluentAssertions;
+using OneScript.DebugProtocol;
 using OneScript.DebugProtocol.TcpServer;
 using Xunit;
 
@@ -16,11 +17,33 @@ public void CanReadReconcileViaBinaryFormatter()
             using (var stream = new MemoryStream(FormatReconcileUtils.GetReconcileMagic()))
             {
                 var reader = new BinaryFormatter();
+                
                 var value = reader.Deserialize(stream);
-                value.Should().Be("1C1C1C");
+                value.Should().BeEquivalentTo(new RpcCall());
             }
         }
 
+        [Fact(Skip = "Manual run only")]
+        public void DumpBinaryStream()
+        {
+            const string filePath = "<path>";
+            using (var stream = new MemoryStream(FormatReconcileUtils.GetReconcileMagic()))
+            {
+                var serializer = new BinaryFormatter();
+                var sampleCall = RpcCall.Create(nameof(IDebuggerService), "$NonExistent$");
+                
+                using (var dest = new MemoryStream())
+                {
+                    serializer.Serialize(dest, sampleCall);
+                    using (var file = new FileStream(filePath, FileMode.Create))
+                    {
+                        dest.Position = 0;
+                        dest.CopyTo(file);
+                    }
+                }
+            }
+        }
+        
         [Fact]
         public void ExchangeReconcileVersions()
         {