C# socket通信TCP和UDP方式

最新推荐文章于 2026-04-21 02:30:47 发布
原创 最新推荐文章于 2026-04-21 02:30:47 发布 · 830 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#C# #socket #TCP #UDP #网络通信

这里写一篇文章来和大家请教一下，关于socket通信的方式

这里我也是通过网络的其他地方整理的代码，来实现自己的功能

但是我发现一个问题，就是如此采用UDP方式，必须先向服务端发送一个数据才能接受到来自服务器定时不断发出的数据。不知道怎么解决。小弟对UDP方式理解的不够深入，求大神指导呢

这里贴出源码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.IO;


namespace SocketHelp
{
    public delegate void ReadDataEvent(byte[] Bytes, int size);
    
    #region TCP协议


    #region ClientTCP
    public class ClientTCP
    {
        private Socket client;
        public byte[] oubytes;
        //public static PrintMsg _PrintMsg;
        public ReadDataEvent ReadData;
        public ClientTCP()
        {
            oubytes =new byte[1024];
        }
        public bool StartClient(string IP, int port)
        {
            try
            {
                client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                client.BeginConnect(IP, port, new AsyncCallback(ConnectTarget), client);
                // 接收输入并发消息  
                //bool send = false;
                //while (true)
                //{
                //    showMsg("ME: " + DateTimeOffset.Now.ToString("G"));
                //    send = SendMsg;
                //    inbytes = Encoding.UTF8.GetBytes(Msg);
                //    client.BeginSend(inbytes, 0, inbytes.Length, SocketFlags.None, new AsyncCallback(SendTarget), client);
                //}
                //client.Close();  
                return true;
            }
            catch (Exception ex)
            {
                Method.writeLog(ex.Message.ToString());
                return false;
            }
        }
        public bool SendData(byte[] Bytes)
        {
            try
            {
                client.BeginSend(Bytes, 0, Bytes.Length, SocketFlags.None, new AsyncCallback(SendTarget), client);
                return true;
            }
            catch (Exception ex)
            {
                Method.writeLog(ex.Message.ToString());
                return false;
            }
        }
        private void ConnectTarget(IAsyncResult res)
        {
            Method.writeLog("已建立连接");
            Socket sever = (Socket)res.AsyncState;
            sever.EndConnect(res);
            sever.BeginReceive(oubytes, 0, oubytes.Length, SocketFlags.None, ReceiveData, sever);
        }


        private void SendTarget(IAsyncResult res)
        {
            //Socket client = (Socket)res.AsyncState;
            //int size = client.EndSend(res);
        }


        private void ReceiveData(IAsyncResult res)
        {
            try
            {
                Socket sever = (Socket)res.AsyncState;
                int size = sever.EndReceive(res);
                if (ReadData != null)
                {
                    //解析数据
                    ReadData(oubytes, size);
                }
                // 继续等待输入  
                sever.BeginReceive(oubytes, 0, oubytes.Length, SocketFlags.None, new AsyncCallback(ReceiveData), sever);
            }
            catch (Exception ex)
            {
                Method.writeLog(ex.Message.ToString());
            }
        }
    }
    #endregion


    #region ServiceTCP
    public class ServiceTCP
    {
        //public static PrintMsg _PrintMsg;
        public ReadDataEvent ReadData;
        //public static SendDataEvent SendData;
        public byte[] oubytes;
        public List<ClientInfo> clientList;
        public ServiceTCP()
        {
            clientList=new List<ClientInfo>();
            oubytes = new byte[1024];
        }
        public bool OpenService(int port)
        {
            try
            {
                IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Any, port);//本机预使用的IP和端口
                Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                server.Bind(localEndPoint); // 绑定IP+端口  
                server.Listen(10); // 开始监听  


                Method.writeLog("等待连接...");
                IAsyncResult res = server.BeginAccept(new AsyncCallback(AcceptTarget), server);
                //while (SendMsg)
                //{
                //    showMsg("ME: " + DateTimeOffset.Now.ToString("G"));
                //    ClientManager.SendMsgToClientList(BroadMsg);
                //}
                //server.Close();
                return true;
            }
            catch(Exception ex)
            {
                Method.writeLog(ex.Message.ToString());
                return false;
            }


        }
        // 监听请求  
        private void AcceptTarget(IAsyncResult res)
        {
            Socket server = (Socket)res.AsyncState;
            Socket client = server.EndAccept(res);
            string address = client.RemoteEndPoint.ToString();


            clientAdd(new ClientInfo() { Socket = client, Address = address, IsOpen = true });
            Method.writeLog(address + "连接进入");
            client.BeginReceive(oubytes, 0, oubytes.Length, SocketFlags.None, new AsyncCallback(ReceiveData), client);


            SendMsgUTF8ToClient("10", address);
            // 继续监听  
            server.BeginAccept(new AsyncCallback(AcceptTarget), server);
        }
        // 接收消息  
        private void ReceiveData(IAsyncResult res)
        {
            try
            {
                Socket client = (Socket)res.AsyncState;
                int size = client.EndReceive(res);
                if (ReadData != null)
                {
                    ReadData(oubytes, size);
                }
                // 继续等待  
                client.BeginReceive(oubytes, 0, oubytes.Length, SocketFlags.None, new AsyncCallback(ReceiveData), client);
            }
            catch(Exception ex)
            {
                Method.writeLog(ex.Message.ToString());
                Method.writeLog("一个客户端断开连接");
            }
        }
        private void SendTarget(IAsyncResult res)
        {
            //Socket client = (Socket)res.AsyncState;
            //int size = client.EndSend(res);
            //client.Shutdown(SocketShutdown.Both);
            //client.Close();
        }


        #region 客户端管理
        
        public void clientAdd(ClientInfo info)
        {
            if (!clientIsExist(info.Address))
            {
                clientList.Add(info);
            }
        }
        public bool clientIsExist(string address)
        {
            return clientList.Exists(item => string.Compare(address, item.Address, true) == 0);
        }
        public void clientClose(string address)
        {
            clientList.ForEach(item =>
            {
                if (string.Compare(address, item.Address, true) == 0)
                {
                    item.IsOpen = false;
                }
            });
        }
        // 发送消息到ClientList  
        public void SendMsgUTF8ToClient(string msg, string address = null)
        {
            byte[] bt = Encoding.UTF8.GetBytes(msg);
            clientList.ForEach(item =>
            {
                if (item.IsOpen && (address == null || item.Address == address))
                {
                    item.Socket.BeginSend(bt, 0, bt.Length, SocketFlags.None, new AsyncCallback(SendTarget), item.Socket);
                }
            });
        }
        public void SendMsgToClient(byte[] bt, string address = null)
        {
            clientList.ForEach(item =>
            {
                if (item.IsOpen && (address == null || item.Address == address))
                {
                    item.Socket.BeginSend(bt, 0, bt.Length, SocketFlags.None, new AsyncCallback(SendTarget), item.Socket);
                }
            });
        }
        #endregion
    }
    //保存客户端信息
    public class ClientInfo
    {
        public Socket Socket { get; set; }
        public bool IsOpen { get; set; }
        public string Address { get; set; }
    }
    #endregion


    #endregion


    #region UDP协议


    #region ClientUDP
    public class ClientUDP
    {
        //客户端 Socket对象
        private Socket clientSocket;
        //服务器端 终点
        private EndPoint epServer;
        //数据存放
        public byte[] oubytes;
        //解析数据委托
        public  ReadDataEvent ReadData;
        public ClientUDP()
        {
            oubytes = new byte[1024];
        }
        public  bool StartClient(string IP, int port)
        {
            try
            {
                //客户端Socket对象实例化
                clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
                //设置服务器端IP地址和对应端口
                IPEndPoint server = new IPEndPoint(IPAddress.Parse(IP), port);
                //实例化服务器端 终点
                epServer = (EndPoint)server;
                clientSocket.Connect(server);
                //byte[] sendData = Encoding.UTF8.GetBytes("连接");
                //clientSocket.BeginSendTo(sendData, 0, sendData.Length, SocketFlags.None, epServer, new AsyncCallback(SendTarget), null);
                clientSocket.BeginReceiveFrom(oubytes, 0, oubytes.Length, SocketFlags.None, ref epServer, new AsyncCallback(ReceiveData), null);
                return true;
            }
            catch (Exception ex)
            {
                Method.writeLog(ex.Message.ToString());
                return false;
            }
        }
        private void ReceiveData(IAsyncResult res)
        {
            try
            {
                int size = clientSocket.EndReceive(res);
                //将接收到的数据打印出来
                if (ReadData != null)
                {
                    ReadData(oubytes, size);
                }
                //继续接受数据
                clientSocket.BeginReceiveFrom(oubytes, 0, oubytes.Length, SocketFlags.None, ref epServer, new AsyncCallback(ReceiveData), null);
            }
            catch (Exception ex)
            {
                Method.writeLog(ex.Message.ToString());
                Method.writeLog("一个客户端断开连接");
            }
        }
        public bool SendData(byte[] Bytes)
        {
            try
            {
                clientSocket.BeginSendTo(Bytes, 0, Bytes.Length, SocketFlags.None, epServer, new AsyncCallback(SendTarget), null);
                return true;
            }
            catch (Exception ex)
            {
                Method.writeLog(ex.Message.ToString());
                return false;
            }
        }
        private void SendTarget(IAsyncResult res)
        {
            clientSocket.EndSend(res);
        }
    }
    #endregion


    #region ServiceUDP
    public class ServiceUDP
    {
        //服务器端Socket对象
        private Socket serverSocket;
        //客户端 终点
        private EndPoint epSender;
        //数据存放
        public byte[] oubytes;
        //解析数据委托
        public ReadDataEvent ReadData;
        public ServiceUDP()
        {
            oubytes = new byte[1024];
        }
        public bool OpenService(int port)
        {
            try
            {
                //实例化服务器端Socket对象
                serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
                //服务器端的IP和端口，IPAddress.Any实际是：0.0.0.0，表示任意，基本上表示本机IP
                IPEndPoint server = new IPEndPoint(IPAddress.Any, 9055);
                //Socket对象跟服务器端的IP和端口绑定
                serverSocket.Bind(server);
                //客户端的IP和端口，端口 0 表示任意端口
                IPEndPoint clients = new IPEndPoint(IPAddress.Any, 0);
                //实例化客户端 终点
                epSender = (EndPoint)clients;
                //开始异步接收消息  接收后，epSender存储的是发送方的IP和端口
                serverSocket.BeginReceiveFrom(oubytes, 0, oubytes.Length, SocketFlags.None, ref epSender, new AsyncCallback(ReceiveData), epSender);
                return true;
            }
            catch (Exception ex)
            {
                Method.writeLog(ex.Message.ToString());
                return false;
            }
        }
        private void ReceiveData(IAsyncResult res)
        {
            try
            {
                //结束异步接收消息  recv 表示接收到的字符数
                int size = serverSocket.EndReceiveFrom(res, ref epSender);
                if (ReadData != null)
                {
                    ReadData(oubytes, size);
                }
                //
                byte[] Bytes = Encoding.ASCII.GetBytes("10");
                serverSocket.BeginSendTo(Bytes, 0, Bytes.Length, SocketFlags.None, epSender, new AsyncCallback(SendTarget), epSender);
                // 继续等待  
                serverSocket.BeginReceiveFrom(oubytes, 0, oubytes.Length, SocketFlags.None, ref epSender, new AsyncCallback(ReceiveData), epSender);
            }
            catch (Exception ex)
            {
                Method.writeLog(ex.Message.ToString());
                Method.writeLog("一个客户端断开连接");
            }
        }
        public bool SendData(byte[] Bytes)
        {
            try
            {
                serverSocket.BeginSendTo(Bytes, 0, Bytes.Length, SocketFlags.None, epSender, new AsyncCallback(SendTarget), epSender);
                //server.BeginSend(Bytes, 0, Bytes.Length, SocketFlags.None, new AsyncCallback(SendTarget), server);
                return true;
            }
            catch (Exception ex)
            {
                Method.writeLog(ex.Message.ToString());
                return false;
            }
        }
        private static void SendTarget(IAsyncResult res)
        {
            //Socket client = (Socket)res.AsyncState;
            //int size = client.EndSend(res);
        }
    }
    #endregion


    #endregion


    public class Method
    {
        public static string GetHostIP()   //获取本地IP
        {
            System.Net.IPHostEntry IpEntry = System.Net.Dns.GetHostEntry(System.Net.Dns.GetHostName());
            for (int i = 0; i != IpEntry.AddressList.Length; i++)
            {
                //从IP地址列表中筛选出IPv4类型的IP地址
                //AddressFamily.InterNetwork表示此IP为IPv4,
                //AddressFamily.InterNetworkV6表示此地址为IPv6类型
                if (IpEntry.AddressList[i].AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
                {
                    return IpEntry.AddressList[i].ToString();
                }
            }
            return "";
        }


        public static void writeLog(string messge)
        {
            string LogtxtPath = System.Windows.Forms.Application.StartupPath + "\\Socketlog.txt";
            if (!File.Exists(LogtxtPath))
            {


                FileStream txtFile = new FileStream(LogtxtPath, FileMode.Create, FileAccess.Write);//创建写入文件 
                StreamWriter sw = new StreamWriter(txtFile, System.Text.Encoding.Unicode);
                sw.WriteLine(DateTime.Now + "-" + messge);//开始写入值
                sw.Close();
                txtFile.Close();


            }
            else
            {
                FileStream txtFile = new FileStream(LogtxtPath, FileMode.Append, FileAccess.Write);
                StreamWriter sw = new StreamWriter(txtFile, System.Text.Encoding.Unicode);
                sw.WriteLine(DateTime.Now + "-" + messge);//开始写入值
                sw.Close();
                txtFile.Close();
            }
        }
    }
}

C# socket编程 上位机一键修改plc参数 汇川TCP/UDP socket通讯示例，亲测可用，适合学习 通讯相关程序写成
05-23
C# socket编程 上位机一键修改plc参数 汇川TCP/UDP socket通讯示例，亲测可用，适合学习 通讯相关程序写成库，都是源码，可以直接复用 关键代码注释清晰 支持汇川全系列plc的modbusTCP通讯， 可以导入导出变量表
C# WPF Socket UDP通讯
05-12
C# WPF ，通过socket udp通讯方式与康耐视相机进行无协议实时通讯，已测试可行
C# UDP Socket 笔记
SangsDog的博客
07-28 1391
C# UDP Socket 笔记网络相关常用接口获取本地IPUDP简介初始化使用发广播收广播Socket简介服务端客户端断开 Socket 链接判断 Socket 是否是连接状态局域网聊天实现 （所有注释全部出自C#官方文档 地址） 网络相关常用接口 获取本地IP //通过网络接口描述来获取IP public static string GetLocalIP_LAN80211() { //GetAllNetworkInterfaces 返回描述本地计算
C# Socket通信从入门到精通（20）——UDP组播（多播）C#代码实现（史上最全）
qq_34059233的博客
10-15 3275
本文介绍的UDP多播是为了解决UDP广播和单播无法跨网段通信的问题，并详解介绍了C#代码实现，由高级工程师多年经验总结而成，绝对干货！
从业务视角看SAP利润中心会计：EC-PCA配置如何支撑多维度盈利分析？
最新发布
weixin_30566111的博客
04-21 378
本文深入探讨了SAP利润中心会计（EC-PCA）在多维度盈利分析中的关键作用。通过EC-PCA配置，企业能够灵活映射组织架构变化，实现跨区域、跨产品的精细化盈利分析。文章结合实战案例，详细解析了成本控制范围、利润中心组架构等核心配置策略，帮助财务管理者将技术参数转化为业务决策支持工具。
Socket通信讲解及C/S结构实现UDP协议通信
weixin_45266856的博客
05-29 3714
所谓套接字(Socket)，就是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象。一个套接字就是网络上进程通信的一端，提供了应用层进程利用网络协议交换数据的机制，是支持TCP/IP协议的路通信的基本操作单元。
C# 通过socket实现UDP 通信
aikb6223的博客
04-27 643
http://blog.csdn.net/u011484013/article/details/51131267 UDP不属于面向连接的通信，在选择使用协议的时候，选择UDP必须要谨慎。在网络质量令人十分不满意的环境下，UDP协议数据包丢失会比较严重。但是由于UDP的特性：它不属于连接型协议，因而具有资源消耗小，处理速度快的优点，所以通常音频、视频和普...
C#中Socket通信用法UDP方式和TCP方式
速冻的博客
03-26 762
本文实例讲述了C#中Socket通信用法。分享给大家供大家参考。具体如下： using using System.Net.Sockets; using System.Net; 一、UDP方式： 服务器端代码: static void Main(string[] args) { int recv; byte[] data = new byte[1024]; IPEndPoint ipe...
C# 使用 Socket (Udp + Tcp)
sudazf的专栏
06-29 5443
一个简单示例，记录下C#中如何使用Socket： 这个示例的作用是：服务端可以监测到是否和客户端连接，并且如果连上了，可以互相收发消息。如上图，我用的本机测试的，如果是不同机器且连着网，请换成对应的局域网ip或者公网映射ip. 步骤： 1.新增个空解决方案，并添加两个winform项目，一个是server端一个是client端： 2.在服务端和客户端分别加入如下代码： 服...
理解UDP、TCP通信的四篇宝典
彼岸花
12-31 1849
理解UDP、TCP通信的四篇宝典系列总结了C#网络通信的原理和简单的实现例程，适合初学者，简单、易懂、详尽。 第一篇 Socket编程 (连接,发送消息) (Tcp、Udp) 本篇文章主要实现Socket在Tcp\Udp协议下相互通讯的方式 (服务器端与客户端的通讯)。 1.基于Tcp协议的Socket通讯类似于B/S架构，面向连接，但不同的是服务器端可以向客户端主动推送消息
C#关于UDP通信的要点
枫杨的专栏
02-04 333
最后更新日期：2020/02/04 注：本文是博主使用C#对UDP通信的学习和测试记录(含网络资料的整理、体验等)，内容可能有错误或偏差，请谨慎采纳。 1.UDP不属于面向连接的通信，在选择使用协议的时候，选择UDP必须要谨慎。在网络质量令人十分不满意的环境下，UDP协议数据包丢失会比较严重。但是由于UDP的特性：它不属于连接型协议，因而具有资源消耗小，处理速度快的优点，所以通常音频、视频和...
c#使用UDP进行聊天通信
故里2130
08-13 6988
UDP和TCP都是网络通信中不可缺少的部分，两者在不同的环境中，应用的场景不一样，UDP在网络不好的情况下，传输会丢包，也就是会丢数据，而TCP不会这样，所以重要的数据使用TCP传输，但是TCP对网络的资源消耗非常的大，例如视频，音频等大量的数据，这个时候就选择UDP，因为UDP占用网络资源比较低，就算丢一帧二帧的图像的数据，也不会有影响的。介于单播和广播之间，也叫组播，从名字上面就能知道，建立一个组，然后向组内的人员发送消息，就类似，微信临时拉一个群，指定群内的人，向群内通知信息。............
C#的Socket实现UDP协议通信
04-24
C#的Socket实现UDP协议通信 CSharp
C#实现TCP和UDP通信
微小冷的学习笔记
03-01 2790
发送和接收看上去是对偶，但难度上完全是两回事，这种感觉就像你给女神发消息，其实很方便，按下发送键就完事儿了。但你等女神的消息，那就比较煎熬，因为你不确定她什么时候会发过来，所以得一直等着。所以，接收比发送麻烦多了，最起码得有一个死循环，如果对方没消息，就死等。
【C#网络编程】Socket，TCP，UDP
weixin_43676950的博客
10-16 2088
上一章节让我们对于套接字的概念有了一些了解，对于如何使用还是有所疑惑。下面让我们去学习一下这一章节，相信学习完这一章，你的疑惑一定能解开不少，让我们开始吧。TCP 旨在检测 IP 提供的主机到主机通道中可能发生的丢失、重复和其他错误，并从中恢复。TCP 提供了一个可靠的字节流通道，因此应用程序不必处理这些问题。它是一个面向连接的协议：在使用它进行通信之前，两个程序必须首先建立 TCP 连接，这涉及在两台通信计算机上的 TCP 实现之间完成握手消息的交换。使用 TCP 类似于文件输入/输出 （I/O）。
C# UDP通信
m0_49096264的博客
02-07 1860
本文介绍了一个基于Winfrom的UDP通信例程
C# Socket之UDP通信
weixin_43956644的博客
12-17 5846
Socket之间的通信可以类比生活中打电话的案例。任何用户在通话之前，首先要占有一部电话机，相当于申请一个Socket，同时要知道对方的号码，相当于对方有一个固定的Socket，然后向对方拨号呼叫，相当于发出连接请求。假如对方在场并空闲，拿起 电话话筒，双方就可以进行通话了。双方的通话过程，是一方向电话机发出信号和对方从电话机接收信号的过程，相当于向socket发送数据和从socket接收数据。通话结束后，一方挂起电话机，相当于关闭socket，撤销连接。 注意：Socket不仅可以在两台电脑之间通信，还可
C#-Socket
2303_76262050的博客
07-24 2445
2、发送Send/接收Receive。3、接收Receive/发送Send。1、创建Socket对象。1）客户端（发送端）示例。4、释放资源Close。
C#编程 socket编程之udp服务器端和客户端
diaosong8043的博客
12-16 789
基于Udp协议是无连接模式通讯，占用资源少，响应速度快，延时低。至于可靠性，可通过应用层的控制来满足。(不可靠连接) 使用Udp协议通讯需要具备以下几个条件： (1).建立一个套接字(Socket) (2).绑定服务器端IP地址及端口号--服务器端 (3).通过SendTo()方法向指定主机发送消息 (需提供主机IP地址及端口) (4).通过ReciveFrom()方法...
C# socket 通信服务概念及Tcp、Udp消息收发
Devout-mzc
09-08 685
使用指定的地址族、套接字类型和协议初始化 Socket 类的新实例。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值