异步套接字C#发送数据但不接收
这是我的密码。我正在成功发送数据,但未接收任何数据。下面是我的代码。我实际上是通过套接字发送23个字节,它执行事件,但它没有接收到数据,服务器正在发回。我希望有持久的双向连接来发送和接收数据异步套接字C#发送数据但不接收,c#,sockets,C#,Sockets,这是我的密码。我正在成功发送数据,但未接收任何数据。下面是我的代码。我实际上是通过套接字发送23个字节,它执行事件,但它没有接收到数据,服务器正在发回。我希望有持久的双向连接来发送和接收数据 using System; using System.Net; using System.Net.Sockets; using System.Threading; using System.Text; using System.Collections.Generic; // State object fo
using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Text;
using System.Collections.Generic;
// 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 AsynchronousClient
{
// The port number for the remote device.
private const int port = 18001;
// 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);
// The response from the remote device.
private static String response = String.Empty;
private static void StartClient()
{
// Connect to a remote device.
try
{
IPEndPoint remoteEP = new IPEndPoint(IPAddress.Parse("192.168.1.140"), port);
// Create a TCP/IP socket.
Socket client = new Socket(AddressFamily.InterNetwork,SocketType.Stream, ProtocolType.Tcp);
// Connect to the remote endpoint.
client.BeginConnect(remoteEP, new AsyncCallback(ConnectCallback), client);
connectDone.WaitOne();
// Send test data to the remote device.
Send(client, "This is a test<EOF>");
sendDone.WaitOne();
// Receive the response from the remote device.
Receive(client);
receiveDone.WaitOne();
// Write the response to the console.
Console.WriteLine("Response received : {0}", response);
// Release the socket.
client.Shutdown(SocketShutdown.Both);
client.Close();
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
private static void ConnectCallback(IAsyncResult ar)
{
try
{
// Retrieve the socket from the state object.
Socket client = (Socket)ar.AsyncState;
// Complete the connection.
client.EndConnect(ar);
Console.WriteLine("Socket connected to {0}",
client.RemoteEndPoint.ToString());
// Signal that the connection has been made.
connectDone.Set();
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
private static void Receive(Socket client)
{
try
{
// Create the state object.
StateObject state = new StateObject();
state.workSocket = client;
// Begin receiving the data from the remote device.
client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
new AsyncCallback(ReceiveCallback), state);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
private static void ReceiveCallback(IAsyncResult ar)
{
try
{
StateObject state = (StateObject)ar.AsyncState;
Socket client = state.workSocket;
// Read data from the remote device.
int bytesRead = client.EndReceive(ar);
if (bytesRead > 0)
{
// There might be more data, so store the data received so far.
state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
// Get the rest of the data.
client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
new AsyncCallback(ReceiveCallback), state);
}
else
{
// All the data has arrived; put it in response.
if (state.sb.Length > 1)
{
response = state.sb.ToString();
}
// Signal that all bytes have been received.
receiveDone.Set();
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
private static void Send(Socket client, String data)
{
// F2 00 DATA FF
List<byte> byteTemp = new List<byte>();
byteTemp.Add(0XF2);
byteTemp.Add(0X00);
byte[] TcpData = Encoding.ASCII.GetBytes("0040005001100180");
foreach (byte eachdata in TcpData)
{
byteTemp.Add(eachdata);
}
byteTemp.Add(0XFF);
byte[] byteData = byteTemp.ToArray();
client.BeginSend(byteData, 0, byteData.Length, 0,
new AsyncCallback(SendCallback), client);
}
private static void SendCallback(IAsyncResult ar)
{
try
{
// Retrieve the socket from the state object.
Socket client = (Socket)ar.AsyncState;
// Complete sending the data to the remote device.
int bytesSent = client.EndSend(ar);
Console.WriteLine("Sent {0} bytes to server.", bytesSent);
// Signal that all bytes have been sent.
sendDone.Set();
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
public static int Main(String[] args)
{
StartClient();
return 0;
}
}
使用系统;
Net系统;
使用System.Net.Sockets;
使用系统线程;
使用系统文本;
使用System.Collections.Generic;
//用于从远程设备接收数据的状态对象。
公共类状态对象
{
//客户端套接字。
公共套接字工作组=null;
//接收缓冲区的大小。
public const int BufferSize=256;
//接收缓冲区。
公共字节[]缓冲区=新字节[BufferSize];
//接收到的数据字符串。
公共StringBuilder sb=新StringBuilder();
}
公共类异步客户端
{
//远程设备的端口号。
专用常量int端口=18001;
//ManualResetEvent实例信号完成。
专用静态手动重置事件已完成=
新手动重置事件(错误);
私有静态手动重置事件sendDone=
新手动重置事件(错误);
私有静态手动重置事件接收完成=
新手动重置事件(错误);
//来自远程设备的响应。
私有静态字符串响应=String.Empty;
私有静态void StartClient()
{
//连接到远程设备。
尝试
{
IPEndPoint remoteEP=新IPEndPoint(IPAddress.Parse(“192.168.1.140”),端口);
//创建TCP/IP套接字。
Socket client=新套接字(AddressFamily.InterNetwork、SocketType.Stream、ProtocolType.Tcp);
//连接到远程端点。
BeginConnect(remoteEP,新的异步回调(ConnectCallback),client);
connectDone.WaitOne();
//将测试数据发送到远程设备。
发送(客户端,“这是一个测试”);
sendDone.WaitOne();
//从远程设备接收响应。
接收(客户);
receiveDone.WaitOne();
//将响应写入控制台。
WriteLine(“收到的响应:{0}”,响应);
//松开插座。
client.Shutdown(SocketShutdown.Both);
client.Close();
}
捕获(例外e)
{
Console.WriteLine(如ToString());
}
}
专用静态无效连接回调(IAsyncResult ar)
{
尝试
{
//从状态对象检索套接字。
套接字客户端=(套接字)ar.AsyncState;
//完成连接。
客户端.EndConnect(ar);
WriteLine(“连接到{0}的套接字”,
client.RemoteEndPoint.ToString());
//表示已建立连接的信号。
connectDone.Set();
}
捕获(例外e)
{
Console.WriteLine(如ToString());
}
}
私有静态void接收(套接字客户端)
{
尝试
{
//创建状态对象。
StateObject状态=新的StateObject();
state.workSocket=客户端;
//开始从远程设备接收数据。
client.BeginReceive(state.buffer,0,StateObject.BufferSize,0,
新建异步回调(ReceiveCallback),状态);
}
捕获(例外e)
{
Console.WriteLine(如ToString());
}
}
私有静态void ReceiveCallback(IAsyncResult ar)
{
尝试
{
StateObject状态=(StateObject)ar.AsyncState;
套接字客户端=state.workSocket;
//从远程设备读取数据。
int bytesRead=client.EndReceive(ar);
如果(字节读取>0)
{
//可能会有更多数据,因此请存储到目前为止收到的数据。
state.sb.Append(Encoding.ASCII.GetString(state.buffer,0,bytesRead));
//获取其余的数据。
client.BeginReceive(state.buffer,0,StateObject.BufferSize,0,
新建异步回调(ReceiveCallback),状态);
}
其他的
{
//所有数据都已到达,请将其作为响应。
如果(说明长度>1)
{
response=state.sb.ToString();
}
//表示已接收到所有字节的信号。
receiveDone.Set();
}
}
捕获(例外e)
{
Console.WriteLine(如ToString());
}
}
私有静态void发送(套接字客户端、字符串数据)
{
//F200数据帧
List byteTemp=新列表();
byteTemp.Add(0XF2);
byteTemp.Add(0X00);
字节[]TcpData=Encoding.ASCII.GetBytes(“0040005001100180”);
foreach(TcpData中的字节eachdata)
{
byteTemp.Add(每个数据);
}
byteTemp.Add(0XFF);
字节[]byteData=byteTemp.ToArray();
client.BeginSend(byteData,0,byteData.Length,0,
新的异步回调(SendCallback),客户端);
}
私有静态void SendCallback(IAsyncResult ar)
{
尝试
{
//从状态对象检索套接字。
套接字客户端=(套接字)ar.AsyncState;
//完成将数据发送到远程设备。
int bytesent=client.EndSend(ar);
WriteLine(“向服务器发送了{0}个字节。”,bytesSent);
//表示已发送所有字节的信号。
sendDone.Set();
}
捕获(例外e)
{
Console.WriteLine(如ToString());
}
}
公共静态int Main(字符串[]args)
{
StartClient();
返回0;
}
}
数据已被接收,但未被用作
private static void ReceiveCallback(IAsyncResult ar)
{
try
{
Console.WriteLine("Receieve Call Back Invoked");
StateObject state = (StateObject)ar.AsyncState;
Socket client = state.workSocket;
// Read data from the remote device.
int bytesRead = client.EndReceive(ar);
Console.WriteLine("Receieve End Receieve");
if (bytesRead > 0)
{
// There might be more data, so store the data received so far.
state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
Console.WriteLine("Read : " + bytesRead.ToString());
// Get the rest of the data.
client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
new AsyncCallback(ReceiveCallback), state);
Console.WriteLine("Begin Receieve completed");
}
else
{
// All the data has arrived; put it in response.
if (state.sb.Length > 1)
{
response = state.sb.ToString();
}
Console.WriteLine("Received data from client");
// Signal that all bytes have been received.
receiveDone.Set();
}
Console.WriteLine("completed receive callback");
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}