AI 助理
备案控制台
开发者社区 人工智能 文章 正文

C#网络编程系列文章(一)之Socket实现异步TCP服务器

2017-12-05 2281
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

开篇

本人因为对于网络编程的喜爱，经常性的使用c#编写各类服务器(e.g TCP服务器，UDP服务器)，但是基本上都是搞着玩，网上也有很多讲c#网络编程的文章，当然我也参考了很多作者写的文章。看了这篇文章以后再也不用导出找资料了。微笑
本系列文章会依次介绍使用Socket实现的异步TCP服务器、同步TCP服务器、异步UDP服务器、同步UDP服务器 and 使用TcpListener和UdpClient实现的异步TCP服务器、同步TCP服务器、异步UDP服务器、同步UDP服务器。

Socket异步TCP服务器

相信搞过网络编程的人来说这个TCP一点也不陌生吧，在C#中微软已经帮我们封装过了一个TcpListener和TcpClient这两个类了，实现了对于套接字的封装，但是呢实际上还是不怎么好用，所以我们用Socket来实现一个异步的TCP服务器。
在本文中我只给出服务器端代码，客户端代码自己可以找找别处，毕竟我只是为了写出一个好的服务器端
下面是代码
[csharp] view plain copy
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Net;

namespace NetFrame.Net.TCP.Sock.Asynchronous
{

/// <summary>  
/// Socket实现的异步TCP服务器  
/// </summary>  
public class AsyncSocketTCPServer : IDisposable  
{  
    #region Fields  
    /// <summary>  
    /// 服务器程序允许的最大客户端连接数  
    /// </summary>  
    private int _maxClient;  

    /// <summary>  
    /// 当前的连接的客户端数  
    /// </summary>  
    private int _clientCount;  

    /// <summary>  
    /// 服务器使用的异步socket  
    /// </summary>  
    private Socket _serverSock;  

    /// <summary>  
    /// 客户端会话列表  
    /// </summary>  
    private List<AsyncSocketState> _clients;  

    private bool disposed = false;  

    #endregion  

    #region Properties  

    /// <summary>  
    /// 服务器是否正在运行  
    /// </summary>  
    public bool IsRunning { get; private set; }  
    /// <summary>  
    /// 监听的IP地址  
    /// </summary>  
    public IPAddress Address { get; private set; }  
    /// <summary>  
    /// 监听的端口  
    /// </summary>  
    public int Port { get; private set; }  
    /// <summary>  
    /// 通信使用的编码  
    /// </summary>  
    public Encoding Encoding { get; set; }  

    #endregion  

    #region 构造函数  

    /// <summary>  
    /// 异步Socket TCP服务器  
    /// </summary>  
    /// <param name="listenPort">监听的端口</param>  
    public AsyncSocketTCPServer(int listenPort)  
        : this(IPAddress.Any, listenPort,1024)  
    {  
    }  

    /// <summary>  
    /// 异步Socket TCP服务器  
    /// </summary>  
    /// <param name="localEP">监听的终结点</param>  
    public AsyncSocketTCPServer(IPEndPoint localEP)  
        : this(localEP.Address, localEP.Port,1024)  
    {  
    }  

    /// <summary>  
    /// 异步Socket TCP服务器  
    /// </summary>  
    /// <param name="localIPAddress">监听的IP地址</param>  
    /// <param name="listenPort">监听的端口</param>  
    /// <param name="maxClient">最大客户端数量</param>  
    public AsyncSocketTCPServer(IPAddress localIPAddress, int listenPort,int maxClient)  
    {  
        this.Address = localIPAddress;  
        this.Port = listenPort;  
        this.Encoding = Encoding.Default;  

        _maxClient = maxClient;  
        _clients = new List<AsyncSocketState>();  
        _serverSock = new Socket(localIPAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);  
    }  

    #endregion  

    #region Method  

    /// <summary>  
    /// 启动服务器  
    /// </summary>  
    public void Start()  
    {  
        if (!IsRunning)  
        {  
            IsRunning = true;  
            _serverSock.Bind(new IPEndPoint(this.Address, this.Port));  
            _serverSock.Listen(1024);  
            _serverSock.BeginAccept(new AsyncCallback(HandleAcceptConnected), _serverSock);  
        }  
    }  

    /// <summary>  
    /// 启动服务器  
    /// </summary>  
    /// <param name="backlog">  
    /// 服务器所允许的挂起连接序列的最大长度  
    /// </param>  
    public void Start(int backlog)  
    {  
        if (!IsRunning)  
        {  
            IsRunning = true;  
            _serverSock.Bind(new IPEndPoint(this.Address, this.Port));  
            _serverSock.Listen(backlog);  
            _serverSock.BeginAccept(new AsyncCallback(HandleAcceptConnected), _serverSock);  
        }  
    }  

    /// <summary>  
    /// 停止服务器  
    /// </summary>  
    public void Stop()  
    {  
        if (IsRunning)  
        {  
            IsRunning = false;  
            _serverSock.Close();  
            //TODO 关闭对所有客户端的连接  

        }  
    }  

    /// <summary>  
    /// 处理客户端连接  
    /// </summary>  
    /// <param name="ar"></param>  
    private void HandleAcceptConnected(IAsyncResult ar)  
    {  
        if (IsRunning)  
        {  
            Socket server = (Socket)ar.AsyncState;  
            Socket client = server.EndAccept(ar);  

            //检查是否达到最大的允许的客户端数目  
            if (_clientCount >= _maxClient)  
            {  
                //C-TODO 触发事件  
                RaiseOtherException(null);  
            }  
            else  
            {  
                AsyncSocketState state = new AsyncSocketState(client);  
                lock (_clients)  
                {  
                    _clients.Add(state);  
                    _clientCount++;  
                    RaiseClientConnected(state); //触发客户端连接事件  
                }  
                state.RecvDataBuffer = new byte[client.ReceiveBufferSize];  
                //开始接受来自该客户端的数据  
                client.BeginReceive(state.RecvDataBuffer, 0, state.RecvDataBuffer.Length, SocketFlags.None,  
                 new AsyncCallback(HandleDataReceived), state);  
            }  
            //接受下一个请求  
            server.BeginAccept(new AsyncCallback(HandleAcceptConnected), ar.AsyncState);  
        }  
    }  
    /// <summary>  
    /// 处理客户端数据  
    /// </summary>  
    /// <param name="ar"></param>  
    private void HandleDataReceived(IAsyncResult ar)  
    {  
        if (IsRunning)  
        {  
            AsyncSocketState state = (AsyncSocketState)ar.AsyncState;  
            Socket client = state.ClientSocket;  
            try  
            {  
                //如果两次开始了异步的接收,所以当客户端退出的时候  
                //会两次执行EndReceive  
                int recv = client.EndReceive(ar);  
                if (recv == 0)  
                {  
                    //C- TODO 触发事件 (关闭客户端)  
                    Close(state);  
                    RaiseNetError(state);  
                    return;  
                }  
                //TODO 处理已经读取的数据 ps:数据在state的RecvDataBuffer中  

                //C- TODO 触发数据接收事件  
                RaiseDataReceived(state);  
            }  
            catch (SocketException)  
            {  
                //C- TODO 异常处理  
                RaiseNetError(state);  
            }  
            finally  
            {  
                //继续接收来自来客户端的数据  
                client.BeginReceive(state.RecvDataBuffer, 0, state.RecvDataBuffer.Length, SocketFlags.None,  
                 new AsyncCallback(HandleDataReceived), state);  
            }  
        }  
    }  

    /// <summary>  
    /// 发送数据  
    /// </summary>  
    /// <param name="state">接收数据的客户端会话</param>  
    /// <param name="data">数据报文</param>  
    public void Send(AsyncSocketState state, byte[] data)  
    {  
        RaisePrepareSend(state);  
        Send(state.ClientSocket, data);  
    }  

    /// <summary>  
    /// 异步发送数据至指定的客户端  
    /// </summary>  
    /// <param name="client">客户端</param>  
    /// <param name="data">报文</param>  
    public void Send(Socket client, byte[] data)  
    {  
        if (!IsRunning)  
            throw new InvalidProgramException("This TCP Scoket server has not been started.");  

        if (client == null)  
            throw new ArgumentNullException("client");  

        if (data == null)  
            throw new ArgumentNullException("data");  
        client.BeginSend(data, 0, data.Length, SocketFlags.None,  
         new AsyncCallback(SendDataEnd), client);  
    }  

    /// <summary>  
    /// 发送数据完成处理函数  
    /// </summary>  
    /// <param name="ar">目标客户端Socket</param>  
    private void SendDataEnd(IAsyncResult ar)  
    {  
        ((Socket)ar.AsyncState).EndSend(ar);  
        RaiseCompletedSend(null);  
    }  
    #endregion  

    #region 事件  

    /// <summary>  
    /// 与客户端的连接已建立事件  
    /// </summary>  
    public event EventHandler<AsyncSocketEventArgs> ClientConnected;  
    /// <summary>  
    /// 与客户端的连接已断开事件  
    /// </summary>  
    public event EventHandler<AsyncSocketEventArgs> ClientDisconnected;  

    /// <summary>  
    /// 触发客户端连接事件  
    /// </summary>  
    /// <param name="state"></param>  
    private void RaiseClientConnected(AsyncSocketState state)  
    {  
        if (ClientConnected != null)  
        {  
            ClientConnected(this, new AsyncSocketEventArgs(state));  
        }  
    }  
    /// <summary>  
    /// 触发客户端连接断开事件  
    /// </summary>  
    /// <param name="client"></param>  
    private void RaiseClientDisconnected(Socket client)  
    {  
        if (ClientDisconnected != null)  
        {  
            ClientDisconnected(this, new AsyncSocketEventArgs("连接断开"));  
        }  
    }  

    /// <summary>  
    /// 接收到数据事件  
    /// </summary>  
    public event EventHandler<AsyncSocketEventArgs> DataReceived;  

    private void RaiseDataReceived(AsyncSocketState state)  
    {  
        if (DataReceived != null)  
        {  
            DataReceived(this, new AsyncSocketEventArgs(state));  
        }  
    }  

    /// <summary>  
    /// 发送数据前的事件  
    /// </summary>  
    public event EventHandler<AsyncSocketEventArgs> PrepareSend;  

    /// <summary>  
    /// 触发发送数据前的事件  
    /// </summary>  
    /// <param name="state"></param>  
    private void RaisePrepareSend(AsyncSocketState state)  
    {  
        if (PrepareSend != null)  
        {  
            PrepareSend(this, new AsyncSocketEventArgs(state));  
        }  
    }  

    /// <summary>  
    /// 数据发送完毕事件  
    /// </summary>  
    public event EventHandler<AsyncSocketEventArgs> CompletedSend;  
      
    /// <summary>  
    /// 触发数据发送完毕的事件  
    /// </summary>  
    /// <param name="state"></param>  
    private void RaiseCompletedSend(AsyncSocketState state)  
    {  
        if (CompletedSend != null)  
        {  
            CompletedSend(this, new AsyncSocketEventArgs(state));  
        }  
    }  

    /// <summary>  
    /// 网络错误事件  
    /// </summary>  
    public event EventHandler<AsyncSocketEventArgs> NetError;  
    /// <summary>  
    /// 触发网络错误事件  
    /// </summary>  
    /// <param name="state"></param>  
    private void RaiseNetError(AsyncSocketState state)  
    {  
        if (NetError != null)  
        {  
            NetError(this, new AsyncSocketEventArgs(state));  
        }  
    }  

    /// <summary>  
    /// 异常事件  
    /// </summary>  
    public event EventHandler<AsyncSocketEventArgs> OtherException;  
    /// <summary>  
    /// 触发异常事件  
    /// </summary>  
    /// <param name="state"></param>  
    private void RaiseOtherException(AsyncSocketState state, string descrip)  
    {  
        if (OtherException != null)  
        {  
            OtherException(this, new AsyncSocketEventArgs(descrip, state));  
        }  
    }  
    private void RaiseOtherException(AsyncSocketState state)  
    {  
        RaiseOtherException(state, "");  
    }  
    #endregion  

    #region Close  
    /// <summary>  
    /// 关闭一个与客户端之间的会话  
    /// </summary>  
    /// <param name="state">需要关闭的客户端会话对象</param>  
    public void Close(AsyncSocketState state)  
    {  
        if (state != null)  
        {  
            state.Datagram = null;  
            state.RecvDataBuffer = null;  

            _clients.Remove(state);  
            _clientCount--;  
            //TODO 触发关闭事件  
            state.Close();  
        }  
    }  
    /// <summary>  
    /// 关闭所有的客户端会话,与所有的客户端连接会断开  
    /// </summary>  
    public void CloseAllClient()  
    {  
        foreach (AsyncSocketState client in _clients)  
        {  
            Close(client);  
        }  
        _clientCount = 0;  
        _clients.Clear();  
    }  
    #endregion  

    #region 释放  
    /// <summary>  
    /// Performs application-defined tasks associated with freeing,   
    /// releasing, or resetting unmanaged resources.  
    /// </summary>  
    public void Dispose()  
    {  
        Dispose(true);  
        GC.SuppressFinalize(this);  
    }  

    /// <summary>  
    /// Releases unmanaged and - optionally - managed resources  
    /// </summary>  
    /// <param name="disposing"><c>true</c> to release   
    /// both managed and unmanaged resources; <c>false</c>   
    /// to release only unmanaged resources.</param>  
    protected virtual void Dispose(bool disposing)  
    {  
        if (!this.disposed)  
        {  
            if (disposing)  
            {  
                try  
                {  
                    Stop();  
                    if (_serverSock != null)  
                    {  
                        _serverSock = null;  
                    }  
                }  
                catch (SocketException)  
                {  
                    //TODO  
                    RaiseOtherException(null);  
                }  
            }  
            disposed = true;  
        }  
    }  
    #endregion  
}

}

事件参数类
[csharp] view plain copy
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace NetFrame.Net.TCP.Sock.Asynchronous
{

/// <summary>  
/// 异步Socket TCP事件参数类  
/// </summary>  
public class AsyncSocketEventArgs:EventArgs  
{  
    /// <summary>  
    /// 提示信息  
    /// </summary>  
    public string _msg;  

    /// <summary>  
    /// 客户端状态封装类  
    /// </summary>  
    public AsyncSocketState _state;  

    /// <summary>  
    /// 是否已经处理过了  
    /// </summary>  
    public bool IsHandled { get; set; }  

    public AsyncSocketEventArgs(string msg)  
    {  
        this._msg = msg;  
        IsHandled = false;  
    }  
    public AsyncSocketEventArgs(AsyncSocketState state)  
    {  
        this._state = state;  
        IsHandled = false;  
    }  
    public AsyncSocketEventArgs(string msg, AsyncSocketState state)  
    {  
        this._msg = msg;  
        this._state = state;  
        IsHandled = false;  
    }  
}

}

用户状态封装
[csharp] view plain copy
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;

namespace NetFrame.Net.TCP.Sock.Asynchronous
{

/// <summary>  
/// 异步SOCKET TCP 中用来存储客户端状态信息的类  
/// </summary>  
public class AsyncSocketState  
{  
    #region 字段  
    /// <summary>  
    /// 接收数据缓冲区  
    /// </summary>  
    private byte[] _recvBuffer;  

    /// <summary>  
    /// 客户端发送到服务器的报文  
    /// 注意:在有些情况下报文可能只是报文的片断而不完整  
    /// </summary>  
    private string _datagram;  

    /// <summary>  
    /// 客户端的Socket  
    /// </summary>  
    private Socket _clientSock;  

    #endregion  

    #region 属性  

    /// <summary>  
    /// 接收数据缓冲区   
    /// </summary>  
    public byte[] RecvDataBuffer  
    {  
        get  
        {  
            return _recvBuffer;  
        }  
        set  
        {  
            _recvBuffer = value;  
        }  
    }  

    /// <summary>  
    /// 存取会话的报文  
    /// </summary>  
    public string Datagram  
    {  
        get  
        {  
            return _datagram;  
        }  
        set  
        {  
            _datagram = value;  
        }  
    }  

    /// <summary>  
    /// 获得与客户端会话关联的Socket对象  
    /// </summary>  
    public Socket ClientSocket  
    {  
        get  
        {  
            return _clientSock;  

        }  
    }  

    #endregion  

    /// <summary>  
    /// 构造函数  
    /// </summary>  
    /// <param name="cliSock">会话使用的Socket连接</param>  
    public AsyncSocketState(Socket cliSock)  
    {  
        _clientSock = cliSock;  
    }  

    /// <summary>  
    /// 初始化数据缓冲区  
    /// </summary>  
    public void InitBuffer()  
    {  
        if (_recvBuffer == null&&_clientSock!=null)  
        {  
            _recvBuffer=new byte[_clientSock.ReceiveBufferSize];  
        }  
    }  

    /// <summary>  
    /// 关闭会话  
    /// </summary>  
    public void Close()  
    {  

        //关闭数据的接受和发送  
        _clientSock.Shutdown(SocketShutdown.Both);  

        //清理资源  
        _clientSock.Close();  
    }  
}

}

本文作者：博悦平台 本文地址http://www.hongshulin001.com 转载请注明出处

文章标签：
C#
网络协议
vr&ar
关键词：
tcp/ip协议网络编程
网络tcp
tcp云服务器 ECS
网络编程socket
网络socket
张博悦
目录
相关文章
cz游客
|
26天前
|
网络协议 安全 网络安全
网络编程：基于socket的TCP/IP通信。
网络编程：基于socket的TCP/IP通信。
cz游客
126 0
龙大吉
|
6天前
|
网络协议 安全 网络安全
震惊！Python Socket竟能如此玩转网络通信，基础到进阶全攻略！
【9月更文挑战第12天】在网络通信中，Socket编程是连接不同应用与服务的基石。本文通过问答形式，从基础到进阶全面解析Python Socket编程。涵盖Socket的重要性、创建TCP服务器与客户端、处理并发连接及进阶话题如非阻塞Socket、IO多路复用等，帮助读者深入了解并掌握网络通信的核心技术。
龙大吉
23 6
穿过生命散发芬芳
|
4天前
|
网络协议 Linux 应用服务中间件
Socket通信之网络协议基本原理
【9月更文挑战第14天】网络协议是机器间交流的约定格式，确保信息准确传达。主要模型有OSI七层与TCP/IP模型，通过分层简化复杂网络环境。IP地址全局定位设备，MAC地址则在本地网络中定位。网络分层后，数据包层层封装，经由不同层次协议处理，最终通过Socket系统调用在应用层解析和响应。
穿过生命散发芬芳
12 1
龙大吉
|
5天前
|
消息中间件 网络协议 网络安全
解锁Python Socket新姿势，进阶篇带你玩转高级网络通信技巧！
【9月更文挑战第13天】在掌握了Python Socket编程基础后，你是否想进一步提升技能？本指南将深入探讨Socket编程精髓，包括从阻塞到非阻塞I/O以提高并发性能，使用`select`进行非阻塞操作示例；通过SSL/TLS加密通信保障数据安全，附带创建SSL服务器的代码实例；以及介绍高级网络协议与框架，如HTTP、WebSocket和ZeroMQ，帮助你简化复杂应用开发。通过学习这些高级技巧，你将在网络编程领域更进一步。
龙大吉
19 2
做梦都在改BUG
|
1月前
|
分布式计算 网络协议 Python
Python网络编程：socket编程
Socket 编程是网络编程的重要部分，主要用于在不同计算机之间进行通信。Python 提供了一个非常强大的 socket 库，使得网络编程变得简单和灵活。本篇博文将详细介绍 Python 的 socket 编程，包括基础概念、核心组件、常用功能，并附上一个综合的示例及其运行结果。
做梦都在改BUG
39 12
热爱技术的小郑
|
30天前
|
网络协议 Java
一文讲明TCP网络编程、Socket套接字的讲解使用、网络编程案例
这篇文章全面讲解了基于Socket的TCP网络编程，包括Socket基本概念、TCP编程步骤、客户端和服务端的通信过程，并通过具体代码示例展示了客户端与服务端之间的数据通信。同时，还提供了多个案例分析，如客户端发送信息给服务端、客户端发送文件给服务端以及服务端保存文件并返回确认信息给客户端的场景。
热爱技术的小郑
68 0
一文讲明TCP网络编程、Socket套接字的讲解使用、网络编程案例
可能只会写BUG
|
14天前
|
存储 网络协议 安全
C语言 网络编程(五)Socket和端口
Socket 是 TCP/IP 五层网络模型中应用层的编程接口，用于实现不同主机间应用程序的双向通信。它作为网络通信的端点，连接应用层与网络协议栈，提供可靠的流式或非流式数据传输服务。Socket 包括流式（SOCKET_STREAM）、数据报（SOCK_DGRAM）和原始套接字（SOCK_RAW）三种类型，分别适用于不同场景。通过 IP 地址和端口号，Socket 能准确识别并转发数据包至指定进程。端口号分为知名端口（1-1023）、注册端口（1024-49151）和动态端口（49152-65535），确保数据准确交付。
可能只会写BUG
37 0
土木林森
|
18天前
|
网络协议 C# 开发者
WPF与Socket编程的完美邂逅：打造流畅网络通信体验——从客户端到服务器端，手把手教你实现基于Socket的实时数据交换
【8月更文挑战第31天】网络通信在现代应用中至关重要，Socket编程作为其实现基础，即便在主要用于桌面应用的Windows Presentation Foundation（WPF）中也发挥着重要作用。本文通过最佳实践，详细介绍如何在WPF应用中利用Socket实现网络通信，包括创建WPF项目、设计用户界面、实现Socket通信逻辑及搭建简单服务器端的全过程。具体步骤涵盖从UI设计到前后端交互的各个环节，并附有详尽示例代码，助力WPF开发者掌握这一关键技术，拓展应用程序的功能与实用性。
土木林森
39 0
土木林森
|
18天前
|
Rust 网络协议 安全
揭开Rust网络编程的神秘面纱：全新的Socket体验，让你告别内存泄漏的噩梦！
【8月更文挑战第31天】Rust语言凭借其卓越的内存安全性和高性能，在网络编程领域展现出独特优势。本文将带你探索Rust中的Socket编程，展示如何使用标准库`std::net`模块轻松实现TCP服务器与客户端。通过简洁的代码示例，你将看到Rust如何简化网络通信流程，并通过`async/await`异步模型高效处理并发连接。此外，Rust社区提供的优秀库如`tokio`和`async-std`进一步增强了异步网络编程的能力。无论是从基础示例还是高级应用，Rust都将为你带来耳目一新的网络编程体验。
土木林森
57 0
穿过生命散发芬芳
|
22天前
|
网络协议 Linux 应用服务中间件
Socket通信之网络协议基本原理
【8月更文挑战第27天】网络协议定义了机器间通信的标准格式，确保信息准确无损地传输。主要分为两种模型：OSI七层模型与TCP/IP模型。
穿过生命散发芬芳
14 0

热门文章

最新文章

  • 1
    7-1 网络编程技术(下)-2
  • 2
    python网络编程学习笔记（1）
  • 3
    Windows Phone 7 网络编程之调用WCF Service
  • 4
    Python网络编程1--笔记
  • 5
    Windows Phone 7 网络编程之RSS阅读器
  • 6
    Java网络编程总结 --URLConnection
  • 7
    Java网络编程从入门到精通（33）：非阻塞I/O的缓冲区（Buffer）
  • 8
    Linux网络编程之原始套接字-ping协议实现
  • 9
    GO语言练习：网络编程 TCP 示例
  • 10
    Python网络编程 - 一个简单的客户端Get请求程序
  • 1
    ELAN：用于图像超分辨率的高效远程注意力网络
    134
  • 2
    构建未来：AI驱动的自适应网络安全防御系统
    187
  • 3
    m基于深度学习网络的手势识别系统matlab仿真,包含GUI界面
    100
  • 4
    基于yolov2深度学习网络的视频手部检测算法matlab仿真
    108
  • 5
    Linux 常用命令汇总（五）：网络操作命令
    61
  • 6
    网络技术基础（16）——DHCP中继
    103
  • 7
    网络技术基础（15）——DHCP简介与配置
    728
  • 8
    网络技术基础（14）——ACL访问控制列表
    553
  • 9
    P2P网络下分布式文件共享场景的测试
    267
  • 10
    【spring（六）】WebSocket网络传输协议
    60

    • 相关课程

    更多
  • 云计算工程师解析与实战-网络专家篇（体验版）
  • 云网络白皮书-阿里云网络系列课
  • Python网络编程
  • 企业上云攻略-阿里云网络产品应用系列教程
  • Linux网络进阶 - TCP/IP协议及OSI七层模型
  • 网络管理者必知-2分钟了解新出台的《网络安全法》

    • 相关电子书

    更多
  • 可编程网络视角的网络创新研究
  • 可编程网络和SDN3.0
  • 开放促进创新：构建开放网络生态

    • 相关实验场景

    更多
  • 通过云拨测对指定服务器进行Ping/DNS监测
  • 容器的网络入门
  • 容器的自定义网络
  • 容器的共享网络模型
  • 使用阿里云容器服务和容器网络文件系统搭建WordPress网站
    • 下一篇
    基于LNMP搭建WordPress