.net socket chatting sample (3) SocketServer

Winform

.net socket chatting sample (3) SocketServer

캡틴노랑이 2021. 4. 15. 21:59

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;  
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Net;
using System.Net.Sockets;
using SocketServer.AsyncSocket;
using SocketCommon;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using Newtonsoft.Json.Linq;

namespace SocketServer
{

public partial class Form1 : Form
    {
        AsyncSocketServer aSocketServer;
                
        delegate void dgGetPacket(PacketData buffer);
        delegate void dgUsersChange(Dictionary<string, string> lst);

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

private void Initialzie()
        {
            aSocketServer = new AsyncSocketServer();
            // 서버에서 받은 Packet을 Form에서 읽어서 처리 하기 위하여 Delegate를 설정한다.
            aSocketServer.ServerGetPacket += DgGetAction;
            aSocketServer.UsersListChange += DgUsersListChange;

//quick debug
            //aSocketServer.StartServer();
            
        }

#region delegate Action

public void DgGetAction(PacketData receiveData)
        {
            if (InvokeRequired)
            {
                dgGetPacket c = new dgGetPacket(DgGetAction);
                BeginInvoke(c, new object[] { receiveData });
            }
            else
            {
                PacketProcess(receiveData);
            }

}

private void PacketProcess(PacketData receiveData)
        {
            PacketData sender = new PacketData();

switch (receiveData.packetType)
            {
                case PacketType.TextData:

txtHistory.AppendText(DateTime.Now.ToString("yyy-MM-dd hh:mm:ss") + " [" + receiveData.SenderID + " to " + receiveData.ReceiverID + " ] " + receiveData.stringData + Environment.NewLine);
                    txtHistory.ScrollToCaret();

switch (receiveData.ReceiverID)
                    {
                        case "ALL":

sender.SenderID = receiveData.SenderID;
                            //sender.ReceiverID = receiveData.ReceiverID;
                            sender.packetType = PacketType.TextData;
                            sender.stringData = receiveData.stringData;

foreach (var d in aSocketServer.usersList)
                            {
                                if (d.Value != "ALL")
                                {
                                    sender.ReceiverID = d.Value;
                                    aSocketServer.Send(d.Value, PacketData.JsonSerialize(sender));
                                }
                            }
                            break;
                        case "Server":
                            //txtHistory.AppendText(DateTime.Now.ToString("yyy-MM-dd hh:mm:ss") + " [" + receiveData.SenderID + " to "+ receiveData.ReceiverID +" ] " + receiveData.stringData + Environment.NewLine);
                            //txtHistory.ScrollToCaret();
                            break;                        
                        default:                            
                            sender.SenderID = receiveData.SenderID;
                            sender.ReceiverID = receiveData.ReceiverID;
                            sender.packetType = PacketType.TextData;
                            sender.stringData = receiveData.stringData;

//aSocketServer.Send(receiveData.ReceiverID, PacketData.Serialize(sender));
                            aSocketServer.Send(receiveData.ReceiverID, PacketData.JsonSerialize(sender));
                            break;                            
                    }             
                    
                    break;

case PacketType.FileData:
                    break;
                case PacketType.SysMessage:
                    txtHistory.AppendText(DateTime.Now.ToString("yyy-MM-dd hh:mm:ss") + " [System] " + receiveData.stringData + Environment.NewLine);
                    txtHistory.ScrollToCaret();
                    break;
                case PacketType.UsersInfo:
                    PacketData pd = new PacketData();
                    Dictionary<string, string> dic = aSocketServer.usersList;
                    
                    pd.packetType = PacketType.UsersInfo;
                    pd.SenderID = "Server";
                    pd.ReceiverID = receiveData.SenderID;
                    pd.stringData = "";
                    pd.UsersList = aSocketServer.usersList;

txtHistory.AppendText(string.Format("{0} [System] {1} wants to send userlist.{2}", DateTime.Now.ToString("yyy-MM-dd hh:mm:ss"), receiveData.SenderID, Environment.NewLine));
                    txtHistory.ScrollToCaret();
                    
                    //aSocketServer.Send(receiveData.SenderID.ToString(), PacketData.Serialize(pd));
                    aSocketServer.Send(receiveData.SenderID.ToString(), PacketData.JsonSerialize(pd));
                    break;
            }
        }

#endregion

#region delegate User List
        public void DgUsersListChange(Dictionary<string, string> usersList)
        {
            if (InvokeRequired)
            {
                dgUsersChange c = new dgUsersChange(DgUsersListChange);
                BeginInvoke(c, new object[] { usersList });
            }
            else
            {
                UsersListChange(usersList);
            }
        }

private void UsersListChange(Dictionary<string, string> usersList)
        {
            cmbUsers.DataSource = null;
            cmbUsers.DataSource = new BindingSource(usersList, null);
            cmbUsers.DisplayMember = "Value";
            cmbUsers.ValueMember = "Key";
            
        }
        #endregion

#region form event
        private void btnOnOff_Click(object sender, EventArgs e)
        {
            if(btnOnOff.Text == "Start")
            {
                btnOnOff.Text = "Stop";

aSocketServer.StartServer();
            }
            else
            {
                btnOnOff.Text = "Start";
            }
        }

private void btnSend_Click(object sender, EventArgs e)
        {
            PacketData pd = new PacketData();
            pd.packetType = PacketType.TextData;
            pd.SenderID = "Server";
            pd.ReceiverID = cmbUsers.Text;    //콤보박스는 이렇게 가져와야됨. ㅡㅡ;
            pd.stringData = txtMessage.Text;

//aSocketServer.Send(cmbUsers.Text.ToString(), PacketData.Serialize(pd));
            aSocketServer.Send(cmbUsers.Text.ToString(), PacketData.JsonSerialize(pd));
        }

private void btnDisconnect_Click(object sender, EventArgs e)
        {
            aSocketServer.ClientDisconnect(cmbUsers.Text.ToString());
        }
        #endregion

}
}

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

namespace SocketServer.AsyncSocket
{
    public class AsyncSocketServer
    {        
        public static ManualResetEvent allDone = new ManualResetEvent(false);
     
        public static Socket g_listener = null;
        private static readonly int Port = 11000;
        private readonly static IPAddress iPAddress = IPAddress.Parse("192.168.18.13");//127.0.0.1");//127.0.0.1

//Users List
        public Dictionary<string, string> usersList;

// 유저를 관리할 Dictionary 선언
        public Dictionary<string, ClientAccessInfo> server_data = new Dictionary<string, ClientAccessInfo>();

public delegate void delegateProcessPacket(PacketData data);
        public event delegateProcessPacket ServerGetPacket;
        public delegate void delegateChangeUserList(Dictionary<string, string> usersList);
        public event delegateChangeUserList UsersListChange;

public AsyncSocketServer()
        {            
        }

public void StartServer()
        {            
            usersList = new Dictionary<string, string>();
            usersList.Add("ALL", "ALL");
            server_data.Clear();
                        
            Server_Start();
        }

private void Server_Start()
        {
            IPEndPoint localEndPoint = new IPEndPoint(iPAddress, Port);
            
            g_listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            
            try
            {
                SendingMessage("Server Start");
                g_listener.Bind(localEndPoint);
                SendingMessage("Listen....");
                g_listener.Listen(100);

g_listener.BeginAccept(new AsyncCallback(AcceptCallback), g_listener);
            }
            catch (Exception e)
            {
                SendingMessage(e.ToString());
            }            
            
            Console.Read();
        }

public void AcceptCallback(IAsyncResult ar)
        {
            try
            {                
                allDone.Set();
             
                g_listener = (Socket)ar.AsyncState;
                Socket handler = g_listener.EndAccept(ar);
                SendingMessage("Connected : " + handler.LocalEndPoint.ToString());
                g_listener.BeginAccept(new AsyncCallback(AcceptCallback), g_listener);
                               
                StateObject state = new StateObject();
                state.workSocket = handler;

handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state);
            }
            catch (Exception e)
            {
                SendingMessage(e.ToString());
            }            
        }
                
        public void ReadCallback(IAsyncResult ar)
        {
            String content = String.Empty;
            StateObject state;
            Socket handler;
            string remoteAddress;

try
            {                
                state = (StateObject)ar.AsyncState;
                handler = state.workSocket;
                remoteAddress = handler.RemoteEndPoint.ToString();
                               
                if (handler.IsConnected())
                {                    
                    int bytesRead = handler.EndReceive(ar);

if (bytesRead > 0)
                    {   
                        PacketData receiveClass = (PacketData)PacketData.JsonDeserialize(state.buffer);
                                                                    
                        //if (!usersList.Contains(receiveClass.SenderID))
                        if (!usersList.ContainsKey(remoteAddress))
                        {
                            if (server_data.ContainsKey(receiveClass.SenderID) == false)
                                state.userID = receiveClass.SenderID;

server_data.Add(receiveClass.SenderID, new ClientAccessInfo(state.workSocket, receiveClass.SenderID, remoteAddress));

usersList.Add(remoteAddress, receiveClass.SenderID);

UsersListChange?.Invoke(usersList);                            
                        }

ServerGetPacket?.Invoke(receiveClass);

handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state);
                        state.workSocket = handler;
                    }
                    else
                    {
                        handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state);
                    }
                }
                else
                {
                    string clientIpAddress = string.Empty;
                    string clientID = string.Empty;
                    
                    try
                    {
                        foreach (var info in server_data)
                        {
                            if (info.Value.IPAddressnPort == remoteAddress)
                            {
                                clientIpAddress = info.Value.IPAddressnPort;
                                clientID = info.Value.ClientID;
                            }
                        }

usersList.Remove(clientIpAddress);
                        server_data.Remove(clientID);

handler.Close();

UsersListChange?.Invoke(usersList);
                        SendingMessage("Client Disconect");                        
                    }
                    catch(Exception e)
                    {                        
                    }                                                           
                }
            }
            catch(Exception e)
            {
                if (e.ToString().Contains("삭제된 개체에 액세스할 수 없습니다.")) //클라이언트 종료시 2번 호출됨.... 문제가 있나봄.
                    return;
                
                SendingMessage(e.ToString());
            }
            finally
            {

}
        }

public void Send(string userID, Byte[] data)
        {
            try {                
                string userNm = "";
                var test = usersList.Select(x => x.Key == userID);

if (server_data.ContainsKey(userID) == false)                
                {                                
                    SendingMessage(string.Format("No User {0}", userID));
                }
                else
                {                    
                    Socket handler = server_data[userID].ClientSocket;

StateObject state = new StateObject();
                    state.workSocket = handler;
                    state.userID = userID;

handler.BeginSend(data, 0, data.Length, 0, new AsyncCallback(SendCallback), state);
                }
            }
            catch (Exception e)
            {
                SendingMessage(e.ToString());
            }
        }

private void SendCallback(IAsyncResult ar)
        {
            try
            {                
                StateObject state = (StateObject)ar.AsyncState;
                Socket handler = state.workSocket;
                
                int bytesSent = handler.EndSend(ar);                
                SendingMessage(string.Format("{0} Sent {1} bytes to client.", state.userID, bytesSent));

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

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

ServerGetPacket?.Invoke(pd);
        }

public void ClientDisconnect(string userID)
        {           
            Socket handler = server_data[userID].ClientSocket;
            string clientIpAddress = string.Empty;
            try {                
                clientIpAddress = handler.RemoteEndPoint.ToString();

handler.Shutdown(SocketShutdown.Both);
                handler.Close();
                server_data.Remove(userID);
                usersList.Remove(clientIpAddress);
                UsersListChange?.Invoke(usersList);

SendingMessage(string.Format("Server kicked {0}.", userID));
            }
            catch (Exception e)
            {
                SendingMessage(e.ToString());
            }
        }        
    }
}

저작자표시