NET平台下TCP实现IOCP例子

最新推荐文章于 2024-09-09 17:19:39 发布
最新推荐文章于 2024-09-09 17:19:39 发布
阅读量984 收藏 2
点赞数
分类专栏： .NET Winform/WPF 计算机网络 网络安全

MainForm.cs窗体代码:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Net;
using System.Text;
using System.Windows.Forms;

namespace IocpServer
{
    public partial class MainForm : Form
    {
        public delegate void SetListBoxCallBack(string str);
        public SetListBoxCallBack setlistboxcallback;
        public void SetListBox(string str)
        {
            infoList.Items.Insert(0, str);
            infoList.SelectedIndex = 0;
        }

        private IoServer iocp = new IoServer(2, 1024);

        public MainForm()
        {
            InitializeComponent();
            #region 初始化IP 和端口号
            IPAddress[] addressList = Dns.GetHostEntry(Environment.MachineName).AddressList;
            ipStr.Text = addressList[addressList.Length - 1].ToString();

            portStr.Text = "1086";
            #endregion
            setlistboxcallback = new SetListBoxCallBack(SetListBox);
        }

        private void startBtn_Click(object sender, EventArgs e)
        {
            iocp.Start(1086);
            iocp.mainForm = this;
            startBtn.Enabled = false;
            stopBtn.Enabled = true;
            SetListBox("监听开启...");
        }

        private void stopBtn_Click(object sender, EventArgs e)
        {
            iocp.Stop();
            startBtn.Enabled = true;
            stopBtn.Enabled = false;
            SetListBox("监听停止...");
        }

        private void exitBtn_Click(object sender, EventArgs e)
        {
            if (stopBtn.Enabled)
                iocp.Stop();
            this.Close();
        }

        private void clearBtn_Click(object sender, EventArgs e)
        {
            infoList.Items.Clear();
        }

    }
}

IoServer.cs

基于SocketAsyncEventArgs 实现 IOCP 服务器

using System;
using System.Collections.Generic;
using System.Text;
using System.Net.Sockets;
using System.Threading;
using System.Net;

namespace IocpServer
{
    /// <summary>
    /// 基于SocketAsyncEventArgs 实现 IOCP 服务器
    /// </summary>
    internal sealed class IoServer
    {
        /// <summary>
        /// 监听Socket，用于接受客户端的连接请求
        /// </summary>
        private Socket listenSocket;

        /// <summary>
        /// 用于服务器执行的互斥同步对象
        /// </summary>
        private static Mutex mutex = new Mutex();

        /// <summary>
        /// 用于每个I/O Socket操作的缓冲区大小
        /// </summary>
        private Int32 bufferSize;

        /// <summary>
        /// 服务器上连接的客户端总数
        /// </summary>
        private Int32 numConnectedSockets;

        /// <summary>
        /// 服务器能接受的最大连接数量
        /// </summary>
        private Int32 numConnections;

        /// <summary>
        /// 完成端口上进行投递所用的IoContext对象池
        /// </summary>
        private IoContextPool ioContextPool;

        public MainForm mainForm;

        /// <summary>
        /// 构造函数，建立一个未初始化的服务器实例
        /// </summary>
        /// <param name="numConnections">服务器的最大连接数据</param>
        /// <param name="bufferSize"></param>
        internal IoServer(Int32 numConnections, Int32 bufferSize)
        {
            this.numConnectedSockets = 0;
            this.numConnections = numConnections;
            this.bufferSize = bufferSize;

            this.ioContextPool = new IoContextPool(numConnections);

            // 为IoContextPool预分配SocketAsyncEventArgs对象
            for (Int32 i = 0; i < this.numConnections; i++)
            {
                SocketAsyncEventArgs ioContext = new SocketAsyncEventArgs();
                ioContext.Completed += new EventHandler<SocketAsyncEventArgs>(OnIOCompleted);
                ioContext.SetBuffer(new Byte[this.bufferSize], 0, this.bufferSize);

                // 将预分配的对象加入SocketAsyncEventArgs对象池中
                this.ioContextPool.Add(ioContext);
            }
        }

        /// <summary>
        /// 当Socket上的发送或接收请求被完成时，调用此函数
        /// </summary>
        /// <param name="sender">激发事件的对象</param>
        /// <param name="e">与发送或接收完成操作相关联的SocketAsyncEventArg对象</param>
        private void OnIOCompleted(object sender, SocketAsyncEventArgs e)
        {
            // Determine which type of operation just completed and call the associated handler.
            switch (e.LastOperation)
            {
                case SocketAsyncOperation.Receive:
                    this.ProcessReceive(e);
                    break;
                case SocketAsyncOperation.Send:
                    this.ProcessSend(e);
                    break;
                default:
                    throw new ArgumentException("The last operation completed on the socket was not a receive or send");
            }
        }

        /// <summary>
        ///接收完成时处理函数
        /// </summary>
        /// <param name="e">与接收完成操作相关联的SocketAsyncEventArg对象</param>
        private void ProcessReceive(SocketAsyncEventArgs e)
        {
            // 检查远程主机是否关闭连接
            if (e.BytesTransferred > 0)
            {
                if (e.SocketError == SocketError.Success)
                {
                    Socket s = (Socket)e.UserToken;
                    //判断所有需接收的数据是否已经完成
                    if (s.Available == 0)
                    {

                        //获取接收到的数据
                        byte[] ByteArray = new byte[e.BytesTransferred];
                        Array.Copy(e.Buffer, 0, ByteArray, 0, ByteArray.Length);

                        //设置发送数据（自定义数据）
                        //byte[] bt = new byte[10] { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 };
                        //e.SetBuffer(e.Offset, bt.Length);
                        //Array.Copy(bt, 0, e.Buffer, 0, bt.Length);
                        //e.SetBuffer(e.Offset, bt.Length);

                        //设置发送的数据（原样返回）
                        Array.Copy(e.Buffer, 0, e.Buffer, e.BytesTransferred, e.BytesTransferred);
                        e.SetBuffer(e.Offset, e.BytesTransferred);


                        if (!s.SendAsync(e))        //投递发送请求，这个函数有可能同步发送出去，这时返回false，并且不会引发SocketAsyncEventArgs.Completed事件
                        {
                            // 同步发送时处理发送完成事件
                            this.ProcessSend(e);
                        }
                    }
                    else if (!s.ReceiveAsync(e))    //为接收下一段数据，投递接收请求，这个函数有可能同步完成，这时返回false，并且不会引发SocketAsyncEventArgs.Completed事件
                    {
                        // 同步接收时处理接收完成事件
                        this.ProcessReceive(e);
                    }
                }
                else
                {
                    this.ProcessError(e);
                }
            }
            else
            {
                this.CloseClientSocket(e);
            }
        }

        /// <summary>
        /// 发送完成时处理函数
        /// </summary>
        /// <param name="e">与发送完成操作相关联的SocketAsyncEventArg对象</param>
        private void ProcessSend(SocketAsyncEventArgs e)
        {
            if (e.SocketError == SocketError.Success)
            {
                Socket s = (Socket)e.UserToken;

                //接收时根据接收的字节数收缩了缓冲区的大小，因此投递接收请求时，恢复缓冲区大小
                e.SetBuffer(0, bufferSize);
                if (!s.ReceiveAsync(e))     //投递接收请求
                {
                    // 同步接收时处理接收完成事件
                    this.ProcessReceive(e);
                }
            }
            else
            {
                this.ProcessError(e);
            }
        }

        /// <summary>
        /// 处理socket错误
        /// </summary>
        /// <param name="e"></param>
        private void ProcessError(SocketAsyncEventArgs e)
        {
            Socket s = e.UserToken as Socket;
            IPEndPoint localEp = s.LocalEndPoint as IPEndPoint;

            this.CloseClientSocket(s, e);

            string outStr = String.Format("套接字错误 {0}, IP {1}, 操作 {2}。", (Int32)e.SocketError, localEp, e.LastOperation);
            mainForm.Invoke(mainForm.setlistboxcallback, outStr);
            //Console.WriteLine("Socket error {0} on endpoint {1} during {2}.", (Int32)e.SocketError, localEp, e.LastOperation);
        }

        /// <summary>
        /// 关闭socket连接
        /// </summary>
        /// <param name="e">SocketAsyncEventArg associated with the completed send/receive operation.</param>
        private void CloseClientSocket(SocketAsyncEventArgs e)
        {
            Socket s = e.UserToken as Socket;
            this.CloseClientSocket(s, e);
        }

        private void CloseClientSocket(Socket s, SocketAsyncEventArgs e)
        {
            Interlocked.Decrement(ref this.numConnectedSockets);

            // SocketAsyncEventArg 对象被释放，压入可重用队列。
            this.ioContextPool.Push(e);            
            string outStr = String.Format("客户 {0} 断开, 共有 {1} 个连接。", s.RemoteEndPoint.ToString(), this.numConnectedSockets);
            mainForm.Invoke(mainForm.setlistboxcallback, outStr);            
            //Console.WriteLine("A client has been disconnected from the server. There are {0} clients connected to the server", this.numConnectedSockets);
            try
            {
                s.Shutdown(SocketShutdown.Send);
            }
            catch (Exception)
            {
                // Throw if client has closed, so it is not necessary to catch.
            }
            finally
            {
                s.Close();
            }
        }

        /// <summary>
        /// accept 操作完成时回调函数
        /// </summary>
        /// <param name="sender">Object who raised the event.</param>
        /// <param name="e">SocketAsyncEventArg associated with the completed accept operation.</param>
        private void OnAcceptCompleted(object sender, SocketAsyncEventArgs e)
        {
            this.ProcessAccept(e);
        }

        /// <summary>
        /// 监听Socket接受处理
        /// </summary>
        /// <param name="e">SocketAsyncEventArg associated with the completed accept operation.</param>
        private void ProcessAccept(SocketAsyncEventArgs e)
        {
            Socket s = e.AcceptSocket;
            if (s.Connected)
            {
                try
                {
                    SocketAsyncEventArgs ioContext = this.ioContextPool.Pop();
                    if (ioContext != null)
                    {
                        // 从接受的客户端连接中取数据配置ioContext

                        ioContext.UserToken = s;

                        Interlocked.Increment(ref this.numConnectedSockets);
                        string outStr = String.Format("客户 {0} 连入, 共有 {1} 个连接。",  s.RemoteEndPoint.ToString(),this.numConnectedSockets);
                        mainForm.Invoke(mainForm.setlistboxcallback,outStr);
                        //Console.WriteLine("Client connection accepted. There are {0} clients connected to the server",
                            //this.numConnectedSockets);

                        if (!s.ReceiveAsync(ioContext))
                        {
                            this.ProcessReceive(ioContext);
                        }
                    }
                    else        //已经达到最大客户连接数量，在这接受连接，发送“连接已经达到最大数”，然后断开连接
                    {
                        s.Send(Encoding.Default.GetBytes("连接已经达到最大数!"));
                        string outStr = String.Format("连接已满，拒绝 {0} 的连接。", s.RemoteEndPoint);
                        mainForm.Invoke(mainForm.setlistboxcallback, outStr);
                        s.Close();
                   }
                }
                catch (SocketException ex)
                {
                    Socket token = e.UserToken as Socket;
                    string outStr = String.Format("接收客户 {0} 数据出错, 异常信息： {1} 。", token.RemoteEndPoint, ex.ToString());
                    mainForm.Invoke(mainForm.setlistboxcallback, outStr);
                    //Console.WriteLine("Error when processing data received from {0}:\r\n{1}", token.RemoteEndPoint, ex.ToString());
                }
                catch (Exception ex)
                {
                    mainForm.Invoke(mainForm.setlistboxcallback, "异常：" + ex.ToString());
                }
                // 投递下一个接受请求
                this.StartAccept(e);
            }
        }

        /// <summary>
        /// 从客户端开始接受一个连接操作
        /// </summary>
        /// <param name="acceptEventArg">The context object to use when issuing 
        /// the accept operation on the server's listening socket.</param>
        private void StartAccept(SocketAsyncEventArgs acceptEventArg)
        {
            if (acceptEventArg == null)
            {
                acceptEventArg = new SocketAsyncEventArgs();
                acceptEventArg.Completed += new EventHandler<SocketAsyncEventArgs>(OnAcceptCompleted);
            }
            else
            {
                // 重用前进行对象清理
                acceptEventArg.AcceptSocket = null;
            }

            if (!this.listenSocket.AcceptAsync(acceptEventArg))
            {
                this.ProcessAccept(acceptEventArg);
            }
        }

        /// <summary>
        /// 启动服务，开始监听
        /// </summary>
        /// <param name="port">Port where the server will listen for connection requests.</param>
        internal void Start(Int32 port)
        {
            // 获得主机相关信息
            IPAddress[] addressList = Dns.GetHostEntry(Environment.MachineName).AddressList;
            IPEndPoint localEndPoint = new IPEndPoint(addressList[addressList.Length - 1], port);

            // 创建监听socket
            this.listenSocket = new Socket(localEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
            this.listenSocket.ReceiveBufferSize = this.bufferSize;
            this.listenSocket.SendBufferSize = this.bufferSize;

            if (localEndPoint.AddressFamily == AddressFamily.InterNetworkV6)
            {
                // 配置监听socket为 dual-mode (IPv4 & IPv6) 
                // 27 is equivalent to IPV6_V6ONLY socket option in the winsock snippet below,
                this.listenSocket.SetSocketOption(SocketOptionLevel.IPv6, (SocketOptionName)27, false);
                this.listenSocket.Bind(new IPEndPoint(IPAddress.IPv6Any, localEndPoint.Port));
            }
            else
            {
                this.listenSocket.Bind(localEndPoint);
            }

            // 开始监听
            this.listenSocket.Listen(this.numConnections);

            // 在监听Socket上投递一个接受请求。
            this.StartAccept(null);

            // Blocks the current thread to receive incoming messages.
            mutex.WaitOne();
        }

        /// <summary>
        /// 停止服务
        /// </summary>
        internal void Stop()
        {
            this.listenSocket.Close();
            mutex.ReleaseMutex();
        }

    }
}

IoContextPool.cs

完成端口上进行投递所用的IoContext对象池

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

namespace IocpServer
{
    /// <summary>
    /// 与每个客户Socket相关联，进行Send和Receive投递时所需要的参数
    /// </summary>
    internal sealed class IoContextPool
    {
        List<SocketAsyncEventArgs> pool;        //为每一个Socket客户端分配一个SocketAsyncEventArgs，用一个List管理，在程序启动时建立。
        Int32 capacity;                         //pool对象池的容量
        Int32 boundary;                         //已分配和未分配对象的边界，大的是已经分配的，小的是未分配的

        internal IoContextPool(Int32 capacity)
        {
            this.pool = new List<SocketAsyncEventArgs>(capacity);
            this.boundary = 0;
            this.capacity = capacity;
        }

        /// <summary>
        /// 往pool对象池中增加新建立的对象，因为这个程序在启动时会建立好所有对象，
        /// 故这个方法只在初始化时会被调用,因此，没有加锁。
        /// </summary>
        /// <param name="arg"></param>
        /// <returns></returns>
        internal bool Add(SocketAsyncEventArgs arg)
        {
            if (arg != null && pool.Count < capacity)
            {
                pool.Add(arg);
                boundary++;
                return true;
            }
            else
                return false;
        }

        /// <summary>
        /// 取出集合中指定对象，内部使用
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        //internal SocketAsyncEventArgs Get(int index)
        //{
        //    if (index >= 0 && index < capacity)
        //        return pool[index];
        //    else
        //        return null;
        //}

        /// <summary>
        /// 从对象池中取出一个对象，交给一个socket来进行投递请求操作
        /// </summary>
        /// <returns></returns>
        internal SocketAsyncEventArgs Pop()
        {
            lock (this.pool)
            {
                if (boundary > 0)
                {
                    --boundary;
                    return pool[boundary];
                }
                else
                    return null;
            }
        }

        /// <summary>
        /// 一个socket客户断开，与其相关的IoContext被释放，重新投入Pool中，备用。
        /// </summary>
        /// <param name="arg"></param>
        /// <returns></returns>
        internal bool Push(SocketAsyncEventArgs arg)
        {
            if (arg != null)
            {
                lock (this.pool)
                {
                    int index = this.pool.IndexOf(arg, boundary);  //找出被断开的客户,此处一定能查到，因此index不可能为-1，必定要大于0。
                    if (index == boundary)         //正好是边界元素
                        boundary++;
                    else
                    {
                        this.pool[index] = this.pool[boundary];     //将断开客户移到边界上，边界右移
                        this.pool[boundary++] = arg;
                    }
                }
                return true;
            }
            else
                return false;
        }
    }
}

运行结果如图:

这里写图片描述

这里写图片描述

.NET跨平台
关注
专栏目录
网络编程笔记<4> 客户端 TCP IOCP
jptaozhantaozhan的专栏
12-07 1823
/********************************************* 类名 ： CTcpIocpClient 功能 ： TCP 客户端完成端口封装 QQ ： 51171107 **********************************************/ #ifndef H_CTCP_IOCP_CLIENT_H #define H_CTC
IOCP的一些使用例子
mydinne的专栏
03-24 361
具体实现方法是，在发送端和接收端分别创建一个完成端口，并将套接字绑定到对应的完成端口上。然后，将这个新的套接字绑定到完成端口上，并开始进行异步I/O操作，接收客户端发送的数据。通过这种方式，服务器就可以同时处理多个客户端的请求，提高程序的并发性和性能。然后，将这个新的套接字绑定到完成端口上，并将请求交给线程池中的某个线程进行处理。以上是一些IOCP的应用例子，当然还有其他的应用场景，比如实现高性能的UDP服务器等。如果你能够掌握好IOCP的实现细节和编程技巧，就可以为程序的性能和效率注入新的活力。
c# 异步网络编程
zhangkaiforex的专栏
09-08 3685
C#编写基于.Net IOCP的高性能服务器2008-10-15 15:01无论什么平台，编写支持高并发性的网络服务器，瓶颈往往出在I/O上，目前最高效的是采用Asynchronous I/O模型，Linux平台提供了epoll，Windows平台提供了I/O Completion Port(IO完成端口，即IOCP)。Windows自winsock2开始就提供了IOCP支
超轻量级、支持插件的 .NET 网络通信框架
最新发布
DotNet技术匠
09-09 1313
给大家推荐一个轻量级的、支持插件的综合网络通信库：TouchSocket。TouchSocket 的基础通信功能包括 TCP、UDP、SSL、RPC 和 HTTP。其中，HTTP 服务器支持 WebSocket、静态网页、XML-RPC、WebAPI 和 JSON-RPC 等扩展插件。此外，TouchSocket 还支持自定义协议的 TouchRPC，具备 SSL 加密、异步调用、权限管理、错误状态返回、服务回调和分布式调用等功能。在空载函数执行时，10 万次调用仅需 3.8 秒；在不返回状态时
简单的IOCP程序(TCP)
xuweilmy的专栏
06-25 713
// tcp_iocp_serve.cpp #include #include #include #include using namespace std; #pragma comment(lib, "Ws2_32.lib") // Socket编程需用的动态链接库 #pragma comment(lib, "Kernel32.lib") // IOCP需要用到的动态
TCP服务器 IOCP设计 讨论
qq_23313467的博客
09-06 287
高性能的socket 服务器设计比较复杂，有的理解起来很困难。目前，在window下socket服务器，普遍评价比较好的使用使用IO完成端口（IOCP）和socket结合起来，效率和速度都可以兼顾。 对这种设计，对于动态内存的分配和释放，理解起来比较困难。 c++ 网络编程（九）TCP/IP windows下 多线程超详细教程 以及 多线程实现服务端 https://blog.csdn.net/q...
TCP/IP网络编程 第二十三章:IOCP
Reol99999的博客
07-23 619
简要的介绍了一下在Windows操作系统下的一个高性能服务器模型-----IOCP
易语言TCP服务器完整源码(基于IOCP实现)
01-25
易语言TCP服务器完整源码基于IOCP（I/O完成端口）实现，这是一套用于构建高效、稳定网络服务的编程实践。IOCP是Windows操作系统中的一种高度优化的异步I/O模型，它能处理大量并发连接，尤其适用于高负载的网络服务器...
易语言-TCP服务器完整源码(基于IOCP实现) v1.4
06-25
使用内置iocp实现异步操作 使用了线程安全的队列操作回调，保证了对应域下的回调操作不需要加锁 async_socket.e 套接字模块。使用复杂，但是灵活。 tcp.e 是标准的服务器和客户 傻瓜封装。同时也是很好的使用例子。 ...
易语言-TCP服务器完整源码(基于IOCP实现) v1.1
07-02
使用内置iocp实现异步操作 使用了线程安全的队列操作回调，保证了对应域下的回调操作不需要加锁 async_socket.e 套接字模块。使用复杂，但是灵活。 tcp.e 是标准的服务器和客户 傻瓜封装。同时也是很好的使用例子。 ...
基于IOCP模型实现TCP服务器、客户端，串口、命名管道等类库（例子）
02-17
封装类源代码，其中TCP服务器多线程监听功能、客户端支持断线重连、多线程串口读写、命名管道监听已经实现。UDP、并口等参考后也较容易实现。特别数据包头解析部分，已经支持多种类型：包头（含数据长度）、特殊类型...
c# .net高性能IOCP服务器
12-29
最大65000个连接，群发消息，指定用户发送消息，断开指定用户
IOCP.NET(强大的IOCP托管库)
11-27
强大的IOCP托管库,可以用于C#.net,VB.NET
网络游戏通讯引擎,高性能IOCP模型(.Net)
xiaoluo123的专栏
07-24 4776
前言     Steed是本人在公司从事通信引擎开发多年的经验基础上开发的一套通用的网络通信库，使用C++语言开发，支持高并发连接，底层使用IOCP技术。设计模式参考了著名的C++准标准库Boost中的Asio库，Steed网络通信库发布有C++动态链接库版（NetworkIoServices.dll）和.Net组件版（NetworkEngineServices.dll）。     这是一套在
.net下的IOCP代码例子[codeproject]
思月行云
08-26 3179
I/O Completion Ports (IOCP) supported on Microsoft Windows platforms has two facets. It first allows I/O handles like file handles, socket handles, etc., to be associated with a completion port. Any async I/O completion event related to the I/O handle asso
NetComm-TCPServer
hintonic的专栏
11-21 365
#pragma once #include #include #include "tcpconnect.h" class CTCPServer :   public CTCPConnect { public:   CTCPServer(void);   ~CTCPServer(void);   friend unsigned __stdcall StartS
C#编写基于.Net IOCP的高性能服务器
热门推荐
未来软件
01-16 1万+
无论什么平台，编写支持高并发性的网络服务器，瓶颈往往出在I/O上，目前最高效的是采用Asynchronous I/O模型，Linux平台提供了epoll，Windows平台提供了I/O Completion Port(IO完成端口，即IOCP)。 Windows自winsock2开始就提供了IOCP支持，可以通过C++直接调用API，但对于基于.Net的C#开发，是在.Net Framework
对于TCP协议中IOCP模型的一些简单的理解
Gnorth的专栏
09-22 2841
请不要觉得这一篇没有代码的文章没意义，对IOCP模型的代码，百度搜索可以得到很多，但是后续很多需要纠结的地方，很多人都经历过，如果你已经在尝试写IOCP服务端了，那么你很可能会对写代码之外的一些设计问题很纠结，那么本文很可能是对你有所帮助的
高性能TcpServer(C#) - 2.创建高性能Socket服务器SocketAsyncEventArgs的实现(IOCP)
07-24 598
高性能TcpServer(C#)-1.网络通信协议 高性能TcpServer(C#)-2.创建高性能Socket服务器SocketAsyncEventArgs的实现(IOCP) 高性能TcpServer(C#) -3.命令通道(处理：掉包，粘包，垃圾包) 高性能TcpServer(C#)-4.文件通道(处理：文件分包，支持断点续传) 高性能TcpServer(C#)...
IOCP技术实现TCP转发与数据通信
IOCP是Windows平台下实现高效网络通信的一种机制，特别适用于处理大量并发连接的场景。通过IOCP，可以高效地进行TCP连接的建立、数据的发送和接收操作。本文将详细介绍IOCP的基础概念、工作原理以及如何在实际项目中...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值