chapter3.txt

3장: 통신 프로그램을 만들자
3.1 소켓 프로그래밍을 시작하자
[소켓이란?]
TCP 혹은 UDP를 쉽게 다루기 위한 통신 API이다.
IP 주소 및 포트 번호를 한 조로 통신 상대를 지정하고 통신한다.
소켓은 가상으로 존재하는 이더넷 포트이다.
즉 가상 케이블로 통신 상대와 이더넷 포트로 연결된 것과 같은 상태로 만든다.

[TCP 소켓 프로그래밍]
TCP는 서버와 클라이언트로 나뉘어 진다.

< TCP 서버의 대기 >
소켓을 사용하려면 다음과 같은 절차를 가진다.
 1. 소켓 생성
 2. 포트번호 할당
 3. 클라이언트 대기

──────────────────────────────────────────────────
* tcp 서버에 접속 : start listener 
──────────────────────────────────────────────────
void StartListener(int port){
  //소켓을 생성한다.
  //리스닝 소켓 이라고 한다.
  m_listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  
  //사용할 포트번호를 할당한다.
  //Bind 함수를 통하여 엔드포인트를 지정한다.
  // 보통 네트워크 단말을 가리키지만 여기서는 네트워크 주소를 지정한다.
  m_listener.Bind(new IPEndPoint(IPAddress.Any, port));

  //대기를 시작한다.
  //Listen 함수를 호출하여 대기상태로 만든다.
  m_listener.Listen(1);

  m_state = State.AcceptClient;
}
──────────────────────────────────────────────────

위와 같은 과정을 마치면 클라이언트의 접속 요청을 받아들여야 한다.

──────────────────────────────────────────────────
* 클라이언트의 접속 요청을 접수 
──────────────────────────────────────────────────
void AcceptClient(){
  if(m_listener != null && m_listener.Poll(0, SelectMode.SelectRead)){
    //클라이언트 접속했다.
    m_socket = m_listener.Accept();
    m_isConnected = true;
  }
}
──────────────────────────────────────────────────

서버는 Accept 함수를 호출하여 클라이언트의 접속을 요청 받는다.
Accept 함수는 클라이언트가 접속을 요청할 때까지 블로킹 한다.
'블로킹'이란 호출한 함수를 처리할 때까지 처리의 제어가 돌아오지 않는 것을 의미한다.
Accept함수를 호출하면 클라이언트와 접속할때까지 이 함수 안에서 처리를 계속하고 그동안 App은 정지한다.

다만 온라인 게임은 블로킹 되서는 게임이 진행되지 않는다.
따라서 'Poll' 함수로 클라이언트가 보내는 데이터를 감시해서 데이터를 수신했을 때만 Accept를 호출하도록 한다.
클라이언트가 접속을 요청하면 Accept함수가 통신을 위한 Socket클래스의 인스턴스를 반환한다.
이후 생성된 소켓으로 통신을 하게 된다.

<TCP 클라이언트 접속>
클라이언트측에서도 통신을 위한 절차는 비슷하다.
1. 소켓 생성
2. IP주소와 포트번호를 지정하여 접속

통신할 서버의 리스닝 소켓이 대기 상태라면 접속할 수있다.

──────────────────────────────────────────────────
TCP 서버로 접속
──────────────────────────────────────────────────
void ClientProcess(){
  m_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.TCP);
  m_socket.NoDelay = true; //버퍼링 제거
  m_socket.SendBufferSize = 0;
  m_socket.Connect(m_address, m_port);
}
──────────────────────────────────────────────────

생성한 소켓은 버퍼링을 없애기 위해 NoDelay 속성을 true로 설정한다.
SendBufferSize 속성은 0으로 설정하고,
Connect 함수를 사용해서 접속 요청을 하며, IP 주소와 포트번호를 지정하여 연결될 서버를 지정한다.

다만 Connect 함수는 블로킹 함수이기때문에 접속을 완료하기 전까지 다른 처리를 실행할 수 없다.
접속에 실패하면 SocketException이 발생한다.

Socket.Blocking 속성을 false로 지정하여 Connect 함수를 블로킹하지 않을 수 있지만,
접속 완료까지 기다리지 않으므로 상대방의 접속이 완료되었는지 App에서 감시해야 한다.

<데이터 송수신>
서버와 클라이언트가 연결 된 후,
서버는 Accept 함수로 가져온 Socket 클래스의 인스턴스를,
클라이언트는 Connect 함수로 접속한 인스턴스를 사용해서 통신한다.
이후 소켓의 Send / Receive 함수로 데이터를 송수신 한다.

──────────────────────────────────────────────────
TCP 송신
──────────────────────────────────────────────────
void ClientProcess(){
  byte[] buffer = 
      System.Text.Encoding.UTF8.GetByte("Hello, this is client.");
  m_socket.Send(buffer, buffer.Length, SocketFlags.None);
}
──────────────────────────────────────────────────
──────────────────────────────────────────────────
TCP 수신
──────────────────────────────────────────────────
void ServerCommunication(){
  byte[] buffer = new byte[1400];
  int recvSize = m_socket.Receive(buffer, buffer.Length, SocketFlags.None);
  if(recvSize > 0){
    string message = System.Text.Encoding.UTF8.GetString(buffer);
    Debug.Log(message);
    m_state = State.StopListener;
  }
}
──────────────────────────────────────────────────

App이 Receive 함수를 호출할 때 까지 데이터는 시스템의 버퍼에 계속 저장된다.
즉, Receive 함수를 호출하지 않은 채 내버려두면 수신 버퍼의 공간이 없어져 더는 수신할 수가 없다.
App에서 적절히 Receive함수를 호출하여 수신 버퍼를 비워줘야 한다.

<통신 상대와 접속 종료>
통신을 종료할 때는 'Shutdown' 함수로 패킷 송수신을 차단하고 'Close'함수로 접속을 끊는다.
──────────────────────────────────────────────────
TCP 접속 종료
──────────────────────────────────────────────────
void ClientProcess(){
  m_socket.Shutdown(SocketShutdown.Both);
  m_socket.Close();

  Debug.Log("End client communication.");
}
──────────────────────────────────────────────────
Shutdown 함수로 송신만 종료시키고 수신이 종료된 뒤에 Close함수를 호출한다.

서버의 대기 상태를 종료할 때는 Close함수를 호출하여 리스닝 소켓을 닫는다.
──────────────────────────────────────────────────
TCP 대기상태 종료
──────────────────────────────────────────────────
void StopListener(){
  if(m_listener != null){
    m_listener.Close();
    m_listener = null;
  }
  m_state = State.EndCommunication;

  Debug.Log("End server Communication.");
}
──────────────────────────────────────────────────

[UDP 소켓 프로그래밍]
UDP는 접속하지 않고도 통신을 할 수 있다.
서버와 클라이언트의 구별도 없고 서버가 대기할 필요도 없다.
단지 소켓을 생성해서 사용할 포트 번호를 지정하는 것만으로 통신을 할 수 있는 상태가 된다.
──────────────────────────────────────────────────
UDP 송수신
──────────────────────────────────────────────────
void SendMessage(){
  //소켓을 생성
  m_socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);

  //메세지 송신
  byte[] buffer = System.Text.Encoding.UTF8.GetByte("Hello, this is client.");
  IPEndPoint endpoint = new IPEndPoint(IPAddress.Parse(m_address), m_port);
  m_socket.SendTo(buffer, buffer.Length, SocketFlags.None, endpoint);

  //접속 종료
  m_socket.Close();

  m_state = State.EndCommunication;

  Debug.Log("End Clienmt Communication.");
}
──────────────────────────────────────────────────

UDP로 송수신할 때는 SendTo 함수, ReceiveFrom 함수를 사용한다.
접속 절차가 없으므로 IP주소와 포트번호를 지정해서 메세지를 보내기만 하면 된다.
SendTo 함수로 송수신할 때마다 IP 주소와 포트번호를 지정하므로 소켓 하나로 여러곳에 데이터를 보낼 수 있다.
ReceiveFrom 함수를 호출할 때마다 IP주소와 포트번호를 가져와서 보낸 곳을 식별한다.

Close 함수를 호출하여 통신을 종료하고 생성한 소켓을 닫으면 통신이 완료된다.

UDP는 비연결형으로 송수신할 수 있지만 Connect 함수를 사용하여 커넥션을 확립할 수 있다.
이렇게 되면 접속한 소켓하고만 송수신 가능하나 Send, Receive 함수를 사용할 수 있고,
어느 단말에서 온 데이터인지 App에서 식별할 필요가 없다.

3.2 네트워크 바이트 오더
[네트워크 바이트 오더란?]
2바이트 이상의 데이터를 송수신 할때는 바이트 오더에 주의해야 한다.
'바이트 오더'란 2바이트 이상의 데이터를 메모리에 배치하는 방식이다.
 - 빅 엔디언(big endian) : 상위 바이트로부터 차례대로 배치
 - 리틀 엔디언(little endian) : 하위 바이트로부터 차례로 배치

[네트워크 바이트 오더를 고려한 데이터 송수신]
송수신측이 서로 다른 프로세서를 사용하면 데이터의 값이 달라질 수 있다.
따라서 처리할 프로세서에 맞는 바이트 오더로 변환해야한다.
처리할 프로세서의 바이트 오더를 '호스트 바이트 오더' 라고 한다.
C#에서는 IPAddress 클래스에 short, int, long의 바이트 오더를 변환하는 메서드가 존재한다.
 - HostToNetworkOrder : 송신할 때 네트워크 바이트 오더로 변환
 - NetworkToHostOrder : 수신한 데이터를 수신한 단말의 엔디언으로 변환

3.3 간단한 통신 라이브러리를 만들어보자
[왜 라이브러리를 만드는가?]
통신의 기본은 다음과 같다.
 - 접속, 송신, 수신, 접속 종료
송 수신이 일어나는 곳 마다 Socket 클래스의 인스턴스를 참조해야 한다.
게임 프로그램에서는 다른 단말과 통신하는 기능이 필요하지 Socket 클래스의 인스턴스를 다룰 필요는 없다.

매번 접속과 접속 종료를 구현하는 것도 불편하다.
따라서 라이브러리로 만들어 놓고 재활용 하는 것이 유용하ㅓ다.

따라서 Socket 클래스의 인스턴스를 숨기고 통신의 기본적인 처리를 제공하는 라이브러리를 만들자.

[API를 검토하자]
Socket 클래스를 래핑하는 간단한 라이브러리를 제작하자.
기본적인 처리는 다음과 같다.
 - 대기 시작(UDP는 수신 포트 지정만), 대기 종료
 - 접속, 접속 종료
 - 송신, 수신

<대기 시작, 대기 종료>
대기하는 Bind함수, Listen 함수에는 각각 엔드 포인트, 최대 접속수가 필요하다.
엔드 포인트에는 IP주소와 포트 번호가 필요하다.
이번 라이브러리에서는 Bind 함수에서 할당할 IP 주소로 IPAddress.Any를 사용하므로 포트 번호와 접속 가능 클라이언트 수를 지정.
시작할 때 할당한 소켓을 Close하면 종료한다.
기본적인 인터페이스는 다음과 같음.

──────────────────────────────────────────────────
대기 시작, 대기 종료 인터페이스
──────────────────────────────────────────────────
//대기 시작
public bool StartServer(int port, int connectionNum);
//대기 종료
public bool StopServer();
──────────────────────────────────────────────────

<접속, 접속 종료>
Socket 클래스에서 Connect 함수로 접속한다.
Connect 함수는 리모트 단말의 엔드포인트가 필요하다.
게임 플레이어에게서 접속할 리모트 단말의 IP주소를 입력받으므로 IP 주소를 문자열로 입력받도록 하자.
매개변수로는 IP주소와 포트번호가 필요하다.

Shutdown함수, Close함수로 접속을 종료하며 종료 시 각각의 함수를 호출하므로 App에서 접속 종료를 요청하면 된다.

──────────────────────────────────────────────────
접속, 접속 종료 인터페이스
──────────────────────────────────────────────────
// 접속
public bool Connect(string address, int port);
// 접속 종료
public bool Disconnect();
──────────────────────────────────────────────────

<송신, 수신>
Socket 클래스에서 TCP 통신으로 송수신할 때는 Send 함수와 Receive 함수를 사용한다.
UDP 통신의 경우 SentTo 함수와 ReceiveFrom 함수를 사용한다.

──────────────────────────────────────────────────
송신, 수신 인터페이스
──────────────────────────────────────────────────
// 데이터 송신
public int Send(byte[] data, int size);
//데이터 수신, ref 키워드는 값을 참조로 전달 받음을 의미한다.
public int Receive(ref byte[] buffer, int size);
──────────────────────────────────────────────────

[이벤트 처리]
Socket 클래스를 직접 다루어 게임을 만든다면, 통신 중 발생한 오류 이벤트를 게임에서 검출하여 대처해야 한다.
하지만 Socket 클래스를 숨겨 라이브러리로 만들면 게임 프로그램은 Socket을 참조할 수 없다.
따라서 라이브러리가 이벤트를 검출해서 알려줘야 한다.
델리케이트를 사용하여 접속, 접속 종료, 오류 발생 이벤트를 게임 프로그램에 알려준다.

C#의 델리케이트(delegate)는 함수의 시그니처를 정의하는 형이다.
함수값의 형과 인수의 파라미터가 일치하는 함수를 등록, 등록한 함수에 파라미터를 전달하여 호출한다.
C++의 함수 포인터 혹은 콜백 함수의 기능과 동일하다.

Socket 클래스를 참조하여 검출하는 이벤트는 다음과 같다.
 - 접속
 - 접속 종료
 - 송신 오류
 - 수신 오류

위와 같은 이벤트가 발생했을 때 게임 프로그램에 알리는 구조를 만들어 보자.
──────────────────────────────────────────────────
이벤트 정의
──────────────────────────────────────────────────
public enum NetEventType{
  Connet = 0,
  Disconnet,
  SendError,
  ReceiveError,
} 

이벤트의 종류와 결과를 모은 정보를 다음과 같이 정의한다.
──────────────────────────────────────────────────
이벤트 결과
──────────────────────────────────────────────────
public enum NetEventResult{
  Failure = -1,
  Success = 0,
}

──────────────────────────────────────────────────
알림 이벤트의 상태
──────────────────────────────────────────────────
public class NetEventState{
  public NetEventType type;
  public NetEventResult result;
}
──────────────────────────────────────────────────

델리게이트를 정의하여 이 정보를 게임 어플리케이션에 알리자.
──────────────────────────────────────────────────
이벤트 알림 델리게이트 정의
──────────────────────────────────────────────────
public delegate void EventHandler(NetEventState state);
──────────────────────────────────────────────────

위와 같은 정보들을 NetworkDef.cs에 저장하면 준비는 끝이다.
델리게이트를 동록하여 이벤트가 발생할 때 호출하는 구조를 만들어 보자.
RegisterEventHandler 함수와 UnregisterEventHandler 함수로 게임에서 호출할 이벤트 함수를
델리게이트 변수 m_handler에 등록하고 삭제할 수 있다.

델리게이트에 등록한 함수를 호출하여 이벤트를 알리는 방법에 대해서 알아보자.
TCP 통신 서버에 클라이언트가 접속했다면, Accept 함수로부터 처리가 되돌아 오면, 
클라이언트와 통신하는 새로운 Socket 클래스의 인스턴스를 받을 수 있다.
Accept 함수에서 인스턴스를 가져왔다면 클라이언트가 접속했다는 뜻이므로 접속 이벤트를 발생시킨다.
이때, 접속 이벤트를 나타내는 'NetEventType.Connect'를 델리게이트에 건네줌으로써 접속 이벤트를 알릴 수 있음.

──────────────────────────────────────────────────
이벤트 알림 호출
──────────────────────────────────────────────────
void AcceptClient(){
  if(m_listener != null && m_listener.Poll(0, SelectMode.SelectRead)){
    //클라이언트 접속
    m_socket = m_listener.Accept();
    m_isConnected = true;

    //이벤트를 알림.
    if(m_handler != null){
      NetEventState state = new NetEventState();
      state.type = NetEventType.Connect;
      state.result = NetEventResult.Success;
      m_hander(state);
    }
  }
}
──────────────────────────────────────────────────

[스레드를 사용해보자]
게임 App의 일부로 통신을 처리하면 게임의 처리에 부하가 올 수 있다.
따라서 별도의 스레드(thread)로 실행하면 게임 쪽 스레드(메인 스레드)에 영향을 주지 않고 통신 가능하다.
멀티코어를 활용하여 통신과 스레드를 서로 다른 코어에서 실행한다면 부하를 줄일 수 있다.
통신 측도 수신 버퍼의 데이터를 게임 버퍼로 수시로 옮길 수 있으므로 수신 버퍼가 넘치지 않고 수신 가능하다.

메인 스레드와 통신 스레드는 데이터를 주고받는 버퍼를 공유한다.
버퍼에 접근할 때만 주의하면 메인 스레드는 통신 스레드에서 이루어지는 데이터 송수신에 대하여 신경 쓰지 않아도 된다.

버퍼에 접근할 때는 그림과 같이 실행되기 때문에 각각의 스레드에서 배타 제어를 해야 한다.
(Thread & Queue.png 참고)

통신 스레드에서 수신 버퍼로 데이터를 수신한다.
통신 스레드에서는 수신 버퍼에 들어온 데이터를 곧바로 큐로 옮긴다.
메인 스레드에서 데이터를 사용할 때는 큐의 맨 앞 데이터를 사용한다.

이처럼 각 스레드에서 비동기로 큐에 접근하면 타이밍에 따라서는 데이터를 잘못 추가하거나 없는 데이터를 가져올 수 있다.
이런 상황을 피하기 위하여 락(lock)을 사용한다.
락은 베타 제어를 하는 매커니즘으로 해당 스레드가 실행 중일때는 다른 스레드를 실행하지 않고, 종료할 때 까지 기다린다.

다만 락은 많이 사용할 경우 서로 충돌 시 한쪽이 정지된다.

따라서 스레드를 이용할 때는 베타 제어를 정확하게 해야한다.

<패킷 큐>
메인스레드와 통신 스레드에서 공유할 큐를 준비하자.

패킷 크기 안으로 들어도록 설계하고, 패킷 단위로 큐에 넣고 뺄 수 있으면 다루기 쉬워진다.
패킷 단위로 데이터를 등록하고 추출하는 인터페이스를 다음과 같이 정의하자.
──────────────────────────────────────────────────
패킷 큐 인터페이스
──────────────────────────────────────────────────
// 데이터를 추가한다.
public int Enqueue(byte[] data, int size);

//데이터를 추출한다.
public int Dequeue(ref byte[] buffer, int size);
──────────────────────────────────────────────────

송수신할 byte[]형 데이터는 MemoryStream 클래스에서 버퍼링 한다.
(MemoryStream.png 참고)
단 MemoryStream 클래스는 데이터의 끊김이 없으므로 패킷으로는 다룰 수 없다.
따라서 큐에 추가하는 패킷의 패킷 크기와 저장 장소를 나타내는 오프셋을 구조체로 만든 패킷 정보를 별도로 관리해야 한다.
List 클래스로 관리하고, 맨 끝에 패킷 정보를 추가한다.

큐에서 패킷을 추출할 때는 앞에서부터 가져온다.
패킷 정보를 앞에서부터 꺼내고 그 패킷 크기만큼 데이터를 Memory Stream에서 가져온다. 
다음과 같이 구현된다.
──────────────────────────────────────────────────
패킷 큐
──────────────────────────────────────────────────
public class PacketQueue{
  //패킷 저장 정보
  struct PacketInfo{
    public int offset;
    public int size;
  };

  // 데이터를 보존할 버퍼
  private MemoryStream m_streamBuffer;

  //패킷 정보 관리 리스트
  private List<PacketInfo> m_offsetList;

  //메모리 배치 오프셋
  private int m_offset = 0;

  //락 오브젝트
  private Object lockObj = new Objcet();

  //생성자 : 여기서 초기화
  public PacketQueue(){
    m_streamBuffer = new MemoryStream();
    m_offsetList = new List<PacketInfo>();
  }

  //큐를 추가한다.
  public int Enqueue(byte[] data, int size){
    PacketInfo info = new packetInfo();

    //패킷 정보 작성
    info.offset = m_offset;
    info.size = size;

    lock(lockObj){
      //패킷 저장 정보 보존
      m_offsetList.Add(info);

      //패킷 데이터 보존
      m_streamBuffer.Position = m_offset;
      m_streamBuffer.Write(data, 0, size);
      m_streamBuffer.Flush();
      m_offset += size;
    }

    return size;
  }

  //큐를 꺼낸다.
  public int Dequeue(ref byte[] buffer, int size){
    if(m_offsetList.Count <= 0){
      return -1;
    }

    int recvSize = 0;
    lock(lockObj){
      PacketInfo info = m_offsetList[0];

      int dataSize = Math.Min(size, info.size);
      m_streamBuffer.Position = info.offset;
      recvSize = m_streamBuffer.Read(buffer, 0, dataSize);

      if(recvSize>0){
        m_offsetList.RemoveAt(0);
      }

      if(m_offsetList.Count == 0){
        Clear();
        m_offset = 0;
      }
    }

    return recvSize;
  }

  //큐를 정리한다.
  public void Clear(){
    byte[] buffer = m_streamBuffer.GetBuffer();
    Array.Clear(buffer, 0, buffer.Length);

    m_streamBuffer.Position = 0;
    m_streamBuffer.SetLength(0);
  }
}
──────────────────────────────────────────────────

패킷 큐를 송신용과 수신용으로 각각 준비하여 메인 스레드와 통신 스레드에서 데이터를 주고 받는다.

[통신 스레드]
통신 스레드에서 실행할 처리와 스레드를 시작하는 방법을 살펴보자.
메인 스레드로 부터 송신 데이터가 등록되면 Socket 클래스의 Send 함수로 데이터를 송신한다.
Receive 함수를 사용하여 수신 데이터를 Socket 클래스의 수신 버퍼에서 메인 스레드와 주고받는 큐로 옮긴다.
이 과정을 스레드가 종료할 때까지 반복한다.
해당 루프를 연속으로 실행하면 다른 스레드로 처리 제어가 돌아가지 않으므로 일정 간격으로 스레드를 시작한다.

──────────────────────────────────────────────────
통신 스레드 처리
──────────────────────────────────────────────────
// 스레드 측의 송수신 처리
public void Dispatch(){
  while(m_threadLoop){
    //클라이언트의 접속을 기다린다.
    AcceptClient();
    //클라이언트와 송수신한다.
    if(m_socket != null && m_isConnected == true){
      //송신
      DispatchSend();
      //수신
      DispatchReceive();
    }
    Thread.Sleep(5);
  }
}

//스레드측 송신
void DispatchSend(){
  if(m_socket.Poll(0, SelectMode.SelectWrite)){
    byte[] buffer = new byte[s_mtu];
    int sendSize = m_sendQueue.Dequeue(ref buffer, buffer.Length);
    while(sendSize > 0){
      m_socket.Send(buffer, snedSize, SocketFlags.None);
      sendSize = m_sendQueue.Dequeue(ref buffer, buffer.Length);
    }
  }
}

//스레드 측 수신
void DispatchReceive(){
  //수신
  wihle(m_socket.Poll(0, SelectMode.SelectRead)){
    byte[] buffer = new byte[s_mut];
    int recvSize = m_sokcet.Receive(buffer, buffer.Length, SocketFlags.None);
    if(recvSize == 0){
      //접속 종료
      Disconnect();
    }
    else if(recvSize > 0){
      m_recvQueue.Enqueue(buffer, recvSize);
    }
  }
}
──────────────────────────────────────────────────

Socket 클래스를 이용하여 송수신하는 Dispatch 함수를 통신 스레드로 시작한다.

──────────────────────────────────────────────────
통신 스레드 시작
──────────────────────────────────────────────────
bool LaunchTread(){
  try{
    //Dispatch용 스레드 시작
    m_thread = new Thread(new TreadStart(Dispatch));
    m_trhead.Start();
  }
  catch{
    Debug.Log("Cannot launch thread.");
    return false;
  }

  m_isStarted = true;

  return true;
}
──────────────────────────────────────────────────

[실제 라이브러리 작성]
위에서 검토한 사항들을 모아서 간단한 라이브러리를 작성해 보자.

1. 통신 기능을 제공하는 클래스를 만든다.
 - 접근성을 위하여 MonoBehaviour 클래스를 상속
 - TransportTCP, TransportUDP 클래스를 정의, Socket을 멤버 변수로 만들어 숨김.
 - 접속, 접속 종료, 송수신 함수를 정의

 서버로 시작하는 경우 리스닝 소켓을 생성, 
 대기부터 일련의 처리를 모은 StartServer 함수를 작성한다.
 해당 함수는 포트번호를 받아 대기하도록 한다.
 접속이 있다면 등록된 이벤트를 호출, 클라이언트 접속을 알림
 대기를 종료할 때는 StopServer 함수를 호출하여 리스닝 소켓의 통신을 정지하고 닫는다.

 ──────────────────────────────────────────────────
 대기 시작, 대기 종료 
 ──────────────────────────────────────────────────
 public bool StartServer(int port, int connectionNum){
   // 리스닝 소켓을 생성한다.
   m_listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
   m_listener.Bind(new IPEndPoint(IPAddress.Any, port));
   m_listener.Listen(connectionNum);
   m_isServer = true;

   return true;
 }

 public void StopServer(){
   //리스닝 소켓을 닫는다.
   m_listener.Close();
   m_listener = null;
   m_isServer = false;
 }
 ──────────────────────────────────────────────────

 대기중인 서버에 접속하는 Connect 함수는 Socket 클래스의 Connect함수를 호출하는 래퍼 함수이다.
 Connect 함수가 블로킹 되는 상태에서 사용되어 접속 처리가 간단해 졌다.
 통신을 끊을 때는 Disconnect 함수를 호출한다. Disconnect함수로 통신을 차단, 소켓을 닫는다.

 ──────────────────────────────────────────────────
접속, 접속 종료
──────────────────────────────────────────────────
public bool Connect(string address, int port){
  m_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  m_socket.NoDelay = true;
  m_socket.Connect(address, port);
  m_isConnected = true;

  return true;
}

public bool Disconnect(){
  //소켓을 닫는다.
  m_socket.Shutdown(SocketShutdown.Both);
  m_socket.Close();
  m_socket = null;

  m_isConnected = false;

  return true;
}
──────────────────────────────────────────────────

통신용 스레드에서 데이터를 송수신 하기 위해 TransportTCP 클래스의 Send 함수로 패킷 큐에 데이터를 등록,
Receive 함수로 패킷 큐에서 데이터를 추출한다.
──────────────────────────────────────────────────
송수신 함수
──────────────────────────────────────────────────
private PacketQueue m_sendQueue = new PacketQueue(); //송신 버퍼
private PacketQueue m_recvQueue = new PacketQueue(); //수신 버퍼

public int Send(byte[] data, int size){
  return m_sendQueue.Enqueue(data, size);
}
public int Receive(ref byte[] buffer, int size){
  return m_recvQueue.Dequeue(ref buffer, size);
}
──────────────────────────────────────────────────

다음으로 이벤트를 처리하는 기능을 추가한다.
이벤트 발생 시 호출하는 함수의 델리게이트를 클래스의 멤버로 정의
이어서 App에서 델리게이트로 호출할 함수를 등록, 삭제하는 함수를 정의
접속 종료 이벤트가 발생했을 때는 이벤트 알림용 델리게이트를 호출, 이벤트 종류와 알림 정보를 등록한 함수에 전달한다.

──────────────────────────────────────────────────
이벤트 처리 함수(TransportTCP.cs)
──────────────────────────────────────────────────
public class TransportTCP : ITrnasport{
  // 알림 델리게이트
  private EventHandler m_handler;

  // 이벤트 알림 함수 등록
  public void RegisterEventHandler(EventHandler handler){
    m_handler += handler;
  }

  //이벤트 알림 함수 삭제
  public void UnregisterEventHandler(EventHandler handler){
    m_handler -= handler;
  }

  public void Disconnect(){
    m_isConnected = false;

    if(m_socket != null){
      //소켓을 닫는다.
      m_socket.Shutdown(SocketShutdown.Both);
      m_sokcet.Close();
      m_socket = null;
    }
    
    // 접속 종료를 알린다.
    if(m_handler != null){
      // 접속 종료 이벤트를 등록된 함수에 알린다.
      m_handler(this, EventType.Disconnet, EventState.Success);
    }
  }
}
──────────────────────────────────────────────────

이것으로 접속과 접속 종료, 송수신이 가능하고 통신 이벤트 발생 시 콜백 기능을 갖춘 라이브러리가 만들어 진다.

3.4 정리
TransportTCP.cs : TCP 통신을 하는 통신 모듈
TransportUDP.cs : UDP 통신을 하는 통신 모듈
PacketQueue.cs : 스레드 간에 패킷 데이터를 공유하는 버퍼