Source Pipe server,communication between different processes using pipes

Code
public class NamedPipeServer : IDisposable

    {

        private string pipeName;

        private NamedPipeServerStream pipeServer;

        private CancellationTokenSource cancellationTokenSource;

        private bool isDisposed;



        public event EventHandler<string[]> ArgumentsReceived;



        public NamedPipeServer(string pipeName)

        {

            if (string.IsNullOrEmpty(pipeName))

                throw new ArgumentException("Pipe name cannot be null or empty.");



            this.pipeName = pipeName;

        }



        public async Task Start()

        {            

            if (pipeServer != null && pipeServer.IsConnected)

                throw new InvalidOperationException("The server is already running.");



            cancellationTokenSource = new CancellationTokenSource();

            pipeServer = new NamedPipeServerStream(pipeName, PipeDirection.InOut, NamedPipeServerStream.MaxAllowedServerInstances, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);

            await pipeServer.WaitForConnectionAsync(cancellationTokenSource.Token);

            _ = Task.Run(() => HandleIncomingMessages(cancellationTokenSource.Token));

        }



        public void Stop()

        {

            cancellationTokenSource?.Cancel();

            pipeServer?.Dispose();

        }        



        private async Task HandleIncomingMessages(CancellationToken cancellationToken)

        {

            using (StreamReader reader = new StreamReader(pipeServer))

            {

                while (!cancellationToken.IsCancellationRequested)

                {

                    try

                    {

                        string data = await reader.ReadLineAsync();

                        if (!string.IsNullOrEmpty(data))

                        {

                            string[] arguments = data.Split(new char[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);

                            ArgumentsReceived?.Invoke(this, arguments);

                        }

                    }

                    catch (IOException ex)

                    {

                        Console.WriteLine($"Pipe server error: {ex.Message}");

                        break;

                    }

                    catch (Exception ex)

                    {

                        Console.WriteLine($"Error: {ex.Message}");

                    }

                }

            }

        }



        public void Dispose()

        {

            Dispose(true);

            GC.SuppressFinalize(this);

        }

        protected virtual void Dispose(bool disposing)

        {

            if (!isDisposed)

            {

                if (disposing)

                {

                    Stop();

                    cancellationTokenSource?.Dispose();

                }



                isDisposed = true;

            }

        }

    }