创建服务器端Socket并绑定IP和端口号
1.引入命名空间:
using System.Net.Sockets;
using System.Net;
2.创建TCP套接字
Socket serverSocket = new Socket(AddressFamily.InterNetwork,SocketType.Stream, ProtocolType.Tcp);
3.绑定IP和端口号
(IPAddress.Parse(“127.0.0.1”);将字符串转化为IP地址)
IPAddress ipAddress = IPAddress.Parse(“127.0.0.1”);
IPEndPoint point = new IPEndPoint(ipAddress, 8888);
serverSocket.Bind(point); //绑定IP和端口号
代码:
using System.Net.Sockets;
using System.Net;
namespace TCP服务器端
{
class Program
{
static void Main(string[] args)
{
//TCP 数据传输方式:流模式
Socket serverSocket = new Socket(AddressFamily.InterNetwork,SocketType.Stream, ProtocolType.Tcp);
IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
IPEndPoint point = new IPEndPoint(ipAddress, 8888);
serverSocket.Bind(point); //绑定IP和端口号
}
}
}
开发服务器端的发送数据和接收数据
1.开始监听端口号 监听不超过10个
serverSocket.Listen(10);
2.接收一个客户端的链接,返回一个客户端套接字
Socket clientSocket = serverSocket.Accept();
3.向客户端发送(字节数组类型)数据
string msg = “hello,你好啊!”;
Byte[] dataBuffer = Encoding.UTF8.GetBytes(msg);
clientSocket.Send(dataBuffer);
4.接收客户端数据,使用字节数组接收,count为接收字节的长度
byte[] receiveBuffer = new byte[1024];
int count = clientSocket.Receive(receiveBuffer);
string msgReceive = Encoding.UTF8.GetString(receiveBuffer, 0, count);
5.关闭和客户端的链接,关闭服务器端
clientSocket.Close();
serverSocket.Close();
代码:
using System.Text;
using System.Net.Sockets;
using System.Net;
namespace TCP服务器端
{
class Program
{
static void Main(string[] args)
{
//TCP 数据传输方式:流模式
Socket serverSocket = new Socket(AddressFamily.InterNetwork,SocketType.Stream, ProtocolType.Tcp);
IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
IPEndPoint point = new IPEndPoint(ipAddress, 8888);
serverSocket.Bind(point); //绑定IP和端口号
//开始监听端口号 监听不超过10个
serverSocket.Listen(10);
//接收一个客户端的链接
Socket clientSocket = serverSocket.Accept();
//向客户端发送数据
string msgSend = "hello,你好啊!";
byte[] sendBuffer = Encoding.UTF8.GetBytes(msg);
clientSocket.Send(sendBuffer);
//接收客户端数据
byte[] receiveBuffer = new byte[1024];
int count = clientSocket.Receive(receiveBuffer);
string msgReceive = Encoding.UTF8.GetString(receiveBuffer, 0, count);
//关闭和客户端的链接,关闭服务器端
clientSocket.Close();
serverSocket.Close();
}
}
}
开发TCP客户端的接收数据和发送数据
1.创建客户端套接字
2.与服务器端建立连接
clientSocket.Connect(new IPEndPoint(IPAddress.Parse(“127.0.0.1”),8888));
3.接收从服务器端发过来的消息
4.向服务器端发送一条消息
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net.Sockets;
using System.Net;
namespace TCP客户端
{
class Program
{
static void Main(string[] args)
{
//创建客户端套接字
Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//与服务器端建立连接
clientSocket.Connect(new IPEndPoint(IPAddress.Parse("127.0.0.1"),8888));
//接收从服务器端发过来的消息
byte[] dataReceive = new byte[1024];
int count = clientSocket.Receive(dataReceive);
string msgReceive = Encoding.UTF8.GetString(dataReceive, 0, count);
Console.WriteLine(msgReceive);
//向服务器端发送一条消息
string str = Console.ReadLine();
byte[] dataSend = Encoding.UTF8.GetBytes(str);
clientSocket.Send(dataSend);
//关闭客户端套接字的连接
clientSocket.Close();
Console.ReadLine();
}
}
}
实现服务器端异步的消息接收
异步接收消息:
开始接收:
clientSocket.BeginReceive(receiveBuffer, 0, 1024, SocketFlags.None, ReceiveCallBack, clientSocket);
ReceiveCallBack为异步接收的回调函数
结束接收(返回接收的字节长度):
int count = clientSocket.EndReceive(ar);
服务器端代码:
using System;
using System.Text;
using System.Net.Sockets;
using System.Net;
namespace TCP服务器端
{
class Program
{
private static byte[] receiveBuffer = new byte[1024];
static void Main(string[] args)
{
StartServerAyync();
Console.ReadLine();
}
static void StartServerAyync()
{
//TCP 数据传输方式:流模式
Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
IPEndPoint point = new IPEndPoint(ipAddress, 8888);
serverSocket.Bind(point); //绑定IP和端口号
//开始监听端口号 监听不超过10个
serverSocket.Listen(10);
//接收一个客户端的链接
Socket clientSocket = serverSocket.Accept();
//向客户端发送数据
string msgSend = "hello,你好啊!";
byte[] sendBuffer = Encoding.UTF8.GetBytes(msgSend);
clientSocket.Send(sendBuffer);
//接收客户端数据
clientSocket.BeginReceive(receiveBuffer, 0, 1024, SocketFlags.None, ReceiveCallBack, clientSocket);
}
static void ReceiveCallBack(IAsyncResult ar)
{
Socket clientSocket = ar.AsyncState as Socket;
int count = clientSocket.EndReceive(ar);
string msgReceive = Encoding.UTF8.GetString(receiveBuffer, 0, count);
Console.WriteLine(msgReceive);
//继续开始接收客户端发送的消息
clientSocket.BeginReceive(receiveBuffer, 0, 1024, SocketFlags.None, ReceiveCallBack, clientSocket);
}
}
}
客户端代码:
using System;
using System.Text;
using System.Net.Sockets;
using System.Net;
namespace TCP客户端
{
class Program
{
static void Main(string[] args)
{
//创建客户端套接字
Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//与服务器端建立连接
clientSocket.Connect(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8888));
//接收从服务器端发过来的消息
byte[] dataReceive = new byte[1024];
int count = clientSocket.Receive(dataReceive);
string msgReceive = Encoding.UTF8.GetString(dataReceive, 0, count);
Console.WriteLine(msgReceive);
string str = Console.ReadLine();
//向服务器端发送一条消息
while (true)
{
byte[] dataSend = Encoding.UTF8.GetBytes(str);
clientSocket.Send(dataSend);
str = Console.ReadLine();
if(str.Equals("exit"))
{
break;
}
}
//关闭客户端套接字的连接
clientSocket.Close();
Console.ReadLine();
}
}
}
修改服务器端开启异步处理客户端链接请求
1开始异步接收客户端的连接:
serverSocket.BeginAccept(AcceptCallBack, serverSocket);
获取与客户端连接的套接字:
Socket clientSocket = serverSocket.EndAccept(ar);
2.当客户端非正常关闭时服务器端会抛出异常,使用try…catch处理异常;当客户端正常关闭时,服务器端不会停止对客户端接收数据,应该对接收数据的字节长度count进行判断,若为0,则客户端正常关闭,即关闭与客户端连接的套接字。
服务器端代码:
using System;
using System.Text;
using System.Net.Sockets;
using System.Net;
namespace TCP服务器端
{
class Program
{
private static int clientCount = 0;
private static byte[] receiveBuffer = new byte[1024];
static void Main(string[] args)
{
StartServerAyync();
Console.ReadLine();
}
static void StartServerAyync()
{
//TCP 数据传输方式:流模式
Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
IPEndPoint point = new IPEndPoint(ipAddress, 8888);
serverSocket.Bind(point); //绑定IP和端口号
//开始监听端口号 监听不超过10个
//serverSocket.Listen(10);
serverSocket.Listen(0);
//接收一个客户端的连接
//Socket clientSocket = serverSocket.Accept();
//异步接收客户端的连接
serverSocket.BeginAccept(AcceptCallBack, serverSocket);
}
//异步等待客户端连接的回调函数
static void AcceptCallBack(IAsyncResult ar)
{
clientCount++;
Console.WriteLine("一个客户端连接上了本服务器,当前连接的客户端数:" + clientCount);
Socket serverSocket = ar.AsyncState as Socket;
Socket clientSocket = serverSocket.EndAccept(ar);
//向客户端发送数据
string msgSend = "hello,你好啊!";
byte[] sendBuffer = Encoding.UTF8.GetBytes(msgSend);
clientSocket.Send(sendBuffer);
//接收客户端数据
clientSocket.BeginReceive(receiveBuffer, 0, 1024, SocketFlags.None, ReceiveCallBack, clientSocket);
//继续异步接收客户端的连接
serverSocket.BeginAccept(AcceptCallBack, serverSocket);
}
//异步接收客户端数据的回调函数
static void ReceiveCallBack(IAsyncResult ar)
{
Socket clientSocket = null;
try
{
clientSocket = ar.AsyncState as Socket;
int count = clientSocket.EndReceive(ar);
//客户端发送的消息为空
if(count == 0)
{
clientCount--;
Console.WriteLine("一个客户端关闭了连接,当前连接的客户端数:" + clientCount);
if (clientSocket != null)
{
clientSocket.Close();
}
return;
}
string msgReceive = Encoding.UTF8.GetString(receiveBuffer, 0, count);
Console.WriteLine("客户端消息:" + msgReceive);
clientSocket.BeginReceive(receiveBuffer, 0, 1024, SocketFlags.None, ReceiveCallBack, clientSocket);
}
catch (Exception e)
{
clientCount--;
Console.WriteLine("一个客户端关闭了连接,当前连接的客户端数:" + clientCount);
if (clientSocket != null)
{
clientSocket.Close();
}
}
}
static void StartServerSync()
{
//TCP 数据传输方式:流模式
Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
IPEndPoint point = new IPEndPoint(ipAddress, 8888);
serverSocket.Bind(point); //绑定IP和端口号
//开始监听端口号 监听不超过10个
serverSocket.Listen(10);
//接收一个客户端的链接
Socket clientSocket = serverSocket.Accept();
//向客户端发送数据
string msgSend = "hello,你好啊!";
byte[] sendBuffer = Encoding.UTF8.GetBytes(msgSend);
clientSocket.Send(sendBuffer);
//接收客户端数据
byte[] receiveBuffer = new byte[1024];
int count = clientSocket.Receive(receiveBuffer);
string msgReceive = Encoding.UTF8.GetString(receiveBuffer, 0, count);
Console.WriteLine("客户端:" + msgReceive);
//关闭和客户端的链接,关闭服务器端
clientSocket.Close();
serverSocket.Close();
}
}
}
客户端代码:
using System;
using System.Text;
using System.Net.Sockets;
using System.Net;
namespace TCP客户端
{
class Program
{
static void Main(string[] args)
{
//创建客户端套接字
Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//与服务器端建立连接
clientSocket.Connect(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8888));
//接收从服务器端发过来的消息
byte[] dataReceive = new byte[1024];
int count = clientSocket.Receive(dataReceive);
string msgReceive = Encoding.UTF8.GetString(dataReceive, 0, count);
Console.WriteLine(msgReceive);
string str = Console.ReadLine();
//向服务器端发送一条消息
while (true)
{
byte[] dataSend = Encoding.UTF8.GetBytes(str);
clientSocket.Send(dataSend);
str = Console.ReadLine();
if(str.Equals("exit"))
{
break;
}
}
//关闭客户端套接字的连接
clientSocket.Close();
Console.ReadLine();
}
}
}
粘包与分包问题
粘包与分包问题
粘包和分包是利用Socket在TCP协议下内部的优化机制
1,什么是粘包
由于TCP协议本身的机制(面向连接的可靠地协议-三次握手机制)客户端与服务器会维持一个连接(Channel),数据在连接不断开的情况下,可以持续不断地将多个数据包发往服务器,但是如果发送的网络数据包太小,那么他本身会启用Nagle算法(可配置是否启用)对较小的数据包进行合并(基于此,TCP的网络延迟要UDP的高些)然后再发送(超时或者包大小足够)。那么这样的话,服务器在接收到消息(数据流)的时候就无法区分哪些数据包是客户端自己分开发送的,这样产生了粘包.
for(int i = 0;i < 100; i ++ )
{
byte[] dataSend = Encoding.UTF8.GetBytes(i.ToString());
clientSocket.Send(dataSend);
}
客户端发送了100条消息,服务器端合并消息后只接收了两次:
2,什么是分包
分包产生的原因:可能是IP分片传输导致的,也可能是传输过程中丢失部分包导致出现的半包,还有可能就是一个包可能被分成了两次传输,在取数据的时候,先取到了一部分(还可能与接收的缓冲区大小有关系),总之就是一个数据包被分成了多次接收。
客户端发1条消息,服务器端分条接收:
解决粘包与分包问题
解决方法:消息定长,比如定一个100,那么读取端每次读取数据就截取100个长度的数据,然后交给业务层去做解析
=>客户端Message:将发送的消息转化为一个字节数组byteData,在将byteData的长度转化为一个字节数组byteLength,然后连接byteLength+byteData=newByte,将newByte交给服务器端去解析
using System;
using System.Text;
namespace TCP客户端
{
class Message
{
public static byte[] GetBytes(string data)
{
byte[] dataBytes = Encoding.UTF8.GetBytes(data);
int dataLength = dataBytes.Length;
byte[] lengthBytes = BitConverter.GetBytes(dataLength);
byte[] newBytes = lengthBytes.Concat(dataBytes).ToArray();
return newBytes;
}
}
}
=>服务器端接收到客户端发来的字节数组后,对该字节数组进行解析,读取数据:
using System;
using System.Text;
namespace TCP服务器端
{
class Message
{
private byte[] data = new byte[1024];
private int startIndex = 0;
public byte[] Data
{
get
{
return this.data;
}
}
public int StartIndex
{
get
{
return this.startIndex;
}
}
public void AddCount(int count)
{
this.startIndex += count;
}
//剩余的空间
public int RemainSize()
{
return data.Length - startIndex;
}
//读取数据
public void ReadMessage()
{
while (true)
{
if(startIndex <= 4)
{
return;
}
int count = BitConverter.ToInt32(data, 0);
Console.WriteLine(count);
if (startIndex - 4 >= count)
{
String str = Encoding.UTF8.GetString(data, 4, count);
Console.WriteLine("解析出一条数据:" + str);
Array.Copy(data, count + 4, data, 0, startIndex - count - 4);
startIndex -= (count + 4);
}
else
{
break;
}
}
}
}
}