.net socket chatting sample (4) SocketClient

Winform

.net socket chatting sample (4) SocketClient

캡틴노랑이 2021. 4. 15. 22:07

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

using SocketClient.AsyncSocket;
using SocketCommon;

namespace SocketClient
{

public partial class Form1 : Form
    {
        private AsyncSocketClient aSocketClient;
        private Dictionary<string, string> UsersList { get; set; }

delegate void dgGetPacket(byte[] buffer);

public Form1()
        {
            InitializeComponent();
            Initialzie();
        }

private void Initialzie()
        {            
            
        }

#region receive delegate

public void DgGetPacket(byte[] buffer)
        {
            if (InvokeRequired)
            {
                dgGetPacket c = new dgGetPacket(DgGetPacket);
                BeginInvoke(c, new object[] { buffer });
            }
            else
            {
                PacketProcess(buffer);
            }
        }

private void PacketProcess(byte[] buffer)
        {            
            PacketData receiveData = (PacketData)PacketData.JsonDeserialize(buffer);

try
            {
                switch (receiveData.packetType)
                {
                    case PacketType.TextData:
                        TextData(receiveData);
                        break;

case PacketType.FileData:
                        break;

case PacketType.SysMessage:
                        SysMessage(receiveData);
                        break;

case PacketType.UsersInfo:
                        UsersInfo(receiveData);
                        break;
                    case PacketType.Disconnect:
                        btnOnOff.Text = "Connect";
                        cmbTarget.DataSource = null;
                        aSocketClient.Dispose();
                        SysMessage(receiveData);
                        break;
                }
            }
            catch(Exception e)
            {
                txtHistory.AppendText(DateTime.Now.ToString("yyy-MM-dd hh:mm:ss") + " [System] " + e.Message + Environment.NewLine);
                txtHistory.ScrollToCaret();
            }

} 
        
        private void TextData(PacketData receiveData)
        {
            txtHistory.AppendText(DateTime.Now.ToString("yyy-MM-dd hh:mm:ss") + " [Sender:" + receiveData.SenderID + "] " + receiveData.stringData + Environment.NewLine);
            txtHistory.ScrollToCaret();
        }

private void SysMessage(PacketData receiveData)
        {
            txtHistory.AppendText(DateTime.Now.ToString("yyy-MM-dd hh:mm:ss") + " [System] " + receiveData.stringData + Environment.NewLine);
            txtHistory.ScrollToCaret();
            
            if (receiveData.stringData.Contains("Socket connected to"))
            {
                PacketData pd = new PacketData();
                pd.packetType = PacketType.UsersInfo;
                pd.SenderID = txtID.Text;
                pd.ReceiverID = "server";
                pd.stringData = "";

aSocketClient.Send(aSocketClient.ClientSock, PacketData.JsonSerialize(pd));
            }
        }

private void UsersInfo(PacketData receiveData)
        {
            UsersList = receiveData.UsersList;
            UsersList = UsersList.InsertAtFirst("Server", "Server", 1);

cmbTarget.DataSource = new BindingSource(UsersList, null);
            cmbTarget.DisplayMember = "Value";
            cmbTarget.ValueMember = "Key";
        }
        #endregion

#region Form Event
        private void btnOnOff_Click(object sender, EventArgs e)
        {
            if (btnOnOff.Text == "Connect")
            {
                btnOnOff.Text = "DisConnect";

aSocketClient = new AsyncSocketClient();
                aSocketClient.ClientGetPacket += DgGetPacket;
                aSocketClient.StartClient(txtServerIP.Text, txtServerPort.Text);
            }
            else
            {
                btnOnOff.Text = "Connect";
                aSocketClient.Disconnect();
                //aSocketClient.Dispose();
            }
        }

private void btnSend_Click(object sender, EventArgs e)
        {
            PacketData pd = new PacketData();
            pd.packetType = PacketType.TextData;
            pd.SenderID = txtID.Text;            
            pd.ReceiverID = cmbTarget.Text.ToString();
            pd.stringData = txtMessage.Text;
            
            aSocketClient.Send(aSocketClient.ClientSock, PacketData.JsonSerialize(pd));
        }

private void btnUserInfo_Click(object sender, EventArgs e)
        {
            PacketData pd = new PacketData();
            pd.packetType = PacketType.UsersInfo;
            pd.SenderID = txtID.Text;
            pd.ReceiverID = "server";
            pd.stringData = "";
                        
            aSocketClient.Send(aSocketClient.ClientSock, PacketData.JsonSerialize(pd));
        }

private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            aSocketClient.Disconnect();
            
        }
        #endregion
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.IO; 
using System.Runtime.Serialization.Formatters.Binary;
using SocketCommon;

namespace SocketClient.AsyncSocket
{
    public class AsyncSocketClient : IDisposable
    {        
        private int port = 11000;
        private IPAddress iPAddress;//= IPAddress.Parse("192.168.18.13");//127.0.0.1
        public static Socket client;
        public Socket ClientSock;

public delegate void SocketConnect(Socket sock);
        public delegate void delegateProcessPacket(byte[] buffer);
                
        private static ManualResetEvent connectDone;// = new ManualResetEvent(false);
        private static ManualResetEvent sendDone;// = new ManualResetEvent(false);
        private static ManualResetEvent receiveDone;// = new ManualResetEvent(false);
        private static ManualResetEvent disconnectDone;// = new ManualResetEvent(false);

public event delegateProcessPacket ClientGetPacket;
                
        private static String response = String.Empty;
        
        public AsyncSocketClient()
        {            
        }

public void StartClient(string serverIP, string serverPort)
        {            
            connectDone = new ManualResetEvent(false);
            sendDone = new ManualResetEvent(false);
            receiveDone = new ManualResetEvent(false);
            disconnectDone = new ManualResetEvent(false);
            
            try
            {
                iPAddress = IPAddress.Parse(serverIP);
                port = int.Parse(serverPort);
                
                IPEndPoint remoteEP = new IPEndPoint(iPAddress, port);

client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                ClientSock = client;

client.BeginConnect(remoteEP, new AsyncCallback(ConnectCallback), client);
                connectDone.WaitOne();

Receive(client);

SendingMessage(string.Format("Response received : {0}", response));

//client.BeginDisconnect(false, new AsyncCallback(DisconnectCallback), client);
            }
            catch (Exception e)
            {
                SendingMessage(e.ToString());
            }
        }

private void ConnectCallback(IAsyncResult ar)
        {
            try
            {
                client = (Socket)ar.AsyncState;
                client.EndConnect(ar);
                
                SendingMessage(string.Format("Socket connected to {0}", client.RemoteEndPoint.ToString()));
                
                connectDone.Set();
            }
            catch (Exception e)
            {
                SendingMessage(e.ToString());
            }
        }

private void Receive(Socket client)
        {
            try
            {                
                StateObject state = new StateObject();
                state.workSocket = client;

client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
            }
            catch (Exception e)
            {
                SendingMessage(e.ToString());
            }
        }

private void ReceiveCallback(IAsyncResult ar)
        {
            try
            {
                StateObject state = (StateObject)ar.AsyncState;
                client = state.workSocket;

if (!client.IsConnected())
                {
                    PacketData pd = new PacketData();
                    pd.packetType = PacketType.Disconnect;
                    pd.SenderID = "";
                    pd.ReceiverID = "";
                    pd.stringData = "Server kicked you.";
                    
                    ClientGetPacket?.Invoke(PacketData.JsonSerialize(pd));
                    return;
                }
                
                int bytesRead = client.EndReceive(ar);

//if (client.Available > 0)
                //{
                    if (bytesRead > 0)
                    {                    
                    PacketData receiveclass = (PacketData)PacketData.JsonDeserialize(state.buffer);

ClientGetPacket?.Invoke(state.buffer);

client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
                    }
                    else
                    {                        
                        if (state.sb.Length > 1)
                        {
                            response = state.sb.ToString();
                        }
  
                        receiveDone.Set();
                    }
                //}
                //else
                //{
                //    SendingMessage("Server disconnected.");
                //}            
            }
            catch (Exception e)
            {
                SendingMessage(e.ToString());
            }
        }

public void Send(Socket handler, Byte[] data)
        {
            try {             
            if(handler.Connected)
                handler.BeginSend(data, 0, data.Length, 0, new AsyncCallback(SendCallback), handler);
            else
                SendingMessage(string.Format("Server disconnected."));
            }
            catch (Exception e)
            {
                SendingMessage(e.ToString());
            }
        }

private void SendCallback(IAsyncResult ar)
        {
            try
            {                
                client = (Socket)ar.AsyncState;             
                int bytesSent = client.EndSend(ar);                                
                SendingMessage(string.Format("Sent {0} bytes to server.", bytesSent));                
                sendDone.Set();
            }
            catch (Exception e)
            {
                SendingMessage(e.ToString());                
            }
        }

public void Disconnect()
        {
            try
            {
                client.Dispose();
                client.Close();

connectDone.Close();
                sendDone.Close();
                receiveDone.Close();

SendingMessage(string.Format("Server disconnected."));
            }
            catch (Exception e)
            {
                SendingMessage(e.ToString());
            }
        }

private void SendingMessage(string message)
        {
            PacketData pd = new PacketData();
            pd.packetType = PacketType.SysMessage;
            pd.stringData = message;

//Byte[] data = PacketData.Serialize(pd);
            Byte[] data = PacketData.JsonSerialize(pd);

ClientGetPacket?.Invoke(data);
        }

public void Dispose()
        {
            client.Dispose();
            connectDone.Dispose();
            sendDone.Dispose();
            receiveDone.Dispose();
        }
    }
}

저작자표시 (새창열림)