DebugVisualizerExtension/NamedPipes/NamedPipeServer.cs

using CommunityToolkit.Mvvm.ComponentModel;
using PipeMethodCalls;

using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

namespace NamedPipes;
public partial class NamedPipesServer(string pipeName,Action<string>? logger = null) : ObservableObject,IDebugVisualizer, IDisposable
{
    ~NamedPipesServer()
    {
        Logger(@"~NamedPipesServer called!");

    }
    public bool IsConnected => PipeServer is { State: PipeState.Connected };
    private PipeServer<IDebugVisualizer>? PipeServer {get; set;}
    private string PipeName { get; } = pipeName;
    private Action<string> Logger { get;  } = logger ?? ((m) => Trace.WriteLine(m));

    public async Task WaitForConnectionAsync()
    {
        if(IsConnected) return;
        if (PipeServer == null || PipeServer.State !=  PipeState.Connected)
        {
            PipeServer?.Dispose();
            PipeServer = new PipeServer<IDebugVisualizer>(new PipeSerializer(), PipeName, () => this);
            PipeServer.SetLogger((m) => Trace.WriteLine(m));
        }      
        Logger("Waiting for client connection...");
        await PipeServer.WaitForConnectionAsync().ConfigureAwait(true);
    }
    public async Task RunAsync(CancellationToken cancellationToken)
    {
        while(!cancellationToken.IsCancellationRequested)
        {
            await WaitForConnectionAsync().ConfigureAwait(true);
            Logger("Client connected.");
            while (IsConnected)
            {
                await Task.Delay(100, cancellationToken).ConfigureAwait(true);
            }
            Logger("Client disconnected.");
        }
    }
    [ObservableProperty]
    public partial VisualizerModel? VisualizerModel { get; private set; }

    public async Task<bool> SetVisualizerModelAsync(VisualizerModel visualizerModel)
    {
        await  Task.Delay(1);
        VisualizerModel = visualizerModel;
        Logger("NamedPipesServer, received object of type: " + visualizerModel.GetType());
        return true;
    }

    public async Task<bool> SetMessageAsync(string message)
    {
        await  Task.Delay(1);
        Logger("Received message: " + message);
        return true;
    }

    public void Dispose()
    {
        GC.SuppressFinalize(this);
        PipeServer?.Dispose();
        PipeServer = null;
    }
}