본문 바로가기
Winform

.net socket chatting sample (4) SocketClient

by 캡틴노랑이 2021. 4. 15.
반응형

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
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
    }
}

 

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
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();
        }
    }
}

 

 

 

 

 

 

 

 

반응형
저작자표시

'Winform' 카테고리의 다른 글

.net socket chatting sample (3) SocketServer  (0) 2021.04.15
.net socket chatting sample (2) SocketCommon  (0) 2021.04.15
.net socket chatting sample (1)  (0) 2021.04.15
기본 combobox  (1) 2020.09.04
Devexpress Grid CustomSummaryCalculate(그리드 특정 조건만 sum)  (0) 2019.05.21

관련글

댓글

티스토리툴바