C#操作QQ的TreeView控件

最新推荐文章于 2023-09-26 22:57:49 发布
最新推荐文章于 2023-09-26 22:57:49 发布
阅读量998 收藏
点赞数 1
分类专栏： C# 文章标签： treeview c#

转载： http://www.cnblogs.com/Rolends/archive/2012/04/23/2467044.html#commentform

C#操作QQ的TreeView控件

image

通过spy++我们可以发现类ATL:30A57F50为treeview控件

我们需实现如下对treeview的操作

1),遍历获取信息 2),单选 3),多选

操作其他进程的步骤这个不区分语言的,一般实现过程如下

1),打开远程进程,这个调用API 函数 OpenProcess来实现

2),分配远程内存,调用API VirtualAllocEx 来实现,当然不是绝对的,当操作是不需要对象,而是通过SendMessage直接返回时就不需要分配

3),内存复制,由本地进程内存复制到远程进程内存,使用WriteProcessMemory来实现,同上不是绝对,只有调用需要读取对象信息时,才有需要

4),发送消息,发送消息就不用说了SendMessage

5),上面发送的消息结果,如果是写入对象的话,那么我们需要读取远程内存到本地和3相反,ReadProcessMemory

6),完了?,没有的.资源没释放,OK,释放资源,一般意义上就完成了

上面所有的步骤在vc里一般都这样实现的

我来讲解一下在C#如何实现操作其他进程的TreeView

1),获取Treeview控件句柄使用API FindWindowEx来实现,下面这个函数是找出所有控件,可以调用之后判断className来获取到控件指针
 public static List<IntPtr> FindControl(IntPtr hwnd, string className, string title = null)
 {
            List<IntPtr> controls = new List<IntPtr>();
            IntPtr handle = IntPtr.Zero;
            while (true)
            {
                IntPtr tmp = handle;
                handle = WinAPIHelper.FindWindowEx(hwnd, tmp, className, title);
                if (handle != IntPtr.Zero)
                {
                    controls.Add(handle);
                }
                else
                    break;
            }
            return controls;
     }

2),读取item

    a),获取根节点

  int retval = WinAPIHelper.SendMessage(hwnd, (int)WinAPIHelper.TV_Messages.TVM_GETNEXTITEM, (int)WinAPIHelper.TVM_GETNEXTITEM.TVGN_ROOT, IntPtr.Zero);

,返回值为节点指针

   b),选择获取到的项

 int r1 = WinAPIHelper.SendMessage(hwnd, (int)WinAPIHelper.TV_Messages.TVM_SELECTITEM,
                  (int)WinAPIHelper.TVM_GETNEXTITEM.TVGN_CARET, new IntPtr(retval));

,返回值为操作结果

   c),展开选中项

 int r2 = WinAPIHelper.SendMessage(hwnd, (int)WinAPIHelper.TV_Messages.TVM_EXPAND,
                        (int)WinAPIHelper.TVM_EXPAND.TVE_EXPAND, new IntPtr(retval));

,返回操作结果

   d),声明ITEM并写入远程内存 
 

                    WinAPIHelper.TVITEM tvItem = new WinAPIHelper.TVITEM();
                    int size = Marshal.SizeOf(tvItem);
                    tvItem.mask = WinAPIHelper.TVIF_TEXT;
                    tvItem.hItem = (IntPtr)retval;
                    tvItem.pszText = (IntPtr)(remoteBuffer.ToInt32() + size + 1);
                    tvItem.cchTextMax = 255;
                    localBuffer = Marshal.AllocHGlobal(Marshal.SizeOf(tvItem));
                    Marshal.StructureToPtr(tvItem, localBuffer, false);
                    bSuccess = WinAPIHelper.WriteProcessMemory(hProcess, remoteBuffer, ref tvItem, size, IntPtr.Zero);

关于item定义,大家可查询MSDN

   e),发送获取Item消息

   WinAPIHelper.SendMessage(hwnd, (int)WinAPIHelper.TV_Messages.TVM_GETITEM, 0, remoteBuffer);

    f),读取远程内存

   bSuccess = WinAPIHelper.ReadProcessMemory(hProcess, remoteBuffer, localBuffer, buff_size, IntPtr.Zero);

    g),将指针转为结构

WinAPIHelper.TVITEM retItem = (WinAPIHelper.TVITEM)
                                   Marshal.PtrToStructure(localBuffer, (Type)typeof(WinAPIHelper.TVITEM))

经过上面的操作我们就获取到了选定的某一项的信息,接下来我们使用

  retval = WinAPIHelper.SendMessage(hwnd, (int)WinAPIHelper.TV_Messages.TVM_GETNEXTITEM, (int)WinAPIHelper.TVM_GETNEXTITEM.TVGN_NEXTVISIBLE, new IntPtr(retval));
来选择下一个项在进行上面的操作,直到返回值为空位置

3),多选实现,多选我们需要通过修改ITEM的状态来实现

  a),声明ITEM(操作为更改状态)

                WinAPIHelper.TVITEM tvItem = new WinAPIHelper.TVITEM();
                tvItem.hItem = items[i].Handle;
                tvItem.mask = WinAPIHelper.TVIF_STATE;
                tvItem.state = WinAPIHelper.TVIS_SELECTED;
                tvItem.stateMask = WinAPIHelper.TVIS_SELECTED;

   b),分配远程内存

IntPtr remoteBuffer = WinAPIHelper.VirtualAllocEx(hPro, IntPtr.Zero, buff_size, WinAPIHelper.AllocationType.Commit, WinAPIHelper.MemoryProtection.ExecuteReadWrite);

   c),写入远程内存

   bool result = WinAPIHelper.WriteProcessMemory(hPro, remoteBuffer, ref tvItem, size, IntPtr.Zero);

   d),设置状态

 int retval = WinAPIHelper.SendMessage(hTv, (int)WinAPIHelper.TV_Messages.TVM_SETITEM, 0, remoteBuffer);

  经过上面就实现了为某一项设置选中状态,实际操作中,我们为提高内存使用效率,是先分配缓冲区,在设置(写入)对象,然后发送指令

下面是完整代码

    public class WinTreeViewItem
    {
        public int Index { get; set; }
        public int lpAddress { get; set; }
        public string Text { get; set; }
        public bool OwnChild { get; set; }
        public IntPtr Handle { get; set; }
    }
    public class TreeViewHelper
    {
        const int buff_size = 1024;
        const int MAX_TVMSTRING = 255;        
        static public List<WinTreeViewItem> GetAllItem(IntPtr hTv)
        {
            return GetItems(hTv, null, null, int.MaxValue);
        }
 
        static public WinTreeViewItem GetItemByText(IntPtr hTv, params string[] text)
        {
            List<string> containsList = new List<string>();
            foreach (var item in text)
            {
                if (item != null && item != "")
                    containsList.Add(item);
            }
            List<WinTreeViewItem> items = GetItems(hTv, containsList, null, 1, false);
            if (items.Count > 0)
                return items[0];
            else
                return null;
        }
 
        static public bool SelectItem(IntPtr hTv, WinTreeViewItem item)
        {
            List<WinTreeViewItem> items = new List<WinTreeViewItem>();
            items.Add(item);
            return SelectItems(hTv, items);
        }
 
        static public List<WinTreeViewItem> GetItems(IntPtr hTv, List<string> containsList, List<string> withOutList, int takeCount)
        {
            return GetItems(hTv, containsList, withOutList, takeCount, false);
        }
 
        static public List<WinTreeViewItem> GetItems(IntPtr hTv, List<string> containsList, List<string> withOutList, int takeCount, bool isAddParent, int containsPreferenceCount = 0, int withOutPreferenceCount = 0)
        {
            if (withOutPreferenceCount < 1 && containsPreferenceCount < 1)
            {
                throw new Exception("两个数量级不能同时为空");
            }
            int tryCount = 0;
            IntPtr hPro = WinAPIHelper.OpenProcess(WinAPIHelper.PROCESS_ALL_ACCESS, false, WndHelper.GetProcessId(hTv));
            List<WinTreeViewItem> withOutResultItems = new List<WinTreeViewItem>();
            List<WinTreeViewItem> containsResultItems = new List<WinTreeViewItem>();
            int index = 0;
            int retval = 0;
        GETROOT:
            if (retval == 0)
            {
                tryCount++;
                if (tryCount > SysConfig.TreeViewItemFindTryCount)
                {
                    return null;
                }
                retval = WinAPIHelper.SendMessage(hTv, (int)WinAPIHelper.TV_Messages.TVM_GETNEXTITEM, (int)WinAPIHelper.TVM_GETNEXTITEM.TVGN_ROOT, IntPtr.Zero);
                Console.WriteLine("根节点" + retval);
                Thread.Sleep(500);
                goto GETROOT;
            }
            tryCount = 0;
            int itemCount = 0;
        FINDCOUNT:
            if (itemCount == 0)
            {
                tryCount++;
                if (tryCount > SysConfig.TreeViewItemFindTryCount)
                {
                    return null;
                }
                itemCount = WinAPIHelper.SendMessage(hTv, (int)WinAPIHelper.TV_Messages.TVM_GETCOUNT, 0, IntPtr.Zero);
                Console.WriteLine("可用创建数量" + itemCount);
                Thread.Sleep(500);
                goto FINDCOUNT;
            }
            IntPtr pStrBufferMemory = WinAPIHelper.VirtualAllocEx(hPro, IntPtr.Zero, MAX_TVMSTRING, WinAPIHelper.AllocationType.Commit, WinAPIHelper.MemoryProtection.ReadWrite);
            IntPtr remoteBuffer = WinAPIHelper.VirtualAllocEx(hPro, IntPtr.Zero, Marshal.SizeOf(typeof(WinAPIHelper.TVITEM)), WinAPIHelper.AllocationType.Commit, WinAPIHelper.MemoryProtection.ExecuteReadWrite);
 
            if (remoteBuffer == IntPtr.Zero)
            {
                Console.WriteLine("远程地址分配失败");
                return null;
            }
            if (pStrBufferMemory == IntPtr.Zero)
            {
                Console.WriteLine("远程地址分配失败");
                return null;
            }
            WinAPIHelper.TVITEM tvItem = new WinAPIHelper.TVITEM();
            // int size = Marshal.SizeOf(tvItem);
            tvItem.mask = WinAPIHelper.TVIF_TEXT;
            tvItem.pszText = pStrBufferMemory;
            tvItem.cchTextMax = MAX_TVMSTRING;
            IntPtr localBuffer = Marshal.AllocHGlobal(Marshal.SizeOf(tvItem));
            Marshal.StructureToPtr(tvItem, localBuffer, false);
            int addCount = 0;
            string tmpcontxt = "";
            while (retval != 0)
            {
                if (index + 1 > itemCount) break;
                tvItem.hItem = (IntPtr)retval;
                var item = new WinTreeViewItem()
                {
                    Index = index,
                    lpAddress = retval
                };
                int r1 = WinAPIHelper.SendMessage(hTv, (int)WinAPIHelper.TV_Messages.TVM_SELECTITEM, (int)WinAPIHelper.TVM_GETNEXTITEM.TVGN_CARET, new IntPtr(retval));
                if (r1 == 0)
                {
                    Console.WriteLine("选择项失败");
                    continue;
                }
                //Thread.Sleep(100);
                int r2 = WinAPIHelper.SendMessage(hTv, (int)WinAPIHelper.TV_Messages.TVM_EXPAND, (int)WinAPIHelper.TVM_EXPAND.TVE_EXPAND, new IntPtr(retval));
                if (r2 == 1)
                {
                    //Console.WriteLine("可以展开");
                    itemCount = WinAPIHelper.SendMessage(hTv, (int)WinAPIHelper.TV_Messages.TVM_GETCOUNT, 0, IntPtr.Zero);
                    item.OwnChild = true;
                }
                else
                {
                    //Console.WriteLine("不可以展开");
                }
                bool bSuccess = WinAPIHelper.WriteProcessMemory(hPro, remoteBuffer, ref tvItem, Marshal.SizeOf(tvItem), IntPtr.Zero);
                if (bSuccess == false)
                {
                    Console.WriteLine("写入远程地址失败");
                    continue;
                }
                int r3 = WinAPIHelper.SendMessage(hTv, (int)WinAPIHelper.TV_Messages.TVM_GETITEM, 0, remoteBuffer);
                if (r3 == 0)
                {
                    Console.WriteLine("选择项操作失败");
                    continue;
                }
                bSuccess = WinAPIHelper.ReadProcessMemory(hPro, remoteBuffer, localBuffer, Marshal.SizeOf(tvItem), IntPtr.Zero);
                if (bSuccess == false)
                {
                    Console.WriteLine("读取远程地址失败");
                    continue;
                }
                WinAPIHelper.TVITEM retItem = (WinAPIHelper.TVITEM)Marshal.PtrToStructure(localBuffer, (Type)typeof(WinAPIHelper.TVITEM));
                int readLen = 0;
                IntPtr pStrLocaAddress = Marshal.AllocHGlobal(MAX_TVMSTRING);
 
                bSuccess = WinAPIHelper.ReadProcessMemory(hPro, pStrBufferMemory, pStrLocaAddress, MAX_TVMSTRING, out readLen);
                string pszItemText = Marshal.PtrToStringUni(pStrLocaAddress);
                // Console.WriteLine(pszItemText);
                item.Handle = tvItem.hItem;
                item.Text = pszItemText;
                bool withOutAdd = false;
                bool containsAdd = false;
                if (item.OwnChild)
                {
                    goto NEXTITEM;
                }
                if (containsList != null)
                {
                    foreach (var conItem in containsList)
                    {
                        if (pszItemText.Trim().Contains(conItem.Trim()))
                        {
                            containsAdd = true; goto ADDITEM;
                        }
                    }
                }
                if (withOutList != null)
                {
                    bool isContains = false;
                    foreach (var outItem in withOutList)
                    {
                        if (pszItemText.Trim().Contains(outItem.Trim()))
                        {
                            isContains = true;
                            goto NEXTITEM;
                        }
                    }
                    if (!isContains)
                    {
                        withOutAdd = true;
                        goto ADDITEM;
                    }
                }
 
            ADDITEM:
                if ((withOutList == null && containsList == null) || (withOutAdd || containsAdd))
                {
                    if (withOutAdd)
                    {
                        if (withOutResultItems.Count < withOutPreferenceCount && takeCount - containsPreferenceCount > withOutResultItems.Count)
                        {
                            withOutResultItems.Add(item);
                            addCount++;
                        }
                    }
                    if (containsAdd)
                    {
                        if (containsResultItems.Count < containsPreferenceCount && takeCount - withOutPreferenceCount > containsResultItems.Count)
                        {
                            containsResultItems.Add(item);
                            addCount++;
                        }
                    }
                    containsAdd = false;
                    withOutAdd = false;
                    if (addCount == takeCount)
                        break;
                }
            NEXTITEM:
                retval = WinAPIHelper.SendMessage(hTv, (int)WinAPIHelper.TV_Messages.TVM_GETNEXTITEM, (int)WinAPIHelper.TVM_GETNEXTITEM.TVGN_NEXTVISIBLE, new IntPtr(retval));
                index++;
            }
            if (localBuffer != IntPtr.Zero)
            {
                try { Marshal.FreeHGlobal(localBuffer); }
                catch { }
            }
            if (remoteBuffer != IntPtr.Zero)
            {
                try { WinAPIHelper.VirtualFreeEx(hPro, remoteBuffer, 0, WinAPIHelper.MEM_RELEASE); }
                catch { }
            }
            if (pStrBufferMemory != IntPtr.Zero)
            {
                try { WinAPIHelper.VirtualFreeEx(hPro, pStrBufferMemory, 0, WinAPIHelper.MEM_RELEASE); }
                catch { }
            }
            if (hPro != IntPtr.Zero)
            {
                try { WinAPIHelper.CloseHandle(hPro); }
                catch { }
            }
            withOutResultItems.AddRange(containsResultItems);
            return withOutResultItems;
        }
 
        static public bool SelectItems(IntPtr hTv, List<WinTreeViewItem> items)
        {
            if (items.Count < 1) return false;
 
            int r1 = WinAPIHelper.SendMessage(hTv, (int)WinAPIHelper.TV_Messages.TVM_SELECTITEM, (int)WinAPIHelper.TVM_GETNEXTITEM.TVGN_CARET, items[0].Handle);
            if (items.Count == 1) return r1 == 1 ? true : false;
            IntPtr hPro = WinAPIHelper.OpenProcess(WinAPIHelper.PROCESS_ALL_ACCESS, false, WndHelper.GetProcessId(hTv));
            IntPtr remoteBuffer = WinAPIHelper.VirtualAllocEx(hPro, IntPtr.Zero, buff_size, WinAPIHelper.AllocationType.Commit, WinAPIHelper.MemoryProtection.ExecuteReadWrite);
            for (int i = 1; i < items.Count; i++)
            {
 
                WinAPIHelper.TVITEM tvItem = new WinAPIHelper.TVITEM();
                tvItem.hItem = items[i].Handle;
                tvItem.mask = WinAPIHelper.TVIF_STATE;
                tvItem.state = WinAPIHelper.TVIS_SELECTED;
                tvItem.stateMask = WinAPIHelper.TVIS_SELECTED;
                int size = Marshal.SizeOf(tvItem);
                bool result = WinAPIHelper.WriteProcessMemory(hPro, remoteBuffer, ref tvItem, size, IntPtr.Zero);
                int retval = WinAPIHelper.SendMessage(hTv, (int)WinAPIHelper.TV_Messages.TVM_SETITEM, 0, remoteBuffer);
 
                Thread.Sleep(100);
            }
            if (remoteBuffer != IntPtr.Zero)
            {
                try { WinAPIHelper.VirtualFreeEx(hPro, remoteBuffer, 0, WinAPIHelper.MEM_RELEASE); }
                catch { }
            }
            if (hPro != IntPtr.Zero)
            {
                try { WinAPIHelper.CloseHandle(hPro); }
                catch { }
            }
            return true;
        }
 
 
    }

VCACC
关注
专栏目录
Qt之使用QTreeView实现QQ好友列表
草上爬的博客
07-19 6113
在MVC中，模型负责获取需要显示的数据，并且存储这些数据的修改。每种数据类型都有它自己对应的模型，但是这些模型提供一个相同的API，用于隐藏内部实现。视图用于将模型数据显示给用户。控制器是模型和视图之间的媒介，将用户的动作解析成对数据的操作，比如查找数据或者修改数据，然后转发给模型执行，最后再将模型中需要被显示的数据直接转发给视图进行显示。同样，这种架构也允许使用不同界面显示同一数据，也能够在不改变数据的情况下添加新的显示界面。☆来自委托的信号在用户编辑数据项时使用，用于告知模型和视图编辑器的状态。....
treeView控件实例--Ajax局部刷新
张亚运的专栏
11-21 3062
结合数据库获得父节点和子节点信息数值：
treeview 实现类似qq列表
dragon434的专栏
12-19 308
&#13; #include enum {    COLUMN = 0,    NUM_COLS};void on_changed(GtkWidget * widget, gpointer statusbar){    GtkTreeIter iter;    GtkTreeModel *model;    char *value;    if (gtk_tree_se...
WPF 自定义TreeView控件样式，仿QQ联系人列表
weixin_53370274的博客
12-15 1659
根据思路，我们需要设置三个样式，TreeView样式，TreeViewItem样式，HierarchicalDataTemplate分层模板样式。像这种联系人列表一般涉及到多层级数据，而且有很多数据是需要动态更新的，如果通过手动一条条增加数据反而更复杂，而且不方便。默认的TreeView控件四周会有边距，因此需要设置下TreeView的样式。另外鼠标经过和鼠标选中的背景色需要变化，因此还需要设置TreeViewItem的样式。分层模板中存在两种样式，一种是分组样式，一种是人员样式。
C#下用API跨进程控制别的窗体的TreeView
weixin_33825683的博客
11-26 886
using System.Text; using System; using System.Runtime.InteropServices; class API { #region "API函数定义 " [DllImport("user32.dll ", CharSet = CharSet.Unicode)] private ...
[C#源码]TreeView控件编写磁盘目录查看器
04-01
在本文中，我们将深入探讨如何使用C#编程语言和TreeView控件来创建一个磁盘目录查看器。这个项目是京华志与精华志共同推出的，旨在帮助开发者掌握C#中的文件系统操作和用户界面设计技巧。 首先，让我们了解`...
C#TreeView的简单使用，如果是想做聊天软件的好友那块可以借鉴
12-06
在C#编程中，`TreeView`控件是一个非常重要的组件，它用于显示具有层次结构的数据。这个控件常被用来创建目录结构、文件系统浏览或者像QQ这样的聊天软件中的联系人列表。`TreeView`控件提供了可视化的树形结构，用户...
重写TreeView控件，实现按下shlft/ctrl多选和拖拽功能
07-01
在C#编程中，`TreeView`控件是Windows Forms中常用的一种控件，用于展示层次化的数据结构。在默认情况下，`TreeView`控件只支持单选操作，不支持通过按住Shift或Ctrl键进行多选，也没有内置的拖放（Drag & Drop）...
c#控件设计整理
05-11
- 专业控件：如DateTimePicker、TreeView、ListView等，提供特定功能，如日期选择、树状视图、列表视图等。 4. **控件事件**： - Click、DoubleClick、MouseMove、MouseClick等，响应用户的操作。 - TextChanged...
C#实现树状结构图。树状目录。
08-02
C#实现目录树状图，完整工程源代码。C#实现目录树状图，完整工程源代码。C#实现目录树状图，完整工程源代码。C#实现目录树状图，完整工程源代码。C#实现目录树状图，完整工程源代码。
TreeViewHelper
03-07
TreeView在指定的Node中便于查找、删除所有子Nodes等操作。
如何选中其他程序ListView控件中的某个ItemVC源代码
03-15
本代码演示了选中 任务管理器 列表控件中的某一项。 关键字：listview,LVM_GETITEMTEXT,LVM_SETITEMSTATE,WriteProcessMemory
winform(c#) 自定义treeview控件
09-17
自定义treeview控件，对原组件扩展了几个属性，根据编码的条件，对treeview进行分级。
C#操作API相关文档,使用API选择TreeView节点,使用API控制TreeView滚动条,使用API控制接收消息的时候任务栏高亮效果,使用API移动窗体...
Smile、2011、
05-13 421
项目告一段落了,整理下在项目中使用WINDOWS的API的理解API常用的三大模块:user32.dll(Windows用户界面相关应用程序接口，用于包括Windows处理，基本用户界面等特性，如创建窗口和发送消息);gdi32.dll(Windows GDI图形用户界面相关程序，包含的函数用来绘制图像和显示文字);kernel32.dll(控制着系统的内存管理、数据的输入输出操作和中断处理); ...
C# 高仿腾讯QQ (实现QQ好友列表-基于ListBox的绘法)
weixin_30542079的博客
03-25 926
C#实现QQ好友列表，一直是我网上百搜却不得其解的控件，几乎找不到相关的信息，而找到的也不是我想要的那种。不过，曾在CSDN上看过到过网上一位大牛用C++实现QQ好友列表这种效果，当然,对于我这个C++基本没学过的小程序员来说，读他的代码却有点像看天书.....不过还好，C++代码看不懂，但从他的文章中却给我了一个实现QQ好友列表的思路-基于ListBox绘法 之前曾...
C#的TreeView控件（树控件）
最新发布
wenchm的博客
09-26 5212
为树控件中的节点设置图标TreeView控件（树控件）可以为用户显示节点层次结构，每个节点又可以包含子节点，包含子节点的节点叫父节点。就像在Windows操作系统的Windows资源管理器功能的左窗口中显示文件和文件夹一样。一、添加和删除树节点。
C#读取目录加载到TreeView
killer9806的专栏
04-02 1746
http://blog.163.com/aoxiangtiankong@yeah/blog/static/8411202620092351359634/ private void Form1_Load(object sender, EventArgs e)  {             TreeNode node = new TreeNode("Images");       
C# TreeView递归显示整个系统盘符文件目录及文件
dreamgis的专栏
01-25 3617
转自：http://www.csharpwin.com/csharpspace/9313r4673.shtml   C# TreeView递归显示整个系统盘符文件目录及文件示例代码如下： using System; using System.Collections.Generic; using System.Linq; using System.Text; u
c# treeview
09-09
- *1* [C# 窗体应用TreeView控件使用](https://blog.csdn.net/qq_46104786/article/details/121486872)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值