Ejemplo n.º 1
0
        public void OnSocketEventCallback(CallbackEventType eventType, object eventFrom, object param)
        {
            switch (eventType)
            {
            case CallbackEventType.ACCEPT_FAIL:     // some AcceptAsync() function fails
                // eventFrom : StartListen() return value: listenID
                Console.WriteLine("Accept Failed!");
                break;


            case CallbackEventType.ACCEPT_SUCCESS:     // Accepted new session
                // eventFrom : StartListen() return value: listenID
                // param : accepted SocketSession
                // var acceptedSession = param as SocketSession;
                break;


            case CallbackEventType.SESSION_RECEIVE_DATA:     // Session received data
                                                             // eventFrom : SocketSession that received data
                                                             // param : received byte array : (byte[])
                                                             // send back

                var session = eventFrom as SocketSession;
                this.ultraES.Send(session, (byte[])param);
                Interlocked.Increment(ref this.echoCount);
                break;


            case CallbackEventType.SESSION_CLOSED:     // Session has been closed
                var closedSession = eventFrom as SocketSession;
                break;
            }
        }
Ejemplo n.º 2
0
        public void OnSocketEventCallback(CallbackEventType eventType, object eventFrom, Object param)
        {
            long temp;

            switch (eventType)
            {
            case CallbackEventType.ACCEPT_FAIL:     // some AcceptAsync() function fails
                // fromID : StartListen() return value: listenID
                Console.WriteLine("Accept Failed!");
                break;


            case CallbackEventType.ACCEPT_SUCCESS:     // Accepted new session
                // fromID : StartListen() return value: listenID
                // param : (long)acceptedSessionID
                var acceptedSession = param as SocketSession;
                //Console.WriteLine("Listener Accept {0}", acceptedSessionID);
                this.acceptSessionIdDic.TryAdd(acceptedSession, 0);
                break;


            case CallbackEventType.SESSION_RECEIVE_DATA:     // Session received data
                                                             // fromID : sessionID that received data
                                                             // param : received byte array : (byte[])
                                                             // send back

                var session = eventFrom as SocketSession;
                var msg     = Encoding.UTF8.GetString((byte[])param);

                this.ultraES.Send(session, (byte[])param);
                var cnt = Interlocked.Increment(ref this.receivedDataCount);


                // disconnect session occasionally
                if (cnt % 2500 == 0)
                {
                    Task.Run(() =>
                    {
                        //Console.WriteLine("Listener Disconnect {0}", fromID);
                        this.ultraES.CloseSession(session);
                    });
                }

                break;


            case CallbackEventType.SESSION_CLOSED:     // Session has been closed
                var closedSession = eventFrom as SocketSession;
                this.acceptSessionIdDic.TryRemove(closedSession, out temp);
                //Console.WriteLine("Listener Closed {0}", fromID);
                break;
            }
        }
Ejemplo n.º 3
0
        void OnSocketEventCallback(CallbackEventType eventType, object eventFrom, object param)
        {
            switch (eventType)
            {
            case CallbackEventType.CONNECT_FAIL:     // TryConnect() failed
                // eventFrom : TryConnect() return value: SocketSession
                // param : (SocketError)
                Console.WriteLine("Connect to Server Failed! {0}");
                break;


            case CallbackEventType.CONNECT_SUCCESS:     // TryConnect() succeed
                // eventFrom : TryConnect() return value: SocketSession
            {
                var session = eventFrom as SocketSession;
                this.sessionDic.TryAdd(session, 0);

                var sendMsg = Encoding.UTF8.GetBytes("1234");
                this.ultraES.Send(session, sendMsg);
            }
            break;


            case CallbackEventType.SESSION_RECEIVE_DATA:     // Session received data
                                                             // eventFrom : SocketSession that received data
                                                             // param : received byte array : (byte[])
            {
                var session = eventFrom as SocketSession;
                var sendMsg = Encoding.UTF8.GetBytes("1234");
                this.ultraES.Send(session, sendMsg);
            }
            break;


            case CallbackEventType.SESSION_CLOSED:     // Session has been closed
            {
                var closedSession = eventFrom as SocketSession;
                int v;
                this.sessionDic.TryRemove(closedSession, out v);
            }
            break;
            }
        }
        void OnSocketEventCallback(CallbackEventType eventType, object eventFrom, Object param)
        {
            switch (eventType)
            {
            case CallbackEventType.CONNECT_FAIL:     // TryConnect() failed
                // eventFrom : TryConnect() return value: SocketSession
                // param : (SocketError)
                Console.WriteLine("Connect to Server Failed!");
                break;


            case CallbackEventType.CONNECT_SUCCESS:     // TryConnect() succeed
                // eventFrom : TryConnect() return value: SocketSession
            {
                var session = eventFrom as SocketSession;
                int start   = 0;
                lock (random)
                {
                    start = random.Next();
                }
                var sendMsg = Encoding.UTF8.GetBytes(string.Format("{0}", start));
                sendNumDic.TryAdd(session, start);

                this.ultraES.Send(session, sendMsg);
            }
            break;


            case CallbackEventType.SESSION_RECEIVE_DATA:     // Session received data
                                                             // eventFrom : SocketSession that received data
                                                             // param : received byte array : (byte[])
            {
                var session = eventFrom as SocketSession;
                var recvMsg = Encoding.UTF8.GetString((byte[])param);

                long v, x;
                if (Int64.TryParse(recvMsg, out x))
                {
                    this.sendNumDic.TryRemove(session, out v);
                    if (v != x)
                    {
                        Console.WriteLine("Error! reply not match sessionID={0} v={1} x={2}", eventFrom, v, x);
                    }
                    else
                    {
                        v++;
                        sendNumDic.TryAdd(session, v);
                        var replyMsg = string.Format("{0}", v);
                        this.ultraES.Send(session, Encoding.UTF8.GetBytes(replyMsg));
                        Interlocked.Increment(ref this.replyRecvCount);
                    }
                }
                else if (recvMsg.Equals("This is Broadcast Message"))
                {
                }
                else
                {
                    // If this happen, Critical Error!
                    Console.WriteLine("Error! unknown msg: {0} {1}", ((byte[])param).Length, recvMsg);
                }

                var cnt = Interlocked.Increment(ref this.receivedDataCount);


                // disconnect session occasionally
                if (cnt % 3500 == 0)
                {
                    Task.Run(() =>
                        {
                            this.ultraES.CloseSession(session);
                        });
                }
            }
            break;


            case CallbackEventType.SESSION_CLOSED:     // Session has been closed
            {
                var  closedSession = eventFrom as SocketSession;
                long v;
                this.sendNumDic.TryRemove(closedSession, out v);
                // reconnect
                this.ultraES.TryConnect(this.ip, this.portNum);
            }
            break;
            }
        }