I am trying to create a program where a server communicates to clients and give them commands about what to do. But when I connect multiple clients it sends the commands to the client multiple random times. My current code:
using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
namespace Server
{
class Program
{
private static byte[] _buffer = new byte[1024];
private static List<Socket> _clientSockets = new List<Socket>();
private static int SERVERPORT = 5555;
private static Socket _serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
private static String command;
static void Main(string[] args)
{
Thread serverThread = new Thread(new ThreadStart(SetupServer));
Thread readThread = new Thread(new ThreadStart(checkInput));
serverThread.Start();
readThread.Start();
}
private static void SetupServer()
{
Console.WriteLine("Setting up server...");
_serverSocket.Bind(new IPEndPoint(IPAddress.Any, SERVERPORT));
_serverSocket.Listen(100);
_serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), null);
}
private static void AcceptCallback(IAsyncResult AR)
{
while (true)
{
if (_serverSocket != null)
{
try
{
Socket socket = _serverSocket.EndAccept(AR);
_clientSockets.Add(socket);
Console.WriteLine("Client conntected");
}
catch
{
}
}
if (command != null)
{
byte[] data = Encoding.ASCII.GetBytes(command);
foreach (Socket s in _clientSockets)
{
s.BeginSend(data, 0, data.Length, SocketFlags.None, new AsyncCallback(SendCallback), s);
}
}
command = null;
_serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), null);
}
}
private static void ReceiveCallback(IAsyncResult AR)
{
Socket socket = (Socket)AR.AsyncState;
//int received = socket.EndReceive(AR);
//byte[] dataBuf = new byte[received];
//Array.Copy(_buffer, dataBuf, received);
//string text = Encoding.ASCII.GetString(dataBuf);
string response = string.Empty;
response = Console.ReadLine();
byte[] data = Encoding.ASCII.GetBytes(response);
socket.BeginSend(data, 0, data.Length, SocketFlags.None, new AsyncCallback(SendCallback), socket);
socket.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), socket);
}
private static void SendCallback(IAsyncResult AR)
{
try {
Socket socket = (Socket)AR.AsyncState;
socket.EndSend(AR);
}
catch {
}
}
public static void checkInput()
{
while (true)
{
command = Console.ReadLine();
}
}
}
}
An example. I start the server and start 3 clients next. This is the output:
I am totally clueless why it sends random times. Also why is there a double 2 on console #2. Thanks in advance!
This caused the problem:
if (command != null)
{
byte[] data = Encoding.ASCII.GetBytes(command);
foreach (Socket s in _clientSockets)
{
s.BeginSend(data, 0, data.Length, SocketFlags.None, new AsyncCallback(SendCallback), s);
}
}
command = null;
I added this piece of code to the readThread thread.
public static void checkInput()
{
while (true)
{
command = Console.ReadLine();
Console.WriteLine("Sending");
byte[] data = Encoding.ASCII.GetBytes(command);
foreach (Socket s in _clientSockets)
{
s.BeginSend(data, 0, data.Length, SocketFlags.None, new AsyncCallback(SendCallback), s);
}
command = null;
}
}
this solved it.
Related
I want to write a programm where multiple clients can join on a server. For now the clients are only able to ask for the servertime, which works perfectly fine, as long as the client and the server are on the same pc. I'm pretty sure that I have to change the EndPoint in the Connect() Method of the client, but I don't know what i should change it to.
Please help me to find a solution for this.
I have this code on my server:
using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;
namespace Multiple_Clients
{
class Program
{
private static int port = 4567;
private static byte[] _buffer = new byte[1024];
private static List<Socket> _clientSockets = new List<Socket>();
private static Socket _serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
static void Main(string[] args)
{
Console.Title = "Server";
setupServer();
Console.ReadLine();
}
private static void setupServer()
{
Console.WriteLine("Setting up server...");
_serverSocket.Bind(new IPEndPoint(IPAddress.Any, port));
_serverSocket.Listen(500);
_serverSocket.BeginAccept(new AsyncCallback(acceptCallback), null);
}
private static void acceptCallback(IAsyncResult AR)
{
Socket socket = _serverSocket.EndAccept(AR);
_clientSockets.Add(socket);
Console.WriteLine("Client connected");
socket.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), socket);
_serverSocket.BeginAccept(new AsyncCallback(acceptCallback), null);
}
private static void receiveCallback(IAsyncResult AR)
{
Socket socket = (Socket)AR.AsyncState;
int received = socket.EndReceive(AR);
byte[] dataBuf = new byte[received];
Array.Copy(_buffer, dataBuf, received);
string text = Encoding.ASCII.GetString(dataBuf);
Console.WriteLine("Text received: " + text);
string response = string.Empty;
if (text.ToLower() != "get time")
{
response = "Invalid Request";
}
else
{
response = DateTime.Now.ToLongTimeString();
}
byte[] data = Encoding.ASCII.GetBytes(response);
socket.BeginSend(data, 0, data.Length, SocketFlags.None, new AsyncCallback(sendCallback), socket);
socket.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), socket);
}
private static void sendCallback(IAsyncResult AR)
{
Socket socket = (Socket)AR.AsyncState;
socket.EndSend(AR);
}
}
}
And this on my client
using System;
using System.Text;
using System.Net;
using System.Net.Sockets;
namespace Multiple_Clients
{
class Program
{
private static int port = 4567;
private static Socket _clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
static void Main(string[] args)
{
Console.Title = "Client";
connect();
sendLoop();
Console.ReadLine();
}
private static void connect()
{
int attempts = 0;
while(!_clientSocket.Connected)
{
try
{
attempts++;
_clientSocket.Connect(IPAddress.Loopback, port);
}
catch(SocketException)
{
Console.Clear();
Console.WriteLine("Connection attempts: " + attempts.ToString());
}
}
Console.Clear();
Console.WriteLine("Connected");
}
private static void sendLoop()
{
while (true)
{
Console.Write("Enter a request:");
string req = Console.ReadLine();
byte[] buffer = Encoding.ASCII.GetBytes(req);
_clientSocket.Send(buffer);
byte[] receivedBuf = new byte[1024];
int rec = _clientSocket.Receive(receivedBuf);
byte[] data = new byte[rec];
Array.Copy(receivedBuf, data, rec);
Console.WriteLine("Received: " + Encoding.ASCII.GetString(data));
}
}
}
}
Any suggestions on how to improve this question are welcome.
Thank you very much for helping me!
Your client allways connect to IPAddress.Loopback ... in fact the local IP Address 127.0.0.1. Exchange IPAddress.Loopback to the real IPAdress of your server, e. g. IPAddress.Parse("192.168.?.?") ...!
I'm connecting to my server on the internal network. But I cannot connect to a server on an external network. The server's firewall on the external network closed. The port forwarding server was.
Server side codes:
private byte[] _buffer = new byte[1024];
private List<Socket> _clientSockets = new List<Socket>();
private Socket _serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
public int PortNo;
private void SetupServer()
{
try
{
_serverSocket.Bind(new IPEndPoint(IPAddress.Any, PortNo));
_serverSocket.Listen(1);
_serverSocket.BeginAccept(new AsyncCallback(AcceptCallBack), null);
}
catch(Exception hata)
{
MessageBox.Show(hata.Message);
}
}
private void AcceptCallBack(IAsyncResult AR)
{
Socket socket = _serverSocket.EndAccept(AR);
_clientSockets.Add(socket);
try
{
socket.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallBack), socket);
_serverSocket.BeginAccept(new AsyncCallback(AcceptCallBack), null);
}
catch(Exception hata)
{
MessageBox.Show(hata.Message);
}
}
private void ReceiveCallBack(IAsyncResult AR)
{
Socket socket = (Socket)AR.AsyncState;
int received = socket.EndReceive(AR);
byte[] dataBuf = new byte[received];
Array.Copy(_buffer, dataBuf, received);
string text = Encoding.ASCII.GetString(dataBuf);
byte[] response = response = ekranGonderme();
try
{
socket.BeginSend(response, 0, response.Length, SocketFlags.None, new AsyncCallback(SendCallBack), null);
socket.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallBack), socket);
}
catch(Exception hata)
{
MessageBox.Show(hata.Message);
}
}
Client Side Codes:
private static Socket _clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
int portNo = 20000;
IPAddress[] server_ip = Dns.GetHostAddresses(server's external ip address);
private void Form1_Load(object sender, EventArgs e)
{
LoopConnect();
LoopSendReceive()
}
private void LoopSendReceive()
{
try
{
byte[] buffer = Encoding.ASCII.GetBytes("ekran_iste");
_clientSocket.Send(buffer);
byte[] receiveBuf = new byte[999999];
int rec = _clientSocket.Receive(receiveBuf);
byte[] data = new byte[rec];
Array.Copy(receiveBuf, data, rec);
MemoryStream ms = new MemoryStream(data);
}
catch
{
}
}
private void LoopConnect()
{
int attempts = 0;
while (!_clientSocket.Connected)
{
try
{
attempts++;
_clientSocket.Connect(server_ip[0], portNo);
}
catch(SocketException)
{
}
}
}
}
I've been working on a chat for 2 people. everything is great (i have some exceptions to solve, but no big deal).
but the problem is, when i send a message from the client to server, then server to client, the server sends the last message it got from the client and only after you send again, it sends the right message and the other way around.
Client
private Socket _socket;
private byte[] _buffer;
private bool ok = false;
private ListBox _listbox;
public ClientSocket(ListBox list)
{
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_listbox = list;
}
public void Connect(string ipAddress, int port)
{
_socket.BeginConnect(new IPEndPoint(IPAddress.Parse(ipAddress), port), ConnectedCallback, null);
if(ok)
Item("Connected to the server!");
else Item("Could not Connect to the server!");
}
public void SendMessage(string text)
{
_buffer = new byte[1024];
_buffer = Encoding.Default.GetBytes(text);
_socket.BeginSend(_buffer, 0, _buffer.Length, SocketFlags.None, SentCallback, null);
}
private void ConnectedCallback(IAsyncResult result)
{
if (_socket.Connected)
{
_socket.EndConnect(result);
_buffer = new byte[1024];
_socket.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, ReceivedCallback, null);
ok = true;
}
}
private void ReceivedCallback(IAsyncResult result)
{
//_buffer = new byte[1024];
int bufLength = _socket.EndReceive(result);
//byte[] packet = new byte[bufLength];
//Array.Copy(_buffer, packet, packet.Length);
Array.Resize(ref _buffer, bufLength);
Item(PacketHandler.Handle(_buffer, _socket));
//PacketHandler.Handle(packet, _socket);
_buffer = new byte[1024];
_socket.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, ReceivedCallback, null);
}
private void SentCallback(IAsyncResult result)
{
_socket.EndSend(result);
//_buffer = new byte[1024];
}
public void Item(string text)
{
if (_listbox.InvokeRequired)
{
_listbox.Invoke(new Action<string>(Item), text);
return;
}
_listbox.Items.Add(text);
}
server
private Socket _socket;
private Socket _client;
private byte[] _buffer = new byte[1024];
private ListBox _listbox;
public ServerSocket(ListBox list)
{
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_listbox = list;
}
public void Bind(int port)
{
_socket.Bind(new IPEndPoint(IPAddress.Any, port));
Item("Server Started");
}
public void Listen(int backlog)
{
_socket.Listen(backlog);
Item("Listening...");
}
public void Accept()
{
_socket.BeginAccept(AcceptedCallback, null);
}
public void SendMessage(string text)
{
_buffer = new byte[1024];
_buffer = Encoding.Default.GetBytes(text);
_client.BeginSend(_buffer, 0, _buffer.Length, SocketFlags.None, SentCallback, null);
}
private void AcceptedCallback(IAsyncResult result)
{
_client = _socket.EndAccept(result);
_buffer = new byte[1024];
_client.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, ReceivedCallback, _client);
//_listbox.Items.Add("Accepted User" + _socket.LocalEndPoint.AddressFamily.ToString() + " ");
//Accept();
}
private void ReceivedCallback(IAsyncResult result)
{
try
{
//_client = result.AsyncState as Socket;
int bufLength = _client.EndReceive(result);
//byte[] packet = new byte[bufferSize];
//Array.Copy(_buffer, packet, packet.Length);
Array.Resize(ref _buffer, bufLength);
Item(PacketHandler.Handle(_buffer, _client));
//Item(PacketHandler.Handle(packet, clientSocket));
//_listbox.Items.Add(PacketHandler.Handle(packet, clientSocket));
_buffer = new byte[1024];
_client.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, ReceivedCallback, _client);
}
catch (SocketException)
{
Item(("User " + _client.LocalEndPoint.ToString() + " has disconnected"));
}
}
private void SentCallback(IAsyncResult result)
{
_client.EndSend(result);
//_buffer = new byte[1024];
}
public void Item(string text)
{
if (_listbox.InvokeRequired)
{
_listbox.Invoke(new Action<string>(Item), text);
return;
}
_listbox.Items.Add(text);
}
cant find a way to fix it, is my code correct?
btw im not a native speaker so bear with my understanding problems :D
_buffer member variable is being used for all send/receive/accept operations. This can cause serious problems, try using separate member buffer variable for each operation.
OK, so I am not very good at programming in general, but I want to try my hand at using sockets. To start I watched a Youtube video which I followed step by step, I got the finished product working 100% to the guides however I wish to modify it in order for the server to be able to send a message to all connected clients.
Here is the youtube video: Youtube Video - Sockets
So this is the code for the server class:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net.Sockets;
using System.Net;
namespace Server
{
class Program
{
private static byte[] buffer = new byte[1024];
public static Socket _serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
public static List<Socket> clientSockets = new List<Socket>();
static void Main(string[] args)
{
Console.Title = "Server, " + clientSockets.Count.ToString() + " clients are connected";
SetupServer();
Console.ReadLine();
}
public static void SetupServer()
{
Console.WriteLine("Setting up server...");
_serverSocket.Bind(new IPEndPoint(IPAddress.Any, 100));
_serverSocket.Listen(5);
_serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), null);
}
public static void AcceptCallback(IAsyncResult AR)
{
Socket socket = _serverSocket.EndAccept(AR);
clientSockets.Add(socket);
Console.WriteLine("Client Connected");
Console.Title = "Server, " + clientSockets.Count.ToString() + " clients are connected";
socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(RecieveCallBack), socket);
_serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), null);
}
private static void RecieveCallBack(IAsyncResult AR)
{
Socket socket = (Socket)AR.AsyncState;
int received = socket.EndReceive(AR);
byte[] databuff = new byte[received];
Array.Copy(buffer, databuff, received);
string s = Encoding.ASCII.GetString(databuff);
Console.WriteLine("Text Received: " + s);
string response = string.Empty;
if (s.ToLower() == "get time")
{
response = DateTime.Now.ToLongTimeString();
}
else
{
response = "Invalid Request";
}
byte[] data = Encoding.ASCII.GetBytes(response);
socket.BeginSend(data, 0, data.Length, SocketFlags.None, new AsyncCallback(sendCallback), socket);
socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(RecieveCallBack), socket);
}
private static void sendCallback(IAsyncResult AR)
{
Socket socket = (Socket)AR.AsyncState;
socket.EndSend(AR);
}
}
}
I had a pretty pathetic attempt at what I wanted to do:
private static void RecieveCallBack(IAsyncResult AR)
{
Socket socket = (Socket)AR.AsyncState;
int received = socket.EndReceive(AR);
byte[] databuff = new byte[received];
Array.Copy(buffer, databuff, received);
string s = Encoding.ASCII.GetString(databuff);
Console.WriteLine("Text Received: " + s);
foreach(Socket s1 in clientSockets){
string response = string.Empty;
if (s.ToLower() == "get time")
{
response = DateTime.Now.ToLongTimeString();
}
else
{
response = "Invalid Request";
}
byte[] data = Encoding.ASCII.GetBytes(response);
s1.BeginSend(data, 0, data.Length, SocketFlags.None, new AsyncCallback(sendCallback), s1);
s1.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(RecieveCallBack), s1);
}
}
wasn't really expecting it too work, but I gave it a go.
Another secondary question:
Is this the line of code which determines what IP and Port the server will be listening on?
_serverSocket.Bind(new IPEndPoint(IPAddress.Any, 100));
Used the same code, had the same problem.
It is not working because the client console is stuck in readLine(), so it is not receiving responses. After you send a command don't call Console.ReadLine again.
To loop trough all clients and send a message:
private static void sentToAll(string s)
{
foreach (Socket socket in clientSockets)
{
byte[] data = Encoding.ASCII.GetBytes(s);
socket.Send(data);
}
}
private static IPEndPoint localEndPoint;
public static String IpAddress = "10.0.0.13";
public static int port = 3000;
localEndPoint = new IPEndPoint(IPAddress.Parse(IpAddress), port);
_serverSocket.Bind(localEndPoint);
Ok so I have a socket connection within my code that is causing a problem. It connects and then disconnects rather quickly. It disconnects after the "connections++;" line. Any ideas?
AS REQUESTED ALL CODE FOR THIS FORM BELOW
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Net;
using System.Net.Sockets;
namespace Middleware
{
public partial class Middleware : Form
{
//variables
private Socket server;
private Socket remoteclient;
private Socket clientreturn;
private Socket serversync;
private byte[] data = new byte[1024];
private byte[] datars = new byte[1024];
private int connections = 0;
public Middleware()
{
InitializeComponent();
Control.CheckForIllegalCrossThreadCalls = false;
}
private void Middleware_Load(object sender, EventArgs e)
{
}
void OnConnectedRemote(IAsyncResult result)
{
try
{
remoteclient.EndConnect(result);
}
catch
{
remoteclient.Close();
}
}
void OnConnected(IAsyncResult result)
{
Socket client = server.EndAccept(result);
connections++;
server.BeginAccept(new AsyncCallback(OnConnected), null);
try
{
txtStatus.Text = "" + connections;
byte[] message = Encoding.ASCII.GetBytes("Welcome to my server");
client.BeginSend(message, 0, message.Length, SocketFlags.None, new AsyncCallback(OnDataSent), client);
}
catch
{
client.Close();
}
}
void OnConnectedSync(IAsyncResult result)
{
Socket sync = serversync.EndAccept(result);
connections++;
//serversync.BeginAccept(new AsyncCallback(OnConnectedSync), null);
try
{
txtStatus.Text = "" + connections;
byte[] message = Encoding.ASCII.GetBytes("Connected to Middleware");
sync.BeginSend(message, 0, message.Length, SocketFlags.None, new AsyncCallback(OnDataSentSync), sync);
}
catch
{
sync.Close();
}
}
void OnDataSent(IAsyncResult result)
{
Socket client = (Socket)result.AsyncState;
try
{
//end send and begin receive from client
int sent = client.EndSend(result);
client.BeginReceive(data, 0, data.Length, SocketFlags.None, new AsyncCallback(OnDataReceived), client);
}
catch (SocketException)
{
//close client
client.Close();
}
}
void OnDataSentSync(IAsyncResult result)
{
Socket sync = (Socket)result.AsyncState;
try
{
//end send and begin receive from client
int sent = sync.EndSend(result);
sync.BeginReceive(data, 0, data.Length, SocketFlags.None, new AsyncCallback(OnDataReceivedSync), sync);
}
catch (SocketException)
{
//close client
sync.Close();
}
}
void OnDataReceivedSync(IAsyncResult result)
{
Socket sync = (Socket)result.AsyncState;
//clientreturn = (Socket)result.AsyncState;
}
void OnDataSentWaiting(IAsyncResult result)
{
Socket sync = (Socket)result.AsyncState;
try
{
//end send and begin receive from client
int sent = sync.EndSend(result);
//sync.BeginReceive(data, 0, data.Length, SocketFlags.None, new AsyncCallback(OnDataReceived), sync);
}
catch (SocketException)
{
//close client
sync.Close();
}
}
void OnDataReceived(IAsyncResult result)
{
Socket client = (Socket)result.AsyncState;
clientreturn = (Socket)result.AsyncState;
try
{
//if nothing is received then close connection
//otherwise get message and add to list box
//create newsocket, bind and listen to create server connection
//begin accept
int receive;
receive = client.EndReceive(result);
//string port = (((IPEndPoint)client.RemoteEndPoint).Port.ToString ());
if (receive == 0)
{
client.Close();
return;
}
else
{
string message = Encoding.ASCII.GetString(data, 0, receive);
lstAll.Items.Add(message);
txtSent.Text = message;
byte[] echomessage = Encoding.ASCII.GetBytes(message);
bool check = remoteclient.Poll(1000, SelectMode.SelectRead);
bool avail = (remoteclient.Available == 0);
if (check & avail)
{
btnConnect.Enabled = true;
btnDisconnect.Enabled = false;
MessageWait(message);
//serversync.BeginSend(echomessage, 0, echomessage.Length, SocketFlags.None, new AsyncCallback(OnDataSentWaiting), serversync);
//client.BeginReceive(data, 0, data.Length, SocketFlags.None, new AsyncCallback(OnDataReceived), client);
}
else
{
client.BeginReceive(data, 0, data.Length, SocketFlags.None, new AsyncCallback(OnDataReceived), client);
remoteclient.BeginSend(echomessage, 0, echomessage.Length, SocketFlags.None, new AsyncCallback(OnRemoteDataSent), remoteclient);
}
}
}
catch (SocketException)
{
//close client
client.Close();
}
}
private void MessageWait(string message)
{
byte[] echomessage = Encoding.ASCII.GetBytes(message);
serversync.BeginSend(echomessage, 0, echomessage.Length, SocketFlags.None, new AsyncCallback(OnDataSentSync), null);
}
void OnRemoteDataSent(IAsyncResult result)
{
try
{
int sent = remoteclient.EndSend(result);
remoteclient.BeginReceive(data, 0, data.Length, SocketFlags.None, new AsyncCallback(OnRemoteDataReceived), null);
}
catch (SocketException)
{
//close server connection
remoteclient.Close();
}
}
void OnRemoteDataReceived(IAsyncResult result)
{
try
{
int receive = remoteclient.EndReceive(result);
string message = Encoding.ASCII.GetString(data, 0, receive);
txtReceived.Text = message + " from Middle";
datars = Encoding.ASCII.GetBytes(txtReceived.Text);
clientreturn.BeginSend(datars, 0, datars.Length, SocketFlags.None, new AsyncCallback(OnDataSentBack), clientreturn);
}
catch (SocketException)
{
//close server
clientreturn.Close();
}
}
void OnDataSentBack(IAsyncResult result)
{
Socket client = (Socket)result.AsyncState;
try
{
int sent = client.EndSend(result);
}
catch (SocketException)
{
//closeserver
client.Close();
}
}
private void btnConnect_Click(object sender, EventArgs e)
{
try
{
btnConnect.Enabled = false;
remoteclient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Parse(txtIP.Text), 2000);
remoteclient.BeginConnect(remoteEndPoint, new AsyncCallback(OnConnectedRemote), null);
}
catch
{
remoteclient.Close();
}
}
private void btnStart_Click(object sender, EventArgs e)
{
int port;
port = int.Parse(txtPort.Text);
btnStart.Enabled = false;
server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint localEP = new IPEndPoint(0, port);
server.Bind(localEP);
server.Listen(4);
server.BeginAccept(new AsyncCallback(OnConnected), null);
txtStatus.Text = "Waiting for client...";
}
private void btnSyncC_Click(object sender, EventArgs e)
{
int port;
port = int.Parse(txtPort.Text);
btnStart.Enabled = false;
serversync = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint localEP2 = new IPEndPoint(0, port);
serversync.Bind(localEP2);
serversync.Listen(1);
serversync.BeginAccept(new AsyncCallback(OnConnectedSync), null);
txtStatus.Text = "Waiting for sync client...";
}
}
}
I bet that there is something wrong with the txtStatus object, and you are actually getting a NullReferenceException which is caught, ignored, and causes the socket to immediately close.