Dapper.NET使用入门(一)【LINQ2Dapper】

最新推荐文章于 2023-04-30 13:35:53 发布
最新推荐文章于 2023-04-30 13:35:53 发布
阅读量7.1k 收藏 1
点赞数
分类专栏： Dapper.NET框架 文章标签： linq Dapper C# NET
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wulex/article/details/52473218
版权

此例子是使用LINQ2Dapper封装

Model实体类

 public class DataType
    {
        public int DataTypeId { get; set; }

        public string Name { get; set; }

        public bool IsActive { get; set; }

        public DateTime? Created { get; set; } 
    }
 public class Document
    {
        public int DocumentId { get; set; }
        public int FieldId { get; set; }
        public string Name { get; set; }
        public DateTime? Created { get; set; } 
    }
 public class Field
    {
        public int FieldId { get; set; }
        public int DataTypeId { get; set; }
        public string Name { get; set; }
    }

上下文

 public class DataContext
    {
        private readonly SqlConnection _connection;

        private Linq2Dapper<DataType> _dataTypes;

        private Linq2Dapper<Document> _documents;
        private Linq2Dapper<Field> _fields;

        public DataContext(string connectionString) : this(new SqlConnection(connectionString))
        {
        }

        public DataContext(SqlConnection connection)
        {
            _connection = connection;
        }

        public Linq2Dapper<DataType> DataTypes
        {
            get { return _dataTypes ?? (_dataTypes = CreateObject<DataType>()); }
        }

        public Linq2Dapper<Field> Fields
        {
            get { return _fields ?? (_fields = CreateObject<Field>()); }
        }

        public Linq2Dapper<Document> Documents
        {
            get { return _documents ?? (_documents = CreateObject<Document>()); }
        }

        private Linq2Dapper<T> CreateObject<T>()
        {
            return new Linq2Dapper<T>(_connection);
        }
    }

Linq2DapperShould.cs辅助类

 public class Linq2DapperShould
    {
        private static string ConnectionString
        {
            get
            {
                return
                    @"Data Source=.\SQLINSTANCE;Initial Catalog=DapperDemo;Persist Security Info=True;User ID=sa;Password=123456;";
            }
        }

        /// <summary>
        /// 选择所有记录
        /// </summary>
        public void SelectAllRecords()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results = cn.Query<DataType>().ToList();
                Console.WriteLine("SelectAllRecords:" + results.Count);
            }
        }

        /// <summary>
        /// 选择所有记录2
        /// </summary>
        public void SelectAllRecords2()
        {
            var cntx = new DataContext(ConnectionString);

            var results = cntx.DataTypes.Where(x => x.Name == "text").ToList();
            Console.WriteLine("SelectAllRecords2:" + results.Count);
        }


        public void SelectSpeedTest()
        {
            for (int i = 0; i < 500; i++)
            {
                using (var cn = new SqlConnection(ConnectionString))
                {
                    cn.Open();
                    var results = cn.Query<DataType>().ToList();
                    Console.WriteLine("SelectSpeedTest:" + results.Count);
                }
            }
        }


        /// <summary>
        /// 连接 查询
        /// </summary>
        public void JoinWhere()
        {
            var cntx = new DataContext(ConnectionString);

            var results = (from d in cntx.DataTypes
                join a in cntx.Fields on d.DataTypeId equals a.DataTypeId
                where a.DataTypeId == 1
                select d).ToList();
            Console.WriteLine("JoinWhere:" + results.Count);
        }

        //多表连接
        public void MultiJoinWhere()
        {
            var cntx = new DataContext(ConnectionString);

            var results = (from d in cntx.DataTypes
                join a in cntx.Fields on d.DataTypeId equals a.DataTypeId
                join b in cntx.Documents on a.FieldId equals b.FieldId
                where a.DataTypeId == 1 && b.FieldId == 1
                select d).ToList();
            Console.WriteLine("MultiJoinWhere:" + results.Count);
        }

        //WHERE 条件
        public void WhereContains()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                var r = (from a in cn.Query<DataType>()
                    where new[] {"text", "int", "random"}.Contains(a.Name)
                    orderby a.Name
                    select a).ToList();
                //where new[] { "text", "int", "random" }.Contains(a.Name)
                //orderby a.Name
                //select a).ToList();

                Console.WriteLine("WhereContains:" + r.Count);
            }
        }

        //WHERE 条件
        public void WhereEquals()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                foreach (var item in new[] {"text", "int"})
                {
                    var results = cn.Query<DataType>(x => x.Name == item).ToList();
                    Console.WriteLine("WhereEquals:" + results.Count);
                }
            }
        }


        //top语句
        public void Top1Statement()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results = cn.Query<DataType>().FirstOrDefault(m => !m.IsActive);
                Console.WriteLine("Top1Statement:" + results.Name);
            }
        }


        //top语句
        public void Top10A()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results = cn.Query<DataType>().Take(5).ToList();
                Console.WriteLine("Top10A:" + results.Count);
            }
        }

        //top语句
        public void Top10B()
        {
            const int topCount = 10;
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results = cn.Query<DataType>().Take(topCount).ToList();
                Console.WriteLine("Top10B:" + results.Count);
            }
        }

        //top语句
        public void Top10C()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                for (int topCount = 1; topCount < 5; topCount++)
                {
                    var results = cn.Query<DataType>().Take(topCount).ToList();
                    Console.WriteLine("Top10C:" + results.Count);
                }
            }
        }

        //唯一值
        public void Distinct()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results = cn.Query<DataType>().Distinct().ToList();
                Console.WriteLine("Distinct:" + results.Count);
            }
        }

        //排序
        public void OrderBy()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results = cn.Query<DataType>().OrderBy(m => m.Name).ToList();
                Console.WriteLine("OrderBy:" + results.Count);
            }
        }

        //多字段排序
        public void OrderByAndThenBy()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results = cn.Query<DataType>().OrderBy(m => m.Name).ThenBy(m => m.DataTypeId).ToList();
                Console.WriteLine("OrderByAndThenBy:" + results.Count);
            }
        }

        //排序
        public void OrderByWithTop()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results = cn.Query<DataType>().OrderBy(m => m.Name).ThenBy(m => m.DataTypeId).Take(5).ToList();
                Console.WriteLine("OrderByWithTop:" + results.Count);
            }
        }


        public void WhereSimpleEqual()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results = cn.Query<DataType>(m => m.Name == "text").ToList();
                Console.WriteLine("WhereSimpleEqual:" + results.Count);
                Console.WriteLine("WhereSimpleEqual:" + results[0].Name);
            }
        }


        public void WhereSimpleEqualWithoutParameter()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results = cn.Query<DataType>(m => m.DataTypeId == m.DataTypeId).ToList();
                Console.WriteLine("WhereSimpleEqualWithoutParameter:" + results.Count);
            }
        }


        public void WhereIsNullOrEmpty()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results = cn.Query<DataType>(m => String.IsNullOrEmpty(m.Name)).ToList();
                Console.WriteLine("WhereIsNullOrEmpty:" + results.Count);
            }
        }


        public void WhereNotIsNullOrEmpty()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results = cn.Query<DataType>(m => !String.IsNullOrEmpty(m.Name)).ToList();
                Console.WriteLine("WhereNotIsNullOrEmpty:" + results.Count);
            }
        }


        public void WhereHasValue()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results = cn.Query<DataType>(m => m.Created.HasValue).ToList();
                Console.WriteLine("WhereHasValue:" + results.Count);
            }
        }


        public void WhereNotHasValue()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results = cn.Query<DataType>(m => !m.Created.HasValue).ToList();
                Console.WriteLine("WhereNotHasValue:" + results.Count);
            }
        }


        public void WhereLike()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results = cn.Query<DataType>(m => m.Name.Contains("te")).ToList();
                Console.WriteLine("WhereLike:" + results.Count);
            }
        }


        public void WhereEndsWith()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results = cn.Query<DataType>(m => m.Name.StartsWith("te")).ToList();
                Console.WriteLine("WhereEndsWith:" + results.Count);
            }
        }


        public void WhereStartsWith()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results = cn.Query<DataType>(m => m.Name.EndsWith("xt")).ToList();
                Console.WriteLine("WhereStartsWith:" + results.Count);
            }
        }


        public void WhereEndsWithAndComparison()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results =
                    cn.Query<DataType>(m => m.Name.StartsWith("te", StringComparison.OrdinalIgnoreCase)).ToList();
                Console.WriteLine("WhereEndsWithAndComparison:" + results.Count);
            }
        }


        public void WhereStartsWithAndComparison()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results =
                    cn.Query<DataType>(m => m.Name.EndsWith("xt", StringComparison.OrdinalIgnoreCase)).ToList();
                Console.WriteLine("WhereStartsWithAndComparison:" + results.Count);
            }
        }


        public void WhereNotLike()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results = cn.Query<DataType>(m => !m.Name.Contains("te")).ToList();
                Console.WriteLine("WhereNotLike:" + results.Count);
            }
        }


        public void WhereNotEndsWith()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results = cn.Query<DataType>(m => !m.Name.StartsWith("te")).ToList();
                Console.WriteLine("WhereNotEndsWith:" + results.Count);
            }
        }


        public void WhereNotStartsWith()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results = cn.Query<DataType>(m => !m.Name.EndsWith("xt")).ToList();
                Console.WriteLine("WhereNotStartsWith:" + results.Count);
            }
        }


        public void TwoPartWhereAnd()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results = cn.Query<DataType>(m => m.Name == "text" && m.Created.HasValue).ToList();
                Console.WriteLine("TwoPartWhereAnd:" + results.Count);
            }
        }


        public void TwoPartWhereOr()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results = cn.Query<DataType>(m => m.Name == "text" || m.Name == "int").ToList();
                Console.WriteLine("TwoPartWhereOr:" + results.Count);
            }
        }


        public void MultiPartWhereAndOr()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results =
                    cn.Query<DataType>(m => m.Name == "text" && (m.Name == "int" || m.Created.HasValue)).ToList();
                Console.WriteLine("MultiPartWhereAndOr:" + results.Count);
            }
        }


        public void MultiPartWhereAndOr2()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var results =
                    cn.Query<DataType>(m => m.Name != "text" && (m.Name == "int" || m.Created.HasValue)).ToList();
                Console.WriteLine("MultiPartWhereAndOr2:" + results.Count);
            }
        }


        public void Single()
        {
            using (var cn = new SqlConnection(ConnectionString))
            {
                cn.Open();
                var result = cn.Query<DataType>().Single(m => m.Name == "text");
                Console.WriteLine("Single:" + result.Name);
            }
        }
    }

Program.cs主程序:

 internal class Program
    {
        private static void Main(string[] args)
        {
            Linq2DapperShould entity = new Linq2DapperShould();
            entity.SelectAllRecords();
            entity.SelectAllRecords2();
            entity.JoinWhere();
            entity.MultiJoinWhere();
            entity.MultiPartWhereAndOr();
            entity.MultiPartWhereAndOr2();
            entity.OrderBy();
            entity.OrderByAndThenBy();
            entity.OrderByWithTop();
            entity.Top10A();
            entity.Top10B();
            entity.Top10C();
            //entity.Top1Statement();
            entity.TwoPartWhereAnd();
            entity.TwoPartWhereOr();
            entity.WhereContains();
            entity.WhereEndsWith();
            entity.WhereEndsWithAndComparison();
            entity.WhereEquals();
            entity.WhereHasValue();
            entity.WhereIsNullOrEmpty();
            entity.WhereLike();
            entity.WhereNotEndsWith();
            entity.WhereNotHasValue();
            entity.WhereNotIsNullOrEmpty();
            entity.WhereNotLike();
            entity.WhereNotStartsWith();
            //entity.WhereSimpleEqual();
            entity.WhereSimpleEqualWithoutParameter();
            entity.WhereStartsWith();
            entity.WhereStartsWithAndComparison();
            //entity.SelectSpeedTest();

            //entity.Single();
            //...
            Console.ReadKey();
        }
    }

数据库sql脚本：

USE [DapperDemo]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [dbo].[Field](
    [FieldId] [int] IDENTITY(1,1) NOT NULL,
    [DataTypeId] [int] NOT NULL,
    [Name] [nvarchar](50) NOT NULL,
    [Created] [datetime] NOT NULL,
 CONSTRAINT [PK_Field] PRIMARY KEY CLUSTERED 
(
    [FieldId] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]
GO
/****** Object:  Table [dbo].[Document]    Script Date: 09/08/2016 16:51:37 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [dbo].[Document](
    [DocumentId] [int] IDENTITY(1,1) NOT NULL,
    [FieldId] [int] NOT NULL,
    [Name] [nvarchar](256) NOT NULL,
    [Created] [datetime] NOT NULL,
 CONSTRAINT [PK_Document] PRIMARY KEY CLUSTERED 
(
    [DocumentId] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]
GO
/****** Object:  Table [dbo].[DataType]    Script Date: 09/08/2016 16:51:37 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [dbo].[DataType](
    [DataTypeId] [int] IDENTITY(1,1) NOT NULL,
    [Name] [nvarchar](128) NOT NULL,
    [IsActive] [bit] NOT NULL,
    [Created] [datetime] NOT NULL,
 CONSTRAINT [PK_DataType] PRIMARY KEY CLUSTERED 
(
    [DataTypeId] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]
GO

运行结果：

这里写图片描述

Linq2Dapper程序集

.NET跨平台
关注
专栏目录
Dapper.Linq：Dapper.Linq
02-04
达珀·林克 免责说明：使用前请先测试和阅读源代码并自觉遵守开源协议 3.x版本说明 可移除dapper，无需依赖dapper，内置一个简约的对象映射器，用作替代dapper 新增简单的java.ibatis的xml功能 新版文档参考：，建议通过单测和二进制学习 建议尽快从Dapper.Linq和Dapper.Common移植到 sqlBatis代码可维护性极好，实体映射规则可定制化，移植成本非常小。 免责说明：使用前先测试 关于作者 电子邮件： QQ：1448376744 QQ群：642555086 设定档 // "LinqTypeMap" file in unit test proj
EFSqlTranslator：可与EF和Dapper一起使用的独立linq to sql转换器
01-28
可与EF和Dapper一起使用的独立linq to sql转换器。 译者是一个小人物库。 要使用该库，请使用您的nuget管理工具安装软件包和 。 签出EFSqlTranslator.ConsoleApp项目，以了解如何设置翻译器。 一，基础翻译 本节...
dapper+linq+json+ztree构建树
每天进步一点点
05-22 3425
dapper获取集合实体 /// /// 获取表tb_sys_zhuowei全部数据 /// public IEnumerable SelectAll_tb_sys_zhuowei() { using (IDbConnection conn = OpenConnection())
[LINQ2Dapper]最完整Dapper To Linq框架(四)---Linq和SQL并行使用
weixin_39349390的博客
06-24 2614
目录 [LINQ2Dapper]最完整Dapper To Linq框架(一)---基础查询 [LINQ2Dapper]最完整Dapper To Linq框架(二)---动态化查询 [LINQ2Dapper]最完整Dapper To Linq框架(三)---实体类关系映射 [LINQ2Dapper]最完整Dapper To Linq框架(四)---Linq和SQL并行使用 [LINQ2Da...
.Net使用Dapper框架(快速上手)
夜飞鼠的专栏
03-10 8658
在.net6快速使用Dapper，本文从Dapper的方法使用、参数、事务和存储过程等方法，提供Dapper框架的代码使用示例使我们快速便捷地使用该ROM框架。
.Net集成Dapper
qq_27860623的博客
08-16 562
3.自己封装一个Repository类，数据库连接，增、删、查、改进行封装。1.在NuGet里面搜索Dapper，找到需要下载的组件包。2.把Dapper安裝到需要使用的类库下面。4.在配置文件里面配置好数据库连接字符串。附录：AcsdbContext类的代码。...
HybridOrm:首先在 Dapper .net 旁边使用 EF 代码的示例
06-26
**HybridOrm: 在Dapper .NET旁使用EF代码的示例** 在现代软件开发中，ORM（对象关系映射）工具如Entity Framework (EF) 和 Dapper 已成为.NET开发人员的重要工具。它们各自拥有独特的优势：EF 提供了强大的数据库...
StackExchange开源.Net ORM框架 Dapper.NET.zip
07-19
Dapper.Net的示例代码： public class Dog {  public int? Age { get; set; }  public Guid Id { get; set; }  public string Name { get; set; }  public float? Weight { get; set...
Linq2Dapper程序集
09-08
**Linq2Dapper程序集** 是一个针对.NET框架的高效数据访问库，它结合了Linq和Dapper的优点，为开发人员提供了简洁、高效的数据库操作API。Linq2Dapper辅助类使得开发者可以直接在项目中引用DLL文件，无需额外安装...
基于Dapper的开源LINQ扩展,且支持分库分表自动生成实体
A4610A的专栏
07-07 863
LnskyDB是基于Dapper的LINQ扩展,支持按时间分库分表,也可以自定义分库分表方法.而且可以T4生成实体类免去手写实体类的烦恼. 文档地址: https://liningit.github.io/LnskyDB/ 开源地址: https://github.com/liningit/LnskyDB
asp.net MVC+Dapper高性能管理系统框架
09-03
开发WEB管理系统时，我们都希望有一套底层框架，把界面都设计好，并且后台程序架构也搭建好，这样只需要在此基础上开发我们自己的业务流程就可以轻松实现管理系统。这个框架就实现了这个需要，前端利用bootstrap实现界面，与后台通过ajax交换数据。后台代码.net mvc控制器调用service服务层，service层调用dao层，而dao层是封装dapper的一个通用类，可以轻松增删改查数据。本框架可以支持ie10、火狐、谷歌等主流浏览器。
dapper帮助类(全异步编程)
10-16
ConnectionString为正常的连接字符串，放在xml里或者程序内都可以，dapper是最快速的轻量级ORM之一，百用不厌 支持批量插入、批量修改
Dapper.DBContext:像EF这样的勇敢蠕虫
05-27
Dapper.DBContext Dapper.DBContext是基于dapper的orm库。 这将帮助您完成80％的工作。 其余20％的工作（例如多表查询）建议您自己编写SQL。 nuget安装 安装包Dapper.DBContext 快速开始 public enum OrderStatus { Create , WaitToPay , Paid } // entity [ Table ( " tb_Order " )] public class Order : IEntity { // default primary key : rule is propertie name Id ,type is int public int Id { get ; set ; } public string Code { get ; set ; } [
.NET CORE使用Dapper操作数据库
qq_43005276的博客
04-30 737
.net core使用dapper操作数据库
[LINQ2Dapper]最完整Dapper To Linq框架---基础查询
weixin_30782293的博客
07-21 505
(一)Model实体类 实体类层需要安装Kogel.Dapper.Extension表名字段特性。[更多特性详情请点击] using Kogel.Dapper.Extension.Attributes; public class users { /// <summary> /// 用户id(特性Identity标识该字段为主键) ...
Dapper.Common基于Dapper的开源LINQ超轻量扩展
dotNET跨平台
06-18 1927
Dapper.Common　　Dapper.Common是基于Dapper的LINQ实现,支持.net core,遵循Linq语法规则、链式调用、配置简单、上手快,支持M...
[LINQ2Dapper]最完整Dapper To Linq框架(二)---动态化查询
weixin_39349390的博客
05-14 1465
目录 [LINQ2Dapper]最完整Dapper To Linq框架(一)---基础查询 [LINQ2Dapper]最完整Dapper To Linq框架(二)---动态化查询 [LINQ2Dapper]最完整Dapper To Linq框架(三)---实体类关系映射 [LINQ2Dapper]最完整Dapper To Linq框架(四)---Linq和SQL并行使用 [LINQ2Da...
[LINQ2Dapper]最完整Dapper To Linq框架(一)---基础查询
热门推荐
weixin_39349390的博客
05-03 1万+
此例子是使用LINQ2Dapper封装，效率优于EntityFramwork，并且支持.NetFramework和.NetCore框架，只依赖于Dapper 支持.net framework4.5.1,.net core2.0及以上,更低版本适配如.netFramework4.0及以下请加群下载 支持Mssql,Oracle,Mysql等数据库 应用层需要引用包Kogel.Dapp...
dapper 使用 IQueryable
最新发布
06-12
Dapper 是一个轻量级的 ORM 框架，它不支持直接使用 IQueryable 接口进行查询。但是，Dapper 提供了一种方式来实现类似于 IQueryable 的延迟执行查询的功能。 Dapper 的查询方法返回一个 IEnumerable，这意味着查询...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值