public void SendData(string data, TransmitedDataType dataType)
        {
            if (IsConnected)
            {
                try
                {
                    if (dataType != TransmitedDataType.Unknown)
                    {
                        data = "C" + (int)dataType + data;
                    }
                    if (data.Length < BufferSize)
                    {
                        data = data.PadRight(BufferSize);
                    }
                    ASCIIEncoding asen = new ASCIIEncoding();
                    byte[]        ba   = asen.GetBytes(data);
                    Console.WriteLine("Transmitting.....");

                    connectionStream.Write(ba, 0, ba.Length);
                    connectionStream.EndWrite(null);
                    networkError = null;
                }
                catch (Exception e)
                {
                    networkError = e;
                    State        = NetworkStates.NetworkError;
                }
            }
        }
        public void SendData(string data, TransmitedDataType dataType)
        {
            if (connected)
            {
                try
                {
                    if (dataType != TransmitedDataType.Unknown)
                    {
                        data = "C" + (int)dataType + data;
                    }

                    if (data.Length < BufferSize)
                    {
                        data = data.PadRight(BufferSize);
                    }
                    ASCIIEncoding asen = new ASCIIEncoding();
                    client.Send(asen.GetBytes(data));
                    networkError = null;
                }
                catch (Exception e)
                {
                    networkError = e;
                    State        = NetworkStates.NetworkError;
                }
            }
        }
Beispiel #3
0
 private void MyServer_OnDataRecived(string data, TransmitedDataType dataType)
 {
     Console.WriteLine("Recived :");
     Console.WriteLine(data);
     txtMessage.Invoke((MethodInvoker)(() =>
     {
         txtMessage.Text = data;
     }));
 }
        void dataRead(IAsyncResult result)
        {
            byte[] buffer = result.AsyncState as byte[];

            string data = ASCIIEncoding.ASCII.GetString(buffer, 0, buffer.Length);

            TransmitedDataType datatype = TransmitedDataType.Unknown;

            data = data.TrimEnd();

            if (data.Length > 4 && data.StartsWith("C"))
            {
                datatype = data.StartsWith("C101") ? TransmitedDataType.Message : data.StartsWith("C102") ?
                           TransmitedDataType.Status : data.StartsWith("C103") ? TransmitedDataType.Command :
                           data.StartsWith("C104") ? TransmitedDataType.Headers : data.StartsWith("C105") ? TransmitedDataType.RawData : TransmitedDataType.Unknown;
                if (datatype == TransmitedDataType.Status)
                {
                    var stateID = Enum.Parse(typeof(NetworkStates), data.Substring(4));

                    if (stateID is NetworkStates)
                    {
                        ServerState = (NetworkStates)stateID;
                        if (ServerState == NetworkStates.Disconnected)
                        {
                            StopReceiving();
                            State       = NetworkStates.Disconnected;
                            ServerState = NetworkStates.Disconnected;
                            connected   = false;
                            client.Close();
                            if (OnServerDisconnected != null)
                            {
                                OnServerDisconnected.Invoke();
                            }
                        }
                        // return;
                    }
                }
                if (datatype != TransmitedDataType.Unknown)
                {
                    data = data.Substring(4);
                }
            }
            latestReceivedData = data;

            if (OnDataReceived != null)
            {
                OnDataReceived.Invoke(data, datatype);
            }

            if (!stopReceiver)
            {
                buffer = new byte[BufferSize];
                connectionStream.BeginRead(buffer, 0, BufferSize, dataRead, buffer);
            }
        }
        void recieveArgs_Completed(object sender, SocketAsyncEventArgs e)
        {
            TransmitedDataType datatype = TransmitedDataType.Unknown;

            var are = (AutoResetEvent)e.UserToken;

            are.Set();

            latestReceivedData = "";
            //  for (int i = 0; i < e.BytesTransferred; i++)
            //    latestReceivedData += Convert.ToChar(e.Buffer[i]);
            latestReceivedData = System.Text.Encoding.Default.GetString(e.Buffer).TrimEnd();
            //latestReceivedData = latestReceivedData.TrimEnd();

            if (latestReceivedData.Length > 4 && latestReceivedData.StartsWith("C"))
            {
                datatype = latestReceivedData.StartsWith("C101") ? TransmitedDataType.Message : latestReceivedData.StartsWith("C102") ?
                           TransmitedDataType.Status : latestReceivedData.StartsWith("C103") ? TransmitedDataType.Command :
                           latestReceivedData.StartsWith("C104") ? TransmitedDataType.Headers : latestReceivedData.StartsWith("C105") ? TransmitedDataType.RawData : TransmitedDataType.Unknown;

                if (datatype != TransmitedDataType.Unknown)
                {
                    latestReceivedData = latestReceivedData.Substring(4);
                }

                if (datatype == TransmitedDataType.Status)
                {
                    var stateID = Enum.Parse(typeof(NetworkStates), latestReceivedData);

                    if (stateID is NetworkStates)
                    {
                        ClientState = (NetworkStates)stateID;
                        if (ClientState == NetworkStates.Disconnected)
                        {
                            StopReceiving();
                            DropAndReset();
                            if (OnClientDisconnected != null)
                            {
                                OnClientDisconnected.Invoke();
                            }
                        }
                        // return;
                    }
                }
            }

            if (OnDataReceived != null)
            {
                OnDataReceived.Invoke(latestReceivedData, datatype);
            }
        }
Beispiel #6
0
 private void Client_OnDataRecived(string data, TransmitedDataType dataType)
 {
     txtMessage.Invoke((MethodInvoker)(() =>
     {
         txtMessage.Text = data;
     }));
     if (dataType == TransmitedDataType.Command)
     {
         if (data == "stop")
         {
             timer1.Stop();
         }
         if (data == "start" && dataIsLoaded)
         {
             timer1.Start();
         }
     }
 }