C# 构造函数避免IL(反编译)代码膨胀的方法--C#编译有点狂啊

最新推荐文章于 2024-08-15 00:03:20 发布
最新推荐文章于 2024-08-15 00:03:20 发布
阅读量2.5k 收藏 2
点赞数 2
分类专栏： C#/ASP.NET 文章标签： c# 构造函数 反编译代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010533180/article/details/68923801
版权

构造器(constructor) 是允许将类型的实例化初始化为良好状态的一种特殊方法。构造器方法在”方法定义元数据表”中始终叫.ctor(代表constructor)。创建一个引用类型的实例时,首先为实例的数据字段分配内存,然后初始化对象的附加字段(类型对象指针和同步块索引),最后调用类型的实例构造器来设置对象的初始状态。
构造引用类型的对象时,在调用类型的实例构造器之前,为对象分配的内存总是先被归零。构造器没有显式重写的所有字段保证都有一个0和null。
实例构造器永远不能被继承。不能有如下的修饰符:virtual,new,override,sealed和abstract。如果定义的类没有显式定义任何构造器,C# 编译器将定义一个默认(无参)构造器。在它的实现中,只是简单地调用了基类的无参构造器。
例如：

public class TestClass{}

等价于

public class TestClass{
 public TestClass():base(){}
}

如果类的修饰符为abstract,那么编译器生成的默认构造参数的可访问性为protected;否则构造器会被赋予public可访问类。如果基类没有提供无参构造器,那么派生类必须显式调用一个基类的构造器,否则编译器会报错。如果类的修饰符为static(sealed 和abstract),编译器根本不会在类定义中生成一个默认构造器。

一个了类型可以定义多个实例构造器。每个构造器都必须有一个不同的签名,而且每个都可以有不同的可访问性。为了使代码可验证,类的实例构造器在访问从基类继承的任何字段之前,必须先调用基类的构造器。如果派生类的构造器没有显式调用一个基类无参构造器,C#编译器会自动生成对默认的基类构造器的调用。最终,System.Object的公共无参构造器会得到调用。该构造器什么都不做,会直接返回。由于System.Object没有定义实例数据字段,所以它的构造器无事可做。
在极少数情况下,可以在不调用实例构造器的前提下创建一个类型的实例。一个典型的例子是Objcet的MemberwiseClone方法。该方法的作用是分配内存,初始化对象的附加字段(类型对象指针和同步块索引),然后将源对象的字节数据复制到新对象中。另外,用运行时序列化器反序列化对象时,通常也不需要调用构造函数。反序列化代码使用System.Runtime.Serialization.FormatterServices类型的GetUninitializedObject或者GetSafeUninitializedObject方法为对象分配内存,期间不用调用构造器。

不要在构造器中调用会影响所构造对象的任何虚方法.原因是假如这个虚方法在当前要实例化的类型的派生类型中进行了重写,就会调用重写的实现。但在继承层次结构中,字段尚未初始化。所以,调用虚方法将导致无法预测的行为 （可以看看我之前写的这篇关于继承理解的文章:http://blog.csdn.net/u010533180/article/details/52709684）

C# 语言提供了一个简单的语法,允许在构造引用类型的一个实例时,对类型中定义的字段进行初始化。

class ConstructorDemo
    {
        private int m_x = 5;
    }

构造ConstructorDemo的对象时,它的字段m_x字段初始化为5。我们看一下对应的IL代码:(IL是VS自带的反编译工具,读者可自行查阅)

.method public hidebysig specialname rtspecialname 
        instance void  .ctor() cil managed
{
  // 代码大小       15 (0xf)
  .maxstack  8
  IL_0000:  ldarg.0
  IL_0001:  ldc.i4.5
  IL_0002:  stfld      int32  ConstructorDemo::m_x
  IL_0007:  ldarg.0
  IL_0008:  call       instance void [mscorlib]System.Object::.ctor() //隐式调用了Object的构造函数
  IL_000d:  nop
  IL_000e:  ret
} // end of method ConstructorDemo::.ctor

通过反编译可看到ConstructorDemo的构造器把值5存储到字段m_x,在调用基类(Object)的构造器。

C# 提供了这样简化的语法,允许以内联方式初始化实例字段。但在幕后,它会将这种语法转换成构造器方法中的代码来执行。这同时提醒我们注意代码的膨胀效益。何为膨胀？我们通过下面的例子来看。重点和知识点来了。
首先用一个无参构造函数和一个int构造函数来看IL代码:

 class ConstructorDemo
    {
        private int m_x = 5;
        private string m_s = "hello world";
        private double m_d = 3.14159;
        private byte m_b = 0xff;
        public ConstructorDemo()
        {

        }
        public ConstructorDemo(int x)
        {
            m_x = x;
        }     
    }

对应的IL代码为:

无参构造函数的IL：
.method public hidebysig specialname rtspecialname 
        instance void  .ctor() cil managed
{
  // 代码大小       54 (0x36)
  .maxstack  8
  IL_0000:  ldarg.0
  IL_0001:  ldc.i4.5
  IL_0002:  stfld      int32 NowCoderProgrammingProject.ConstructorDemo::m_x
  IL_0007:  ldarg.0
  IL_0008:  ldstr      "hello world"
  IL_000d:  stfld      string NowCoderProgrammingProject.ConstructorDemo::m_s
  IL_0012:  ldarg.0
  IL_0013:  ldc.r8     3.1415899999999999
  IL_001c:  stfld      float64 NowCoderProgrammingProject.ConstructorDemo::m_d
  IL_0021:  ldarg.0
  IL_0022:  ldc.i4     0xff
  IL_0027:  stfld      uint8 NowCoderProgrammingProject.ConstructorDemo::m_b
  IL_002c:  ldarg.0
  IL_002d:  call       instance void [mscorlib]System.Object::.ctor()
  IL_0032:  nop
  IL_0033:  nop
  IL_0034:  nop
  IL_0035:  ret
} // end of method ConstructorDemo::.ctor

int构造函数的IL代码:
.method public hidebysig specialname rtspecialname 
        instance void  .ctor(int32 x) cil managed
{
  // 代码大小       61 (0x3d)
  .maxstack  8
  IL_0000:  ldarg.0
  IL_0001:  ldc.i4.5
  IL_0002:  stfld      int32 NowCoderProgrammingProject.ConstructorDemo::m_x
  IL_0007:  ldarg.0
  IL_0008:  ldstr      "hello world"
  IL_000d:  stfld      string NowCoderProgrammingProject.ConstructorDemo::m_s
  IL_0012:  ldarg.0
  IL_0013:  ldc.r8     3.1415899999999999
  IL_001c:  stfld      float64 NowCoderProgrammingProject.ConstructorDemo::m_d
  IL_0021:  ldarg.0
  IL_0022:  ldc.i4     0xff
  IL_0027:  stfld      uint8 NowCoderProgrammingProject.ConstructorDemo::m_b
  IL_002c:  ldarg.0
  IL_002d:  call       instance void [mscorlib]System.Object::.ctor()
  IL_0032:  nop
  IL_0033:  nop
  IL_0034:  ldarg.0
  IL_0035:  ldarg.1
  IL_0036:  stfld      int32 NowCoderProgrammingProject.ConstructorDemo::m_x
  IL_003b:  nop
  IL_003c:  ret
} // end of method ConstructorDemo::.ctor

通过上面的两端IL代码 我们还没有发现有什么问题,现在我们在增加一个构造函数。

class ConstructorDemo
    {
        private int m_x = 5;
        private string m_s = "hello world";
        private double m_d = 3.14159;
        private byte m_b = 0xff;
        public ConstructorDemo()
        {

        }
        public ConstructorDemo(int x)
        {
            m_x = x;
        }
        public ConstructorDemo(string s)
        {
            m_s = s;
            m_d = 10;
        }
    }

我们现在只看新增这个string类型对应的IL源码:

.method public hidebysig specialname rtspecialname 
        instance void  .ctor(string s) cil managed
{
  // 代码大小       76 (0x4c)
  .maxstack  2
  IL_0000:  ldarg.0
  IL_0001:  ldc.i4.5
  IL_0002:  stfld      int32 NowCoderProgrammingProject.ConstructorDemo::m_x
  IL_0007:  ldarg.0
  IL_0008:  ldstr      "hello world"
  IL_000d:  stfld      string NowCoderProgrammingProject.ConstructorDemo::m_s
  IL_0012:  ldarg.0
  IL_0013:  ldc.r8     3.1415899999999999
  IL_001c:  stfld      float64 NowCoderProgrammingProject.ConstructorDemo::m_d
  IL_0021:  ldarg.0
  IL_0022:  ldc.i4     0xff
  IL_0027:  stfld      uint8 NowCoderProgrammingProject.ConstructorDemo::m_b
  IL_002c:  ldarg.0
  IL_002d:  call       instance void [mscorlib]System.Object::.ctor()
  IL_0032:  nop
  IL_0033:  nop
  IL_0034:  ldarg.0
  IL_0035:  ldarg.1
  IL_0036:  stfld      string NowCoderProgrammingProject.ConstructorDemo::m_s
  IL_003b:  ldarg.0
  IL_003c:  ldc.r8     10.
  IL_0045:  stfld      float64 NowCoderProgrammingProject.ConstructorDemo::m_d
  IL_004a:  nop
  IL_004b:  ret
} // end of method ConstructorDemo::.ctor

我们和上面的int构造函数的IL代码对比发现,有很多相似的IL,我们在增加一个int和string的类型的构造函数。

  class ConstructorDemo
    {
        private int m_x = 5;
        private string m_s = "hello world";
        private double m_d = 3.14159;
        private byte m_b = 0xff;
        public ConstructorDemo()
        {

        }
        public ConstructorDemo(int x)
        {
            m_x = x;
        }
        public ConstructorDemo(string s)
        {
            m_s = s;
            m_d = 10;
        }
        public ConstructorDemo(int x, string s)
        {
            m_x = x;
            m_s = s;
        }
    }

我们看一下对应的IL代码:

.method public hidebysig specialname rtspecialname 
        instance void  .ctor(int32 x,
                             string s) cil managed
{
  // 代码大小       68 (0x44)
  .maxstack  2
  IL_0000:  ldarg.0
  IL_0001:  ldc.i4.5
  IL_0002:  stfld      int32 NowCoderProgrammingProject.ConstructorDemo::m_x
  IL_0007:  ldarg.0
  IL_0008:  ldstr      "hello world"
  IL_000d:  stfld      string NowCoderProgrammingProject.ConstructorDemo::m_s
  IL_0012:  ldarg.0
  IL_0013:  ldc.r8     3.1415899999999999
  IL_001c:  stfld      float64 NowCoderProgrammingProject.ConstructorDemo::m_d
  IL_0021:  ldarg.0
  IL_0022:  ldc.i4     0xff
  IL_0027:  stfld      uint8 NowCoderProgrammingProject.ConstructorDemo::m_b
  IL_002c:  ldarg.0
  IL_002d:  call       instance void [mscorlib]System.Object::.ctor()
  IL_0032:  nop
  IL_0033:  nop
  IL_0034:  ldarg.0
  IL_0035:  ldarg.1
  IL_0036:  stfld      int32 NowCoderProgrammingProject.ConstructorDemo::m_x
  IL_003b:  ldarg.0
  IL_003c:  ldarg.2
  IL_003d:  stfld      string NowCoderProgrammingProject.ConstructorDemo::m_s
  IL_0042:  nop
  IL_0043:  ret
} // end of method ConstructorDemo::.ctor

在看这个对应的IL代码发现其实和上面的几个构造函数有很多重复的代码,即初始化变量。如果在新增一个字段或者新增一个构造函数,就意味每个构造函数都会有对应重复的变量初始化,尤其是新增内联字段,代码会增加的更多。如果每个构造函数对字段值进行赋值操作,那么对应生成的IL代码会更多（读者可自行尝试）这就是代码的膨胀。

对应的解决方案就是创建单个构造器来执行这些公共初始化。然后让其它构造器显式调用这个公共初始化构造器。这样可以减少生成的代码。在C#中利用this关键字来显式调用另一个构造器:对上面的代码修改如下:

class ConstructorDemo2
    {
        private int m_x;
        private string m_s;
        private double m_d;
        private byte m_b;
        public ConstructorDemo2()
        {
            m_x = 5;
            m_s = "hello world";
            m_d = 3.14159;
            m_b = 0xff;
        }
        public ConstructorDemo2(int x)
            : this()
        {
            m_x = x;
        }
        public ConstructorDemo2(string s)
            : this()
        {
            m_s = s;
            m_d = 10;
        }
        public ConstructorDemo2(int x, string s)
            : this()
        {
            m_x = x;
            m_s = s;
        }
    }

对应的IL代码如下:

无参:
.method public hidebysig specialname rtspecialname 
        instance void  .ctor() cil managed
{
  // 代码大小       54 (0x36)
  .maxstack  8
  IL_0000:  ldarg.0
  IL_0001:  call       instance void [mscorlib]System.Object::.ctor()
  IL_0006:  nop
  IL_0007:  nop
  IL_0008:  ldarg.0
  IL_0009:  ldc.i4.5
  IL_000a:  stfld      int32 NowCoderProgrammingProject.ConstructorDemo2::m_x
  IL_000f:  ldarg.0
  IL_0010:  ldstr      "hello world"
  IL_0015:  stfld      string NowCoderProgrammingProject.ConstructorDemo2::m_s
  IL_001a:  ldarg.0
  IL_001b:  ldc.r8     3.1415899999999999
  IL_0024:  stfld      float64 NowCoderProgrammingProject.ConstructorDemo2::m_d
  IL_0029:  ldarg.0
  IL_002a:  ldc.i4     0xff
  IL_002f:  stfld      uint8 NowCoderProgrammingProject.ConstructorDemo2::m_b
  IL_0034:  nop
  IL_0035:  ret
} // end of method ConstructorDemo2::.ctor


int类型构造参数:

.method public hidebysig specialname rtspecialname 
        instance void  .ctor(int32 x) cil managed
{
  // 代码大小       17 (0x11)
  .maxstack  8
  IL_0000:  ldarg.0
  IL_0001:  call       instance void NowCoderProgrammingProject.ConstructorDemo2::.ctor()
  IL_0006:  nop
  IL_0007:  nop
  IL_0008:  ldarg.0
  IL_0009:  ldarg.1
  IL_000a:  stfld      int32 NowCoderProgrammingProject.ConstructorDemo2::m_x
  IL_000f:  nop
  IL_0010:  ret
} // end of method ConstructorDemo2::.ctor


string 类型参数:
.method public hidebysig specialname rtspecialname 
        instance void  .ctor(string s) cil managed
{
  // 代码大小       32 (0x20)
  .maxstack  8
  IL_0000:  ldarg.0
  IL_0001:  call       instance void NowCoderProgrammingProject.ConstructorDemo2::.ctor()
  IL_0006:  nop
  IL_0007:  nop
  IL_0008:  ldarg.0
  IL_0009:  ldarg.1
  IL_000a:  stfld      string NowCoderProgrammingProject.ConstructorDemo2::m_s
  IL_000f:  ldarg.0
  IL_0010:  ldc.r8     10.
  IL_0019:  stfld      float64 NowCoderProgrammingProject.ConstructorDemo2::m_d
  IL_001e:  nop
  IL_001f:  ret
} // end of method ConstructorDemo2::.ctor


string 和int类型参数

.method public hidebysig specialname rtspecialname 
        instance void  .ctor(int32 x,
                             string s) cil managed
{
  // 代码大小       24 (0x18)
  .maxstack  8
  IL_0000:  ldarg.0
  IL_0001:  call       instance void NowCoderProgrammingProject.ConstructorDemo2::.ctor()
  IL_0006:  nop
  IL_0007:  nop
  IL_0008:  ldarg.0
  IL_0009:  ldarg.1
  IL_000a:  stfld      int32 NowCoderProgrammingProject.ConstructorDemo2::m_x
  IL_000f:  ldarg.0
  IL_0010:  ldarg.2
  IL_0011:  stfld      string NowCoderProgrammingProject.ConstructorDemo2::m_s
  IL_0016:  nop
  IL_0017:  ret
} // end of method ConstructorDemo2::.ctor

读者可以对比一下编译生成的代码少了很多。这是很推荐的一种写法。
我在附上几幅对比图,会更加明了(左侧统一为ConstructorDemo源码,右侧统一为ConstructorDemo2):

无参构造函数IL代码对比图

这里写图片描述

int构造函数IL代码对比图

这里写图片描述

string构造函数IL代码对比图

这里写图片描述

int,string构造函数IL代码对比图

这里写图片描述

参考资料:
CLR VIA C#(第3版)

菜鸟葫芦娃
关注
专栏目录
最新版C#反编译工具ilspy,很强大,很好用,收费的Reflector都哭了
07-27
最新版C#反编译工具ilspy,很强大,很好用,经本人使用，收费的Reflector都略逊一筹。
查看C#的反编译语言IL
qq_35433081的博客
05-16 1198
IL基础语法 : https://www.jb51.net/article/39635.htm
C#小结：C#反编译神器ILSpy的下载和使用
最新发布
m0_67412019的博客
08-15 548
以为windows系统64位为例，点击此处安装。
“C# 不停止膨胀，必将走向灭亡”
程序人生的博客
02-15 1505
【CSDN 编者按】编程语言更新的频率是越快越好，还是越慢越好，不断增加的功能是否真的就是开发者想要的？原文链接：https://medium.com/codex/c-is-dying-fa21a96107c5声明：本文为 CSDN 翻译，未经允许，禁止转载。作者 | Andrew Zuo译者 | 弯月 责编 | 屠敏出品 | CSDN（ID：CSDNnews）我很喜欢 C#。大学毕业后，...
C#、VB、IL反编译工具_ILSpy_Master（最新）.rar
06-12
ILSpy是.NET开发中必备的反编译工具，ILSpy的界面与Reflector相似，左边以树型控件显示程序集和它的类型，右边是对应的源代码。基础的反编译功能，与Reflector相比，丝毫不差，甚至有时候用Reflector无法反编译(因为加密)的程序集，用ILSpy可以反编译。
C# 反编译工具之ILSpy
11-20
所有的对话框、菜单和提示均已中文化 预置了调试插件，支持在ILSpy中无源代码直接调试程序集 调整主程序编译平台为X86，以在64位系统中调试
如何通过IL了解C#类的构造函数浅析
01-01
前言 我们知道，在调用构造函数时，C#会先对类中的字段、属性进行初始化操作。那么，问题来了，为什么在调用构造函数前会初始化类中的字段和属性呢...使用ildasm工具对.exe文件进行IL反编译，下面是构造函数的IL代码：
ILSpy-2.3 c# 反编译工具
06-08
1. **反编译**: ILSpy能够将.NET程序集（.dll或.exe文件）中的元数据和IL代码转换为易于理解的C#或VB.NET源代码。这对于学习、调试或逆向工程其他人的软件项目非常有用。 2. **资源查看器**: 工具不仅限于代码，还...
C#反编译工具-Reflector_7.3.0.18_10
04-14
《C#反编译工具-Reflector_7.3.0.18_10》是一款专门用于解析和理解C#代码的软件，它能够帮助开发者深入探究.NET框架下的程序集内部工作原理。Reflector以其强大的功能和易用性，在编程社区中广受欢迎。 一、...
C＃反编译程序Reflector下载和使用方法
01-21
Reflector 是一款著名的C#反编译工具，由Lutz Roeder开发，允许开发者查看、分析和理解.NET框架下的编译后代码，包括C#、VB.NET和IL（中间语言）。通过Reflector，开发者可以查看到源代码级别的细节，这对于学习、...
C#-继承、子类调用父类的构造函数、访问修饰符protected
Nikita
12-29 5252
继承代码示例 子类继承父类的 //Teacher类,Student类:Person类 //子类：父类 //派生类：基类 public class Person//父类 { private string _name; public string Name { get { return _name; } set { _name = value; ...
C#构造函数
DEV HOME
10-04 2917
C#构造函数是一种特殊的成员函数,它主要用于为对象分配存储空间,对数据成员进行初始化.     (1)C#构造函数的名字必须与类同名;     (2)C#构造函数没有返回类型,它可以带参数,也可以不带参数;     (3)C#构造函数的主要作用是完成对类的初始化工作;     (4)在创建一个类的新对象（使用new关键字）时，系统回自动调用给类的构造函数初始化新对象;     C#的类有
初探IL：从IL看C#语法（一）使用ILSpy和ILDasm的使用
ZslLoveMiwa的博客
05-06 7034
一.工具介绍1. ILSpy.exe（点击下载）：用来查看IL代码；2. ILDasm（点击下载）：看.net Framework中的程序集中方法的源码（通过反编译），即BCL中的代码； 工具在开发工具中有，也可以从上面的连接链接中下载。二.C#程序的编译过程1. 预编译：从C#代码编译为MSIL中间语言代码的过程；2. 即时编译（JIT）：从MSIL中间语言代码编译为机器代码的过程；三.简单的实...
C# 构造函数与析构函数
eskimoer的专栏
03-24 2646
（1）构造函数 除非是static，否则编译器将会给每一个没有构造函数的类指定一个默认的构造函数 构造函数private时候，类不能被实例化 派生类可以通过base来显式的调用基类的构造函数，当无显式调用时，编译器会自动的调用基类的默认构造函数 基类没有默认构造函数，派生类必须显式的调用base 构造函数可以标记为 public，protected，private，internal，pr
C#中的构造函数，私有构造函数，静态构造函数以及构造函数的执行顺序
weixin_36504157的博客
08-21 2029
1.默认构造函数：如果类中没有定义构造函数那么程序会默认的为类创建一个无参数构造函数用以对类进行实例化，如果有构造函数的话，那么程序就不会创建默认构造函数 2静态构造函数，不能访问实例成员，只能用来初始化一些静态字段或者属性，仅在第一次调用类的任何成员时自动执行，不带访问修饰符，不带任何参数，每个类只能有一个静态构造函数，但可以同时还有一个无参实例构造函数， 3.私有构造函数：把访问的属性设置...
C#.Net里面的.CCtor和Ctor是什么呢
dotNET跨平台
09-26 610
1.前言RT:有人问Net里面的.CCtor和Ctor是什么？首先说答案，.CCtor是静态构造函数，.Ctor是非静态构造函数。通过例子分析下这两个特殊的函数，本篇看下。2.概述先上例子：public class ABC{ public ABC(){ } int i=0x10; } public class BBC:ABC{ public BBC(){ } int i =...
C#构造函数、操作符重载以及自定义类型转换
weixin_30868855的博客
09-11 131
构造器 　　构造器（构造函数）是将类型的实例初始化的特殊方法。构造器可分为实例构造器和类型构造器，本节将详细介绍有关内容。 实例构造器 　　顾名思义，实例构造器的作用就是对类型的实例进行初始化。如果类没有显示定义任何构造器，C#编译器会定义一个默认的无参构造器。相反，如果类中已经显示地定义了一个构造器，那么就不会再生成默认构造器了。定义实例构造器的语法这里就不再多做阐述了（该懂得要懂呀），下面通...
反编译C#的dll文件并修改，再重新生成dll
热门推荐
Sbangm的专栏
08-01 2万+
前话：自从换了份工作，着重于JAVA底层接口服务开发，就很少写博客文章了，一来事情比较忙，二来封闭式的开发让我不能时刻把新的技术问题解决方案写下来。 今天公司一个C#的项目svn上代码不是最新的，代码编写人又离职了，只能把已编译且下在使用的dll文件取下来，反编译后再修改代码。 1、把dll文件导入到ildasm工具中，ildasm是由微软提供的.net程序反编译工具，位于“C:\Progra
C#对象结构
farmwang的专栏
08-06 482
.ctor：类的构造函数，在类被实例化时，它会被自动调用。   class test     {              } 类test中没有显示的构造函数，现在用ILDasm.exe打开编译后生成的exe文件，会看到： 可以看到这里有个.ctor，我们没有定义构造函数，但这里却出现了.ctor，这就说明了： 当没有显示定义构造函数时，会自动生成一个构造函数，它没有
C#入门：构造函数详解与.NET编译过程
本资源是一份关于C#入门的经典PPT，着重介绍了构造函数在C#编程中的应用以及.NET框架的工作原理。主要内容分为两部分： 1. 构造函数实例讲解： - 在`Student`类中，有两个构造函数。第一个是无参构造函数，通过`: ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值