C# TCP/UDP网络调试基础通信代码，适合小白初学参考
源码下载链接
本示例源码下载地址（完整工程代码，可直接编译运行）
开发环境
win7
vs2017（社区版）
主要功能
实现TCPServer TCPClient UDP的连接通信，字符串和HEX数据收发功能测试
软件截图
主界面代码
using System
;
using System
.Collections
.Generic
;
using System
.ComponentModel
;
using System
.Data
;
using System
.Drawing
;
using System
.Linq
;
using System
.Text
;
using System
.Windows
.Forms
;
namespace UDPTest
{
public partial class MainForm : Form
{
delegate void RtbData(string str
, Color color
);
RtbData RtbDataUpdate
;
TCPSocket _testTcpSocket
= new TCPSocket();
public MainForm()
{
InitializeComponent();
}
private void MainForm_Load(object sender
, EventArgs e
)
{
cmb_SocketType
.SelectedIndex
= 0;
RtbDataUpdate
= new RtbData(RtbDataInit
);
_testTcpSocket
.BufferReceChange
+= OnTestBufferReceChange
;
_testTcpSocket
.ConnStateChange
+= OnTeseTcpStateChange
;
}
private void btn_OpenOrClose_Click(object sender
, EventArgs e
)
{
SetTestTcpSocket();
if (!_testTcpSocket
._connState
)
{
_testTcpSocket
.tcpOpen();
}
else
{
_testTcpSocket
.tcpClose();
}
}
private void btn_Send_Click(object sender
, EventArgs e
)
{
if (cb_SendHex
.Checked
)
{
_testTcpSocket
.SendData(Utils
.hexStringToByte(txb_SendData
.Text
));
}
else
{
_testTcpSocket
.SendData(System
.Text
.Encoding
.Default
.GetBytes(txb_SendData
.Text
));
}
}
private void txb_SendData_KeyPress(object sender
, KeyPressEventArgs e
)
{
if (cb_SendHex
.Checked
)
{
char inputChar
= e
.KeyChar
;
if ((inputChar
>= 48 && inputChar
<= 57)
|| (inputChar
>= 65 && inputChar
<= 70)
|| (inputChar
>= 97 && inputChar
<= 102)
|| (inputChar
== ' ')
|| (inputChar
== 8)
|| (inputChar
== 3)
|| (inputChar
== 13))
{
}
else
{
MessageBox
.Show("非Hex数据");
e
.KeyChar
= '\0';
}
}
}
private void cb_NetTime_CheckedChanged(object sender
, EventArgs e
)
{
if (!_testTcpSocket
._connState
|| txb_SendData
.Text
.Trim().Length
== 0)
{
cb_NetTime
.Checked
= false;
return;
}
if (cb_NetTime
.Checked
)
{
_testTcpSocket
.tCPCaclyTimer
.Interval
= Convert
.ToInt32(nud_TcpTime
.Value
);
_testTcpSocket
.tCPCaclyTimer
.AutoReset
= true;
if (cb_SendHex
.Checked
)
{
_testTcpSocket
._caclyBuffer
= Utils
.hexStringToByte(txb_SendData
.Text
);
}
else
{
_testTcpSocket
._caclyBuffer
= System
.Text
.Encoding
.Default
.GetBytes(txb_SendData
.Text
);
}
_testTcpSocket
.tCPCaclyTimer
.Start();
txb_SendData
.ReadOnly
= true;
nud_TcpTime
.ReadOnly
= true;
}
else
{
_testTcpSocket
.tCPCaclyTimer
.Stop();
txb_SendData
.ReadOnly
= false;
nud_TcpTime
.ReadOnly
= false;
}
}
private void cb_SendHex_CheckedChanged(object sender
, EventArgs e
)
{
if (cb_SendHex
.Checked
)
{
txb_SendData
.Text
= Utils
.DecStringToHex(txb_SendData
.Text
);
}
else
{
txb_SendData
.Text
= Utils
.HexStringToDec(txb_SendData
.Text
);
}
}
private void OnTestBufferReceChange(object sender
, EventArgs e
)
{
if (cb_StopShow
.Checked
)
{
return;
}
string res
= "";
if (cb_Hex
.Checked
)
{
res
= Utils
.ByteToHexStr(((TCPSocket
)sender
)._tcpReceData
) + "\r\n";
}
else
{
res
= System
.Text
.Encoding
.Default
.GetString(((TCPSocket
)sender
)._tcpReceData
) + "\r\n";
}
if (cb_ShowTime
.Checked
)
{
res
= DateTime
.Now
.ToString("hh:mm:ss:fff") + "=>>> " + res
;
}
RtbDataShow("【收】 " + res
, Color
.Green
);
}
private void OnTeseTcpStateChange(object sender
, EventArgs e
)
{
this.Invoke((Action
)(() =>
{
btn_OpenOrClose
.Text
= _testTcpSocket
._connState
? "断开" : "连接";
cmb_SocketType
.Enabled
= !_testTcpSocket
._connState
;
txb_TargetIp
.Enabled
= !_testTcpSocket
._connState
;
txb_targetPort
.Enabled
= !_testTcpSocket
._connState
;
txb_localPort
.Enabled
= !_testTcpSocket
._connState
;
}));
if (_testTcpSocket
._connState
)
{
RtbDataShow("\r\n本地IP" + Utils
.GetIPAddress() + "\r\n", Color
.Red
);
}
}
private void SetTestTcpSocket()
{
try
{
switch (cmb_SocketType
.SelectedIndex
)
{
case 0:
_testTcpSocket
._tcpType
= TCPType
.TCPServer
;
break;
case 1:
_testTcpSocket
._tcpType
= TCPType
.TCPClient
;
break;
case 2:
_testTcpSocket
._tcpType
= TCPType
.UDP
;
break;
default:
_testTcpSocket
._tcpType
= TCPType
.TCPServer
;
break;
}
_testTcpSocket
._targetIP
= txb_TargetIp
.Text
;
_testTcpSocket
._targetPort
= Convert
.ToInt32(txb_targetPort
.Text
.Trim());
_testTcpSocket
._localProt
= Convert
.ToInt32(txb_localPort
.Text
.Trim());
}
catch (Exception ex
)
{
MessageBox
.Show(ex
.ToString());
}
}
public void RtbDataInit(string str
, Color color
)
{
this.rtb_Data
.SelectionColor
= color
;
this.rtb_Data
.AppendText(str
);
this.rtb_Data
.Focus();
this.rtb_Data
.Select(this.rtb_Data
.TextLength
, 0);
this.rtb_Data
.ScrollToCaret();
}
public void RtbDataShow(string str
)
{
this.Invoke(RtbDataUpdate
, str
, Color
.Black
);
}
public void RtbDataShow(string str
, Color color
)
{
this.Invoke(RtbDataUpdate
, str
, color
);
}
public void RtbDataShow(string str
, bool b
)
{
if (b
)
{
this.Invoke(RtbDataUpdate
, str
, Color
.Green
);
}
else
{
this.Invoke(RtbDataUpdate
, str
, Color
.Red
);
}
}
}
}
```csharp
public enum TCPType
{
TCPServer
,
TCPClient
,
UDP
}
public class TCPSocket
{
#region
public event EventHandler BufferReceChange
;
public event EventHandler ConnStateChange
;
public event EventHandler TcpReceiveSumChange
;
public event EventHandler TcpStateChange
;
public event EventHandler TcpClientReconnect
;
private void OnBufferReceChange(EventArgs eventArgs
)
{
this.BufferReceChange
?.Invoke(this, eventArgs
);
}
private void OnConnStateChange(EventArgs eventArgs
)
{
this.ConnStateChange
?.Invoke(this, eventArgs
);
}
private void OnTcpReceiveSumChange(EventArgs eventArgs
)
{
this.TcpReceiveSumChange
?.Invoke(this, eventArgs
);
}
private void OnTcpStateChange(EventArgs eventArgs
)
{
this.TcpStateChange
?.Invoke(this, eventArgs
);
}
private void OnTcpClientReconnect(EventArgs eventArgs
)
{
this.TcpClientReconnect
?.Invoke(this, eventArgs
);
}
#endregion
#region 参数
private bool connState
= false;
public bool _connState
{
get { return connState
; }
set
{
this.OnConnStateChange(new EventArgs());
connState
= value;
}
}
private string targetIp
= "255.255.255.255";
public string _targetIP
{
get { return targetIp
; }
set { targetIp
= value; }
}
private int targetPort
= 18503;
public int _targetPort
{
get { return targetPort
; }
set { targetPort
= value; }
}
private string localIP
= Utils
.GetIPAddress();
public string _localIP
{
get { return localIP
; }
}
private int localProt
;
private string currentIP
;
public string _currentIP
{
get { return currentIP
; }
set { currentIP
= value; }
}
private int currentPort
;
private int _currentPort
{
get { return currentPort
; }
set { currentPort
= value; }
}
public int _localProt
{
get { return localProt
; }
set { localProt
= value; }
}
private long tcpReceiveSum
;
public long _tcpReceiveSum
{
get { return tcpReceiveSum
; }
set
{
tcpReceiveSum
= value;
this.OnTcpReceiveSumChange(new EventArgs());
}
}
private long tcpSendSum
;
public long _tcpSendSum
{
get { return tcpSendSum
; }
set { tcpSendSum
= value; }
}
private byte[] bufferRece
;
public byte[] _tcpReceData
{
get { return bufferRece
; }
set { bufferRece
= value; }
}
private byte[] caclyBuffer
;
public byte[] _caclyBuffer
{
get { return caclyBuffer
; }
set { caclyBuffer
= value; }
}
#endregion
Thread ReceiveData
= null;
UdpClient udp
= new UdpClient();
Dictionary
<string, Socket
> clientConnectionItems
= new Dictionary<string, Socket
> { };
public Socket _localSocket
= null;
public Socket _targetSocket
= null;
private TCPType tcpType
= TCPType
.TCPServer
;
public TCPType _tcpType
{
get { return tcpType
; }
set { tcpType
= value; }
}
public TCPSocket()
{
tCPCaclyTimer
.Elapsed
+= TcpTest_Elapsed
;
}
public TCPSocket(TCPType tcp
, int targerPort
)
{
this._tcpType
= tcp
;
this._targetPort
= targetPort
;
}
public TCPSocket(TCPType tcp
, string tIP
, int tPort
, int lProt
)
{
this._tcpType
= tcp
;
this._targetIP
= tIP
;
this._targetPort
= tPort
;
this._localProt
= lProt
;
}
## 封装类
```csharp
//网络通信类型
public enum TCPType
{
TCPServer,
TCPClient,
UDP
}
public class TCPSocket
{
#region/************* 自定义事件 捕获数据变化 *******************/
public event EventHandler BufferReceChange; //Socket接收数据事件
public event EventHandler ConnStateChange; //Socket连接状态变化事件
public event EventHandler TcpReceiveSumChange; //TCP接受数据变化事件
public event EventHandler TcpStateChange; //TCP状态变化事件
public event EventHandler TcpClientReconnect; //
private void OnBufferReceChange(EventArgs eventArgs)
{
this.BufferReceChange?.Invoke(this, eventArgs);
}
private void OnConnStateChange(EventArgs eventArgs)
{
this.ConnStateChange?.Invoke(this, eventArgs);
}
private void OnTcpReceiveSumChange(EventArgs eventArgs)
{
this.TcpReceiveSumChange?.Invoke(this, eventArgs);
}
private void OnTcpStateChange(EventArgs eventArgs)
{
this.TcpStateChange?.Invoke(this, eventArgs);
}
private void OnTcpClientReconnect(EventArgs eventArgs)
{
this.TcpClientReconnect?.Invoke(this, eventArgs);
}
#endregion
#region 参数
private bool connState = false; //连接状态
public bool _connState
{
get { return connState; }
set
{
this.OnConnStateChange(new EventArgs());
connState = value;
}
}
private string targetIp = "255.255.255.255"; //发送数据目标IP 默认值
public string _targetIP
{
get { return targetIp; }
set { targetIp = value; }
}
private int targetPort = 18503; //发送数据目标端口
public int _targetPort
{
get { return targetPort; }
set { targetPort = value; }
}
private string localIP = Utils.GetIPAddress(); //本机电脑IP
public string _localIP
{
get { return localIP; }
}
private int localProt; //本地端口
private string currentIP; //当前接收数据 IP
public string _currentIP
{
get { return currentIP; }
set { currentIP = value; }
}
private int currentPort;
private int _currentPort
{
get { return currentPort; }
set { currentPort = value; }
}
public int _localProt
{
get { return localProt; }
set { localProt = value; }
}
private long tcpReceiveSum; //网络接受数据总数
public long _tcpReceiveSum
{
get { return tcpReceiveSum; }
set
{
tcpReceiveSum = value;
this.OnTcpReceiveSumChange(new EventArgs());
}
}
private long tcpSendSum; //网络发送数据总数
public long _tcpSendSum
{
get { return tcpSendSum; }
set { tcpSendSum = value; }
}
private byte[] bufferRece; //缓存接受到的数据
public byte[] _tcpReceData
{
get { return bufferRece; }
set { bufferRece = value; }
}
private byte[] caclyBuffer;//循环发送的数据
public byte[] _caclyBuffer
{
get { return caclyBuffer; }
set { caclyBuffer = value; }
}
#endregion
Thread ReceiveData = null; //udp tcp clienct接受数据线程
UdpClient udp = new UdpClient();
//存储客户端信息
Dictionary<string, Socket> clientConnectionItems = new Dictionary<string, Socket> { }; //ip端口 套接字
public Socket _localSocket = null; //本地套接字
public Socket _targetSocket = null; //连接目标套接字
//网络通信类型 默认TCPServer
private TCPType tcpType = TCPType.TCPServer;
public TCPType _tcpType
{
get { return tcpType; }
set { tcpType = value; }
}
public TCPSocket()
{
tCPCaclyTimer.Elapsed += TcpTest_Elapsed;
}
public TCPSocket(TCPType tcp, int targerPort)
{
this._tcpType = tcp;
this._targetPort = targetPort;
}
/// <summary>
///
/// </summary>
/// <param name="tcp">通信类型</param>
/// <param name="tIP">目标IP</param>
/// <param name="tPort">目标端口</param>
/// <param name="lProt">本地IP</param>
public TCPSocket(TCPType tcp, string tIP, int tPort, int lProt)
{
this._tcpType = tcp;
this._targetIP = tIP;
this._targetPort = tPort;
this._localProt = lProt;
}
//打开网络通信
public bool tcpOpen()
{
try
{
tcpClose();
if (_tcpType == TCPType.UDP)
{
return UdpOpen();
}
else if (_tcpType == TCPType.TCPServer)
{
return OpenServer();
}
else if (_tcpType == TCPType.TCPClient)
{
return ConnServer();
}
return true;
}
catch (Exception ex)
{
return false;
}
}
//发送数据
public bool SendData(byte[] buffer)
{
if (_tcpType == TCPType.UDP)
{
return UdpSend(buffer);
}
else if (_tcpType == TCPType.TCPClient)
{
return tcpClientSendData(buffer);
}
else
{
return TcpServerSendData(buffer);
}
}
#region TCP server
public bool OpenServer()
{
try
{
_localSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPAddress address = IPAddress.Parse(_localIP);//IP地址
IPEndPoint point = new IPEndPoint(address, _localProt);//IP地址端口绑定网络节点
_localSocket.Bind(point); //监听绑定的网络节点
_localSocket.Listen(20); //将套接字的监听队列长度限制为20
Thread threadwatch = new Thread(WatchConnecting);//负责监听客户端的线程
threadwatch.IsBackground = true;
threadwatch.Start();//
_connState = true;
return true;
}
catch (Exception ex)
{
_connState = false;
return false;
}
finally
{
this.OnConnStateChange(new EventArgs());
}
}
//监听客户端发来的请求
public void WatchConnecting()
{
while (true)
{
try
{
_targetSocket = _localSocket.Accept();//连接成功
}
catch (Exception ex)
{
_connState = false;
this.OnConnStateChange(new EventArgs());
break;
}
//获取客户端的IP和端口号
IPAddress clientIP = (_targetSocket.RemoteEndPoint as IPEndPoint).Address;
int clientPort = (_targetSocket.RemoteEndPoint as IPEndPoint).Port;
string remoteEndPoint = _targetSocket.RemoteEndPoint.ToString();//客户端网络节点
clientConnectionItems.Add(remoteEndPoint, _targetSocket);//客户端信息存储起来
IPEndPoint netpoint = _targetSocket.RemoteEndPoint as IPEndPoint;
//创建一个通信线程
ParameterizedThreadStart pts = new ParameterizedThreadStart(Recv);
Thread thread = new Thread(pts);
//设置为后台线程，随着主线程退出而退出
thread.IsBackground = true;
thread.Name = "ATK TcpServer网络通信线程";
thread.Start(_targetSocket); //开始通信线程
}
}
//服务端接收数据线程
public void Recv(object socketclientpara)
{
Socket socketServer = socketclientpara as Socket;
while (true)
{
if (!connState)
{
this.OnConnStateChange(new EventArgs());
break;
}
//创建一个内存缓冲区 1024字节 缓冲区太大容易丢失数据 虚拟串口处理不来
byte[] arrServerRecMsg = new byte[1024];
//将接收到的信息存入到内存缓冲区，并返回其字节数组的长度
try
{
int length = socketServer.Receive(arrServerRecMsg);
_tcpReceiveSum += length;
if (length == 0)//接收到的数据长度为0 客户端断开连接
{
clientConnectionItems.Remove(socketServer.RemoteEndPoint.ToString());
socketServer.Close();
break;
}
string Ip = "0.0.0.0";
int Point = 0;
Utils.EndPointGetIpAndPoint(socketServer.RemoteEndPoint.ToString(), out Ip, out Point);
_tcpReceData = new byte[length];
Buffer.BlockCopy(arrServerRecMsg, 0, _tcpReceData, 0, length); //TCP服务端接受的数据
this.OnBufferReceChange(new EventArgs());
}
catch (Exception ex)
{
try
{
clientConnectionItems.Remove(socketServer.RemoteEndPoint.ToString());
}
catch
{
tcpClose();
}
socketServer.Close();
break;
}
}
}
//服务端发送数据
public bool TcpServerSendData(byte[] buffer)
{
try
{
_targetSocket.Send(buffer);
return true;
}
catch (Exception ex)
{
_connState = false;
this.OnConnStateChange(new EventArgs());
return false;
}
}
#endregion
#region TCP Client
//连接服务端
private bool ConnServer()
{
try
{
_targetSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);//定义套接字监听
IPAddress address = IPAddress.Parse(_targetIP);//IP地址
IPEndPoint point = new IPEndPoint(address, _targetPort);//IP地址端口绑定网络节点
try
{
_targetSocket.Connect(point);
}
catch
{
_connState = false;
return false;
}
ReceiveData = new Thread(new ThreadStart(TcpClientReceiveDataThread));
ReceiveData.IsBackground = true;
ReceiveData.Name = "Tcp Client接收数据";
ReceiveData.Start();
connState = true;
return true;
}
catch (Exception ex)
{
_connState = false;
return false;
}
finally
{
this.OnConnStateChange(new EventArgs());
}
}
//tcp client接受数据线程
private void TcpClientReceiveDataThread()
{
while (true)
{
try
{
byte[] arrRecvmsg = new byte[1024];
//将客户端套接字接收到的数据存入内存缓冲区，并获取长度
int length = _targetSocket.Receive(arrRecvmsg);
if (length == 0)
{
_connState = false;
break;
}
_tcpReceiveSum += length;
_tcpReceData = new byte[length];
Buffer.BlockCopy(arrRecvmsg, 0, _tcpReceData, 0, length);
this.OnBufferReceChange(new EventArgs());
}
catch (Exception ex)
{
_connState = false;
this.OnConnStateChange(new EventArgs());
break;
}
}
}
//tcp client 发送数据
private bool tcpClientSendData(byte[] buffer)
{
try
{
_targetSocket.Send(buffer);
return true;
}
catch (Exception ex)
{
_connState = false;
this.OnConnStateChange(new EventArgs());
return false;
}
}
#endregion
#region UPD通信 连接目标主机 接受数据
//打开UDP通信
public bool UdpOpen()
{
try
{
UdpCLose();
udp = new UdpClient(0);
//_localIP = (udp.Client.LocalEndPoint as IPEndPoint).Address.ToString();
_localProt = (udp.Client.LocalEndPoint as IPEndPoint).Port;
Console.WriteLine("端口" + _localProt);
ReceiveData = new Thread(new ThreadStart(UdpReceThread));
ReceiveData.IsBackground = true;
ReceiveData.Name = "UDP 接收数据线程";
ReceiveData.Start();
connState = true;
return true;
}
catch (Exception ex)
{
_connState = false;
return false;
}
finally
{
this.OnConnStateChange(new EventArgs());
}
}
//UDP发送数据
public bool UdpSend(byte[] buffer)
{
try
{
//65 84 43 83 69 65 82 67 72 63 13 10
// udp.Send(buffer, buffer.Length, "192.168.3.255", _targetPort);
udp.Send(buffer, buffer.Length, _targetIP, _targetPort);
return true;
}
catch (Exception ex)
{
_connState = false;
this.OnConnStateChange(new EventArgs());
return false;
}
}
//UDP接收数据线程
public void UdpReceThread()
{
try
{
while (true)
{
IPEndPoint remoteIpEndPoint = null;
byte[] receiveBytes = udp.Receive(ref remoteIpEndPoint);
_currentIP = remoteIpEndPoint.Address.ToString();
_currentPort = remoteIpEndPoint.Port;
_tcpReceData = new byte[receiveBytes.Length];
Buffer.BlockCopy(receiveBytes, 0, _tcpReceData, 0, receiveBytes.Length);
this.OnBufferReceChange(new EventArgs());
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
_connState = false;
this.OnConnStateChange(new EventArgs());
}
}
#endregion
//关闭网络通信
public void tcpClose()
{
if (_tcpType == TCPType.UDP)
{
UdpCLose();
}
else if (_tcpType == TCPType.TCPClient)
{
closeTcpClent();
}
else
{
closeTcpServer();
}
_connState = false;
Thread.Sleep(100);
}
//关闭TCP Server
private void closeTcpServer()
{
try
{
foreach (var item in clientConnectionItems)
{
clientConnectionItems[item.Key].Disconnect(false);
}
_localSocket.Close();
clientConnectionItems.Clear();
}
catch (Exception)
{
}
}
//关闭TCP CLient
private void closeTcpClent()
{
try
{
if (ReceiveData != null)
{
ReceiveData.Abort();
}
_targetSocket.Close();
}
catch (Exception ex)
{
Console.WriteLine("closeTcpClent" + ex.ToString());
}
try
{
_targetSocket = null;
}
catch
{
}
}
//关闭UDp
private void UdpCLose()
{
try
{
udp.Close();
}
catch (Exception ex)
{//异常不做处理
return;
}
}
public System.Timers.Timer tCPCaclyTimer = new System.Timers.Timer(); //网络循环发送数据计时器
//重发计时器
private void TcpTest_Elapsed(object sender, ElapsedEventArgs e)
{
SendData(_caclyBuffer);
}
}
这是之前学习时写的代码库存，随便整理一下分享给大家了，转载注明一下出处，谢谢！说不定能挣两积分，虽然不怎么在这里玩0.0
有上位机需求，网络tcp udp，串口（232-485等），USB-HID，websocket，物联网（设备连云控制如iot，dtu等）需求可以留言
