Listener

수업

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

namespace ServerCore
{
    class Listener
    {
        Socket _listenSocket;
        Action<Socket> _onAcceptHandler; // Accept 완료 시 실행할 함수

        public void Init(IPEndPoint endPoint, Action<Socket> onAcceptHandler)
        {
            // 문지기 교육
            _listenSocket = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
            _onAcceptHandler += onAcceptHandler;
            // 영업 시작
            // 최대 대기수
            _listenSocket.Listen(10); // 최대 대기 큐 크기 설정


            SocketAsyncEventArgs args = new SocketAsyncEventArgs();
            args.Completed += new EventHandler<SocketAsyncEventArgs>(OnAcceptCompleted);
            // 최조 한번은 등록을 해줘야함
            RegisterAccept(args);

        }
        void RegisterAccept(SocketAsyncEventArgs args)
        {
            args.AcceptSocket = null; // 이전 Accept 소켓 초기화

            bool pending = _listenSocket.AcceptAsync(args); // 비동기 Accept 실행 // 펜딩을 뱉어줌
            if (pending == false) // 즉시 완료된 경우
                OnAcceptCompleted(null, args);
        }

        void OnAcceptCompleted(object sender, SocketAsyncEventArgs args)
        {
            if (args.SocketError == SocketError.Success)
            {
                // 콜백 방식을 이용해서 인자로 받아서 완료되면 호출
                // 클라이언트 Accept 완료 후 처리
                _onAcceptHandler.Invoke(args.AcceptSocket);
            }
            else
            {
                Console.WriteLine($"Accept Error: {args.SocketError}");
            }
            // 모든 일이 끝남 다음 턴을 위해 준비해둠
            RegisterAccept(args); // 다음 Accept 예약 (낚시줄 다시 던지기)
        }
        public Socket Accept()
        {
            return _listenSocket.Accept();// 비동기 의미 조금 나중에 처리될 수 있다.
            // 어떤식으로든 알려줘야함
            // 비동기는 많은 언어에서 사용함
            // 우선 알아야할 것은 실제로 처리되는 부분이 둘로 쪼개져서 두번 만들어야함

        }

    }
}
using System.Net.Sockets;
using System.Net;
using System.Text;

namespace ServerCore
{
    class Program
    {

        static Listener _listener = new Listener();

        static void OnAcceptHandler(Socket clientSocket)
        {
            try
            {
                // 1️ 클라이언트 데이터 수신
                byte[] recvBuff = new byte[1024];
                int recvBytes = clientSocket.Receive(recvBuff);
                string recvData = Encoding.UTF8.GetString(recvBuff, 0, recvBytes);
                Console.WriteLine($"[From Client] {recvData}");

                // 2️ 클라이언트에 응답 전송
                byte[] sendBuff = Encoding.UTF8.GetBytes("Welcome to MMORPG Server!");
                clientSocket.Send(sendBuff);

                // 3️ 소켓 종료
                clientSocket.Shutdown(SocketShutdown.Both);
                clientSocket.Close();
            }
            catch (Exception e)
            {
                Console.WriteLine($"[Error] {e}");
            }
        }
        // DNS (Domain Name System)
        // IP 주소를 숨겨주는 도메인 네임을 설정해줌
        static void Main(string[] args)
        {
            string host = Dns.GetHostName();
            IPHostEntry ipHost = Dns.GetHostEntry(host);
            IPAddress ipAddr = ipHost.AddressList[0];
            IPEndPoint endPoint = new IPEndPoint(ipAddr, 7777);

            // 2️⃣ Listener 초기화 및 Accept 핸들러 등록
            _listener.Init(endPoint, OnAcceptHandler);
            Console.WriteLine("Server Listening...");

            while (true)
            {
                // 서버가 종료되지 않도록 유지
            }



        }
    }
}
using System.Net;
using System.Net.Sockets;
using System.Text;

namespace DummyClient
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // DNS
            string host = Dns.GetHostName();
            IPHostEntry ipHost = Dns.GetHostEntry(host);
            IPAddress ipAddr = ipHost.AddressList[0];
            IPEndPoint endPoint = new IPEndPoint(ipAddr, 7777);

            while(true)
            {
                // 휴대폰 설정
                Socket socket = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);


                try
                {
                    // 문지기한테 입장 문의
                    socket.Connect(endPoint);

                    Console.WriteLine($"Connected to {socket.RemoteEndPoint.ToString()}");

                    // 보낸다

                    byte[] sendBuff = Encoding.UTF8.GetBytes("Hello Server!");
                    socket.Send(sendBuff);

                    // 받는다
                    byte[] recvBuff = new byte[1024];
                    int recvBytes = socket.Receive(recvBuff);
                    string recvData = Encoding.UTF8.GetString(recvBuff, 0, recvBytes);
                    Console.WriteLine($"[From Server] {recvData}");

                    socket.Shutdown(SocketShutdown.Both);
                    socket.Close();
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.ToString());
                }

                Thread.Sleep(100);
            }
            
            

        }
    }
}

---

✅ 주제

• 본 강의는 C# 기반 TCP 네트워크 서버에서 Listener 클래스를 통해 비동기 소켓 수신 구조를 설계하는 방법을 학습한다.

• 특히 SocketAsyncEventArgs와 AcceptAsync() 메서드를 활용한 비동기 Accept 처리,
  Completed 이벤트, 콜백 구조로 분리된 수신 처리 방식, 반복 등록 기반의 비동기 루프 구조에 대해 철저히 분석한다.

• Listener 클래스와 실제 서버 실행 구조인 Program.cs 간의 연결 방식을 학습한다.

• Action<Socket> 형식의 콜백 등록과, 클라이언트 접속 시 데이터 수신/송신/종료 흐름을 구현하는 OnAcceptHandler(),
  DummyClient를 통한 반복 테스트 환경까지 구성한다.

• 이 흐름을 통해 서버와 클라이언트 간 비동기 소켓 처리의 완전한 연동 구조를 파악한다

---

📚 개념

🔸 Listener란?

• Listener는 서버 측에서 클라이언트의 연결 요청을 수신(Accept)하기 위한 문지기 역할의 소켓이다.
• Listener 소켓은 직접 데이터를 주고받지는 않으며, 오로지 연결 요청을 받고 이를 세션 처리 로직에 넘기는 역할을 한다.

🔸 비동기 Accept 방식이 필요한 이유

• 전통적인 Accept() 함수는 Blocking 함수로, 클라이언트가 접속하지 않으면 무한 대기 상태가 된다.
• 수백~수천 명의 클라이언트가 동시 접속하는 실시간 서버에서는 블로킹 구조로는 서버가 정지되기 쉽다.
• 이를 해결하기 위해 AcceptAsync()와 SocketAsyncEventArgs를 활용한 이벤트 기반 비동기 수신 처리 방식이 필수적이다.

🔸 콜백 방식의 필요성

• Listener는 단순히 클라이언트 접속을 수락(Accept)만 담당하며,
  연결 이후 어떤 작업을 할지는 외부에서 전달된 콜백 함수(Action<Socket>)를 통해 처리된다.
• 이렇게 처리 책임을 분리하면 Listener는 더욱 범용적이고 유연하게 재사용 가능하다.

---

📘 용어 정리

용어	설명
Listener 소켓	클라이언트의 접속 요청을 받기 위해 서버 측에 상시 열려 있는 수신 전용 소켓
Accept	클라이언트와 연결을 수락하고 새로운 통신용 소켓을 반환하는 과정
AcceptAsync()	Accept 작업을 비동기적으로 처리하며, 결과는 이벤트로 통보받음
SocketAsyncEventArgs	AcceptAsync 등 비동기 소켓 함수의 상태를 담는 이벤트 객체
Completed 이벤트	AcceptAsync가 완료되었을 때 호출되는 콜백 함수 등록 위치
RegisterAccept()	다음 클라이언트 연결을 위한 AcceptAsync 등록 함수
Pending	AcceptAsync가 즉시 완료되지 않고 나중에 완료될 예정이라는 상태
Action<Socket>	소켓을 인자로 받는 델리게이트(콜백 함수)
Invoke()	등록된 Action을 실행하는 메서드
OnAcceptHandler()	클라이언트 접속 이후 데이터 처리 및 종료를 수행하는 실제 함수
DummyClient	서버 수신 처리를 테스트하기 위한 자동 접속 클라이언트 프로그램

---

💻 Listener 클래스 코드 구조

public class Listener
{
    Socket _listenSocket;
    Action<Socket> _onAcceptHandler;

    public void Init(IPEndPoint endPoint, Action<Socket> onAcceptHandler)
    {
        _listenSocket = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
        _onAcceptHandler += onAcceptHandler;

        _listenSocket.Bind(endPoint);      // 문지기 교육
        _listenSocket.Listen(10);          // 영업 시작

        SocketAsyncEventArgs args = new SocketAsyncEventArgs();
        args.Completed += new EventHandler<SocketAsyncEventArgs>(OnAcceptCompleted);
        RegisterAccept(args);              // 최초 낚시줄 던지기
    }

🔍 설명

• Init() 함수는 서버 시작 시 호출되며,
  소켓을 생성 → 바인딩 → Listen(대기열 설정) → 비동기 Accept 준비까지 진행한다.
• SocketAsyncEventArgs 객체는 Accept 작업의 상태 저장 및 완료 이벤트 처리 역할을 한다.
• args.Completed += ... 구문은 비동기 Accept가 완료되었을 때 호출될 콜백 함수를 등록하는 과정이다.

---

💻 AcceptAsync 비동기 등록

    void RegisterAccept(SocketAsyncEventArgs args)
    {
        args.AcceptSocket = null; // 이전 클라이언트 소켓 제거

        bool pending = _listenSocket.AcceptAsync(args); // 비동기 수신 요청

        if (pending == false)
        {
            // 바로 완료되었을 경우 직접 콜백 호출
            OnAcceptCompleted(null, args);
        }
    }

🔍 설명

• AcceptAsync()는 호출 즉시 true 또는 false를 반환한다.
  • true: 아직 클라이언트가 없고, 나중에 Completed 이벤트가 호출될 예정
  • false: 이미 클라이언트가 붙어 있어 즉시 완료 → 수동으로 OnAcceptCompleted() 호출 필요
• args.AcceptSocket = null은 이전 Accept 작업의 클라이언트 소켓 정보를 제거하는 필수 처리이다.
  • 제거하지 않으면 "SocketAsyncEventArgs 이미 소켓이 연결되어 있습니다" 오류 발생

---

💻 Accept 완료 콜백 처리

    void OnAcceptCompleted(object sender, SocketAsyncEventArgs args)
    {
        if (args.SocketError == SocketError.Success)
        {
            // 외부에서 전달받은 클라이언트 처리 함수 실행
            _onAcceptHandler.Invoke(args.AcceptSocket);
        }
        else
        {
            Console.WriteLine($"Accept Error: {args.SocketError}");
        }

        // 다음 클라이언트를 위해 다시 낚시줄 등록
        RegisterAccept(args);
    }
}

🔍 설명

• OnAcceptCompleted()는 AcceptAsync가 완료되었을 때 자동 호출되는 콜백 함수다.
• args.SocketError가 성공일 경우, args.AcceptSocket에 클라이언트와 연결된 세션 소켓이 담겨 있다.
• 이 소켓은 _onAcceptHandler.Invoke()를 통해 외부 처리 로직(예: 데이터 수신)으로 전달된다.
• 마지막에는 반드시 다시 RegisterAccept()를 호출하여 다음 클라이언트 접속 대기를 이어간다.

---

🔁 전체 흐름 요약 (비유: 낚시 구조)

[Init()]
   ↓
RegisterAccept(args)   ← 낚시대를 던진다
   ↓
클라이언트 접속
   ↓
AcceptAsync 완료
   ↓
OnAcceptCompleted()    ← 물고기 잡았다
   ↓
_onAcceptHandler()     ← 손님 응대
   ↓
RegisterAccept(args)   ← 다음 손님 기다림

💻 코드 분석 — Program.cs 구조

✅ Main 함수

static void Main(string[] args)
{
    string host = Dns.GetHostName();
    IPHostEntry ipHost = Dns.GetHostEntry(host);
    IPAddress ipAddr = ipHost.AddressList[0];
    IPEndPoint endPoint = new IPEndPoint(ipAddr, 7777);

    _listener.Init(endPoint, OnAcceptHandler);  // Listener 초기화 및 콜백 등록

    Console.WriteLine("Server Listening...");

    while (true)
    {
        ; // 서버가 종료되지 않도록 유지
    }
}

🔍 설명

• 서버 실행 시 Init() 호출을 통해 Listener가 소켓 생성, 바인딩, Listen, AcceptAsync 등록을 수행
• 두 번째 인자로 OnAcceptHandler를 전달 → Accept가 완료되었을 때 실행될 클라이언트 처리 로직을 넘긴 것
• 서버는 무한 루프를 통해 종료되지 않고 실행 상태 유지

---

✅ OnAcceptHandler 함수

static void OnAcceptHandler(Socket clientSocket)
{
    try
    {
        byte[] recvBuff = new byte[1024];
        int recvBytes = clientSocket.Receive(recvBuff);
        string recvData = Encoding.UTF8.GetString(recvBuff, 0, recvBytes);
        Console.WriteLine($"[From Client] {recvData}");

        byte[] sendBuff = Encoding.UTF8.GetBytes("Welcome to MMORPG Server!");
        clientSocket.Send(sendBuff);

        clientSocket.Shutdown(SocketShutdown.Both);
        clientSocket.Close();
    }
    catch (Exception e)
    {
        Console.WriteLine($"[Error] {e}");
    }
}

🔍 설명

• 클라이언트가 접속하고 메시지를 전송하면 Receive()로 수신 처리
• 받은 데이터를 문자열로 출력 후, 서버에서 환영 메시지를 보내고 소켓을 종료
• 이 구조는 향후 Session 클래스로 대체되어 클라이언트와의 지속 통신 구조로 발전할 수 있음

---

💻 코드 분석 — DummyClient 구조

✅ 반복 접속 테스트용 클라이언트

while (true)
{
    Socket socket = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);

    try
    {
        socket.Connect(endPoint);
        Console.WriteLine($"Connected to {socket.RemoteEndPoint}");

        byte[] sendBuff = Encoding.UTF8.GetBytes("Hello Server!");
        socket.Send(sendBuff);

        byte[] recvBuff = new byte[1024];
        int recvBytes = socket.Receive(recvBuff);
        string recvData = Encoding.UTF8.GetString(recvBuff, 0, recvBytes);
        Console.WriteLine($"[From Server] {recvData}");

        socket.Shutdown(SocketShutdown.Both);
        socket.Close();
    }
    catch (Exception e)
    {
        Console.WriteLine(e.ToString());
    }

    Thread.Sleep(100);  // 0.1초마다 반복 접속
}

🔍 설명

• 0.1초마다 서버에 새로 접속하여 메시지를 보내고 응답을 수신한 후 종료
• 서버의 AcceptAsync()가 비동기로 잘 등록되어 있다면 끊김 없이 모든 요청을 처리 가능
• 실전 서버에서는 수백 명의 클라이언트가 동시에 연결 요청을 보내는 환경을 이 구조로 테스트 가능

---

🔁 Listener와 Program 전체 흐름 요약

[Main()]
  ↓
_listener.Init(endpoint, OnAcceptHandler)   ← 콜백 등록
  ↓
RegisterAccept(args)                        ← 낚시대 던짐
  ↓
클라이언트 접속 (DummyClient)
  ↓
AcceptAsync 완료
  ↓
OnAcceptCompleted()
  ↓
_onAcceptHandler.Invoke(socket)
     ↓
    Receive, Send, Close
  ↓
다시 RegisterAccept(args)

---

✅ 핵심 요약

항목	내용
Listener 클래스	클라이언트 접속을 수신하고, 외부 콜백으로 연결 처리 위임
AcceptAsync	비동기 Accept 요청 함수로, 작업 완료 시 이벤트 발생
SocketAsyncEventArgs	AcceptAsync의 상태 보관 + 이벤트 전달 객체
RegisterAccept	클라이언트 수신 대기 등록 (낚시줄 던지기)
OnAcceptCompleted	Accept 완료 시 콜백 함수로 클라이언트 소켓 처리
반복 흐름	RegisterAccept → AcceptAsync → OnAcceptCompleted → 다시 RegisterAccept
콜백 등록 구조	Listener는 클라이언트 연결 이후의 로직을 외부에 위임함
OnAcceptHandler	실제 데이터 송수신 및 연결 종료 처리 담당
DummyClient	반복 접속 테스트로 Listener 구조의 안정성 검증
흐름 반복	AcceptAsync → 완료 → _onAcceptHandler 실행 → RegisterAccept 재등록

---