Simulator/DroneClient/NetClient.cs

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

namespace DroneSimulator
{
  internal class NetClient
  {
    public class ConnectData
    {
      public bool Connect;

      public Socket? Server;
    }

    public class ReceiveData
    {
      public byte[]? Buffer;
      public int Size;

      public Socket? Server;
    }

    private class ServerData
    {
      public const int size = 1024;
      public byte[] buffer = new byte[size];
    }

    private Socket? ServerSocket = null;
    private ServerData DataServer = new ServerData();

    public delegate void ClientCallback(object o);

    private ClientCallback? ConnectionCallback;
    private ClientCallback? ReceiveCallback;

    public enum ClientState { Error, Connected, Stop };

    public ClientState Connect(string Addr, int Port, ClientCallback Connection, ClientCallback Receive)
    {
      if (ServerSocket != null)
      {
        ServerSocket.Close();
        ServerSocket = null;
        return ClientState.Stop;
      }

      ConnectionCallback = Connection;
      ReceiveCallback = Receive;

      IPEndPoint ep = new IPEndPoint(IPAddress.Parse(Addr), Port);
      ServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

      try
      {
        ServerSocket.Connect(ep);
      }
      catch { ServerSocket.Close(); ServerSocket = null; return ClientState.Error; }

      ConnectionCallback(new ConnectData { Connect = true, Server = ServerSocket });

      ReceiveData receiveData = new ReceiveData { Buffer = DataServer.buffer, Size = ServerData.size, Server = ServerSocket };
      ServerSocket.BeginReceive(DataServer.buffer, 0, ServerData.size, 0, new AsyncCallback(ReadCallback), receiveData);

      return ClientState.Connected;
    }

    public void Close()
    {
      ServerSocket?.Close();
      ServerSocket = null;
    }

    public void ReadCallback(IAsyncResult ar)
    {
      ReceiveData cd = (ReceiveData)ar.AsyncState;
      if (cd == null) return;

      int bytes = 0;
      try { bytes = ServerSocket.EndReceive(ar); }
      catch {  }

      if (bytes == 0)
      {
        ServerSocket?.Close();

        if (ServerSocket != null) ConnectionCallback(new ConnectData { Connect = false, Server = null });

        ServerSocket = null;

        return;
      }

      ReceiveCallback(new ReceiveData { Buffer = cd.Buffer, Size = bytes, Server = ServerSocket });

      ServerSocket?.BeginReceive(cd.Buffer, 0, ServerData.size, 0, new AsyncCallback(ReadCallback), cd);
    }
  }
}