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

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

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

开篇

本人因为对于网络编程的喜爱，经常性的使用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
关键词：
C# socket
tcp云服务器 ECS
网络tcp
C#服务器
C#异步
张博悦
目录
相关文章
长梦
|
3月前
|
C# 开发者
C# 一分钟浅谈：Socket 编程基础
【10月更文挑战第7天】本文介绍了Socket编程的基础知识、基本操作及常见问题，通过C#代码示例详细展示了服务器端和客户端的Socket通信过程，包括创建、绑定、监听、连接、数据收发及关闭等步骤，帮助开发者掌握Socket编程的核心技术和注意事项。
长梦
128 3
C# 一分钟浅谈：Socket 编程基础
蓝易云
|
15天前
|
网络协议 C# 开发工具
C#中简单Socket编程
1. 先运行服务器代码。服务器将开始监听指定的IP和端口，等待客户端连接。 1. 然后运行客户端代码。客户端将连接到服务器并发送消息。 1. 服务器接收到消息后，将回应客户端，并在控制台上显示接收到的消息。 1. 客户端接收到服务器的回应消息，并在控制台上显示。
蓝易云
55 15
jsjsjjs
|
28天前
|
负载均衡 网络协议 算法
不为人知的网络编程(十九)：能Ping通，TCP就一定能连接和通信吗？
这网络层就像搭积木一样，上层协议都是基于下层协议搭出来的。不管是ping（用了ICMP协议）还是tcp本质上都是基于网络层IP协议的数据包，而到了物理层，都是二进制01串，都走网卡发出去了。 如果网络环境没发生变化，目的地又一样，那按道理说他们走的网络路径应该是一样的，什么情况下会不同呢？ 我们就从路由这个话题聊起吧。
jsjsjjs
63 4
不为人知的网络编程(十九)：能Ping通，TCP就一定能连接和通信吗？
vohelon
|
3月前
|
域名解析 网络协议 数据库
TCP/IP服务器
【10月更文挑战第20天】TCP/IP服务器
vohelon
136 65
技术内容小助手
|
24天前
|
网络协议
TCP报文格式全解析：网络小白变高手的必读指南
本文深入解析TCP报文格式，涵盖源端口、目的端口、序号、确认序号、首部长度、标志字段、窗口大小、检验和、紧急指针及选项字段。每个字段的作用和意义详尽说明，帮助理解TCP协议如何确保可靠的数据传输，是互联网通信的基石。通过学习这些内容，读者可以更好地掌握TCP的工作原理及其在网络中的应用。
技术内容小助手
243 3
最好zzz
|
2月前
|
监控 网络协议 网络性能优化
网络通信的核心选择：TCP与UDP协议深度解析
在网络通信领域，TCP（传输控制协议）和UDP（用户数据报协议）是两种基础且截然不同的传输层协议。它们各自的特点和适用场景对于网络工程师和开发者来说至关重要。本文将深入探讨TCP和UDP的核心区别，并分析它们在实际应用中的选择依据。
最好zzz
74 3
长梦
|
2月前
|
设计模式 API C#
C# 一分钟浅谈：GraphQL 服务器端实现
本文通过C#语言从零开始构建一个简单的GraphQL服务器端实现，介绍了环境准备、项目创建、定义Schema、配置GraphQL等步骤。同时，探讨了常见问题如数据源问题、类型定义不一致、性能问题和权限控制，提供了相应的解决方法。希望帮助读者更好地理解和应用GraphQL。
长梦
44 3
沙漠尽头的狼
|
3月前
|
消息中间件 网络协议 C#
C#使用Socket实现分布式事件总线，不依赖第三方MQ
`CodeWF.EventBus.Socket` 是一个轻量级的、基于Socket的分布式事件总线系统，旨在简化分布式架构中的事件通信。它允许进程之间通过发布/订阅模式进行通信，无需依赖外部消息队列服务。
沙漠尽头的狼
74 6
C#使用Socket实现分布式事件总线，不依赖第三方MQ
zzy的aly
|
3月前
|
Python
Socket学习笔记(二):python通过socket实现客户端到服务器端的图片传输
使用Python的socket库实现客户端到服务器端的图片传输，包括客户端和服务器端的代码实现，以及传输结果的展示。
zzy的aly
192 3
Socket学习笔记(二):python通过socket实现客户端到服务器端的图片传输
zzy的aly
|
3月前
|
JSON 数据格式 Python
Socket学习笔记(一):python通过socket实现客户端到服务器端的文件传输
本文介绍了如何使用Python的socket模块实现客户端到服务器端的文件传输，包括客户端发送文件信息和内容，服务器端接收并保存文件的完整过程。
zzy的aly
217 1
Socket学习笔记(一):python通过socket实现客户端到服务器端的文件传输

热门文章

最新文章

  • 1
    阿里云先知安全沙龙(武汉站) - 网络空间安全中的红蓝对抗实践
  • 2
    TCP报文格式全解析：网络小白变高手的必读指南
  • 3
    云原生应用网关进阶：阿里云网络ALB Ingress 全能增强
  • 4
    基于改进遗传优化的BP神经网络金融序列预测算法matlab仿真
  • 5
    Linux网络文件系统NFS：配置与管理指南
  • 6
    网络安全视角：从地域到账号的阿里云日志审计实践
  • 7
    什么是零信任模型？如何实施以保证网络安全？
  • 8
    基于AI的网络流量分析：构建智能化运维体系
  • 9
    动态IP代理技术详解及网络性能优化
  • 10
    揭示Transformer重要缺陷！北大提出傅里叶分析神经网络FAN，填补周期性特征建模缺陷
  • 1
    【Azure Function】C#独立工作模式下参数类型 ServiceBusReceivedMessage 无法正常工作
    89
  • 2
    code runner 运行C#项目
    68
  • 3
    C#中简单Socket编程
    56
  • 4
    C#集合数据去重的5种方式及其性能对比测试分析
    34
  • 5
    C#/.NET/.NET Core拾遗补漏合集（24年12月更新）
    35
  • 6
    C#/.NET/.NET Core技术前沿周刊 | 第 15 期（2024年11.25-11.30）
    34
  • 7
    基于 C# 编写的 Visual Studio 文件编码显示与修改扩展插件
    35
  • 8
    C#/.NET/.NET Core技术前沿周刊 | 第 16 期（2024年12.01-12.08）
    30
  • 9
    一个包含了 50+ C#/.NET编程技巧实战练习教程
    69
  • 10
    C#集合数据去重的5种方式及其性能对比测试分析
    43

    • 相关课程

    更多
  • 企业上云攻略-阿里云网络产品应用系列教程
  • Linux网络进阶 - TCP/IP协议及OSI七层模型
  • 网络管理者必知-2分钟了解新出台的《网络安全法》
  • 7天玩转云服务器
  • 云服务器选型、迁云最佳实践
  • 云服务器ECS基本操作

    • 相关电子书

    更多
  • 如何运维千台以上游戏云服务器
  • 网站/服务器取证 实践与挑战
  • ECS块储存产品全面解析

    • 相关实验场景

    更多
  • 基于ECS和OSS快速搭建个人简历网站
  • 使用ECS和RDS搭建个人博客
  • 利用云备份Cloud Backup实现ECS文件备份
  • 基于ECS搭建FTP服务
  • 使用ECS和OSS搭建个人网盘
  • 基于ECS搭建云上博客
    • 下一篇
    DataWorks智能交互式数据开发与分析之旅