編集履歴

質問編集履歴

コードがクライアント側でした申し訳ありません

2019/06/26 05:34

投稿

akiya_0608

スコア14

title CHANGED Viewed

File without changes

body CHANGED Viewed

@@ -7,82 +7,89 @@
 サーバー:
 ```C#
 class Program
-{
+{
-    //====================================================
-    //Client
-    //====================================================
     static void Main(string[] args)
     {
+        //Server
+        BaseServer listener = new BaseServer();
-        Console.WriteLine("入力してください");
+        listener.Init("127.0.0.1", 12345);
-        string sendMsg = Console.ReadLine();
+        var task = listener.StartAccept();
-        //ipアドレスとポート番号設定
-        string ipOrHost = "127.0.0.1";
-        int port = 12345;
-        //sendData
-        System.Text.Encoding enc = System.Text.Encoding.UTF8;
-        byte[] body = enc.GetBytes(sendMsg);
-        //通信
-        BaseSocket sock = new BaseSocket();
-        sock.Init(ipOrHost, port);
-        sock.StartRecvThread();                     //非同期通信Recv
         while (true)
         {
-            sock.Send(body, body.Length);
-            sock.Update();
+            listener.BeginUpdate();
-            while (sock.RecvDataSize() > 0)
+            if (listener.clientList.Count > 0)
             {
+                foreach (TcpRecvServer client in listener.clientList)
+                {
+                    while (client.RecvDataListCount() > 0)
+                    {
-                byte[] data = sock.GetRecvData();
+                        byte[] data = client.GetRecvDataList();
+                        if(client.Send(data, data.Length)<0)
+                        {
+                            break;
+                        }
-                string text = System.Text.Encoding.UTF8.GetString(data);
+                        Console.WriteLine("data合計={0}", client.RecvDataListCount());
+                    }
+                }
+            }
-                Console.WriteLine("recvDataSize={0},data={1}", data.Length, text);
+            listener.EndUpdate();
-            }
         }
     }
-}
+}
-class BaseSocket
+class TcpRecvServer
 {
+    public const int BUFSIZE = 2048;
+    object lockObj = new object();
+    public Socket socket { get; }
+    public byte[] ReceiveBuffer;
-    private List<byte> recvTempDataList = new List<byte>();
+    public List<byte> recvTempDataList = new List<byte>();
-    private List<byte[]> recvDataList=new List<byte[]>();
+    public List<byte[]> recvDataList = new List<byte[]>();
-    //ソケット作成
-    private System.Net.Sockets.TcpClient tcp;
-    private System.Net.Sockets.NetworkStream ns;
-    private Object lockObject = new Object();
-    private bool deleteFlg = false;
+    public bool deleteFlg { get; private set; } = false;
+    public bool threadDeleteFlg { get; private set; } = false;
+    public TcpRecvServer(Socket _socket)
+    {
+        socket = _socket;
+        ReceiveBuffer = new byte[BUFSIZE];
+    }
+    public byte[] GetRecvDataList()
+    {
+        byte[] returnData;
+        lock (lockObj)
+        {
+            returnData = recvDataList[0];
+            recvDataList.RemoveAt(0);
+        }
+        return returnData;
+    }
-    public BaseSocket() { }
+    public void AddRecvDateList(byte[] _data)
+    {
+        lock (lockObj)
+        {
+            recvDataList.Add(_data);
+        }
+    }
-    ~BaseSocket() { Close(); }
-    public void Init(string _ipAddr, int _port)
+    public int RecvDataListCount()
     {
-        tcp = new System.Net.Sockets.TcpClient(_ipAddr, _port);
-        //メッセージ
+        int count;
-        Console.WriteLine("サーバー({0}:{1})と接続しました({2}:{3})。", ((System.Net.IPEndPoint)tcp.Client.RemoteEndPoint).Address,
-            ((System.Net.IPEndPoint)tcp.Client.RemoteEndPoint).Port,
-            ((System.Net.IPEndPoint)tcp.Client.LocalEndPoint).Address,
-            ((System.Net.IPEndPoint)tcp.Client.LocalEndPoint).Port);
-        //通信設定
+        lock (lockObj)
+        {
-        ns = tcp.GetStream();
+             count= recvDataList.Count;
-        ns.ReadTimeout = 10000;
+        }
-        ns.WriteTimeout = 10000;
+        return count;
     }
-    public void Send(byte[] _sendData, int _dataSize)
+    public int Send(byte[] _sendData, int _dataSize)
     {
+        int sendSize=-1;
         byte[] sendHeader;
         //header設定
@@ -92,91 +99,206 @@
         sendHeader.CopyTo(sendBytes, 0);
         _sendData.CopyTo(sendBytes, sendHeader.Length);
+        try
+        {
+            if (socket.Connected)
+            {
+                sendSize=socket.Send(sendBytes, sendBytes.Length, 0);
+            }
+            else
+            {
+                Console.WriteLine("sendError");
+            }
+        }
+        catch(System.ObjectDisposedException)
+        {
-        //send
+            //閉じた時
+            /*
+            System.Console.WriteLine("閉じました。");
+            this.OnDeleteFlg();
+            */
+        }
+        catch (SocketException e)
+        {
-        ns.Write(sendBytes, 0, sendBytes.Length);
+            Console.WriteLine("ソケットが切断されています。");
+            Console.WriteLine(e);
+        }
+        return sendSize;
     }
-    public void Update()
+    public void OnDeleteFlg()
     {
-        Routine();
+        lock (lockObj)
+        {
+            deleteFlg = true;
+        }
     }
-    public void Close()
+    public void OnThreadDeleteFlg()
     {
+        lock (lockObj)
+        {
-        deleteFlg = true;
+            deleteFlg = true;
-        ns.Close();
+        }
-        tcp.Close();
     }
+}
+class BaseServer
+{
+    public List<TcpRecvServer> clientList { get;} = new List<TcpRecvServer>();
+    private List<TcpRecvServer> addClientList = new List<TcpRecvServer>();
+    private readonly object lockObj=new Object();
+    Socket listener;
+    public BaseServer() { }
-    private void Routine()
+    public void BeginUpdate()
     {
+        //addClientListのための排他制御
-        lock (lockObject)
+        lock (lockObj)
         {
-            while (recvTempDataList.Count > sizeof(int))
+            if (addClientList.Count > 0)
             {
-                int byteSize = (int)recvTempDataList[0];
-                Console.WriteLine("Routine size={0}\n", byteSize);
-                if (recvTempDataList.Count > byteSize+sizeof(int))
-                {
-                    byte[] addData;
-                    addData = recvTempDataList.GetRange(sizeof(int), byteSize).ToArray();
-                    recvDataList.Add(addData);
+                clientList.AddRange(addClientList);
-                    recvTempDataList.RemoveRange(0, sizeof(int) + byteSize);
+                addClientList = new List<TcpRecvServer>();
-                }
-                else
-                {
-                    return;
-                }
             }
         }
     }
-    public void Recv()
+    public void EndUpdate()
     {
-        while (true)
+        if (clientList.Count <= 0) return;
+        List<TcpRecvServer> deleteList = new List<TcpRecvServer>();
+        foreach (TcpRecvServer client in clientList)
         {
-            if (deleteFlg) { break; }
+            if (client.deleteFlg == true)
-            byte[] resBytes = new byte[1024];
-            int resSize = -1;
-            resSize = ns.Read(resBytes, 0, resBytes.Length);
-            if (resSize == 0)
             {
-                Console.WriteLine("サーバーが切断しました。");
-                deleteFlg = true;
+                deleteList.Add(client);
             }
+        }
+        foreach (TcpRecvServer client in deleteList)
+        {
-            else if (resSize > 0)
+            clientList.Remove(client);
+        }
+    }
+    public void Init(string _ip, int _port)
+    {
+        //ListenするIPアドレス
+        IPAddress ipAdd = IPAddress.Parse(_ip);
+        //TcpListenerオブジェクトを作成する
+        IPEndPoint ipe = new IPEndPoint(ipAdd, _port);
+        listener = new Socket(ipe.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
+        listener.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
+        listener.Bind(ipe);
+        listener.Listen(1000);
+    }
+    public async Task StartAccept()
+    {
+        await Task.Run(() =>
+        {
+            while (true)
             {
-                Array.Resize(ref resBytes, resSize);
+                TcpRecvServer temp =new TcpRecvServer(listener.Accept());
-                lock (lockObject)
+                lock (lockObj)
                 {
-                    recvTempDataList.AddRange(resBytes);
+                    addClientList.Add(temp);
+                    Console.WriteLine("接続あり");
                 }
-                Console.WriteLine("recvSize={0},recvDataListSize={1}\n", resSize, recvTempDataList.Count);
+                StartReceive(temp);
             }
-        }
+        });
     }
+    //===========================================================================
+    //recv関係
+    //===========================================================================
+    //データ受信スタート
-    public int RecvDataSize()
+    private static void StartReceive(TcpRecvServer _server)
     {
+        //非同期受信を開始
+        _server.socket.BeginReceive(_server.ReceiveBuffer,
+                0,
-        return recvDataList.Count;
+                _server.ReceiveBuffer.Length,
+                System.Net.Sockets.SocketFlags.None,
+                new System.AsyncCallback(ReceiveDataCallback),
+                _server);
     }
-    public async void StartRecvThread()
+    //BeginReceiveのコールバック
+    private static void ReceiveDataCallback(System.IAsyncResult ar)
     {
+        //状態オブジェクトの取得
+        TcpRecvServer server = (TcpRecvServer)ar.AsyncState;
+        //読み込んだ長さを取得
-        await Task.Run(() =>
+        int len = 0;
+        try
         {
+            if(server.socket.Connected)len = server.socket.EndReceive(ar);
+        }
+        catch (System.ObjectDisposedException)
+        {
+            //閉じた時
+            System.Console.WriteLine("閉じました。");
+            server.OnDeleteFlg();
+            return;
+        }
+        //切断されたか調べる
+        if (len <= 0)
+        {
+            System.Console.WriteLine("切断されました。");
+            server.socket.Close();
+            server.OnDeleteFlg();
+            return;
+        }
+        //受信したデータを蓄積する
+        Array.Resize(ref server.ReceiveBuffer, len);
+        server.recvTempDataList.AddRange(server.ReceiveBuffer);
+        //受信用配列のサイズを元に戻す
+        Array.Resize(ref server.ReceiveBuffer, TcpRecvServer.BUFSIZE);
+        //データの整形
+        while (server.recvTempDataList.Count>sizeof(int))
+        {
+            int byteSize = (int)server.recvTempDataList[0];
+            if (server.recvTempDataList.Count > byteSize+sizeof(int))
+            {
+                byte[] addData;
+                addData = server.recvTempDataList.GetRange(sizeof(int), byteSize).ToArray();
+                server.AddRecvDateList(addData);
+                server.recvTempDataList.RemoveRange(0, sizeof(int) + byteSize);
+            }
+            else
+            {
+                break;
+            }
+        }
+        //再び受信開始
+        if(server.socket.Connected)server.socket.BeginReceive(server.ReceiveBuffer,
+                0,
+                server.ReceiveBuffer.Length,
+                System.Net.Sockets.SocketFlags.None,
+                new System.AsyncCallback(ReceiveDataCallback),
-            this.Recv();
+                server);
-        });
     }
-    public byte[] GetRecvData()
-    {
-        byte[] returnData;
-        returnData = recvDataList[0];
-        recvDataList.RemoveAt(0);
-        return returnData;
-    }
 }
 ```
 ### 実装環境
 mac