optimize readjsonprotocol

Author: CppCXY

.idea/.idea.LanguageServer.Framework/.idea/copilot.data.migration.ask2agent.xml

@@ -8,12 +8,13 @@
 using EmmyLua.LanguageServer.Framework.Server;
 using EmmyLua.LanguageServer.Framework.Server.Handler;
 using EmmyLua.LanguageServer.Framework.Server.JsonProtocol;
+using EmmyLua.LanguageServer.Framework.Server.Metrics;
 using EmmyLua.LanguageServer.Framework.Server.RequestManager;
 using EmmyLua.LanguageServer.Framework.Server.Scheduler;
 
 namespace EmmyLua.LanguageServer.Framework;
 
-public abstract class LSPCommunicationBase
+public abstract class LSPCommunicationBase : IDisposable
 {
     public JsonSerializerOptions JsonSerializerOptions { get; } = new()
     {
@@ -43,6 +44,25 @@ public abstract class LSPCommunicationBase
 
     public ClientCapabilities ClientCapabilities { get; set; } = null!;
 
+    /// <summary>
+    /// 性能指标收集器
+    /// </summary>
+    public IPerformanceMetricsCollector? MetricsCollector
+    {
+        get => _metricsCollector;
+        set
+        {
+            _metricsCollector = value;
+            // 同步到Writer
+            Writer.MetricsCollector = value;
+        }
+    }
+    private IPerformanceMetricsCollector? _metricsCollector;
+
+    protected CancellationTokenSource? ExitTokenSource { get; private set; }
+    private readonly SemaphoreSlim _exitTokenLock = new(1, 1);
+    private bool _disposed;
+
     protected LSPCommunicationBase(Stream input, Stream output)
     {
         Reader = new JsonProtocolReader(input, JsonSerializerOptions);
@@ -76,6 +96,14 @@ public LSPCommunicationBase AddHandler(IJsonHandler handler)
         return this;
     }
 
+    /// <summary>
+    /// 获取当前的性能指标快照
+    /// </summary>
+    public PerformanceMetrics? GetMetrics()
+    {
+        return MetricsCollector?.GetMetrics();
+    }
+
     public Task SendNotification(NotificationMessage notification)
     {
         Writer.WriteNotification(notification);
@@ -104,13 +132,18 @@ private async Task OnDispatch(Message message)
             {
                 if (RequestHandlers.TryGetValue(request.Method, out var handler))
                 {
+                    MetricsCollector?.RecordRequestStart(request.Method);
+                    var startTime = DateTime.UtcNow;
+                    var success = false;
+
                     try
                     {
                         var token = ClientRequestTokenManager.Create(request.Id);
                         var result = await handler(request, token).ConfigureAwait(false);
                         if (!token.IsCancellationRequested)
                         {
                             Writer.WriteResponse(request.Id, result);
+                            success = true;
                         }
                         else
                         {
@@ -146,6 +179,8 @@ private async Task OnDispatch(Message message)
                     finally
                     {
                         ClientRequestTokenManager.ClearToken(request.Id);
+                        var duration = DateTime.UtcNow - startTime;
+                        MetricsCollector?.RecordRequestComplete(request.Method, duration, success);
                     }
                 }
                 else
@@ -163,7 +198,23 @@ private async Task OnDispatch(Message message)
             {
                 if (NotificationHandlers.TryGetValue(notification.Method, out var handler))
                 {
-                    await handler(notification, CancellationToken.None);
+                    MetricsCollector?.RecordNotification(notification.Method);
+
+                    try
+                    {
+                        // 创建取消令牌以支持通知处理的取消
+                        using var cts = CancellationTokenSource.CreateLinkedTokenSource(
+                            ExitTokenSource?.Token ?? CancellationToken.None);
+                        await handler(notification, cts.Token);
+                    }
+                    catch (OperationCanceledException)
+                    {
+                        // Notification 被取消，忽略
+                    }
+                    catch (Exception e)
+                    {
+                        Console.Error.WriteLine($"[Notification Handler] Error handling '{notification.Method}': {e}");
+                    }
                 }
 
                 break;
@@ -183,52 +234,106 @@ protected virtual bool BaseHandle(Message message)
 
     public Task Run()
     {
-        _mutexForExitTokenSource.WaitOne();
-        if (ExitTokenSource is not null)
-            throw new InvalidOperationException("Already running.");
-        ExitTokenSource = new CancellationTokenSource();
-        var task = Task.Run(async () =>
+        _exitTokenLock.Wait();
+        try
         {
-            try
+            if (ExitTokenSource is not null)
+                throw new InvalidOperationException("Already running.");
+
+            ExitTokenSource = new CancellationTokenSource();
+
+            var task = Task.Run(async () =>
             {
-                while (ExitTokenSource.IsCancellationRequested is false)
+                try
                 {
-                    var message = await Reader.ReadAsync(ExitTokenSource.Token);
-                    if (BaseHandle(message))
+                    while (!ExitTokenSource.IsCancellationRequested)
                     {
-                        continue;
-                    }
+                        var message = await Reader.ReadAsync(ExitTokenSource.Token);
+                        MetricsCollector?.RecordMessageReceived();
+
+                        if (BaseHandle(message))
+                        {
+                            continue;
+                        }
 
-                    Scheduler.Schedule(OnDispatch, message);
+                        Scheduler.Schedule(OnDispatch, message);
+                    }
+                }
+                catch (OperationCanceledException)
+                {
+                    await Console.Error.WriteLineAsync("LSPCommunication exited");
                 }
+                catch (Exception e)
+                {
+                    Console.Error.WriteLine(e);
+                }
+                finally
+                {
+                    ExitTokenSource?.Dispose();
+                    ExitTokenSource = null;
+                }
+            });
+
+            return task;
+        }
+        finally
+        {
+            _exitTokenLock.Release();
+        }
+    }
+
+    public void Exit()
+    {
+        _exitTokenLock.Wait();
+        try
+        {
+            if (ExitTokenSource is null)
+                throw new InvalidOperationException("Run() must be called before exit");
+            ExitTokenSource.Cancel();
+        }
+        finally
+        {
+            _exitTokenLock.Release();
+        }
+    }
+
+    protected virtual void Dispose(bool disposing)
+    {
+        if (_disposed) return;
+
+        if (disposing)
+        {
+            // 取消运行
+            try
+            {
+                Exit();
             }
-            catch (OperationCanceledException)
+            catch
             {
-                await Console.Error.WriteLineAsync("LSPCommunication exited");
+                // Ignore if not running
             }
-            catch (Exception e)
+
+            // 释放资源
+            ExitTokenSource?.Dispose();
+            _exitTokenLock.Dispose();
+
+            if (Scheduler is IDisposable disposableScheduler)
             {
-                Console.Error.WriteLine(e);
+                disposableScheduler.Dispose();
             }
-            finally
+
+            if (Writer is IDisposable disposableWriter)
             {
-                ExitTokenSource.Dispose();
-                ExitTokenSource = null;
+                disposableWriter.Dispose();
             }
-        });
-        _mutexForExitTokenSource.ReleaseMutex();
-        return task;
-    }
+        }
 
-    protected CancellationTokenSource? ExitTokenSource { get; private set; }
-    private readonly Mutex _mutexForExitTokenSource = new();
+        _disposed = true;
+    }
 
-    public void Exit()
+    public void Dispose()
     {
-        _mutexForExitTokenSource.WaitOne();
-        if (ExitTokenSource is null)
-            throw new InvalidOperationException("Run() must be called before exit");
-        ExitTokenSource!.Cancel();
-        _mutexForExitTokenSource.ReleaseMutex();
+        Dispose(true);
+        GC.SuppressFinalize(this);
     }
 }