Сетевое приложение, которое будет автоматически находить свои запущенные экземпляры в локальной сети

    /// <summary>
    /// Keep data of remote host
    /// </summary>
    class Host
    {
        public IPAddress IP { get; set; }
        public DateTime LastHeartbeat { get; set; }
 
        public void OnHeartbeatReceived()
        {
            LastHeartbeat = DateTime.Now;
        }
 
        public override string ToString()
        {
            return IP.ToString();
        }
    }

    /// <summary>
    /// UDP server/client with auto heartbeats
    /// </summary>
    class Server
    {
        private const int HEARTBEAT_INTERVAL = 1000;
 
        public int Port = 45450;
        public event Action<IPEndPoint, byte[]> MessageReceived = delegate { };
 
        private UdpClient udp;
 
        /// <summary>
        /// Start
        /// </summary>
        public void Start()
        {
            //start udp client
            udp = new UdpClient(Port);
            //start receive messages
            udp.BeginReceive(OnReceived, null);
            //start heartbeat loop (in background thread)
            ThreadPool.QueueUserWorkItem(HeartbeatLoop);
        }
 
        /// <summary>
        /// Send message (broadcast)
        /// </summary>
        public void SendMessageAsync(byte[] bytes)
        {
            SendMessageAsync(bytes, new IPEndPoint(IPAddress.Broadcast, Port));
        }
 
        /// <summary>
        /// Send message to remote host
        /// </summary>
        public void SendMessageAsync(byte[] bytes, IPEndPoint endPoint)
        {
            //send async
            udp.BeginSend(bytes, bytes.Length, endPoint, OnSent, null);
        }
 
        private void OnSent(IAsyncResult ar)
        {
            //finsh sending
            udp.EndSend(ar);
        }
 
        private void OnReceived(IAsyncResult ar)
        {
            //receve bytes
            var remote = new IPEndPoint(IPAddress.Broadcast, Port);
            var bytes = udp.EndReceive(ar, ref remote);
 
            //fire event
            MessageReceived(remote, bytes);
 
            //start receive next message
            udp.BeginReceive(OnReceived, null);
        }
 
        private void HeartbeatLoop(object state)
        {
            //infinity loop
            while (true)
            {
                //wait
                Thread.Sleep(HEARTBEAT_INTERVAL);
 
                //send broadcast empty message
                udp.Send(new byte[0], 0, new IPEndPoint(IPAddress.Broadcast, Port));
            }
        }
    }

    class Controller
    {
        const int DEAD_INTERVAL = 3000;
        const int CHECK_DEAD_INTERVAL = 1000;
 
        private object locker = new object();
 
        public Server Server { get; private set; }
        public List<Host> Hosts { get; private set; } = new List<Host>();
 
        public event Action<IPAddress, string> MessageReceived = delegate { };
        public event Action HostsChanged = delegate { };
 
        public void Start()
        {
            //start server
            Server = new Server();
            Server.MessageReceived += ServerMessageReceived;
            Server.Start();
 
            //start main loop
            ThreadPool.QueueUserWorkItem(RemoveDeadHostsLoop);
        }
 
        public void SendMessage(string message)
        {
            var bytes = Encoding.UTF8.GetBytes(message);
            Server.SendMessageAsync(bytes);
        }
 
        private void ServerMessageReceived(IPEndPoint remote, byte[] bytes)
        {
            //is heartbeat?
            if (bytes.Length == 0)
                OnHeartbeatReceived(remote.Address);
            else
            {
                //is message
                var str = Encoding.UTF8.GetString(bytes);
                MessageReceived(remote.Address, str);
            }
        }
 
        private void OnHeartbeatReceived(IPAddress remoteIP)
        {
            //find host
            var host = Hosts.FirstOrDefault(h => h.IP.Equals(remoteIP));
 
            //not found => create new host
            if (host == null)
            {
                //new host
                host = new Host() { IP = remoteIP };
                lock (locker)
                    Hosts.Add(host);
 
                //fire event
                HostsChanged();
            }
 
            //update heartbeat of host
            host.OnHeartbeatReceived();
        }
 
        private void RemoveDeadHostsLoop(object state)
        {
            while (true)
            {
                Thread.Sleep(CHECK_DEAD_INTERVAL);
 
                var deadTime = DateTime.Now.AddMilliseconds(-DEAD_INTERVAL);
                var count = 0;
 
                lock (locker)
                    count = Hosts.RemoveAll(h => h.LastHeartbeat < deadTime);
 
                //fire event
                if (count > 0)
                    HostsChanged();
            }
        }
    }

    public partial class MainForm : Form
    {
        private Controller controller;
 
        public MainForm()
        {
            InitializeComponent();
 
            controller = new Controller();
            controller.HostsChanged += Controller_HostsChanged;
            controller.MessageReceived += Controller_MessageReceived;
            controller.Start();
        }
 
        private void Controller_MessageReceived(IPAddress remote, string message)
        {
            if (InvokeRequired)
            {
                Invoke((MethodInvoker)(()=> { Controller_MessageReceived(remote, message); }));
                return;
            }
            tbMessages.AppendText(remote + Environment.NewLine + message + Environment.NewLine);
        }
 
        private void Controller_HostsChanged()
        {
            ftHosts.Build(controller.Hosts);
        }
 
        private void btSendMessage_Click(object sender, EventArgs e)
        {
            controller.SendMessage(tbNewMessage.Text);
            tbNewMessage.Clear();
        }
 
        private void tbNewMessage_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter)
                btSendMessage.PerformClick();
        }
    }

    class ClientServerTCP
    {
        private TcpListener listener;
 
        public int Port = 45451;
        public event Action<IPEndPoint, byte[]> MessageReceived = delegate { };
 
        public void Start()
        {
            //start tcp listener
            listener = new TcpListener(Port);
            //start receive tcp incoming connections
            listener.Start();
            listener.BeginAcceptTcpClient(OnIncomingConnection, null);
        }
 
        private void OnIncomingConnection(IAsyncResult ar)
        {
            //finish accept incoming connection
            var tcp = listener.EndAcceptTcpClient(ar);
 
            //start receive next message
            listener.BeginAcceptTcpClient(OnIncomingConnection, null);
 
            //receive message
            using (var stream = tcp.GetStream())
            using (var br = new BinaryReader(stream))
            {
                //read data size
                var size = br.ReadInt32();
                //read data
                var data = br.ReadBytes(size);
                //fire event
                MessageReceived(tcp.Client.RemoteEndPoint as IPEndPoint, data);
            }
        }
 
 
        /// <summary>
        /// Send message to remote host (via TCP)
        /// </summary>
        public void SendMessageAsync(byte[] bytes, IPAddress remote)
        {
            //send async
            var tcp = new TcpClient();
            tcp.BeginConnect(remote, Port, (ar) => OnTCPConnected(ar, tcp, bytes), null);
        }
 
        private void OnTCPConnected(IAsyncResult ar, TcpClient tcp, byte[] bytes)
        {
            //finish connect
            tcp.EndConnect(ar);
 
            //send
            using (var stream = tcp.GetStream())
            using (var bw = new BinaryWriter(stream))
            {
                //send data size
                bw.Write(bytes.Length);
                //send data
                bw.Write(bytes);
            }
        }
    }

class Host
    {
        public IPAddress IP { get; set; }
        public override string ToString()
        {
            return IP.ToString();
        }
    }
    class Server
    {
        public int port = 45450;
        private object locker = new object();
        public List<Host> Hosts { get; private set; } = new List<Host>();
 
        public delegate void Action(IPEndPoint ip, byte[] bytes);
        public event Action MessageReceived;
 
        public delegate void Action2();
        public event Action2 HostsChanged;
 
        Client client = new Client();
        private UdpClient udp;
 
        public void StartUDP()
        {
            udp = new UdpClient(port);
            //начинаем получение пустого сообщения
            udp.BeginReceive(OnReceived, null);
            ThreadPool.QueueUserWorkItem(HeartbeatLoop);
            MessageReceived += ServerMessageReceived;
        }
        //отправляем пустое сообщение по udp
        private void HeartbeatLoop(object state)
        {
            udp.Send(new byte[0], 0, new IPEndPoint(IPAddress.Broadcast, port));
        }
        private void OnReceived(IAsyncResult ar)
        {
            IPEndPoint remote = new IPEndPoint(IPAddress.Broadcast, port);
            byte[] bytes = udp.EndReceive(ar, ref remote);
            //событие
            MessageReceived(remote, bytes);
            //начинаем получение следующего сообщения
            udp.BeginReceive(OnReceived, null);
        }
 
        private void ServerMessageReceived(IPEndPoint remote, byte[] bytes)
        {
            if (bytes.Length == 0)
                OnHeartbeatReceived(remote.Address); return;
        }
        private void OnHeartbeatReceived(IPAddress remoteIP)
        {
            //ищем хост
            Host host = Hosts.FirstOrDefault(h => h.IP.Equals(remoteIP));
 
            //если не нашли слздаем новый хост
            if (host == null)
            {
                //new host
                host = new Host() { IP = remoteIP };
                lock (locker)
                    Hosts.Add(host);
 
                //событие
                HostsChanged();
            }
        }
        //отправка по tcp
        public void SendMessage(string message, IPAddress remote)
        {
            byte[] bytes = Encoding.UTF8.GetBytes(message);
           Connect(bytes, remote);
        }
        public void Connect(byte[] bytes, IPAddress remote)
        {
            TcpClient tcp = new TcpClient();
            tcp.BeginConnect(remote, port, (ar) => OnTCPConnected(ar, tcp, bytes), null);
        }
        public void OnTCPConnected(IAsyncResult ar, TcpClient tcp, byte[] bytes)
        {
            tcp.EndConnect(ar);
 
            NetworkStream stream = tcp.GetStream();
            BinaryWriter bw = new BinaryWriter(stream);
            {
                bw.Write(bytes.Length);
                bw.Write(bytes);
            }
        }
    }

 class Client
    {
        private TcpListener listener;
 
        public int port = 45451;
        public delegate void Action(IPEndPoint ip, byte[] bytes);
        public event Action MessageReceived;
        public delegate void Action2(IPAddress ip, string msg);
        public event Action2 MessageReceived2;
 
        public void Start()
        {
            listener = new TcpListener(port);
            listener.Start();
            listener.BeginAcceptTcpClient(OnIncomingConnection, null);
            MessageReceived += ClientMessageReceived;
        }
 
        private void OnIncomingConnection(IAsyncResult ar)
        {
            TcpClient tcp = listener.EndAcceptTcpClient(ar);
 
            //начинаем получение следующего сообщения
            listener.BeginAcceptTcpClient(OnIncomingConnection, null);
 
            //получаем сообщение
            NetworkStream stream = tcp.GetStream();
            BinaryReader br = new BinaryReader(stream);
            {
                int size = br.ReadInt32();
                byte[] data = br.ReadBytes(size);
                MessageReceived(tcp.Client.RemoteEndPoint as IPEndPoint, data);
            }
        }
        private void ClientMessageReceived(IPEndPoint remote, byte[] bytes)
        {
            string str = Encoding.UTF8.GetString(bytes);
            MessageReceived2(remote.Address, str);
        }
    }

public partial class MainForm : Form
    {
        Server server = new Server();
        Client client = new Client();
        public MainForm()
        {
            InitializeComponent();
            server.HostsChanged += HostsChanged;
            client.MessageReceived2 += AddMessageReceived;
            server.StartUDP();
            client.Start();
        }
 
        private void AddMessageReceived(IPAddress remote, string message)
        {
            if (InvokeRequired)
            {
                Invoke((MethodInvoker)(()=> { AddMessageReceived(remote, message); }));
                return;
            }
            tbMessages.AppendText(remote + "\n" + message + "\n");
        }
 
        private void HostsChanged()
        {
            ftHosts.Build(server.Hosts);
        }
 
        private void btSendMessage_Click(object sender, EventArgs e)
        {
                Host remote = ftHosts.SelectedNode as Host;
                if (remote == null) return;
                server.SendMessage(tbNewMessage.Text, remote.IP);
                tbMessages.AppendText("Sent to " + remote + " via TCP" + "\n" + tbNewMessage.Text + "\n");
                tbNewMessage.Clear();
        }
    }

public void Connect(byte[] bytes, IPAddress remote)
        {
            TcpClient tcp = new TcpClient();
            tcp.BeginConnect(remote, port, (ar) => OnTCPConnected(ar, tcp, bytes), null);
        }
        public void OnTCPConnected(IAsyncResult ar, TcpClient tcp, byte[] bytes)
        {
            tcp.EndConnect(ar);
 
            NetworkStream stream = tcp.GetStream();
            BinaryWriter bw = new BinaryWriter(stream);
            {
                bw.Write(bytes.Length);
                bw.Write(bytes);
            }
        }