Пример #1
0
        protected override void DispatchMessage(MessageRecievedEvent evt)
        {
            switch (evt.Message.FuncId)
            {
            case 8000:
            {
                var msg = new CheckVersionInMessage(evt.Sender, evt.Message, evt.Data);
                msg.Coroutine = new Coroutine(item => CheckVersion(item, msg));
                msg.Coroutine.MoveNext();
            }
            break;

            case 8001:
            {
                var msg = new CheckVersion2InMessage(evt.Sender, evt.Message, evt.Data);
                msg.Coroutine = new Coroutine(item => CheckVersion2(item, msg));
                msg.Coroutine.MoveNext();
            }
            break;

            case 8002:
            {
                var msg = new CheckVersion3InMessage(evt.Sender, evt.Message, evt.Data);
                msg.Coroutine = new Coroutine(item => CheckVersion3(item, msg));
                msg.Coroutine.MoveNext();
            }
            break;

            default:
                break;
            }
        }
Пример #2
0
        public void ReadCallback(IAsyncResult ar)
        {
            StateObject state = (StateObject)ar.AsyncState;

            Socket = state.WorkSocket;
            ISocketMessage message = new JsonSocketMessage();

            try
            {
                int bytesRead = Socket.EndReceive(ar);

                if (bytesRead > 0)
                {
                    foreach (var msg in message.Deserialize(state.Buffer))
                    {
                        switch (msg.MessageType)
                        {
                        case SocketMessageType.Method:
                            MethodRecievedEvent?.Invoke(this,
                                                        MethodSignatureDto.DeserializeMethodObject(msg.Message));
                            break;

                        case SocketMessageType.Methods:
                            break;

                        case SocketMessageType.MethodExecution:
                            break;

                        case SocketMessageType.Identity:
                            ClientIdentificationEvent?.Invoke(this, Guid.Parse(msg.Message));
                            break;

                        case SocketMessageType.Normal:
                            MessageRecievedEvent?.Invoke(this, msg);
                            break;

                        default:
                            throw new ArgumentOutOfRangeException();
                        }
                    }

                    Socket.BeginReceive(state.Buffer, 0, state.BufferSize, 0, ReadCallback, state);
                }

                else
                {
                }
            }
            catch (SocketException e)
            {
                _logger.Warn(e.Message);
            }
        }
Пример #3
0
 public void ServerNotify(string state)
 {
     try
     {
         MessageRecievedEvent?.Invoke(this, state);
         LogServer.LogStatus(STT.General.INFO_GENERAL, $"Notification from client sent to client side");
     }
     catch (Exception e)
     {
         string s = e.Message;
     }
 }