Generic Client-Server DotNet Remoting with Server CallBack

namespace TestLibrary
{
    /// Interface provided by the server for clients.
    public interface ITestInterface : IConnect<EventArgs>
    {
        /// The server will send this message back to the clients asynchronously
        void Execute(string message);

        /// The server will send this message back to the clients asynchronously
        void Execute(Guid clientID, string message);

        /// The server will send this message back to the clients synchronously.
        void ExecuteSync(string message);

        /// The server will generate an exception.
        void ExecuteException();

        /// The server will notify an exception.
        void ExecuteNotifyException();
    }
}

namespace TestLibrary
{
    [Serializable]
    public class TestMessageArgs : EventArgs
    {
        /// The message.
        public string Message { get; }

        /// Constructs a TestMessageArgs object.
        public TestMessageArgs(string message)
        {
            Message = message;
        }
    }
}

namespace TestServer
{
	/// Class to manage a TestServer.
	public class TestServer : RemoteServer<TestSink>
	{
		/// Constructs a TestServer object, the base class has no default constructor.
		public TestServer(IChannel channel)
			: base(channel) { }

		/// Notify all clients
		public void SendNotificationToAllClients(string message)
		{
			Sink?.PerformNotifyClients(new TestMessageArgs(message));
		}
	}
}

namespace TestServer
{
    /// Class to manage the Server Sink defined by its Interface.
    public class TestSink : NotifyClientSink, ITestInterface
    {
        /// The server will send the message back to the clients asynchronously.
        public void Execute(string message)
        {
            PerformNotifyClients(new TestMessageArgs(message));
        }

        /// The server will send the message back to the client asynchronously.
        public void Execute(Guid clientID, string message)
        {
            PerformNotifyClient(clientID, new TestMessageArgs(message));
        }

        /// The server will send the message back to the clients synchronously.
        public void ExecuteSync(string message)
        {
            PerformNotifyClientsSync(new TestMessageArgs(message));
        }

        /// The server will generate an exception.
        public void ExecuteException()
        {
            throw new NotImplementedException("ExecuteException");
        }

        /// The server will notify an exception.
        public void ExecuteNotifyException()
        {
            try
            {
                // server code that generates an exception
                throw new ApplicationException("ExecuteNotifyException");
            }
            catch (Exception ex)
            {
                PerformNotifyClients(new NotifyExceptionArgs(ex));
            }
        }
    }
}

namespace TestClient
{
    /// <summary>
    /// Class to manage a TestClient
    /// </summary>
    public class TestClient : IDisposable
    {
        private Delay _delay;
        private RemoteConnector<ITestInterface> _remoteConnector;
        private Guid ClientID => _remoteConnector.ClientID;
        private ITestInterface TestProvider => _remoteConnector.RemoteObject;

        public RemoteState RemoteState => _remoteConnector.RemoteState;

        /// Dispose this object
        public void Dispose()
        {
            _remoteConnector?.Dispose();
        }

        /// <summary>
        /// Initialize a remote connector to the server giving the channel.
        /// </summary>
        /// <param name="channel">The channel.</param>
        public void Initialize(IChannel channel)
        {
            // instantiate the client
            _remoteConnector = new RemoteConnector<ITestInterface>(new CHANNEL());
            _remoteConnector.Callback += OnRemoteCallback;
            _remoteConnector.RemoteStateChanged += OnRemoteStateChanged;
        }

        /// <summary>
        /// Notification from the server to the client.
        /// </summary>
        /// <param name="sender">The sender is the client ID.</param>
        /// <param name="e">The event argument.</param>
        private void OnRemoteCallback(object sender, EventArgs e)
        {
            // is notification for me ?
            if ((Guid)sender != ClientID)
                return;

            // the server sends me a message
            if (e is TestMessageArgs args1)
                Console.WriteLine("Message from Server: " + args1.Message);

            // the server sends me an exception
            else if (e is NotifyExceptionArgs args2)
                Console.WriteLine("Exception from Server: " + args2.Exception.Message);
        }

        /// <summary>
        /// Notification when the remote connection is changed.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="remoteState">The new remote state.</param>
        private void OnRemoteStateChanged(object sender, RemoteState remoteState)
        {
            switch (remoteState)
            {
                case RemoteState.Connected:
                    Console.WriteLine("RemoteState: [" + RemoteState +
                    "] Client [" + ClientID +
                    "] Delay [" + _delay.TotalMilliseconds + "] ms");
                    // execute commands on the server
                    ExecuteCommandsOnServer();
                    break;
                default:
                    Console.WriteLine("RemoteState: [" + RemoteState + "]");
                    break;
            }
        }

        /// Starts the connection with the server.
        public void Start()
        {
            if (_remoteConnector == null)
                throw new ApplicationException("Please call Initialize before Start");
            _delay = new Delay();
            _remoteConnector.Start(10); // wait 10s to connect to the server else exception
        }

        /// Stops the connection with the server.
        public void Stop()
        {
            _remoteConnector?.Stop();
        }

        /// Execute commands on the server.
        private void ExecuteCommandsOnServer()
        {
            // the server will send back notification asynchronously to all clients
            for (int i = 1; i <= 3; i++)
            {
                TestProvider.Execute("Hello TestServer all #" + i);
                Thread.Sleep(500);
            }

            // the server will send back notification asynchronously to me
            for (int i = 1; i <= 3; i++)
            {
                TestProvider.Execute(ClientID, "Hello TestServer me #" + i);
                Thread.Sleep(500);
            }

            // the server will send back notification synchronously to all client
            for (int i = 1; i <= 3; i++)
            {
                TestProvider.ExecuteSync("Hello TestServer Sync all #" + i);
                Thread.Sleep(500);
            }

            // the server will generate an exception
            try
            {
                TestProvider.ExecuteException();
            }
            catch (Exception ex)
            {
                Console.WriteLine("** Server exception: " + ex.Message);
            }

            // execute method on the server, the server will notify an exception
            TestProvider.ExecuteNotifyException();
        }
    }
}