Sockets - Multi Connection

Guten Tag,

Undzwar ich habe einen Client der Wen er gestartet wird ein Packet gesendet der dann auch Antwort wartet nach der Antwort wieder auf ein Packet. So geht das neinpaar mal.

Und das alle ohne Socket zu schließen habe bisher nur mit Sockets gearbeitet wo der eine was Sendet und der andere darauf reagiert aber sowas noch nicht.

Könntet ihr veilleicht ein beichspiel posten wie man das am besten machenn kann..

Versteh nicht so ganz wo dein Problem liegt. Solltest vill genauer erklären wo du nicht weiter kommst.

Evtl. bringt dich "Asynchrones Empfangen/Senden" weiter

ja habe ich nun auch gemacht jedoch kommt nach starten direkt press any key to continue in der Console..

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Collections;
using System.Net;
using System.Windows.Forms;
using System.Threading;


namespace GameServer
{
    public class Server
    {

        public static ArrayList m_workerSocketList = ArrayList.Synchronized(new System.Collections.ArrayList());

        public AsyncCallback pfnWorkerCallBack;
        private Socket m_mainSocket;
        public delegate void UpdateRichEditCallback(string text);
        public delegate void UpdateClientListCallback();

        private int m_clientCount = 0;

        public const UInt16 BUFFERSIZE = 4096;
        private static byte[] _buffer = new byte[BUFFERSIZE];

        public byte[] Buffer
        {
            get
            {
                return _buffer;
            }
        }


        public static void SendToClient(byte[] msg, int clientNumber)
        {

            Socket workerSocket = (Socket)m_workerSocketList[clientNumber - 1];
            workerSocket.Send(msg);

        }


        public void StartServer()
        {
            // server initalizate
            Console.WriteLine("Initalizate Login Server on Port 15779");

            //Please change the bellow information to your proper mysql info
            m_mainSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            IPEndPoint ipLocal = new IPEndPoint(IPAddress.Any, 15779);
            m_mainSocket.Bind(ipLocal);
            m_mainSocket.Listen(5);  // Maximale 5 Connections

            Console.WriteLine("Backlog set to 5");
            try
            {
                    m_mainSocket.BeginAccept(new AsyncCallback(OnClientConnect), null);
            }
            catch
            {
            }
        }



        public void OnClientConnect(IAsyncResult asyn)
        {

            Console.WriteLine("Client connected..");
            try
            {

                Socket workerSocket = m_mainSocket.EndAccept(asyn);
                Interlocked.Increment(ref m_clientCount);
                Server.m_workerSocketList.Add(workerSocket);
                workerSocket.Send(new byte[] { 0x01, 0x00, 0x00, 0x50, 0x00, 0x00, 0x01 }); // Accept Packet 01000050000001

                WaitForData(workerSocket, m_clientCount);

                m_mainSocket.BeginAccept(new AsyncCallback(OnClientConnect), null);
            }
            catch (SocketException se)
            {
                Console.WriteLine("Error, onClientConnect");
                MessageBox.Show(se.Message);
            }

        }



        public class SocketPacket
        {

            public SocketPacket(Socket socket, int clientNumber)
            {
                m_currentSocket = socket;
                m_clientNumber = clientNumber;
            }
            public System.Net.Sockets.Socket m_currentSocket;
            public int m_clientNumber;

            public byte[] dataBuffer = new byte[4096];
        }

        private void Process(byte[] buffer, int index)
        {
            // Convert to Hex
            string hex = CConvert.ByteToString(buffer);

            // Handle Packet
            string handled = Handle.HandleData(hex);

            if (handled == "NONE")
            {

            }
            else
            {
                SendToClient(CConvert.HexToByte(handled), index);
            }
        }

        public void WaitForData(System.Net.Sockets.Socket soc, int clientNumber)
        {
            try
            {
                if (pfnWorkerCallBack == null)
                {
                    pfnWorkerCallBack = new AsyncCallback(OnDataReceived);
                }

                SocketPacket theSocPkt = new SocketPacket(soc, clientNumber);

                soc.BeginReceive(_buffer, 0, BUFFERSIZE, SocketFlags.None, pfnWorkerCallBack, theSocPkt);
            }
            catch (SocketException se)
            {
                MessageBox.Show(se.Message);
            }
        }



        public void OnDataReceived(IAsyncResult asyn)
        {

            SocketPacket socketData = (SocketPacket)asyn.AsyncState;
            try
            {


                try
                {

                    int packetSize = socketData.m_currentSocket.EndReceive(asyn);
                    if (packetSize > 0)
                    {
                        Process(_buffer, socketData.m_clientNumber);
                    }

                    try
                    {
                        WaitForData(socketData.m_currentSocket, socketData.m_clientNumber);

                    }
                    catch { }

                }
                catch { }


            }
            catch (ObjectDisposedException)
            {
                System.Diagnostics.Debugger.Log(0, "1", "\nOnDataReceived: Socket has been closed\n");
            }
            catch (SocketException se)
            {
                if (se.ErrorCode == 10054) // Error code for Connection reset by peer
                {
                    string msg = "Client " + socketData.m_clientNumber + " Disconnected" + "\n";


                    // Remove the reference to the worker socket of the closed client
                    // so that this object will get garbage collected
                    Server.m_workerSocketList[socketData.m_clientNumber - 1] = null;

                }
                else
                {
                    MessageBox.Show(se.Message);
                }
            }
        }



        public void CloseSockets()
        {
            /*
            if (m_mainSocket != null)
             {
                 m_mainSocket.Close();
             }
             Socket workerSocket = null;
             for (int i = 0; i < m_workerSocketList.Count; i++)
             {
                 workerSocket = (Socket)m_workerSocketList[i];
                 if (workerSocket != null)
                 {
                     workerSocket.Close();
                     workerSocket = null;
                 }
             }
        */
            m_mainSocket.Close();



        }


    }
}

Die CConvert Klasse ist vorhande genauso wie die anderen Klassen..

Nur es kommt auch kein fehler anscheind startet es und danahc beendet sich es sofort..