С наступающим Новым годом! Форум программистов, компьютерный форум, киберфорум
Наши страницы
C# .NET
Войти
Регистрация
Восстановить пароль
 
Рейтинг 4.50/10: Рейтинг темы: голосов - 10, средняя оценка - 4.50
MrHacKeR
1 / 1 / 0
Регистрация: 17.01.2012
Сообщений: 58
1

Socket Server/Client. Падение клиента при коннекте к серверу

23.02.2012, 01:12. Просмотров 1817. Ответов 7
Метки нет (Все метки)

В общем есть сервер:
C++
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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Net;
 
namespace Server
{
    class Program
    {
        static List<EndPoint> sockets = new List<EndPoint>();
        static string textToSend = null;
        static void Main()
        {
            
            Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            server.Bind(new IPEndPoint(IPAddress.Any, 5080));
            server.Listen(100);
 
            server.BeginAccept(ConnectCallback, server);
 
            string input;
            Console.WriteLine("Type 'exit' to quit");
            while ((input = Console.ReadLine().ToLower()) != "exit") ;
        }
 
        static void ConnectCallback(IAsyncResult iar)
        {
 
            
            Socket server = (Socket)iar.AsyncState;
            
            try
            {
                
                Socket client = server.EndAccept(iar);
                sockets.Add (client.RemoteEndPoint);
                Console.WriteLine("Новый клиент: {0}", client.RemoteEndPoint);
                AsyncState state = new AsyncState { socket = client, buffer = new byte[client.ReceiveBufferSize] };
                byte[] data = Encoding.UTF8.GetBytes("Здравствуйте");
                client.BeginReceive(state.buffer, 0, state.buffer.Length, SocketFlags.None, ReceiveCallback, state);
                client.BeginSend(data, 0, data.Length, SocketFlags.None, SendCallback, state);
            }
            catch (SocketException e)
            {
                Console.WriteLine("Error accepting connection: {0}", e.Message);
            }
            server.BeginAccept(ConnectCallback, server);
        }
 
        static void ReceiveCallback(IAsyncResult iar)
        {
            AsyncState state = (AsyncState)iar.AsyncState;
            try
            {
                int recv = state.socket.EndReceive(iar);
                if (recv == 0)
                {
                    Console.WriteLine("Client {0} has closed connection", state.socket.RemoteEndPoint);
                    state.socket.Close();
                }
                else
                {
                    string text = Encoding.UTF8.GetString(state.buffer, 0, recv);
                    textToSend = state.socket.RemoteEndPoint.ToString() +"  "+ text;
 
 
                    Console.WriteLine("{0}: {1}", state.socket.RemoteEndPoint, text);
                    byte[] answer = Encoding.UTF8.GetBytes(textToSend);
                    for (int i = 0; i < sockets.ToArray().Length; i++)
                    {
                        System.Threading.Thread.Sleep(100);
                        state.socket.BeginSendTo(answer, 0, answer.Length, SocketFlags.None, sockets[i], SendCallback, state);
                    }
                }
            }
            catch (SocketException e)
            {
                Console.WriteLine("Error receiving from {0}: {1}", state.socket.RemoteEndPoint, e.Message);
                state.socket.Close();
            }
        }
 
        static void SendCallback(IAsyncResult iar)
        {
            AsyncState state = (AsyncState)iar.AsyncState;
            try
            {
                int sent = state.socket.EndSend(iar);
 
               
                state.socket.BeginReceive(state.buffer, 0, state.buffer.Length, SocketFlags.None, ReceiveCallback, state);
                
            }
            catch (SocketException e)
            {
                Console.WriteLine("Error sending to {0}: {1}", state.socket.RemoteEndPoint, e.Message);
                state.socket.Close();
            }
        }
    }
 
    struct AsyncState
    {
        public Socket socket;
        public byte[] buffer;
    }
}

и клиент
C#
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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Net;
 
 
namespace Client
{
    class Program
    {
        static Socket sck;
        static byte[] buffer;
 
        static void Main(string[] args)
        {
            Socket accept = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
 
 
            sck = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            IPEndPoint endpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 5080);
            
 
                sck.BeginConnect(endpoint,ReceiveCallback,sck);
                Console.WriteLine("Connectin Succes");
 
                
            
 
        }
 
       
 
        static void ReceiveCallback(IAsyncResult iar)
        {
            AsyncState state = (AsyncState)iar.AsyncState;
 
            byte[] data = state.buffer;
            state.socket.Receive(data);
 
            try
            {
                int recv = state.socket.EndReceive(iar);
                
                string text = Encoding.UTF8.GetString(state.buffer, 0, recv);
                Console.WriteLine(text);
 
 
                    
                   
            }
            
            catch (SocketException e)
            {
                Console.WriteLine("Error receiving from {0}: {1}", state.socket.RemoteEndPoint, e.Message);
                state.socket.Close();
            }
        }
 
        static void SendCallback(IAsyncResult iar)
        {
            AsyncState state = (AsyncState)iar.AsyncState;
            try
            {
                int sent = state.socket.EndSend(iar);
 
 
                state.socket.BeginReceive(state.buffer, 0, state.buffer.Length, SocketFlags.None, ReceiveCallback, state);
 
            }
            catch (SocketException e)
            {
                Console.WriteLine("Error sending to {0}: {1}", state.socket.RemoteEndPoint, e.Message);
                state.socket.Close();
            }
        }
    }
 
 struct AsyncState
    {
        public Socket socket;
        public byte[] buffer;
    }
}
При конекте клиента к серверу консоль сразу же закрывается (в логе сервера клиент подсоединяется и сразу же закрывается). Что я не так делаю?
0
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
23.02.2012, 01:12
Ответы с готовыми решениями:

Ошибка при сериализации от клиента серверу
Передаём данные между сервером и клиентом, при первой сериализации от клиента к...

Необработанное исключение при подключении клиента к серверу
Добрый вечер, нуждаюсь в вашей помощи. Есть у меня такой вот код: using...

При подключении второго клиента к серверу возникает ошибка "IAsyncResult не был получен"
Всем привет, у меня проблема с асинхронными сокетами. Суть: Пишу простенький...

Помогите подключиться к Socket серверу через Proxy C#
Проблема в следующем. Есть клиент - серверное приложение написанное на ...

Передача архива от клиента к серверу
Клиент скачивает файлы .txt затем их изменяет, но это всё понятно, а ещё нужно...

7
Vitall
756 / 536 / 80
Регистрация: 03.07.2011
Сообщений: 1,020
23.02.2012, 01:30 2

Не по теме:

Ну так чеж ,сервер на плюсах написан ,а клиент на решетке

0
MrHacKeR
1 / 1 / 0
Регистрация: 17.01.2012
Сообщений: 58
23.02.2012, 01:34  [ТС] 3
Цитата Сообщение от Vitall Посмотреть сообщение

Не по теме:

Ну так чеж ,сервер на плюсах написан ,а клиент на решетке

и сервер на решетке....
0
outoftime
║XLR8║
764 / 663 / 212
Регистрация: 25.07.2009
Сообщений: 3,320
Записей в блоге: 5
23.02.2012, 05:33 4
AsyncTcpServer
C#
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
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Text;
using PockerServer.Classes.Events;
using System.IO;
 
namespace PockerServer.Classes
{
    /// <summary>
    /// An Asynchronous TCP Server that makes use of system managed threads
    /// and callbacks to stop the server ever locking up.
    /// </summary>
    public class AsyncTcpServer
    {
        private TcpListener tcpListener;
        private List<Client> clients;
        private const int maximumClientCount = 2;
        public List<ClientSendMessageEventArgs> MessageList { get; set; }
 
        private static object syncRoot = new object();
        private static AsyncTcpServer server;
        public static AsyncTcpServer Instanse
        {
            get
            {
                if (server == null)
                {
                    lock (syncRoot)
                    {
                        if (server == null)
                        {
                            IPAddress addr = new IPAddress(new byte[] { 127, 0, 0, 1 });
                            server = new AsyncTcpServer(addr, 30000);
                        }
                    }
                }
                return server;
            }
        }
 
        /// <summary>
        /// Constructor for a new server using an IPAddress and Port
        /// </summary>
        /// <param name="localaddr">The Local IP Address for the server.</param>
        /// <param name="port">The port for the server.</param>
        public AsyncTcpServer(IPAddress localaddr, int port)
            : this()
        {
            tcpListener = new TcpListener(localaddr, port);
        }
 
        /// <summary>
        /// Constructor for a new server using an end point
        /// </summary>
        /// <param name="localEP">The local end point for the server.</param>
        public AsyncTcpServer(IPEndPoint localEP)
            : this()
        {
            tcpListener = new TcpListener(localEP);
        }
 
        /// <summary>
        /// Private constructor for the common constructor operations.
        /// </summary>
        private AsyncTcpServer()
        {
            this.Encoding = Encoding.Default;
            this.clients = new List<Client>();
            this.MessageList = new List<ClientSendMessageEventArgs>();
        }
 
        /// <summary>
        /// The encoding to use when sending / receiving strings.
        /// </summary>
        public Encoding Encoding { get; set; }
 
        /// <summary>
        /// An enumerable collection of all the currently connected tcp clients
        /// </summary>
        public IEnumerable<TcpClient> TcpClients
        {
            get
            {
                foreach (Client client in this.clients)
                {
                    yield return client.TcpClient;
                }
            }
        }
 
        /// <summary>
        /// Starts the TCP Server listening for new clients.
        /// </summary>
        public void Start()
        {
            this.tcpListener.Start();
            this.tcpListener.BeginAcceptTcpClient(AcceptTcpClientCallback, null);
        }
 
        /// <summary>
        /// Stops the TCP Server listening for new clients and disconnects
        /// any currently connected clients.
        /// </summary>
        public void Stop()
        {
            this.tcpListener.Stop();
            lock (this.clients)
            {
                foreach (Client client in this.clients)
                {
                    client.TcpClient.Client.Disconnect(false);
                }
                this.clients.Clear();
            }
        }
 
        /// <summary>
        /// Writes a string to a given TCP Client
        /// </summary>
        /// <param name="tcpClient">The client to write to</param>
        /// <param name="data">The string to send.</param>
        public void Write(TcpClient tcpClient, string data)
        {
            byte[] bytes = this.Encoding.GetBytes(data);
            Write(tcpClient, bytes);
        }
 
        /// <summary>
        /// Writes a string to all clients connected.
        /// </summary>
        /// <param name="data">The string to send.</param>
        public void Write(string data)
        {
            foreach (Client client in this.clients)
            {
                Write(client.TcpClient, data);
            }
        }
 
        /// <summary>
        /// Writes a byte array to all clients connected.
        /// </summary>
        /// <param name="bytes">The bytes to send.</param>
        public void Write(byte[] bytes)
        {
            foreach (Client client in this.clients)
            {
                Write(client.TcpClient, bytes);
            }
        }
 
        /// <summary>
        /// Writes a byte array to a given TCP Client
        /// </summary>
        /// <param name="tcpClient">The client to write to</param>
        /// <param name="bytes">The bytes to send</param>
        public void Write(TcpClient tcpClient, byte[] bytes)
        {
            NetworkStream networkStream = tcpClient.GetStream();
            networkStream.BeginWrite(bytes, 0, bytes.Length, WriteCallback, tcpClient);
        }
 
        /// <summary>
        /// Callback for the write opertaion.
        /// </summary>
        /// <param name="result">The async result object</param>
        private void WriteCallback(IAsyncResult result)
        {
            TcpClient tcpClient = result.AsyncState as TcpClient;
            if (tcpClient.Connected)
            {
                NetworkStream networkStream = tcpClient.GetStream();
                networkStream.EndWrite(result);
            }
        }
 
        /// <summary>
        /// Callback for the accept tcp client opertaion.
        /// </summary>
        /// <param name="result">The async result object</param>
        private void AcceptTcpClientCallback(IAsyncResult result)
        {
            TcpClient tcpClient = tcpListener.EndAcceptTcpClient(result);
            byte[] buffer = new byte[tcpClient.ReceiveBufferSize];
            Client client = new Client(tcpClient, buffer);
            lock (this.clients)
            {
                if (this.clients.Count > maximumClientCount)
                {
                    this.Write(client.TcpClient, "Server is overloaded.");
                    client.TcpClient.Client.Disconnect(true);
                    return;
                }
                else
                {
                    this.clients.Add(client);
                }
            }
            NetworkStream networkStream = client.NetworkStream;
            networkStream.BeginRead(client.Buffer, 0, client.Buffer.Length, ReadCallback, client);
            tcpListener.BeginAcceptTcpClient(AcceptTcpClientCallback, null);
        }
 
        /// <summary>
        /// Callback for the read opertaion.
        /// </summary>
        /// <param name="result">The async result object</param>
        private void ReadCallback(IAsyncResult result)
        {
            Client client = result.AsyncState as Client;
            if (client == null)
            {
                return;
            }
 
            NetworkStream networkStream = null;
            int read = 0;
            try
            {
                networkStream = client.NetworkStream;
                read = networkStream.EndRead(result);
            }
            catch (IOException exception)
            {
                Console.WriteLine(exception.Message);
                return;
            }
 
            if (read == 0)
            {
                lock (this.clients)
                {
                    this.clients.Remove(client);
                    return;
                }
            }
 
            string data = this.Encoding.GetString(client.Buffer, 0, read);
            MessageManager.Instanse.Recived(new ClientSendMessageEventArgs()
            {
                Message = data,
                TcpClient = client.TcpClient
            });
            networkStream.BeginRead(client.Buffer, 0, client.Buffer.Length, ReadCallback, client);
        }
    }
 
    /// <summary>
    /// Internal class to join the TCP client and buffer together 
    /// for easy management in the server
    /// </summary>
    internal class Client
    {
        /// <summary>
        /// Constructor for a new Client
        /// </summary>
        /// <param name="tcpClient">The TCP client</param>
        /// <param name="buffer">The byte array buffer</param>
        public Client(TcpClient tcpClient, byte[] buffer)
        {
            if (tcpClient == null) throw new ArgumentNullException("tcpClient");
            if (buffer == null) throw new ArgumentNullException("buffer");
            this.TcpClient = tcpClient;
            this.Buffer = buffer;
        }
 
        /// <summary>
        /// Gets the TCP Client
        /// </summary>
        public TcpClient TcpClient { get; private set; }
 
        /// <summary>
        /// Gets the Buffer.
        /// </summary>
        public byte[] Buffer { get; private set; }
 
        /// <summary>
        /// Gets the network stream
        /// </summary>
        public NetworkStream NetworkStream { get { return TcpClient.GetStream(); } }
    }
}

AsyncTcpClient
C#
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
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
 
namespace Poker.Classes
{
    public class AsyncTcpClient
    {
        private IPAddress[] addresses;
        private int port;
        private WaitHandle addressesSet;
        private TcpClient tcpClient;
        private int failedConnectionCount;
 
        private static object syncRoot = new object();
        private static AsyncTcpClient server;
        public static AsyncTcpClient Instanse
        {
            get
            {
                if (server == null)
                {
                    lock (syncRoot)
                    {
                        if (server == null)
                        {
                            server = new AsyncTcpClient("127.0.0.1", 30000);
                            server.Connect();
                        }
                    }
                }
                return server;
            }
        }
 
        /// <summary>
        /// Construct a new client from a known IP Address
        /// </summary>
        /// <param name="address">The IP Address of the server</param>
        /// <param name="port">The port of the server</param>
        public AsyncTcpClient(IPAddress address, int port)
            : this(new[] { address }, port)
        {
        }
 
        /// <summary>
        /// Construct a new client where multiple IP Addresses for
        /// the same client are known.
        /// </summary>
        /// <param name="addresses">The array of known IP Addresses</param>
        /// <param name="port">The port of the server</param>
        public AsyncTcpClient(IPAddress[] addresses, int port)
            : this(port)
        {
            this.addresses = addresses;
        }
 
        /// <summary>
        /// Construct a new client where the address or host name of
        /// the server is known.
        /// </summary>
        /// <param name="hostNameOrAddress">The host name or address of the server</param>
        /// <param name="port">The port of the server</param>
        public AsyncTcpClient(string hostNameOrAddress, int port)
            : this(port)
        {
            addressesSet = new AutoResetEvent(false);
            Dns.BeginGetHostAddresses(hostNameOrAddress, GetHostAddressesCallback, null);
        }
 
        /// <summary>
        /// Private constuctor called by other constuctors
        /// for common operations.
        /// </summary>
        /// <param name="port"></param>
        private AsyncTcpClient(int port)
        {
            if (port < 0)
                throw new ArgumentException();
            this.port = port;
            this.tcpClient = new TcpClient();
            this.Encoding = Encoding.Default;
        }
 
        /// <summary>
        /// The endoding used to encode/decode string when sending and receiving.
        /// </summary>
        public Encoding Encoding { get; set; }
 
        /// <summary>
        /// Attempts to connect to one of the specified IP Addresses
        /// </summary>
        public void Connect()
        {
            if (addressesSet != null)
                //Wait for the addresses value to be set
                addressesSet.WaitOne();
            //Set the failed connection count to 0
            Interlocked.Exchange(ref failedConnectionCount, 0);
            //Start the async connect operation
            tcpClient.BeginConnect(addresses, port, ConnectCallback, null);
        }
 
        /// <summary>
        /// Writes a string to the network using the defualt encoding.
        /// </summary>
        /// <param name="data">The string to write</param>
        /// <returns>A WaitHandle that can be used to detect
        /// when the write operation has completed.</returns>
        public void Write(string data)
        {
            byte[] bytes = Encoding.GetBytes(data);
            Write(bytes);
        }
 
        /// <summary>
        /// Writes an array of bytes to the network.
        /// </summary>
        /// <param name="bytes">The array to write</param>
        /// <returns>A WaitHandle that can be used to detect
        /// when the write operation has completed.</returns>
        public void Write(byte[] bytes)
        {
            NetworkStream networkStream = tcpClient.GetStream();
            //Start async write operation
            networkStream.BeginWrite(bytes, 0, bytes.Length, WriteCallback, null);
        }
 
        /// <summary>
        /// Callback for Write operation
        /// </summary>
        /// <param name="result">The AsyncResult object</param>
        private void WriteCallback(IAsyncResult result)
        {
            NetworkStream networkStream = tcpClient.GetStream();
            networkStream.EndWrite(result);
        }
 
        /// <summary>
        /// Callback for Connect operation
        /// </summary>
        /// <param name="result">The AsyncResult object</param>
        private void ConnectCallback(IAsyncResult result)
        {
            try
            {
                tcpClient.EndConnect(result);
            }
            catch
            {
                //Increment the failed connection count in a thread safe way
                Interlocked.Increment(ref failedConnectionCount);
                if (failedConnectionCount >= addresses.Length)
                {
                    //We have failed to connect to all the IP Addresses
                    //connection has failed overall.
                    return;
                }
            }
 
            //We are connected successfully.
            NetworkStream networkStream = tcpClient.GetStream();
            byte[] buffer = new byte[tcpClient.ReceiveBufferSize];
            //Now we are connected start asyn read operation.
            networkStream.BeginRead(buffer, 0, buffer.Length, ReadCallback, buffer);
        }
 
        /// <summary>
        /// Callback for Read operation
        /// </summary>
        /// <param name="result">The AsyncResult object</param>
        private void ReadCallback(IAsyncResult result)
        {
            int read;
            NetworkStream networkStream;
            try
            {
                networkStream = tcpClient.GetStream();
                read = networkStream.EndRead(result);
            }
            catch
            {
                //An error has occured when reading
                return;
            }
 
            if (read == 0)
            {
                //The connection has been closed.
                return;
            }
 
            byte[] buffer = result.AsyncState as byte[];
            string data = this.Encoding.GetString(buffer, 0, read);
            MessageManager.Instanse.Recived(data);
            networkStream.BeginRead(buffer, 0, buffer.Length, ReadCallback, buffer);
        }
 
        /// <summary>
        /// Callback for Get Host Addresses operation
        /// </summary>
        /// <param name="result">The AsyncResult object</param>
        private void GetHostAddressesCallback(IAsyncResult result)
        {
            addresses = Dns.EndGetHostAddresses(result);
            //Signal the addresses are now set
            ((AutoResetEvent)addressesSet).Set();
        }
    }
}

Это мои клиент и сервер, надеюсь понятно что к чему...
1
MrHacKeR
1 / 1 / 0
Регистрация: 17.01.2012
Сообщений: 58
25.02.2012, 23:35  [ТС] 5
Кто может навести пример на моём коде?Очень прошу;(

Добавлено через 23 часа 15 минут
переписал клиент, но не помогло;( В чём тут ошибка? Клиент подсоединятся - отправляет сообщение и разрывает соединение. Помогите пожалуйста;(
C#
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
using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Text;
 
// State object for receiving data from remote device.
public class StateObject
{
    // Client socket.
    public Socket workSocket = null;
    // Size of receive buffer.
    public const int BufferSize = 256;
    // Receive buffer.
    public byte[] buffer = new byte[BufferSize];
    // Received data string.
    public StringBuilder sb = new StringBuilder();
}
 
public class Client
{
    // The port number for the remote device.
    private const int port = 5080;
 
    // ManualResetEvent instances signal completion.
    private static ManualResetEvent connectDone =
        new ManualResetEvent(false);
    private static ManualResetEvent sendDone =
        new ManualResetEvent(false);
    private static ManualResetEvent receiveDone =
        new ManualResetEvent(false);
 
    static byte[] data;
    static Socket sck;
 
 
 
    public static void Main()
    {
        sck = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        IPEndPoint end = new IPEndPoint(IPAddress.Parse("127.0.0.1"),5080);
 
        sck.BeginConnect(end, ConnectCallBack, sck);
 
    }
 
    static void ConnectCallBack(IAsyncResult iar){
        
        Socket client = (Socket)iar.AsyncState;
        AsyncState state = new AsyncState { socket = client, buffer = new byte[client.ReceiveBufferSize] };
 
        String textdata = "привет";
        byte[] data = Encoding.UTF8.GetBytes(textdata) ;
        try
        {
            client.EndConnect(iar);
            state.socket.BeginSend(data, 0, data.Length, SocketFlags.None, SendCallback, state);
            connectDone.Set();
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
        }
    }
 
   static void SendCallback(IAsyncResult iar)
        {
            AsyncState state = (AsyncState)iar.AsyncState;
            try
            {
                int sent = state.socket.EndSend(iar);
 
               
                state.socket.BeginReceive(state.buffer, 0, state.buffer.Length, SocketFlags.None, ReceiveCallback, state);
                
            }
            catch (SocketException e)
            {
                Console.WriteLine("Error sending to {0}: {1}", state.socket.RemoteEndPoint, e.Message);
                state.socket.Close();
            }
        }
    
 
    static void ReceiveCallback(IAsyncResult iar)
    {
        AsyncState state = (AsyncState)iar.AsyncState;
        try
        {
            int recv = state.socket.EndReceive(iar);
            if (recv == 0)
            {
                Console.WriteLine("Client {0} has closed connection", state.socket.RemoteEndPoint);
                state.socket.Close();
            }
            else
            {
                string text = Encoding.UTF8.GetString(state.buffer, 0, recv);
                
 
 
                Console.WriteLine("{0}: {1}", state.socket.RemoteEndPoint, text);
                byte[] answer = Encoding.UTF8.GetBytes(text);
               
                state.socket.BeginSend(answer, 0, answer.Length, SocketFlags.None, SendCallback, state);
                
            }
        }
        catch (SocketException e)
        {
            Console.WriteLine("Error receiving from {0}: {1}", state.socket.RemoteEndPoint, e.Message);
            state.socket.Close();
        }
    }
 
    struct AsyncState
    {
        public Socket socket;
        public byte[] buffer;
    }
}
0
outoftime
║XLR8║
764 / 663 / 212
Регистрация: 25.07.2009
Сообщений: 3,320
Записей в блоге: 5
26.02.2012, 01:02 6
Логика у тебя корявая, зачем тебе на ReceiveCallback делать SendCallback и в SendCallback вызывать ReceiveCallback? ReceiveCallback должен быть зациклен, а SendCallback вызываться по нужде.
0
MrHacKeR
1 / 1 / 0
Регистрация: 17.01.2012
Сообщений: 58
26.02.2012, 02:36  [ТС] 7
Цитата Сообщение от outoftime Посмотреть сообщение
Логика у тебя корявая, зачем тебе на ReceiveCallback делать SendCallback и в SendCallback вызывать ReceiveCallback? ReceiveCallback должен быть зациклен, а SendCallback вызываться по нужде.
Как мне зациклить ReceiveCallback?
0
outoftime
║XLR8║
764 / 663 / 212
Регистрация: 25.07.2009
Сообщений: 3,320
Записей в блоге: 5
26.02.2012, 09:16 8
http://www.cyberforum.ru/post2518270.html
1
26.02.2012, 09:16
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
26.02.2012, 09:16

Реализация клиента для подключения к серверу на WebSocket
Добрый день. Есть сервер разработанный на c++. Сервер использует подлинный...

Client-server chat
Здравствуйте, можете сказать что в чате не так, не считая структуры. ...

TCP server client
Здравствуйте, первый раз делаю подобное, много примеров о том как передать...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
8
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2018, vBulletin Solutions, Inc.
Рейтинг@Mail.ru