AI 助理
备案控制台
开发者社区 云原生 文章 正文

Socket编程 (异步通讯) (Tcp,Udp) - Part2

2013-05-16 1933
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 原文 http://www.cnblogs.com/zengqinglei/archive/2013/04/30/3051629.html Socket编程(异步通讯)（Tcp,Udp） 　　上一章主要展示了Socket的Tcp\Udp两种协议下的基本通讯方式，属于同步通讯。

原文 http://www.cnblogs.com/zengqinglei/archive/2013/04/30/3051629.html

Socket编程(异步通讯)（Tcp,Udp）

　　上一章主要展示了Socket的Tcp\Udp两种协议下的基本通讯方式，属于同步通讯。至于一个服务器对应多个客户端，或者对应多个请求，我们采用的是多线程的方式来解决此问题。然而本章节我们将有更好的方式去实现它：Socket在Tcp\Udp两种协议下的异步通讯方式。

基于Tcp协议异步：

　　BeginAccept方法和EndAccept方法

　　包含在System.Net.Sockets命名空间下。异步Tcp使用BeginAccept方法开始接受新的客户端连接请求，该方法中系统自动利用线程池创建需要的线程，并在操作完成时利用异步回调机制调用提供给它的方法，同时返回相应的状态参数，然后方可利用EndAccept方法结束该连接请求.

　　BeginRecive方法和EndRecive方法

　　异步Tcp使用BeginRecive方法和开始接受客户端发送的的消息，该方法如上同理，接受完毕后调用回调函数传递相应的状态参数。利用EndRecive方法接受接受消息。

　　至于BeginSend方法和EndSend方法、BeginConnect方法和EndConnect方法与上类似。

 

下面我们来看看如何在Tcp协议下进行客户端与服务器端之间的通讯：

服务器端：　　

复制代码 
using System;
using System.Collections.Generic;
using System.Text;
#region 命名空间
using System.Net;
using System.Net.Sockets;
using System.Threading;
#endregion

namespace AsynServerConsole
{
    /// <summary>
    /// Tcp协议异步通讯类(服务器端)
    /// </summary>
    public class AsynTcpServer
    {
        #region Tcp协议异步监听
        /// <summary>
        /// Tcp协议异步监听
        /// </summary>
        public void StartListening()
        {
            //主机IP
            IPEndPoint serverIp = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8686);
            Socket tcpServer = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            tcpServer.Bind(serverIp);
            tcpServer.Listen(100);
            Console.WriteLine("异步开启监听...");
            AsynAccept(tcpServer);
        }
        #endregion

        #region 异步连接客户端
        /// <summary>
        /// 异步连接客户端
        /// </summary>
        /// <param name="tcpServer"></param>
        public void AsynAccept(Socket tcpServer)
        {
            tcpServer.BeginAccept(asyncResult =>
            {
                Socket tcpClient = tcpServer.EndAccept(asyncResult);
                Console.WriteLine("server<--<--{0}", tcpClient.RemoteEndPoint.ToString());
                AsynSend(tcpClient, "收到连接...");//发送消息
                AsynAccept(tcpServer);
                AsynRecive(tcpClient);
            }, null);
        }
        #endregion

        #region 异步接受客户端消息
        /// <summary>
        /// 异步接受客户端消息
        /// </summary>
        /// <param name="tcpClient"></param>
        public void AsynRecive(Socket tcpClient)
        {
            byte[] data = new byte[1024];
            try
            {
                tcpClient.BeginReceive(data, 0, data.Length, SocketFlags.None,
                asyncResult =>
                {
                    int length = tcpClient.EndReceive(asyncResult);
                    Console.WriteLine("server<--<--client:{0}", Encoding.UTF8.GetString(data));
                    AsynSend(tcpClient, "收到消息...");
                    AsynRecive(tcpClient);
                }, null);
            }
            catch (Exception ex)
            {
                Console.WriteLine("异常信息：", ex.Message);
            }
        }
        #endregion

        #region 异步发送消息
        /// <summary>
        /// 异步发送消息
        /// </summary>
        /// <param name="tcpClient">客户端套接字</param>
        /// <param name="message">发送消息</param>
        public void AsynSend(Socket tcpClient, string message)
        {
            byte[] data = Encoding.UTF8.GetBytes(message);
            try
            {
                tcpClient.BeginSend(data, 0, data.Length, SocketFlags.None, asyncResult =>
                {
                    //完成发送消息
                    int length = tcpClient.EndSend(asyncResult);
                    Console.WriteLine("server-->-->client:{0}", message);
                }, null);
            }
            catch (Exception ex)
            {
                Console.WriteLine("异常信息：{0}", ex.Message);
            }
        }
        #endregion
    }
}
复制代码

 

客户端：

复制代码 
using System;
using System.Collections.Generic;
using System.Text;
#region 命名空间
using System.Net;
using System.Net.Sockets;
using System.Threading;
#endregion

namespace AsynClientConsole
{
    /// <summary>
    /// Tcp协议异步通讯类(客户端)
    /// </summary>
    public class AsynTcpClient
    {
        #region 异步连接
        /// <summary>
        /// Tcp协议异步连接服务器
        /// </summary>
        public void AsynConnect()
        {
            //主机IP
            IPEndPoint serverIp = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8686);
            Socket tcpClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            tcpClient.BeginConnect(serverIp, asyncResult =>
            {
                tcpClient.EndConnect(asyncResult);
                Console.WriteLine("client-->-->{0}", serverIp.ToString());
                AsynSend(tcpClient, "我上线了...");
                AsynSend(tcpClient, "第一次发送消息...");
                AsynSend(tcpClient, "第二次发送消息...");
                AsynRecive(tcpClient);
            }, null);
        }
        #endregion

        #region 异步接受消息
        /// <summary>
        /// 异步连接客户端回调函数
        /// </summary>
        /// <param name="tcpClient"></param>
        public void AsynRecive(Socket tcpClient)
        {
            byte[] data = new byte[1024];
            tcpClient.BeginReceive(data, 0, data.Length, SocketFlags.None, asyncResult =>
            {
                int length = tcpClient.EndReceive(asyncResult);
                Console.WriteLine("client<--<--server:{0}", Encoding.UTF8.GetString(data));
                AsynRecive(tcpClient);
            }, null);
        }
        #endregion

        #region 异步发送消息
        /// <summary>
        /// 异步发送消息
        /// </summary>
        /// <param name="tcpClient">客户端套接字</param>
        /// <param name="message">发送消息</param>
        public void AsynSend(Socket tcpClient, string message)
        {
            byte[] data = Encoding.UTF8.GetBytes(message);
            tcpClient.BeginSend(data, 0, data.Length, SocketFlags.None, asyncResult =>
            {
                //完成发送消息
                int length = tcpClient.EndSend(asyncResult);
                Console.WriteLine("client-->-->server:{0}", message);
            }, null);
        }
        #endregion
    }
}
复制代码

通讯效果如下图：

服务器：

客户端：

上面我们完成了基于Tcp协议下的Socket通讯，那么Udp协议下的通讯我们将以什么样的形式来通讯呢？毕竟Udp协议下是无连接模式。

基于Udp协议的异步通讯：

　　其实与Tcp协议具有的方法类似，但由于Udp协议是无连接模式，我们所用到方法就无BeginConnect和EndConnect方法。我们所要做的就是收发消息的处理。

　　在Udp协议的异步通讯中，我们需要注意一下几个编程点：

　　1.在EndRecive方法中，由于无状态返回模式，不能返回发送端的Remote，所以我们需要在该方法中获取活动端的Remote，然后利用EndRecive方法结束接受该消息接受。

　　2.客户端由于无需Connect到服务器端，但是需要先向服务器端发送一个请求如Send一些消息。让服务器端确定自己Remote，然后可利用Recive方法接收其他终端发送过来的消息。

下面将演示Udp协议下异步通讯：

服务器端：

 

复制代码 
using System;
using System.Collections.Generic;
using System.Text;
#region 命名空间
using System.Net;
using System.Net.Sockets;
using System.Threading;
#endregion

namespace AsynServerConsole
{
    /// <summary>
    /// Udp协议异步通讯类(服务器端)
    /// </summary>
    public class AsynUdpServer
    {
        #region 容器对象
        /// <summary>
        /// 容器对象
        /// </summary>
        public class StateObject
        {
            //服务器端
            public Socket udpServer = null;
            //接受数据缓冲区
            public byte[] buffer = new byte[1024];
            //远程终端
            public EndPoint remoteEP;
        }

        public StateObject state;
        #endregion

        #region 服务器绑定终端节点
        public void ServerBind()
        {
            //主机IP
            IPEndPoint serverIp = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8686);
            Socket udpServer = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
            udpServer.Bind(serverIp);
            Console.WriteLine("server ready...");
            IPEndPoint clientIp = new IPEndPoint(IPAddress.Any, 0);
            state = new StateObject();
            state.udpServer = udpServer;
            state.remoteEP = (EndPoint)clientIp;
            AsynRecive();
        }
        #endregion

        #region 异步接受消息
        public void AsynRecive()
        {
            state.udpServer.BeginReceiveFrom(state.buffer, 0, state.buffer.Length, SocketFlags.None, ref state.remoteEP,
                new AsyncCallback(ReciveCallback), null);
        }
        #endregion

        #region 异步接受消息回调函数
        public void ReciveCallback(IAsyncResult asyncResult)
        {
            if (asyncResult.IsCompleted)
            {
                //获取发送端的终节点
                IPEndPoint ipep = new IPEndPoint(IPAddress.Any, 0);
                EndPoint remoteEP = (EndPoint)ipep;
                state.udpServer.EndReceiveFrom(asyncResult, ref remoteEP);
                Console.WriteLine("server<--<--client:{0}", Encoding.UTF8.GetString(state.buffer));
                //向发送端通知：收到消息
                state.remoteEP = remoteEP;
                AsynSend("收到消息");
                //继续接受消息
                AsynRecive();
            }
        }
        #endregion

        #region 异步发送消息
        public void AsynSend(string message)
        {
            Console.WriteLine("server-->-->client:{0}", message);
            byte[] buffer = Encoding.UTF8.GetBytes(message);
            state.udpServer.BeginSendTo(buffer, 0, buffer.Length, SocketFlags.None, state.remoteEP,
                new AsyncCallback(SendCallback), null);
        }
        #endregion

        #region 异步发送消息回调函数
        public void SendCallback(IAsyncResult asyncResult)
        {
            //消息发送完毕
            if (asyncResult.IsCompleted)
            {
                state.udpServer.EndSendTo(asyncResult);
            }
        }
        #endregion
    }
}
复制代码

 

客户端：

 

 

复制代码 
using System;
using System.Collections.Generic;
using System.Text;
#region 命名空间
using System.Net;
using System.Net.Sockets;
using System.Threading;
#endregion

namespace AsynClientConsole
{
    /// <summary>
    /// Udp协议异步通讯类(客户端)
    /// </summary>
    public class AsynUdpClient
    {
        #region 容器对象
        /// <summary>
        /// 容器对象
        /// </summary>
        public class StateObject
        {
            //客户端套接字
            public Socket udpClient = null;
            //接收信息缓冲区
            public byte[] buffer = new byte[1024];
            //服务器端终节点
            public IPEndPoint serverIp;
            //远程终端节点
            public EndPoint remoteEP;
        }

        public StateObject state;
        #endregion

        #region 客户端初始化
        public void InitClient()
        {
            state = new StateObject();
            state.udpClient = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
            state.serverIp = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8686);
            state.remoteEP = (EndPoint)(new IPEndPoint(IPAddress.Any, 0));
            //此处注意：
            //  由于当前是客户端，所以没有绑定终节点
            //  不可直接接收消息，必须先向其他终端发送信息告知本机终节点
            AsynSend("第1次发送消息");
            AsynSend("第2次发送消息");
            AsynRecive();
        }
        #endregion

        #region 异步接收来自其他终端发送的消息
        public void AsynRecive()
        {
            state.udpClient.BeginReceiveFrom(state.buffer, 0, state.buffer.Length, SocketFlags.None, ref state.remoteEP,
                new AsyncCallback(ReciveCallback), null);
        }
        #endregion

        #region 异步接收来自其他终端发送的消息回调函数
        public void ReciveCallback(IAsyncResult asyncResult)
        {
            //信息接收完成
            if (asyncResult.IsCompleted)
            {
                state.udpClient.EndReceiveFrom(asyncResult, ref state.remoteEP);
                Console.WriteLine("client<--<--{0}:{1}", state.remoteEP.ToString(), Encoding.UTF8.GetString(state.buffer));
                AsynRecive();
            }
        }
        #endregion

        #region 异步发送消息
        public void AsynSend(string message)
        {
            Console.WriteLine("client-->-->{0}:{1}", state.serverIp.ToString(), message);
            byte[] buffer = Encoding.UTF8.GetBytes(message);
            state.udpClient.BeginSendTo(buffer, 0, buffer.Length, SocketFlags.None, state.serverIp,
                new AsyncCallback(SendCallback), null);
        }
        #endregion

        #region 异步发送消息回调函数
        public void SendCallback(IAsyncResult asyncResult)
        {
            //消息发送完成
            if (asyncResult.IsCompleted)
            {
                state.udpClient.EndSendTo(asyncResult);
            }
        }
        #endregion
    }
}
复制代码

 

通讯效果如下图：

 

服务器：

 

客户端：

 

总结：基于异步模式的通讯无须采用多线程来服务多个客户端以及多个请求，这样的通讯模式效率更高。

　　同步上面Tcp效果展示图，我们发现客户端分几次连续发送的消息被服务器端一次接收了，读成了一条数据，而这就是Socket通讯基于Tcp协议下发生的粘包问题，下面一种我们将着重对Tcp协议的通讯信息封包，拆包以解决上面问题。

　　同样Udp协议通讯下属于无连接模式通讯，客户端只管将消息发送出去，或者由于网络原因，而造成的丢包问题，下一章也将采用一定的方式解决。

最后附上源码：Socket-Part2.zip

作者：曾庆雷
出处：http://www.cnblogs.com/zengqinglei
本页版权归作者和博客园所有，欢迎转载，但未经作者同意必须保留此段声明， 且在文章页面明显位置给出原文链接，否则保留追究法律责任的权利
文章标签：
网络协议
容器
Java
关键词：
tcp UDP
tcp/ip协议通讯
UDP tcp
socket通讯
tcp/ip协议udp
杰克.陈
目录
相关文章
最好zzz
|
3月前
|
网络协议 机器人 C++
KUKA机器人Socket通讯配置方法：技术干货分享
【10月更文挑战第7天】在现代自动化生产线上，KUKA机器人凭借其高效、灵活和精确的特点，成为众多企业的首选。为了实现KUKA机器人与其他设备或系统之间的数据交互，Socket通讯配置显得尤为重要。本文将详细介绍KUKA机器人Socket通讯的配置方法，帮助大家在工作中更好地掌握这一技术。
最好zzz
360 2
蓝易云
|
3月前
|
网络协议 Linux 网络性能优化
Linux基础-socket详解、TCP/UDP
综上所述，Linux下的Socket编程是网络通信的重要组成部分，通过灵活运用TCP和UDP协议，开发者能够构建出满足不同需求的网络应用程序。掌握这些基础知识，是进行更复杂网络编程任务的基石。
蓝易云
193 1
bruce_xiaowei
|
3月前
|
网络协议 测试技术 网络安全
Python编程-Socket网络编程
Python编程-Socket网络编程
bruce_xiaowei
34 0
热爱技术的小郑
|
5月前
|
网络协议 Java
一文讲明TCP网络编程、Socket套接字的讲解使用、网络编程案例
这篇文章全面讲解了基于Socket的TCP网络编程，包括Socket基本概念、TCP编程步骤、客户端和服务端的通信过程，并通过具体代码示例展示了客户端与服务端之间的数据通信。同时，还提供了多个案例分析，如客户端发送信息给服务端、客户端发送文件给服务端以及服务端保存文件并返回确认信息给客户端的场景。
热爱技术的小郑
431 0
一文讲明TCP网络编程、Socket套接字的讲解使用、网络编程案例
穿过生命散发芬芳
|
4月前
|
网络协议 Linux
TCP 和 UDP 的 Socket 调用
【9月更文挑战第6天】
穿过生命散发芬芳
43 0
东方睿赢
|
6月前
|
网络协议 开发者 Python
深度探索Python Socket编程：从理论到实践，进阶篇带你领略网络编程的魅力！
【7月更文挑战第25天】在网络编程中, Python Socket编程因灵活性强而广受青睐。本文采用问答形式深入探讨其进阶技巧。**问题一**: Socket编程基于TCP/IP,通过创建Socket对象实现通信,支持客户端和服务器间的数据交换。**问题二**: 提升并发处理能力的方法包括多线程(适用于I/O密集型任务)、多进程(绕过GIL限制)和异步IO(asyncio)。**问题三**: 提供了一个使用asyncio库实现的异步Socket服务器示例,展示如何接收及响应客户端消息。通过这些内容,希望能激发读者对网络编程的兴趣并引导进一步探索。
东方睿赢
67 4
龙大吉
|
6月前
|
开发者 Python
Python Socket编程：不只是基础，更有进阶秘籍，让你的网络应用飞起来！
【7月更文挑战第25天】在网络应用蓬勃发展的数字时代，Python凭借其简洁的语法和强大的库支持成为开发高效应用的首选。本文通过实时聊天室案例，介绍了Python Socket编程的基础与进阶技巧，包括服务器与客户端的建立、数据交换等基础篇内容，以及使用多线程和异步IO提升性能的进阶篇。基础示例展示了服务器端监听连接请求、接收转发消息，客户端连接服务器并收发消息的过程。进阶部分讨论了如何利用Python的`threading`模块和`asyncio`库来处理多客户端连接，提高应用的并发处理能力和响应速度。掌握这些技能，能使开发者在网络编程领域更加游刃有余，构建出高性能的应用程序。
龙大吉
40 3
众所周知
|
6月前
|
网络协议 Python
网络世界的建筑师：Python Socket编程基础与进阶，构建你的网络帝国！
【7月更文挑战第26天】在网络的数字宇宙中，Python Socket编程是开启网络世界大门的钥匙。本指南将引领你从基础到实战，成为网络世界的建筑师。
众所周知
70 2
土木林森
|
6月前
|
网络协议 程序员 视频直播
Python Socket编程秘籍：从基础概念到实战应用，助你成为网络编程高手！
【7月更文挑战第26天】
土木林森
77 2
东方睿赢
|
6月前
|
消息中间件 网络协议 网络安全
Python Socket编程：打造你的专属网络通道，基础篇与进阶篇一网打尽！
【7月更文挑战第26天】在网络编程领域，Python以简洁语法和强大库支持成为构建应用的首选。Socket编程为核心，实现计算机间的数据交换。
东方睿赢
77 1