Problem medThreading Vs. CPU Usage / Netværks Applikation

Hej alle sammen...

Jeg har et problem, jeg sidder og skriver et program der lytter på netværket, Ideen er at den modtager en streng, hvorefter den kører en funktion der returnerer noget tilsvarende data fra et array... Hvad den gør er egentlig ikke så vigtigt, problemet er at jeg kører den fra en Windows Applikation som en "Thread".

Dette får uheldigvis den selv samme netværks applikation til at bruge 50% CPU kraft(CPU temperaturen stiger omkring 14 grader), dette er ikke så godt, dog skal det siges at programmet virker som det er nu, så der skal helst ikke så store ændringer i det. Hvis der er nogen der genkender koden i ListenerMain er det nok rigtig nok, det er noget jeg har snuppet fra et konsol program jeg lavede engang som en del af en øvelse, kan dog ikke huske hvor.

en af mine egne ideer var at lave noget kode der udfører en "Suspend()" på ListenerMain når der ikke var noget trafik til den, men den eneste måde jeg selv kender til at gøre dette er at lave en ny tråd der gør det for mig, og den kommer også til at anvende 50% CPU kraft.

Er der nogen der har en god ide?

Forhånd tak...

<copy paste af koden>

public void ListenerMain(){
            listen = true;

            IPHostEntry Iphe = null;
            IPEndPoint Ipep = null;
            Socket Server = null;

            Iphe = Dns.Resolve(Dns.GetHostName());
            Ipep = new IPEndPoint(Iphe.AddressList[0], 4444);
            Server = new Socket(Ipep.Address.AddressFamily,SocketType.Stream,ProtocolType.Tcp);

            ArrayList Client = new ArrayList();
            string rln = null;

            Client.Capacity = 256;
            Server.Blocking = false;
           
            Server.Bind(Ipep);
            Server.Listen(32);               

            while(listen){
                if(Server.Poll(0, SelectMode.SelectRead)){
                    int i = Client.Add(new TcpSock());
                    ((TcpSock)Client[i]).tcpSock = Server.Accept();
                    ((TcpSock)Client[i]).SendLn("Connected");
                }

                for(int i = 0; i < Client.Count; i++){
                    if (((TcpSock)Client[i]).tcpSock.Poll(0, SelectMode.SelectRead)){
                        if(((TcpSock)Client[i]).Recv(ref rln) > 0)
                        {
                            if(rln == "\r\n")
                            {
                                ((TcpSock)Client[i]).RecvLn(ref rln);
                                ((TcpSock)Client[i]).Send(DoQuery(i.ToString() + ": " + rln));
                            }
                        }
                        else{
                        ((TcpSock)Client[i]).tcpSock.Shutdown(SocketShutdown.Both);
                        ((TcpSock)Client[i]).tcpSock.Close();
                            Client.RemoveAt(i);
                        }
                    }   
                }
            }
            funktion_end = true;
        }
    }

    public class TcpSock{
   
        int tcpIndx = 0;
        int tcpByte = 0;
        byte[] tcpRecv = new byte[1024];
        public Socket tcpSock;

        public int Recv(ref string tcpRead)
        {
            tcpByte = tcpSock.Available;
            if(tcpByte > tcpRecv.Length - tcpIndx)
                tcpByte = tcpRecv.Length - tcpIndx;

            tcpByte = tcpSock.Receive(tcpRecv,tcpIndx,tcpByte,SocketFlags.Partial);
            tcpRead = Encoding.ASCII.GetString(tcpRecv,tcpIndx,tcpByte);
            tcpIndx+= tcpByte;
           
            return tcpRead.Length;
        }

        public int RecvLn(ref string tcpRead)
        {
            tcpRead = Encoding.ASCII.GetString(tcpRecv,0,tcpIndx);
            tcpIndx = 0;
            return tcpRead.Length;
        }

        public int Send(string tcpWrite)
        {
            return tcpSock.Send(Encoding.ASCII.GetBytes(tcpWrite));
        }

        public int SendLn(string tcpWrite)
        {
            return tcpSock.Send(Encoding.ASCII.GetBytes(tcpWrite + "\r\n"));
        }
    }
}