.net Socket 网络编程(四)

最新推荐文章于 2026-04-02 12:07:58 发布
原创 最新推荐文章于 2026-04-02 12:07:58 发布 · 1.5k 阅读 · 3 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#socket #.net #编程 #网络 #byte
#string
本文介绍了一个使用.NET框架实现的异步Socket服务器与客户端程序。通过IAsyncResult模式，文章详细展示了如何构建异步监听和处理客户端连接请求的方法。此外，还讨论了如何确保数据完整接收及发送，并提供了一种通过特定标记判断数据接收完毕的方式。

 在(三)中我们用多线程简单实现了异步，这里用微软为我们提供的IAsyncResult模式来实现

现在代码增多了，把处理套接字的部分单独创建一个类SocketServer
代码如下，同时仍然保留了同步的Listen方法，这里异步的监听命名为AsyncListen

class SocketServer
    {
        private int _port;
        private string _ip;
        private string _hostName;
        private int _backlog; //队列连接数

    private IPEndPoint ipEndPoint;
        private IPAddress ipAddress;
        private IPHostEntry ipHostEntry;
        private Socket listener;

        public int Port
        {
            get { return _port; }
            set { _port = value; }
        }
        public int BackLog
        {
            get { return _backlog; }
            set { _backlog = value; }
        }
        public string IP
        {
            get { return _ip; }
            set { _ip = value; }
        }
        public string HostName
        {
            get { return _hostName; }
            set { _hostName = value; }
        }    


        public UploadServer()
        {
            listener = null;
            _ip = "127.0.0.1";
            _port = 7788;
            _backlog = 10;
            _hostName = String.Empty;
        }

        /// <summary>
        /// 初始化服务器地址
    /// </summary>
        private void InitIPInfo()
        {
            if (_ip == String.Empty)
            {
                if (_hostName != String.Empty)
                {
                    ipHostEntry = Dns.GetHostEntry(_hostName);
                    ipAddress = ipHostEntry.AddressList[0];
                }
                else
                {
                    throw new Exception("未指定有效服务器地址");
                }
            }
            else
            {
                ipAddress = IPAddress.Parse(_ip);
                ipHostEntry = Dns.GetHostEntry(ipAddress);
            }
            ipEndPoint = new IPEndPoint(ipAddress, _port);
        }

        public void Listen()
        {
            InitIPInfo();
            listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            listener.Bind(ipEndPoint);
            listener.Listen(_backlog);
            Console.WriteLine("服务启动，开始监听");
            Console.WriteLine("等待客户端连接...");

            Socket clientSocket = listener.Accept();
            Console.WriteLine("建立连接");

            // 接受数据
      byte[] buffer = new byte[1024];
            clientSocket.Receive(buffer);
            Console.WriteLine("接受客户端信息：{0}", Encoding.GetEncoding("gb2312").GetString(buffer));
            //回复客户端
      byte[] backBuffer = new byte[1024];
            string backString = "收到数据";

            backBuffer = Encoding.GetEncoding("gb2312").GetBytes(backString);
            clientSocket.Send(backBuffer);

            clientSocket.Shutdown(SocketShutdown.Both);
            clientSocket.Close();
            Console.WriteLine("关闭客户端连接");
        }

        public void AsyncListen()
        {
            InitIPInfo();

            listener = new Socket(ipEndPoint.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);

            listener.Bind(ipEndPoint);
            listener.Listen(_backlog);

            Console.WriteLine("服务启动，开始监听");
            Console.WriteLine("等待客户端连接...");

            listener.BeginAccept(new AsyncCallback(acceptCallback), listener);
        }

        private void acceptCallback(IAsyncResult ar) 
        {
            Socket listener = (Socket)ar.AsyncState;
            Socket clientSocket = listener.EndAccept(ar); //获得客户端套接字接口
      Console.WriteLine("建立连接");

            StateObject state = new StateObject();
            state.WorkSocket = clientSocket;
            clientSocket.BeginReceive(state.buffer, 0, StateObject.BufferSize, SocketFlags.None, new AsyncCallback(readCallback), state); //开始接受数据
        }

        public class StateObject
        {
            public Socket WorkSocket = null;
            public static int BufferSize = 1024;
            public byte[] buffer = new byte[BufferSize];
        }

        //结束挂起的异步读取
        public static void readCallback(IAsyncResult ar)
        {
            StateObject state = (StateObject)ar.AsyncState;
            Socket clientSocket = state.WorkSocket;

            if (clientSocket.Connected)
            {
                int read = clientSocket.EndReceive(ar);//结束挂起的异步读取


        //一直接受数据到没有为止
        if (read > 0)
                {
                    clientSocket.BeginReceive(state.buffer, 0, StateObject.BufferSize, SocketFlags.None, new AsyncCallback(readCallback), state);
                }

                Console.WriteLine("接受客户端信息：{0}", Encoding.GetEncoding("gb2312").GetString(state.buffer));
                //回复客户端
                byte[] backBuffer = new byte[1024];
                string backString = "收到数据";

                backBuffer = Encoding.GetEncoding("gb2312").GetBytes(backString);
                clientSocket.Send(backBuffer);
                clientSocket.Close();
            }
            else
            {
                Console.WriteLine("连接已经关闭！");
            }
            
        }

    }

在Program.cs如下调用

SocketServer us = new SocketServer();
us.AsyncListen();

OK运行查看效果

上面的例子基本实现，实际存在问题还很多
比如
如果客户端传送的数据一次接受不完
没有服务器端向客户端发送信息
而且判断是否接受完客户端数据上面的例子也有问题，下面来完善一下

class SocketServer
    {
        private int _port;
        private string _ip;
        private string _hostName;
        private int _backlog; //队列连接数

    private IPEndPoint ipEndPoint;
        private IPAddress ipAddress;
        private IPHostEntry ipHostEntry;
        private Socket listener;

        private static ManualResetEvent allDone = new ManualResetEvent(false);

        public int Port
        {
            get { return _port; }
            set { _port = value; }
        }
        public int BackLog
        {
            get { return _backlog; }
            set { _backlog = value; }
        }
        public string IP
        {
            get { return _ip; }
            set { _ip = value; }
        }
        public string HostName
        {
            get { return _hostName; }
            set { _hostName = value; }
        }

        public class StateObject
        {
            public Socket WorkSocket = null;
            public static int BufferSize = 2;
            public byte[] buffer = new byte[BufferSize];
            public StringBuilder sb = new StringBuilder();
        }

        public SocketServer()
        {
            listener = null;
            _ip = "127.0.0.1";
            _port = 7788;
            _backlog = 10;
            _hostName = String.Empty;

        }

        /// <summary>
        /// 初始化服务器地址
    /// </summary>
        private void InitIPInfo()
        {
            if (_ip == String.Empty)
            {
                if (_hostName != String.Empty)
                {
                    ipHostEntry = Dns.GetHostEntry(_hostName);
                    ipAddress = ipHostEntry.AddressList[0];
                }
                else
                {
                    throw new Exception("未指定有效服务器地址");
                }
            }
            else
            {
                ipAddress = IPAddress.Parse(_ip);
                ipHostEntry = Dns.GetHostEntry(ipAddress);
            }
            ipEndPoint = new IPEndPoint(ipAddress, _port);
        }

        public void Listen()
        {
            InitIPInfo();
            listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            listener.Bind(ipEndPoint);
            listener.Listen(_backlog);
            Console.WriteLine("服务启动，开始监听");
            Console.WriteLine("等待客户端连接...");

            Socket clientSocket = listener.Accept();
            Console.WriteLine("建立连接");

            // 接受数据
      byte[] buffer = new byte[1024];
            clientSocket.Receive(buffer);
            Console.WriteLine("接受客户端信息：{0}", Encoding.GetEncoding("gb2312").GetString(buffer));
            //回复客户端
            byte[] backBuffer = new byte[1024];
            string backString = "收到数据";

            backBuffer = Encoding.GetEncoding("gb2312").GetBytes(backString);
            clientSocket.Send(backBuffer);

            clientSocket.Shutdown(SocketShutdown.Both);
            clientSocket.Close();
            Console.WriteLine("关闭客户端连接");
        }

        public void AsyncListen()
        {
            InitIPInfo();

            listener = new Socket(ipEndPoint.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);

            try
            {
                listener.Bind(ipEndPoint);
                listener.Listen(_backlog);

                Console.WriteLine("服务启动，开始监听");
                Console.WriteLine("等待客户端连接...");
                while (true)
                {
                    allDone.Reset();
                    listener.BeginAccept(new AsyncCallback(acceptCallback), listener);
                    allDone.WaitOne();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("发生错误:"+ex.Message);
            }
            
        }

        private void acceptCallback(IAsyncResult ar) 
        {
            Console.WriteLine("acceptCallback 被调用");
            Socket listener = (Socket)ar.AsyncState;
            Socket clientSocket = listener.EndAccept(ar); //获得客户端套接字接口
      Console.WriteLine("建立连接");
            allDone.Set();

            StateObject state = new StateObject();
            state.WorkSocket = clientSocket;
            clientSocket.BeginReceive(state.buffer, 0, StateObject.BufferSize, SocketFlags.None, new AsyncCallback(readCallback), state); //开始接受数据

        }

        public void readCallback(IAsyncResult ar)
        {
            StateObject state = (StateObject)ar.AsyncState;
            Socket clientSocket = state.WorkSocket;

            try
            {
                int read = 0;
                read = clientSocket.EndReceive(ar);//结束挂起的异步读取

        if (read > 0)
                {
                    state.sb.Append(Encoding.GetEncoding("gb2312").GetString(state.buffer, 0, read));
                    Console.WriteLine(state.sb.ToString());

                    if (state.sb.ToString().IndexOf("<end>") > -1)
                    {

                        Console.WriteLine("已经接收完数据");
                        //回复客户端
            byte[] backBuffer = new byte[1024];
                        string backString = "已经收到数据";

                        backBuffer = Encoding.GetEncoding("gb2312").GetBytes(backString);
                        clientSocket.BeginSend(backBuffer, 0, backBuffer.Length, SocketFlags.None, new AsyncCallback(SendCallback), state);
                    }
                    else
                    {
                        clientSocket.BeginReceive(state.buffer, 0, StateObject.BufferSize, SocketFlags.None, new AsyncCallback(readCallback), state);
                    }
                }
            }
            catch (SocketException se)
            {
                if (se.ErrorCode == 10054)
                {
                    Console.WriteLine("客户端已断开连接！");
                }
                else
                {
                    Console.WriteLine(se.Message);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }

            
        }

        private void SendCallback(IAsyncResult ar)
        {
            Console.WriteLine("SendCallback 被调用");
            try
            {
                StateObject state = (StateObject)ar.AsyncState;
                Socket handle = state.WorkSocket;
                int bytesSent = handle.EndSend(ar);
                Console.WriteLine("发送到客户端 {0}", bytesSent);
                Console.WriteLine("接受客户端信息：{0}",state.sb.ToString() );
                handle.Shutdown(SocketShutdown.Both);
                handle.Close();

            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }

    }


这里判断客户端传送数据是否接受完成时个比较麻烦的问题
这里在客户端传入的字符串中用了<end>标志来判断
如果使用EndReceive的返回值是否大于1来判断会出现无法调用委托方法的情况也不报错
因为当没有数据传输到服务器端的时候BeginReceive并不会调用委托
自己感觉靠添加额外定制符号的办法不是很让人舒服，暂时也没有其他好的解决办法，如果有朋友知道告诉我一下哈：）

下面贴出客户端修改为异步以后的代码

    public class StateObject
    {
        public Socket workSocket = null;
        public static int BufferSize = 1024;
        public byte[] buffer = new byte[BufferSize];
        public StringBuilder sb = new StringBuilder();
    }


    class SocketClient
    {
        private int _port;
        private string _ip;
        private string _hostName;

        private IPEndPoint ipEndPoint;
        private IPAddress ipAddress;
        private IPHostEntry ipHostEntry;

        private static ManualResetEvent connectDone = new ManualResetEvent(false);
        private static ManualResetEvent sendDone = new ManualResetEvent(false);
        private static ManualResetEvent receiveDone = new ManualResetEvent(false);
        private static String response = String.Empty; //服务器返回的信息

        public int Port
        {
            get { return _port; }
            set { _port = value; }
        }
        public string IP
        {
            get { return _ip; }
            set { _ip = value; }
        }
        public string HostName
        {
            get { return _hostName; }
            set { _hostName = value; }
        }

        private void InitIPInfo()
        {
            if (_ip == String.Empty)
            {
                if (_hostName != String.Empty)
                {
                    ipHostEntry = Dns.GetHostEntry(_hostName);
                    ipAddress = ipHostEntry.AddressList[0];
                }
                else
                {
                    throw new Exception("未指定有效服务器地址");
                }
            }
            else
            {
                ipAddress = IPAddress.Parse(_ip);
                ipHostEntry = Dns.GetHostEntry(ipAddress);
            }
            ipEndPoint = new IPEndPoint(ipAddress, _port);
        }

        public UploadClient()
        {
            _ip = "127.0.0.1";
            _port = 7788;
            _hostName = String.Empty;
        }

        public void Connect()
        {
            InitIPInfo();

            try
            {
                ///创建socket并连接到服务器
                Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                Console.WriteLine("等待连接…");
                serverSocket.Connect(ipEndPoint);//连接到服务器
                Console.WriteLine("已连接");

                //发送数据
                byte[] buffer = new byte[1024];
                buffer = Encoding.GetEncoding("gb2312").GetBytes("Godling is a good man!<end>");
                serverSocket.Send(buffer);

                //接受数据
                byte[] bufferGet = new byte[1024];
                serverSocket.Receive(bufferGet);
                Console.WriteLine("接受服务端信息：{0}", Encoding.GetEncoding("gb2312").GetString(bufferGet));

                serverSocket.Shutdown(SocketShutdown.Both);
                serverSocket.Close();

            }
            catch (ArgumentNullException e)
            {
                Console.WriteLine("argumentNullException: {0}", e);
            }
            catch (SocketException e)
            {
                Console.WriteLine("SocketException:{0}", e);
            }

            Console.WriteLine("Press Enter to Exit");
        }

        //开始异步连接
        public void AsyncConnect()
        {
            try
            {
                InitIPInfo();

                Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                serverSocket.BeginConnect(ipEndPoint, new AsyncCallback(ConnectCallback), serverSocket);
                connectDone.WaitOne(); //阻止运行直到连接成功

                //发送数据
                string data = "你能收到我吗？<end>";
                byte[] byteData = Encoding.GetEncoding("gb2312").GetBytes(data);
                serverSocket.BeginSend(byteData, 0, byteData.Length, SocketFlags.None, new AsyncCallback(SendCallback), serverSocket);
                sendDone.WaitOne();


                StateObject state = new StateObject();
                state.workSocket = serverSocket;
                serverSocket.BeginReceive(state.buffer, 0, StateObject.BufferSize, SocketFlags.None, new AsyncCallback(ReceiveCallback), state);
                receiveDone.WaitOne();
                Console.WriteLine("接收到服务器信息：{0}", response);

                serverSocket.Shutdown(SocketShutdown.Both);
                serverSocket.Close();
            }
            catch(Exception ex)
            {
                Console.WriteLine("发生异常"+ex.Message);
            }

        }

        // 连接完成回调方法
        private void ConnectCallback(IAsyncResult ar)
        {
            try
            {
                Socket serverSocket = (Socket)ar.AsyncState;
                serverSocket.EndConnect(ar);
                Console.WriteLine("已连接到{0}",serverSocket.RemoteEndPoint.ToString());

                connectDone.Set();
            }
            catch (Exception e)
            {
                Console.WriteLine("连接错误！"+e.ToString());
            }

        }

        // 数据发送回调方法
        private static void SendCallback(IAsyncResult ar)
        {
            try
            {
                Socket serverSocket = (Socket)ar.AsyncState;
                int bytesSent = serverSocket.EndSend(ar);
                Console.WriteLine("向服务器发送数据 {0} bytes", bytesSent);

                sendDone.Set();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }

        // 接收数据回调方法
        private static void ReceiveCallback(IAsyncResult ar)
        {
            StateObject state = (StateObject)ar.AsyncState;
            Socket serverSocket = state.workSocket;

            int read = 0;

            if (serverSocket.Connected)
            {
                read = serverSocket.EndReceive(ar);
            }
            if (read > 0)
            {
                state.sb.Append(Encoding.GetEncoding("gb2312").GetString(state.buffer, 0, read));
                try
                {
                    serverSocket.BeginReceive(state.buffer, 0, StateObject.BufferSize, SocketFlags.None, new AsyncCallback(ReceiveCallback), state);
                }
                catch (SocketException se)
                {
                    if (se.ErrorCode == 10054)
                    {
                        Console.WriteLine("远程主机已经断开连接！");
                    }
                }
            }
            else
            {
                if (state.sb.Length > 1)
                {
                    response = state.sb.ToString();
                }
                receiveDone.Set();
            }
            
        }




    }
muduo网络库：各类功能
zxf347085420的博客
12-12 1147
readCallback_、writeCallback_、errorCallback_、closeCallback_：一系列的回调函数，用于处理不同类型的事件。} // 检查是否没有感兴趣的事件。用户会自定义 [连接建立/关闭后的处理函数] 、[收到消息后的处理函数]、[消息发送完后的处理函数]以及Muduo库中定义的[连接关闭后的处理函数]。updateChannel(Channel channel)： 更新一个Channel，即在Poller中更新该Channel所关注的事件。
续实例解析SOCKET编程模型之异步通信篇（上）
06-20 1139
http://dev.csdn.net/develop/article/26/26762.shtm    .NET 框架的 Socket 类实际上是 Winsock32 API 提供的套接字服务的托管代码版本。其中Socket 类为网络通信提供了一套丰富的方法和属性，大多数情况下，Socket 类方法只是将数据封送到它们的本机Win32 副本中并处理任何必要的安全检查。Socket 类
服务器监听类Acceptor及Tcp连接TcpConnection的建立与关闭（fd耗尽的解决方案）
Likes的博客
04-22 1334
https://blog.csdn.net/sinat_35261315/article/details/78343266 通常服务器在处理客户端连接请求时，为了不阻塞在accept函数上，会将监听套接字注册到io复用函数中，当客户端请求连接时，监听套接字变为可读，随后在回调函数调用accept接收客户端连接。muduo将这一部分封装成了Acceptor类，用于执行接收客户端请求的任务。 类...
Channel事件管理类实现(模块三)
weixin_67595436的博客
02-04 476
类功能 类定义 类实现
【C#网络编程】Socket，TCP，UDP
weixin_43676950的博客
10-16 2091
上一章节让我们对于套接字的概念有了一些了解，对于如何使用还是有所疑惑。下面让我们去学习一下这一章节，相信学习完这一章，你的疑惑一定能解开不少，让我们开始吧。TCP 旨在检测 IP 提供的主机到主机通道中可能发生的丢失、重复和其他错误，并从中恢复。TCP 提供了一个可靠的字节流通道，因此应用程序不必处理这些问题。它是一个面向连接的协议：在使用它进行通信之前，两个程序必须首先建立 TCP 连接，这涉及在两台通信计算机上的 TCP 实现之间完成握手消息的交换。使用 TCP 类似于文件输入/输出 （I/O）。
关于VB.NET使用Socket网络编程
cncbook1979的博客
05-21 406
例如：\n\n5.2.1 TCP/IP协议\nTCP/IP协议是在网络编程中常用的协议之一，它是一种面向连接的协议，能够保证数据传输的可靠性和顺序性。\n\n5.2.2 UDP协议\nUDP协议是另一种常用的协议，它是一种无连接的协议，不保证数据传输的可靠性和顺序性，但是具有较高的传输速度。\n\n5.2.4 HTTP协议\nHTTP协议是应用最广泛的协议之一，它是一种基于请求和响应的协议，常用于Web应用程序的通信。HTTP协议是一种无状态的、面向文本的协议，它使用请求-响应模式进行通信。
.net网络编程之一:Socket编程
木月的专栏
11-17 857
在.net下进行网络编程其实也相对比较简单，因为在.net类库已经提供了大量封装好的类。在.net下网络编程比较底层的类是System.Net.Sockets.Socket类，这个类提供了丰富的方法和属性，并且还提供了异步数据传输支持。对Socket类做一个简单的介绍，它有如下常见方法：public Socket Accept ()：为新建连接创建新的 Socket。    public void
C#网络编程实战：创建Socket聊天室
weixin_31419153的博客
08-08 931
网络编程是开发网络应用的基础，C#作为一种现代编程语言，提供了强大的网络通信能力。C#的网络编程能力主要依靠.NET框架中的System.Net和System.Net.Sockets命名空间。通过这些命名空间中的类和方法，开发者可以轻松创建客户端和服务器程序，实现数据在网络上的发送和接收。在本章中，我们将首先了解网络编程的基本概念和C#网络编程的相关技术基础，然后逐步深入了解如何使用C#中的Socket类进行详细的网络通信操作。
[C#] .net网络编程之一:Socket编程
火星人的充电房
06-02 632
 在.net下进行网络编程其实也相对比较简单，因为在.net类库已经提供了大量封装好的类。在.net下网络编程比较底层的类是System.Net.Sockets.Socket类，这个类提供了丰富的方法和属性，并且还提供了异步数据传输支持。对Socket类做一个简单的介绍，它有如下常见方法：public Socket Accept ()：为新建连接创建新的 Socket。    publ
.net中socket编程
qq_43430964的博客
11-12 1489
在.net下进行网络编程其实也相对比较简单，因为在.net类库已经提供了大量封装好的类。在.net下网络编程比较底层的类是System.Net.Sockets.Socket类，这个类提供了丰富的方法和属性，并且还提供了异步数据传输支持。 对Socket类做一个简单的介绍，它有如下常见方法： public Socket Accept ()：为新建连接创建新的 Socket。 public void Bind (EndPoint localEP)：使 Socket 与一个本地终结点相关联。 public voi
nix 网络编程权威指南：socket、net、ifaddrs 完整解析
最新发布
gitblog_00119的博客
04-02 897
nix 是一个为 Rust 开发者提供友好的 *nix 系统 API 绑定的开源项目，它简化了在 Rust 中进行系统编程的复杂度，尤其是在网络编程领域。本文将全面解析 nix 库中的 socket、net 和 ifaddrs 模块，帮助开发者快速掌握 Rust 网络编程的核心技能。 ## 一、nix 网络编程核心模块概览 📚 nix 库将网络相关功能组织在多个模块中，其中最核心的包括：
C#网络编程之 socket
u012802070的专栏
12-25 617
一、C# .NET 网络编程相关类 IPAddress 类 用于表示一个 IP 地址，常用构造方法： IPAddress address = IPAddress.Parse("192.168.1.1"); IPAddress 类还有其他的一些共用方法，具体可以在IPAddress类查询。 DNS 类 它是一个静态类，主要用途将主机名和电子邮件目标地址映射成 IP 地址，即域名解析功能。常用方法如下： DNS 类还提供了异步的方法，具体可以参考DNS 类。 IPEndP...
C# 网络编程之 socket 编程
summer
12-22 2121
一、C# .NET 网络编程相关类 IPAddress 类 用于表示一个 IP 地址，常用构造方法： IPAddress address = IPAddress.Parse("192.168.1.1"); IPAddress 类还有其他的一些共用方法，具体可以在 IPAddress类 查询。 DNS 类 它是一个静态类，主要用途将主机名和电子邮件目标地址映射成 IP 地址，即域名解
net网络编程之一 Socket编程
ytfghytf的博客
11-07 866
net网络编程之一 Socket编程
.NET TCP、UDP、Socket、WebSocket
唐宋元明清2188
10-26 816
【声明】CSDN只做转发不做时时更新，最新博客请关注博客园做.NET应用开发肯定会用到网络通信，而进程间通信是客户端开发使用频率较高的场景。进程间通信方式主要有命名管道、消息队列、共享内存、Socket通信，个人使用最多的是Sokcet相关。而Socket也有很多使用方式，Socket、WebSocket、TcpClient、UdpClient，是不是很多？HttpClient与TcpClient、WebSocket之间有什么关系？这里我们分别介绍下这些通信及使用方式。
.NET Socket网络编程
何鹏飞的博客
07-27 421
在.NET中，可以使用System.Net.Sockets命名空间中的类来实现Socket编程。在进行Socket编程时，还可以使用其他相关的类和方法，如TcpListener、UdpClient、SocketAsyncEventArgs等，以实现更加灵活的功能。需要注意的是，在.NET中还有其他一些相关的类和方法，例如TcpListener、UdpClient、SocketAsyncEventArgs等，可以更加灵活地实现Socket编程。
Go 语言使用 net 包实现 Socket 网络编程
Meng小羽的个人博客
05-25 742
友情提示：此篇文章大约需要阅读10分钟12秒，不足之处请多指教，感谢你的阅读。订阅本站 此文章首发于 Debug客栈 ｜https://www.debuginn.cn TCP/IP TCP/IP 传输协议，即传输控制/网络协议，也叫作网络通讯协议。它是在网络的使用中的最基本的通信协议。TCP/IP 传输协议对互联网中各部分进行通信的标准和方法进行了规定。并且，TCP/IP 传输协议是保证网络数据信息及时、完整传输的两个重要的协议。TCP/IP 传输协议是严格来说是一个四层的体系结构，应用层、传输层、.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值