C# Rookiss Part4 게임서버 : Session

🙇‍♀️Session

세션 종합본.

🪐Session

namespace ServerCore
{
    abstract class Session
    {
        Socket _socket;
        int _disconnected = 0;

        object _lock = new object();
        Queue<byte[]> _sendQueue = new Queue<byte[]>();
        List<ArraySegment<byte>> _pendingList = new List<ArraySegment<byte>>();
        SocketAsyncEventArgs _sendArgs = new SocketAsyncEventArgs();
        SocketAsyncEventArgs _recvArgs = new SocketAsyncEventArgs();

        public abstract void OnConnected(EndPoint endPoint);
        public abstract void OnRecv(ArraySegment<byte> buffer);
        public abstract void OnSend(int numOfBytes);
        public abstract void OnDisconnected(EndPoint endPoint);

        public void Start(Socket socket)
        {
            _socket = socket;

            _recvArgs.Completed += new EventHandler<SocketAsyncEventArgs>(OnRecvCompleted);
            _recvArgs.SetBuffer(new byte[1024], 0, 1024);

            _sendArgs.Completed += new EventHandler<SocketAsyncEventArgs>(OnSendCompleted);

            RegisterRecv();
        }

        public void Send(byte[] sendBuff)
        {
            lock (_lock)
            {
                _sendQueue.Enqueue(sendBuff);
                if (_pendingList.Count == 0)
                    RegisterSend();
            }
        }

        public void Disconnect()
        {
            if (Interlocked.Exchange(ref _disconnected, 1) == 1)
                return;

            OnDisconnected(_socket.RemoteEndPoint);
            _socket.Shutdown(SocketShutdown.Both);
            _socket.Close();
        }

        #region 네트워크 통신

        void RegisterSend()
        {
            _pendingList.Clear();
            while (_sendQueue.Count > 0)
            {
                byte[] buff = _sendQueue.Dequeue();
                _pendingList.Add(new ArraySegment<byte>(buff, 0, buff.Length));
            }
            _sendArgs.BufferList = _pendingList;

            bool pending = _socket.SendAsync(_sendArgs);
            if (pending == false)
                OnSendCompleted(null, _sendArgs);
        }

        void OnSendCompleted(object sender, SocketAsyncEventArgs args)
        {
            lock (_lock)
            {
                if (args.BytesTransferred > 0 && args.SocketError == SocketError.Success)
                {
                    try
                    {
                        _sendArgs.BufferList = null;
                        _pendingList.Clear();

                        OnSend(_sendArgs.BytesTransferred);

                        if (_sendQueue.Count > 0)
                            RegisterSend();

                    }
                    catch (Exception e)
                    {
                        Console.WriteLine($"OnSendCompleted Failed {e}");
                    }
                }
                else
                {
                    // TODO DIsconnect
                    Disconnect();
                }
            }
        }

        void RegisterRecv()
        {
            bool pending = _socket.ReceiveAsync(_recvArgs);
            if (pending == false)
                OnRecvCompleted(null, _recvArgs);
        }

        void OnRecvCompleted(object sender, SocketAsyncEventArgs args)
        {

            if (args.BytesTransferred > 0 && args.SocketError == SocketError.Success)
            {
                try
                {
                    OnRecv(new ArraySegment<byte>(args.Buffer, args.Offset, args.BytesTransferred));
                    RegisterRecv();
                }
                catch (Exception e)
                {
                    Console.WriteLine($"OnRecvCompleted Failed {e}");
                }
            }
            else
            {
                Disconnect();
            }
        }

        #endregion
    }
}

🪐분석

• Session1 - Recv

  • SocketAsyncEventArgs는 독립적이여서 여러개를 만들면 각자가 일을 함 - 쓰레드처럼 생각하면 될듯

  • Async계열의 함수를 만들고 AsyncEventArgs를 넣어 준 경우 콜백함수는 별도의 쓰레드를 만든다

  • Session으로 만든 부분은 Receive, Send, Disconnect

• Session2 - Send

  • Send는 그 시점에 RegisterSend를 하게 만들어줌 - SocketAsyncEvent를 새로 만들어 주고 SetBuffer를 한 후 RegitserSend

  • => 재사용 할 수 없음, 부하가 큼(네트워크 송수신 부분이 부하가 큼), 유저모드에서 네트워크 패킷을 보내는 것의 보통 불가능하고 이런것들은 운영체제가 커널단에서 함

  • => SocketAsyncEventArgs를 재사용하고 싶고 데이터를 뭉쳐서 보내고 싶다!! ( SocketAsyncEventArgs )를 밖으로 빼자

  • Queue를 만들어서 차곡차곡 쌓아서 순차적으로 처리 되게 만들기 ( OnSendCompleted가 끝나기 전까지 보내지 않고 Queue에 쌓기)

  • Send는 언제 사용될지 예측 할 수 없기 때문에 미리 맴버변수로 _sendArgs를 만들고 실제 사용될 때 Register안에서 _sendArgs를 사용하는 방식, 보내는 작업이 완료 되지 않을 때 누군가가 보내는 작업을 한다면 일단 Queue에 쌓아두었다가 나중에 처리

• Session3 - BufferList

  • BufferList와 SetBuffer는 동시에 사용 못함

  • ArraySegment : 어떤 Array의 일부를 반환하는 구조체 - 힙이 아니라 스택에 할당됨

  • cs은 cpp와 달리 포인터의 개념이 없기 때문에 주소를 넘기는게 아니라 인덱스를 넘기고 크기를 정함 - ex) new ArraySegment (buff, 0, buff.Length)

• Session4 - 추상클래스를 만들고 이벤트형식으로 콜백하기

  • abstract 클래스는 막바로 사용 못함

  • 콜백형식을 취하기 위해 Session을 상속받은 GameSession을 만들어서 추상클래스 구현

  • _sessionFactory 세션을 어떤 방식으로 누구를 만들어 줄지 정의하는 Func( out 결과값이 있음 ) => 세션을 누구를 만들어줄지 정의하면서 사용해야 됨 ( _listner.Init(endPoint, () => { return new GameSession(); }

  • 컨텐츠단과 엔진단을 구별하기 위한 작업들!

  • -> Session session = _sessionFactory.Invoke(); 사용가능, 어떤 세션을 만들지 모르니까 Session을 뱉는 _sessionFactory를 만든것이 포인트