服务端操作
//1、创建IPE
int port = 6000;
string host = "127.0.0.1";
IPAddress ip = IPAddress.Parse(host);
IPEndPoint ipe = new IPEndPoint(ip, port);
//2、创建socket
Socket sSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//3、绑定端口与ip
//如果要指定本地 IP 地址和端口号，请在调用 Listen 方法之前调用 Bind 方法
sSocket.Bind(ipe);
//4、监听，如果希望基础服务提供商为你分配一个可用端口，请使用端口号零
//如果使用面向连接的协议（例如 TCP），则服务器可以使用 Listen 方法侦听连接
sSocket.Listen(0);
Console.WriteLine("监听已经打开，请等待");
//5、获取通信socket
//receive message， Accept 方法处理任何传入连接请求，并返回可用于与远程主机通信的 Socket
Socket serverSocket = sSocket.Accept();
Console.WriteLine("连接已经建立");
string recStr = "";
byte[] recByte = new byte[4096];
//6、接收数据。若要传递数据，请调用 Send 或 Receive 方法
int bytes = serverSocket.Receive(recByte, recByte.Length, 0);
recStr += Encoding.ASCII.GetString(recByte, 0, bytes);
//send message
Console.WriteLine("服务器端获得信息:{0}", recStr);
string sendStr = "send to client :hello";
byte[] sendByte = Encoding.ASCII.GetBytes(sendStr);
//7、发送数据
serverSocket.Send(sendByte, sendByte.Length, 0);
serverSocket.Close();
sSocket.Close();
client
//1、创建ipe
int port = 6000;
string host = "127.0.0.1";//服务器端ip地址
IPAddress ip = IPAddress.Parse(host);
IPEndPoint ipe = new IPEndPoint(ip, port);
//2、创建socket
Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//3、connect
clientSocket.Connect(ipe);
//4、send message
string sendStr = "send to server : hello,ni hao";
byte[] sendBytes = Encoding.ASCII.GetBytes(sendStr);
clientSocket.Send(sendBytes);
//5、receive message
string recStr = "";
byte[] recBytes = new byte[4096];
int bytes = clientSocket.Receive(recBytes, recBytes.Length, 0);
recStr += Encoding.ASCII.GetString(recBytes, 0, bytes);
Console.WriteLine(recStr);
clientSocket.Close();
下面的代码实现异步：
using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
// 客户端请求状态信息保存在这里
public class StateObject
{
// Client socket.
// 客户端的socket
public Socket workSocket = null;
// Size of receive buffer.
public const int BufferSize = 1024;
// Receive buffer.
public byte[] buffer = new byte[BufferSize];
// Received data string.
public StringBuilder sb = new StringBuilder();
}
public class AsynchronousSocketListener
{
public static List<Socket> ClientSockets = new List<Socket>();
// 线程信号
public static ManualResetEvent allDone = new ManualResetEvent(false);
/// <summary>
/// 构造函数
/// </summary>
public AsynchronousSocketListener()
{
}
/// <summary>
/// 开始监听
/// </summary>
public static void StartListening()
{
// Establish the local endpoint for the socket.
// The DNS name of the computer
// running the listener is "host.contoso.com".
IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
IPAddress ipAddress = ipHostInfo.AddressList[3];
IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);
// Create a TCP/IP socket.
Socket listener = new Socket(ipAddress.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
// Bind the socket to the local endpoint and listen for incoming connections.
try
{
listener.Bind(localEndPoint);
listener.Listen(100);
Task.Run(()=> {
while (true)
{
// Set the event to nonsignaled state.
allDone.Reset();
// Start an asynchronous socket to listen for connections.
// AsyncCallback 让回调函数在单独的线程中执行
Console.WriteLine("Waiting for a connection...");
// 处理传入的请求,这个只有在客户端发起握手的时候才调用
listener.BeginAccept(
new AsyncCallback(AcceptCallback),
listener);
// Wait until a connection is made before continuing.
allDone.WaitOne();
}
});
while (true)
{
for (int i = 0; i < ClientSockets.Count; i++)
{
try
{
Send(ClientSockets[i], "hello i am server
");
}
catch (Exception)
{
ClientSockets.RemoveAt(i);
}
}
Thread.Sleep(100);
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
Console.WriteLine("
Press ENTER to continue...");
Console.Read();
}
/// <summary>
/// 监听回调
/// </summary>
/// <param name="ar"></param>
public static void AcceptCallback(IAsyncResult ar)
{
// 标记主线程继续执行
allDone.Set();
// 获取socket来处理client请求
Socket listener = (Socket)ar.AsyncState;
Socket handler = listener.EndAccept(ar);
// 创建数据对象（储存接收数据）
StateObject state = new StateObject();
state.workSocket = handler;
//存储请求来的socket，方便从server发送到client
ClientSockets.Add(handler);
Console.WriteLine(ClientSockets.Count);
// 处理传递进来的数据
handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
new AsyncCallback(ReadCallback), state);
}
/// <summary>
/// 读取客户端请求数据回调
/// </summary>
/// <param name="ar"></param>
public static void ReadCallback(IAsyncResult ar)
{
String content = String.Empty;
// Retrieve the state object and the handler socket
// from the asynchronous state object.
// 在read回调函数中调用 IAsyncResult（ar） 的 AsyncState 方法，以获取传递给 BeginReceive 方法的状态对象
// 此时就已经获取到客户端请求的数据，存储在state.buffer中，如果此时还有数据进来也不会填充state的buffer，而是等待下一次回调被调用
StateObject state = (StateObject)ar.AsyncState;
// 从此状态对象中提取接收 Socket
Socket handler = state.workSocket;
// Read data from the client socket.
// 获取 Client Socket后，可以调用 EndReceive 方法成功完成(关闭) BeginReceive 方法中启动的异步读取操作，并返回所读取的字节数
int bytesRead = handler.EndReceive(ar);
if (bytesRead > 0)
{
// There might be more data, so store the data received so far.
// 可能会有很多数据要接收，暂存当前已经接收到的数据，StateObject.buffer在ar.AsyncState的时候就已经被填充（实测）
state.sb.Clear();
state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
// Check for end-of-file tag. If it is not there, read
// more data.
// 检查end-of-file，如果没哟检测到就再继续读。
content = state.sb.ToString();
Console.WriteLine(content);
/*
if (content.IndexOf("<EOF>") > -1)
{
// All the data has been read from the
// client. Display it on the console.
Console.WriteLine("Read {0} bytes from socket.
Data : {1}",
content.Length, content);
// Echo the data back to the client.
Send(handler, content);
}
else
{
// Not all data received. Get more.
// 没有读取到所有数据，继续读取，这里是个递归
handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
new AsyncCallback(ReadCallback), state);
}*/
handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
new AsyncCallback(ReadCallback), state);
}
}
private static void Send(Socket handler, String data)
{
// Convert the string data to byte data using ASCII encoding.
// 转换string到字节数组。使用ASCII编码
byte[] byteData = Encoding.ASCII.GetBytes(data);
// Begin sending the data to the remote device.
// 开始发送，异步发送
// 这里的handler是客户端client请求来的
handler.BeginSend(byteData, 0, byteData.Length, 0,
new AsyncCallback(SendCallback), handler);
}
/// <summary>
/// 发送回调，发送什么如何发送在这里实现
/// </summary>
/// <param name="ar"></param>
private static void SendCallback(IAsyncResult ar)
{
try
{
// Retrieve the socket from the state object
// 获取socket ,ar.AsyncState返回的是个object类型，可以转为state也可以转为socket
Socket handler = (Socket)ar.AsyncState;
// Complete sending the data to the remote device.
// 在回调方法中，调用 IAsyncResult 参数的 AsyncState 方法以获取发送 Socket。
// 获取 Socket后，可以调用 EndSend 方法成功完成发送操作，并返回发送的字节数。
int bytesSent = handler.EndSend(ar);
//Console.WriteLine("Sent {0} bytes to client.", bytesSent);
//handler.Shutdown(SocketShutdown.Both);
//handler.Close();
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
public static int Main(String[] args)
{
StartListening();
return 0;
}
}