Gate.Gate.OnBackendMessageReceived C# (CSharp) Method

OnBackendMessageReceived() private method

private OnBackendMessageReceived ( IRemote conn, Network.Message msg ) : void
conn IRemote
msg Network.Message
return void
        private void OnBackendMessageReceived(IRemote conn, Message msg)
        {
            Console.WriteLine("OnBackendMessageReceived id:{0} ip:{1} port:{2}", conn.Id, conn.RemoteIp, conn.RemotePort);
            Console.WriteLine("OnBackendMessageReceived msgLen:{0}", msg.Buffer.Length);

            // forward backend msg to frontend, 
            // which is based on forwardId associated with the msg

            var stream = new MemoryStream(msg.Buffer);
            var br = new BinaryReader(stream);
            var msgType = (GateMessage)br.ReadByte();

            Console.WriteLine("OnBackendMessageReceived msgType:{0}", msgType);

            switch (msgType)
            {
                #region Broker Component
                case GateMessage.Subscribe:
                    {
                        var key = br.ReadInt32();
                        var uuid = new Guid(br.ReadBytes(UuidLen));

                        Console.WriteLine("OnBackendMessageReceived key:{0} uuid:{1}", key, uuid);
                        broker.AddRouting(key, uuid, conn);
                    }
                    break;
                case GateMessage.Unicast:
                    {
                        var uuid = new Guid(br.ReadBytes(UuidLen));

                        Console.WriteLine("OnBackendMessageReceived uuid:{0}", uuid);
                        // uuid to client IRemote
                        IRemote remote = null;
                        if (!uuidToClients.TryGetValue(uuid, out remote))
                        {
                            return;
                        }

                        PushReceivedMessage(remote, msg.Buffer, msg.Buffer.Length - UuidLen - 1, UuidLen + 1);
                    }
                    break;
                #endregion

                #region Forward Component
                case GateMessage.AddForward:
                case GateMessage.RemoveForward:
                    {
                        var uuid = new Guid(br.ReadBytes(UuidLen));
                        var forwardId = br.ReadInt32();

                        Console.WriteLine("OnBackendMessageReceived uuid:{0} forwardId:{1}", uuid, forwardId);
                        // todo 
                        // what if backend control forward first,
                        // then client handshake?
                        switch (msgType)
                        {
                            case GateMessage.AddForward:
                                forwardManager.AddForward(uuid, forwardId);
                                break;
                            case GateMessage.RemoveForward:
                                forwardManager.RemoveForward(uuid, forwardId);
                                break;
                        }
                    }
                    break;
                case GateMessage.Multicast:
                    {
                        var forwardId = br.ReadInt32();

                        Console.WriteLine("OnBackendMessageReceived forwardId:{0}", forwardId);
                        // forwardId to client IRemotes
                        foreach (var uuid in forwardManager.GetForwardGroup(forwardId))
                        {
                            IRemote remote = null;
                            if (uuidToClients.TryGetValue(uuid, out remote))
                            {
                                PushReceivedMessage(remote, msg.Buffer, msg.Buffer.Length - 4 - 1, 4 + 1);
                            }
                        }
                    }
                    break;
                #endregion
            }
        }