//private async Task ReadDataAsync(TcpClient mClient)
        //{
        //    try
        //    {
        //        StreamReader clientStreamReader = new StreamReader(mClient.GetStream());
        //        char[] buff = new char[64];
        //        int readByteCount = 0;

        //        while(true)
        //        {
        //            readByteCount=await clientStreamReader.ReadAsync(buff,0,buff.Length);

        //            if(readByteCount<=0)
        //            {
        //                Console.WriteLine("Disconnect from server");
        //                mClient.Close();
        //                break;
        //            }

        //            Console.WriteLine(string.Format("Received bytes: {0} - Message: {1}",readByteCount,new string(buff)));
        //            OnRaiseTextReceivedEvent(new TextReceivedEventsArgs(mClient.Client.RemoteEndPoint.ToString(), new string(buff)));
        //            Array.Clear(buff, 0, buff.Length);
        //        }
        //    }
        //    catch(Exception ex)
        //    {
        //        Console.WriteLine(ex.ToString());

        //    }
        //}

        private async Task ReadDataAsync(TcpClient mClient)
        {
            try
            {
                //StreamReader clientStreamReader = new StreamReader(mClient.GetStream());
                byte[] buff          = new byte[1024];
                int    readByteCount = 0;

                while (true)
                {
                    readByteCount = await mClient.GetStream().ReadAsync(buff, 0, buff.Length);

                    if (readByteCount <= 0)
                    {
                        Console.WriteLine("Disconnect from server");
                        mClient.Close();
                        break;
                    }

                    SocketDataTransfer received_data = ByteArrayToObject(buff, readByteCount);
                    //Console.WriteLine(string.Format("Received bytes: {0} - Message: {1}", readByteCount, new string(buff)));
                    //OnRaiseTextReceivedEvent(new TextReceivedEventsArgs(mClient.Client.RemoteEndPoint.ToString(), new string(buff)));
                    OnRaiseSocketDataTransferEvent(new SocketDataTransferEventsArgs(received_data));

                    Array.Clear(buff, 0, buff.Length);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
        }
        public async void SendToAll(SocketDataTransfer socketDataTransfer)
        {
            if (socketDataTransfer == null)
            {
                return;
            }

            try
            {
                byte[] buffMessage = ObjectToByteArray(socketDataTransfer);

                //foreach (TcpClient c in mClients)
                //{
                //    c.GetStream().WriteAsync(buffMessage, 0, buffMessage.Length);
                //}

                List <string> users = connected_user_to_socket_map.Keys.ToList();
                foreach (string user in users)
                {
                    connected_user_to_socket_map[user].GetStream().WriteAsync(buffMessage, 0, buffMessage.Length);
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
        }
        private SocketDataTransfer ByteArrayToObject(byte[] arrBytes, int buff_length)
        {
            MemoryStream    memStream = new MemoryStream();
            BinaryFormatter binForm   = new BinaryFormatter();

            memStream.Write(arrBytes, 0, buff_length);
            memStream.Seek(0, SeekOrigin.Begin);
            SocketDataTransfer obj = (SocketDataTransfer)binForm.Deserialize(memStream);

            return(obj);
        }
        //private async void TakeCareOfTCPClient(TcpClient paramClient)
        //{
        //    NetworkStream stream = null;
        //    StreamReader reader = null;

        //    try
        //    {
        //        stream = paramClient.GetStream();
        //        reader = new StreamReader(stream);

        //        char[] buff = new char[64];

        //        while(KeepRunning)
        //        {
        //            Debug.WriteLine("*** Ready to read");
        //            int nRet=await reader.ReadAsync(buff,0,buff.Length);
        //            System.Diagnostics.Debug.WriteLine("Returned: "+nRet);

        //            if(nRet==0)
        //            {
        //                RemoveveClient(paramClient);
        //                Debug.WriteLine("Socket disonnected");
        //                break;
        //            }

        //            string receivedText = new string(buff);

        //            Debug.WriteLine("*** RECEIVED: "+receivedText);

        //            OnRaiseTextReceivedEvent(new TextReceivedEventsArgs(paramClient.Client.RemoteEndPoint.ToString(),receivedText));
        //            Array.Clear(buff,0,buff.Length);

        //        }
        //    }
        //    catch(Exception ex)
        //    {
        //        RemoveveClient(paramClient);
        //        Debug.WriteLine(ex.ToString());
        //    }

        //}


        private async void TakeCareOfTCPClient(TcpClient paramClient)
        {
            NetworkStream stream = null;
            StreamReader  reader = null;

            try
            {
                stream = paramClient.GetStream();
                reader = new StreamReader(stream);

                byte[] buff = new byte[1024];

                while (KeepRunning)
                {
                    Debug.WriteLine("*** Ready to read");
                    int nRet = await stream.ReadAsync(buff, 0, buff.Length);

                    System.Diagnostics.Debug.WriteLine("Returned: " + nRet);

                    if (nRet == 0)
                    {
                        RemoveClient(paramClient);
                        Debug.WriteLine("Socket disonnected");
                        break;
                    }

                    SocketDataTransfer socketDataTransfer = ByteArrayToObject(buff, nRet);
                    if (socketDataTransfer.command == Globals.cmd_update_users_list)
                    {
                        connected_user_to_socket_map[socketDataTransfer.user_name] = paramClient;

                        string UserIPAddress, UserPort, UserName;
                        ClientConnectedEventsArgs eaClientConnected;
                        UserIPAddress = ((IPEndPoint)paramClient.Client.RemoteEndPoint).Address.ToString();
                        UserPort      = ((IPEndPoint)paramClient.Client.RemoteEndPoint).Port.ToString();
                        UserName      = socketDataTransfer.user_name;

                        //eaClientConnected = new ClientConnectedEventsArgs(paramClient.Client.RemoteEndPoint.ToString());
                        eaClientConnected = new ClientConnectedEventsArgs(UserIPAddress, UserPort, UserName);
                        OnRaiseClientConnectedEvent(eaClientConnected);
                    }
                    OnRaiseSocketDataTransferEvent(new SocketDataTransferEventsArgs(socketDataTransfer));
                    Array.Clear(buff, 0, buff.Length);
                }
            }
            catch (Exception ex)
            {
                RemoveClient(paramClient);
                Debug.WriteLine(ex.ToString());
            }
        }
        private byte[] ObjectToByteArray(SocketDataTransfer obj)
        {
            if (obj == null)
            {
                return(null);
            }

            BinaryFormatter bf = new BinaryFormatter();
            MemoryStream    ms = new MemoryStream();

            bf.Serialize(ms, obj);

            return(ms.ToArray());
        }
        //public async Task SendToServer(string strInputUser)
        //{
        //    if(string.IsNullOrEmpty(strInputUser))
        //    {
        //        Console.WriteLine("Empty string supplied to send");
        //        return;
        //    }

        //    if(mClient!=null)
        //    {
        //        if(mClient.Connected)
        //        {
        //            StreamWriter clientStreamWriter = new StreamWriter(mClient.GetStream());
        //            clientStreamWriter.AutoFlush = true;

        //            await clientStreamWriter.WriteAsync(strInputUser);
        //            Console.WriteLine("Data sent...");
        //        }
        //    }
        //}

        public async Task SendToServer(SocketDataTransfer socketDataTransfer)
        {
            if (socketDataTransfer == null)
            {
                Console.WriteLine("Empty data supplied to send");
                return;
            }

            if (mClient != null)
            {
                if (mClient.Connected)
                {
                    byte[] buffMessage = ObjectToByteArray(socketDataTransfer);
                    await mClient.GetStream().WriteAsync(buffMessage, 0, buffMessage.Length);

                    Console.WriteLine("Data sent...");
                }
            }
        }
Пример #7
0
 public SocketDataTransferEventsArgs(SocketDataTransfer socketDataTransfer)
 {
     this.socketDataTransfer = socketDataTransfer;
 }