serwer wysyłający wiadomości

z pewną pomocą stworzyłem program serwer-klient mogący obslugiwać kilka połączeń. Teraz próbując dodać do niego opcję wysyłania wiadomości z serwera wciąż coś sie sypie/ie gra... jak to obsłużyc? Czas mnie goni coraz bardziej, a wciąż nie mogę sobie z tym niby banalnym problemem poradzić. Jest źle, pomocy!;)
mój działający jeszcze kod:

main:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace SilentMultiConnectionS
{
    public partial class Main1 : Form
    {
        listener listener;
        public Main1()
        {
            InitializeComponent();
            listener = new listener(8);
            listener.SocketAccepted += new SilentMultiConnectionS.listener.SocketAcceptedHanler(listener_SocketAccepted);
            Load += new EventHandler(Main1_Load);
        }

        void Main1_Load(object sender, EventArgs e)
        {
            listener.Start();
        }

        void listener_SocketAccepted(System.Net.Sockets.Socket e)
        {
            Client client = new Client(e);
            client.Received += new Client.ClientReceivedHandler(client_Received);
            client.Disconnected += new Client.ClientDisconnectedHandler(client_Disconnected);
    

            Invoke((MethodInvoker)delegate
                {
                    ListViewItem i = new ListViewItem();
                    i.Text = client.EndPoint.ToString();
                    i.SubItems.Add(client.ID);
                    i.SubItems.Add("XX");
                    i.SubItems.Add("CC");
                    i.Tag = client;
                    listView1.Items.Add(i);    
                });
        }

        

        void client_Disconnected(Client sender)
        {
            Invoke((MethodInvoker)delegate
            {
                for (int i = 0; i < listView1.Items.Count; i++)
                {
                    Client client = listView1.Items[i].Tag as Client;

                    if (client.ID == sender.ID)
                    {
                        listView1.Items.RemoveAt(i);
                        break;
                    }
                }
            }); 
        }

        void client_Received(Client sender, byte[] data)
        {
            Invoke((MethodInvoker)delegate
            {
                for (int i = 0; i < listView1.Items.Count; i++)
                {
                    Client client = listView1.Items[i].Tag as Client;

                    if (client.ID == sender.ID)
                    {
                        listView1.Items[i].SubItems[2].Text = Encoding.Default.GetString(data);
                        listView1.Items[i].SubItems[3].Text = DateTime.Now.ToString();
                        break;
                    }
                }
            }); 
        }

        private void btnWyslij_Click(object sender, EventArgs e)
        {
            
            
        }

            
    }
}
 

klasa client:

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.Net.Sockets;

namespace SilentMultiConnectionS
{
    class Client
    {
        public string ID
        {
            get;
            private set;
        }

        public IPEndPoint EndPoint
        {
            get;
            private set;
        }

        Socket sck;
        public Client(Socket accepted)
        {
            sck = accepted;
            ID = Guid.NewGuid().ToString();
            EndPoint = (IPEndPoint)sck.RemoteEndPoint;
            sck.BeginReceive(new byte[] {0}, 0, 0, 0, callback, null);
            
              
        }

        void callback(IAsyncResult ar)
        {
            try
            {
                sck.EndReceive(ar);

                byte[] buf= new byte[8192];

                int rec = sck.Receive(buf, buf.Length, 0);

                if (rec < buf.Length)
                {
                    Array.Resize<byte>(ref buf, rec);
                }

                if (Received != null)
                {
                    Received(this, buf);
                }

                sck.BeginReceive(new byte[] { 0 }, 0, 0, 0, callback, null);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                Close();

                if (Disconnected != null)
                {
                    Disconnected(this);
                }
            }
        }

        public void Close()
        {
            sck.Close();
            sck.Dispose();
        }

        public delegate void ClientReceivedHandler(Client sender, byte[] data);
        public delegate void ClientDisconnectedHandler(Client sender);       

        public event ClientReceivedHandler Received;
        public event ClientDisconnectedHandler Disconnected;
        
    }
}

klasa listener:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.Net.Sockets;

namespace SilentMultiConnectionS
{
    class listener
    {
        Socket s;

        public bool Listening
        {
            get;
            private set;
        }

        public int Port
        {
            get;
            private set;
        }

        public listener(int port)
        {
            Port = port;
            s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        }

        public void Start()
        {
            if(Listening)
                return;

            s.Bind(new IPEndPoint(0,Port));
            s.Listen(0);

            s.BeginAccept(callback, null);
            Listening = true;

        }

        public void Stop()
        {
            if(!Listening)
                return;

            s.Close();
            s.Dispose();
            s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        }

        void callback(IAsyncResult ar)
        {
            try
            {
                Socket s = this.s.EndAccept(ar);

                if (SocketAccepted != null)
                {
                    SocketAccepted(s);
                }

                this.s.BeginAccept(callback, null);
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }

        public delegate void SocketAcceptedHanler(Socket e);
        public event SocketAcceptedHanler SocketAccepted;
    }
}