Exemple #1
0
 // Block for input from the World server. Checks every 500ms and if
 // there is a message then this returns a string of that message.
 // Otherwise, the only other value, null, is returned when the thread
 // isn't connected anymore.
 protected string NextEvent()
 {
     byte[] bytes;
     while (this.connected)
     {
         //Thread.Sleep(500);
         bytes = world.ReceiveImmediate();
         if (bytes == null)
         {
             continue;
         }
         return(Encoding.ASCII.GetString(bytes));
     }
     return(null);
 }
Exemple #2
0
        public void RecieveDataAsClient()
        {
            try
            {
                Task.Factory.StartNew(() =>
                {
                    while (!_ctsCancellationTokenSource.IsCancellationRequested)
                    {
                        byte[] _IncomingData = _subscribeSocket.ReceiveImmediate();

                        if (_IncomingData == null)
                        {
                            continue;
                        }


                        byte[] buffer = _IncomingData.Skip(10).Take(_IncomingData.Length - 2).ToArray();

                        //if ((MessageType)BitConverter.ToInt16(_IncomingData, 0) != MessageType.HEARTBEAT)
                        //{
                        //    cout = cout + 1;
                        //    eDataUpdate.Invoke(cout.ToString());
                        //}
                        switch ((MessageType)BitConverter.ToInt16(_IncomingData, 0))
                        {
                        case MessageType.ORDER:
                            {
                                //NNFPktCracker(buffer);
                                short TransactionCode = 0;
                                var MsgHeader         = (Message_Header)DataPacket.RawDeserialize(buffer.Skip(0).Take(40).ToArray(), typeof(Message_Header));
                                TransactionCode       = IPAddress.HostToNetworkOrder(MsgHeader.TransactionCode);
                                checkCase(TransactionCode, buffer);

                                break;
                            }

                        case MessageType.ORDERRej:
                            {
                                ORDERRej(buffer);
                                break;
                            }

                        case MessageType.LOGIN:
                            {
                                NNFInOut.Instance.SIGN_ON_REQUEST_OUT(buffer);

                                long client_Autoid = Global.Instance.ClientId - 100;
                                _subscribeSocket.Subscribe(
                                    BitConverter.GetBytes((short)MessageType.ORDERRej).Concat(BitConverter.GetBytes(Global.Instance.ClientId)).ToArray());

                                _subscribeSocket.Subscribe(
                                    BitConverter.GetBytes((short)MessageType.MESSAGE).Concat(BitConverter.GetBytes(Global.Instance.ClientId)).ToArray());

                                _subscribeSocket.Subscribe(
                                    BitConverter.GetBytes((short)MessageType.HEARTBEAT).Concat(BitConverter.GetBytes(0)).ToArray());

                                _subscribeSocket.Subscribe(
                                    BitConverter.GetBytes((short)MessageType.ORDER).Concat(BitConverter.GetBytes(Global.Instance.ClientId)).ToArray());

                                _subscribeSocket.Subscribe(
                                    BitConverter.GetBytes((short)MessageType.ORDER).Concat(BitConverter.GetBytes(client_Autoid)).ToArray());
                                _subscribeSocket.Subscribe(
                                    BitConverter.GetBytes((short)MessageType.ORDERRej).Concat(BitConverter.GetBytes(client_Autoid)).ToArray());
                                _subscribeSocket.Subscribe(
                                    BitConverter.GetBytes((short)MessageType.MESSAGE).Concat(BitConverter.GetBytes(client_Autoid)).ToArray());

                                Global.LastTime = System.DateTime.Now;
                                break;
                            }

                        case MessageType.MESSAGE:
                            {
                                MESSAGE(buffer);
                                break;
                            }

                        case MessageType.HEARTBEAT:
                            {
                                HeartBeat(buffer);
                                Global.LastTime = System.DateTime.Now;
                                break;
                            }

                        default:
                            MessageBox.Show("Some invalid packet recieved from Server Message Code " + "Error ");
                            break;
                        }


                        _ctsCancellationTokenSource.Token.ThrowIfCancellationRequested();
                    }
                }, _ctsCancellationTokenSource.Token);
            }
            catch (OperationCanceledException e)
            {
                Console.WriteLine("Cancellation invoked");
            }
            catch (AggregateException e)
            {
                if (e.InnerException is OperationCanceledException)
                {
                    if (_requestSocket != null)
                    {
                        _requestSocket.Dispose();
                    }
                    if (_subscribeSocket != null)
                    {
                        _subscribeSocket.Dispose();
                    }
                }
                else
                {
                    Console.WriteLine("Some unexpected exception ");
                }
            }
            catch (Exception Ex)
            {
                Console.WriteLine("Exception Raised from Index " + "  " + Ex.Message);
            }
        }