EF 通用数据层 增删改查操作，泛型类II

最新推荐文章于 2024-04-06 16:02:04 发布
最新推荐文章于 2024-04-06 16:02:04 发布
阅读量8.3k 收藏 19
点赞数 8
分类专栏： .Net(C#) 文章标签： C# EF 泛型 通用增删改查
本文详细介绍了一个针对MSSql数据库的数据访问层实现方案，包括增删改查等核心功能的具体实现方式。提供了多种场景下数据库操作的方法，如单个实体的增删改查、批量操作、条件查询及分页查询等。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

using System;
using System.Collections.Generic;
using System.Data.Entity.Infrastructure;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
 
namespace DAL
{
	/// MSSql 数据库 数据层 父类
	/// </summary>
	/// <typeparam name="T"></typeparam>
	public class BaseDAL<T> where T : class,new()
	{
		/// <summary>
		/// EF 上下文对象
		/// </summary>
		DbContext db = new DBContextFactory().GetDbContext();


//增
#region 1.0 新增实体，返回受影响的行数 +  int Add(T model)
	/// <summary>
	/// 1.0 新增实体，返回受影响的行数
	/// </summary>
	/// <param name="model"></param>
	/// <returns>返回受影响的行数</returns>
	public int Add(T model)
	{
	    db.Set<T>().Add(model);
	    //保存成功后，会将自增的id设置给model的主键属性，并返回受影响的行数。
	    return db.SaveChanges();
	}
	#endregion
	#region 1.1 新增实体，返回对应的实体对象 + T AddReturnModel(T model)
	/// <summary>
	/// 1.1 新增实体，返回对应的实体对象
	/// </summary>
	/// <param name="model"></param>
	/// <returns></returns>
	public T AddReturnModel(T model)
	{
	    db.Set<T>().Add(model);
	    db.SaveChanges();
	    return model;
	}
	#endregion

//删
#region 2.0 根据id删除 +  int Del(T model)
	/// <summary>
	/// 2.0 根据id删除
	/// </summary>
	/// <param name="model">必须包含要删除id的对象</param>
	/// <returns></returns>
	public int Del(T model)
	{
	    db.Set<T>().Attach(model);
	    db.Set<T>().Remove(model);
	    return db.SaveChanges();
	}
	#endregion
	#region 2.1 根据条件删除 + int DelBy(Expression<Func<T, bool>> delWhere)
	/// <summary>
	/// 2.1 根据条件删除
	/// </summary>
	/// <param name="delWhere"></param>
	/// <returns>返回受影响的行数</returns>
	public int DelBy(Expression<Func<T, bool>> delWhere)
	{
	    //2.1.1 查询要删除的数据
	    List<T> listDeleting = db.Set<T>().Where(delWhere).ToList();
	    //2.1.2 将要删除的数据 用删除方法添加到 EF 容器中
	    listDeleting.ForEach(u =>
		{
		    db.Set<T>().Attach(u);  //先附加到EF 容器
		    db.Set<T>().Remove(u); //标识为删除状态
		});
	    //2.1.3 一次性生成sql语句 到数据库执行删除
	    return db.SaveChanges();
	}
	#endregion

//改
#region 3.0 修改实体 +  int Modify(T model)
		/// <summary>
		/// 修改实体
		/// </summary>
		/// <param name="model"></param>
		/// <returns></returns>
		public int Modify(T model)
		{
			DbEntityEntry entry = db.Entry<T>(model);
			entry.State = EntityState.Modified;
			return db.SaveChanges();
		}
		#endregion
		#region 3.1 修改实体，可修改指定属性 + int Modify(T model, params string[] propertyNames)
		/// <summary>
		/// 3.1 修改实体，可修改指定属性
		/// </summary>
		/// <param name="model"></param>
		/// <param name="propertyName"></param>
		/// <returns></returns>
		public int Modify(T model, params string[] propertyNames)
		{
			//3.1.1 将对象添加到EF中
			DbEntityEntry entry = db.Entry<T>(model);
			//3.1.2 先设置对象的包装状态为 Unchanged
			entry.State = EntityState.Unchanged;
			//3.1.3 循环被修改的属性名数组
			foreach (string propertyName in propertyNames)
			{
				//将每个被修改的属性的状态设置为已修改状态；这样在后面生成的修改语句时，就只为标识为已修改的属性更新
				entry.Property(propertyName).IsModified = true;
			}
			return db.SaveChanges();
		}
		#endregion
		#region 3.2 批量修改 + int ModifyBy(T model, Expression<Func<T, bool>> whereLambda, params string[] modifiedPropertyNames)
		/// <summary>
		/// 3.2 批量修改
		/// </summary>
		/// <param name="model"></param>
		/// <param name="whereLambda"></param>
		/// <param name="modifiedPropertyNames"></param>
		/// <returns></returns>
		public int ModifyBy(T model, Expression<Func<T, bool>> whereLambda, params string[] modifiedPropertyNames)
		{
			//3.2.1 查询要修改的数据
			List<T> listModifing = db.Set<T>().Where(whereLambda).ToList();
			//3.2.2 获取实体类类型对象
			Type t = typeof(T);
			//3.2.3 获取实体类所有的公共属性
			List<PropertyInfo> propertyInfos = t.GetProperties(BindingFlags.Instance | BindingFlags.Public).ToList();
			//3.2.4 创建实体属性字典集合
			Dictionary<string, PropertyInfo> dicPropertys = new Dictionary<string, PropertyInfo>();
			//3.2.5 将实体属性中要修改的属性名 添加到字典集合中  键：属性名  值：属性对象
			propertyInfos.ForEach(p =>
				{
					if (modifiedPropertyNames.Contains(p.Name))
					{
						dicPropertys.Add(p.Name, p);
					}
				});
			//3.2.6 循环要修改的属性名
			foreach (string propertyName in modifiedPropertyNames)
			{
				//判断要修改的属性名是否在实体类的属性集合中存在
				if (dicPropertys.ContainsKey(propertyName))
				{
					//如果存在，则取出要修改的属性对象
					PropertyInfo proInfo = dicPropertys[propertyName];
					//取出要修改的值
					object newValue = proInfo.GetValue(model, null);
					//批量设置要修改对象的属性
					foreach (T item in listModifing)
					{
						//为要修改的对象的要修改的属性设置新的值
						proInfo.SetValue(item, newValue, null);
					}
				}
			}
			//一次性生成sql语句 到数据库执行
			return db.SaveChanges();
		}
		#endregion

//查，查单个model
#region 4.0 根据条件查询单个model + T GetModel(Expression<Func<T, bool>> whereLambda)
	/// <summary>
	/// 4.0 根据条件查询单个model
	/// </summary>
	/// <param name="whereLambda"></param>
	/// <returns></returns>
	public T GetModel(Expression<Func<T, bool>> whereLambda)
	{
	    return db.Set<T>().Where(whereLambda).AsNoTracking().FirstOrDefault();
	}
	#endregion
	#region 4.1 根据条件查询单个model并排序  +  T GetModel<TKey>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda, bool isAsc = true)
	/// <summary>
	/// 4.1 根据条件查询单个model并排序
	/// </summary>
	/// <typeparam name="TKey"></typeparam>
	/// <param name="whereLambda"></param>
	/// <param name="orderLambda"></param>
	/// <param name="isAsc"></param>
	/// <returns></returns>
	public T GetModel<TKey>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda, bool isAsc = true)
	{
	    if (isAsc)
	    {
		return db.Set<T>().Where(whereLambda).OrderBy(orderLambda).AsNoTracking().FirstOrDefault();
	    }
	    else
	    {
		return db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda).AsNoTracking().FirstOrDefault();
	    }
	}
	#endregion

//查，查List
#region  5.0 根据条件查询 + List<T> GetListBy(Expression<Func<T, bool>> whereLambda)
	/// <summary>
	/// 5.0 根据条件查询
	/// </summary>
	/// <param name="whereLambda"></param>
	/// <returns></returns>
	public List<T> GetListBy(Expression<Func<T, bool>> whereLambda)
	{
	    return db.Set<T>().Where(whereLambda).AsNoTracking().ToList();
	}
	#endregion
	#region 5.1 根据条件查询，并排序 +  List<T> GetListBy<TKey>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda, bool isAsc = true)
	/// <summary>
	/// 5.1 根据条件查询，并排序
	/// </summary>
	/// <typeparam name="TKey"></typeparam>
	/// <param name="whereLambda"></param>
	/// <param name="orderLambda"></param>
	/// <param name="isAsc"></param>
	/// <returns></returns>
	public List<T> GetListBy<TKey>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda, bool isAsc = true)
	{
	    if (isAsc)
	    {
		return db.Set<T>().Where(whereLambda).OrderBy(orderLambda).AsNoTracking().ToList();
	    }
	    else
	    {
		return db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda).AsNoTracking().ToList();
	    }
	}
	#endregion
	#region 5.2 根据条件查询Top多少个，并排序 + List<T> GetListBy<TKey>(int top, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda, bool isAsc = true)
	/// <summary>
	/// 5.2 根据条件查询Top多少个，并排序
	/// </summary>
	/// <typeparam name="TKey"></typeparam>
	/// <param name="top"></param>
	/// <param name="whereLambda"></param>
	/// <param name="orderLambda"></param>
	/// <param name="isAsc"></param>
	/// <returns></returns>
	public List<T> GetListBy<TKey>(int top, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda, bool isAsc = true)
	{
	    if (isAsc)
	    {
		return db.Set<T>().Where(whereLambda).OrderBy(orderLambda).Take(top).AsNoTracking().ToList();
	    }
	    else
	    {
		return db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda).Take(top).AsNoTracking().ToList();
	    }
	}
	#endregion
#region  5.3 根据条件排序查询  双排序 + List<T> GetListBy<TKey1, TKey2>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey1>> orderLambda1, Expression<Func<T, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)
	/// <summary>
	/// 5.3 根据条件排序查询  双排序
	/// </summary>
	/// <typeparam name="TKey1"></typeparam>
	/// <typeparam name="TKey2"></typeparam>
	/// <param name="whereLambda"></param>
	/// <param name="orderLambda1"></param>
	/// <param name="orderLambda2"></param>
	/// <param name="isAsc1"></param>
	/// <param name="isAsc2"></param>
	/// <returns></returns>
	public List<T> GetListBy<TKey1, TKey2>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey1>> orderLambda1, Expression<Func<T, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)
	{
	    if (isAsc1)
	    {
		if (isAsc2)
		{
		    return db.Set<T>().Where(whereLambda).OrderBy(orderLambda1).ThenBy(orderLambda2).AsNoTracking().ToList();
		}
		else
		{
		    return db.Set<T>().Where(whereLambda).OrderBy(orderLambda1).ThenByDescending(orderLambda2).AsNoTracking().ToList();
		}
	    }
	    else
	    {
		if (isAsc2)
		{
		    return db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda1).ThenBy(orderLambda2).AsNoTracking().ToList();
		}
		else
		{
		    return db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda1).ThenByDescending(orderLambda2).AsNoTracking().ToList();
		}
	    }
	} 
	#endregion
#region 5.3 根据条件排序查询Top个数  双排序 + List<T> GetListBy<TKey1, TKey2>(int top, Expression<Func<T, bool>> whereLambda, System.Linq.Expressions.Expression<Func<T, TKey1>> orderLambda1, Expression<Func<T, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)
	/// <summary>
	///  5.3 根据条件排序查询Top个数  双排序
	/// </summary>
	/// <typeparam name="TKey1"></typeparam>
	/// <typeparam name="TKey2"></typeparam>
	/// <param name="top"></param>
	/// <param name="whereLambda"></param>
	/// <param name="orderLambda1"></param>
	/// <param name="orderLambda2"></param>
	/// <param name="isAsc1"></param>
	/// <param name="isAsc2"></param>
	/// <returns></returns>
	public List<T> GetListBy<TKey1, TKey2>(int top, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey1>> orderLambda1, Expression<Func<T, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)
	{
	    if (isAsc1)
	    {
		if (isAsc2)
		{
		    return db.Set<T>().Where(whereLambda).OrderBy(orderLambda1).ThenBy(orderLambda2).Take(top).AsNoTracking().ToList();
		}
		else
		{
		    return db.Set<T>().Where(whereLambda).OrderBy(orderLambda1).ThenByDescending(orderLambda2).Take(top).AsNoTracking().ToList();
		}
	    }
	    else
	    {
		if (isAsc2)
		{
		    return db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda1).ThenBy(orderLambda2).Take(top).AsNoTracking().ToList();
		}
		else
		{
		    return db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda1).ThenByDescending(orderLambda2).Take(top).AsNoTracking().ToList();
		}
	    }
	} 
	#endregion

//查，带分页查询
#region 6.0 分页查询 + List<T> GetPagedList<TKey>
	/// <summary>
	/// 分页查询 + List<T> GetPagedList
	/// </summary>
	/// <typeparam name="TKey"></typeparam>
	/// <param name="pageIndex">页码</param>
	/// <param name="pageSize">页容量</param>
	/// <param name="whereLambda">条件 lambda表达式</param>
	/// <param name="orderBy">排序 lambda表达式</param>
	/// <returns></returns>
	public List<T> GetPagedList<TKey>(int pageIndex, int pageSize, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderByLambda, bool isAsc = true)
	{
	    // 分页 一定注意： Skip 之前一定要 OrderBy
	    if (isAsc)
	    {
		return db.Set<T>().Where(whereLambda).OrderBy(orderByLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToList();
	    }
	    else
	    {
		return db.Set<T>().Where(whereLambda).OrderByDescending(orderByLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToList();
	    }
	}
	#endregion
	#region 6.1分页查询 带输出 +List<T> GetPagedList<TKey>
	/// <summary>
	/// 分页查询 带输出
	/// </summary>
	/// <typeparam name="TKey"></typeparam>
	/// <param name="pageIndex"></param>
	/// <param name="pageSize"></param>
	/// <param name="rowCount"></param>
	/// <param name="whereLambda"></param>
	/// <param name="orderBy"></param>
	/// <param name="isAsc"></param>
	/// <returns></returns>
	public List<T> GetPagedList<TKey>(int pageIndex, int pageSize, ref int rowCount, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderByLambda, bool isAsc = true)
	{
	    rowCount = db.Set<T>().Where(whereLambda).Count();
	    if (isAsc)
	    {
		return db.Set<T>().OrderBy(orderByLambda).Where(whereLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToList();
	    }
	    else
	    {
		return db.Set<T>().OrderByDescending(orderByLambda).Where(whereLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToList();
	    }
	}
	#endregion
	#region 6.2 分页查询 带输出 并支持双字段排序
	/// <summary>
	/// 分页查询 带输出 并支持双字段排序
	/// </summary>
	/// <typeparam name="TKey"></typeparam>
	/// <param name="pageIndex"></param>
	/// <param name="pageSize"></param>
	/// <param name="rowCount"></param>
	/// <param name="whereLambda"></param>
	/// <param name="orderByLambda1"></param>
	/// <param name="orderByLambda2"></param>
	/// <param name="isAsc1"></param>
	/// <param name="isAsc2"></param>
	/// <returns></returns>
	public List<T> GetPagedList<TKey1, TKey2>(int pageIndex, int pageSize, ref int rowCount, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey1>> orderByLambda1, Expression<Func<T, TKey2>> orderByLambda2, bool isAsc1 = true, bool isAsc2 = true)
	{
	    rowCount = db.Set<T>().Where(whereLambda).Count();
	    if (isAsc1)
	    {
		if (isAsc2)
		{
		    return db.Set<T>().OrderBy(orderByLambda1).ThenBy(orderByLambda2).Where(whereLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToList();
		}
		else
		{
		    return db.Set<T>().OrderBy(orderByLambda1).ThenByDescending(orderByLambda2).Where(whereLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToList();
		}
	    }
	    else
	    {
		if (isAsc2)
		{
		    return db.Set<T>().OrderByDescending(orderByLambda1).ThenBy(orderByLambda2).Where(whereLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToList();
		}
		else
		{
		    return db.Set<T>().OrderByDescending(orderByLambda1).ThenByDescending(orderByLambda2).Where(whereLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToList();
		}
	    }
	}
	#endregion
	}
	}

基于 abp vNext 和 .NET Core 开发博客项目 - 自定义仓储之增删改查
阿星Plus
05-20 741
上一篇文章我们用Code-First的方式创建了博客所需的实体类，生成了数据库表，完成了对EF Core的封装。本篇说一下自定义仓储的实现方式，其实在abp框架中已经默认给我们实现了默认...
abp+dapper+mysql_基于 abp vNext 和 .NET Core 开发博客项目 - 自定义仓储之增删改查
weixin_39901685的博客
02-06 1382
上一篇文章(https://www.cnblogs.com/meowv/p/12913676.html)我们用Code-First的方式创建了博客所需的实体类，生成了数据库表，完成了对EF Core的封装。本篇说一下自定义仓储的实现方式，其实在abp框架中已经默认给我们实现了默认的通用(泛型)仓储，IRepository，有着标准的CRUD操作，可以看：https://docs.abp.io/zh...
EF+MVC+三层（MVC +三层架构+EF对数据库对数据库进行增删改查小案例）.zip
05-11
MVC +三层架构+EF对数据库对数据库进行增删改查小案例
通用增删改查方法
GSDS3143514的专栏
09-09 308
1.增删改通用的方法 传入SQL语句和SQL占位符 public static Boolean adu(String sql ,Object ...objs) { Boolean f =false; try { Connection con=DBUtil.getconnection(); ...
EF框架增删改查 简单封装
weixin_42199478的博客
05-05 477
EF框架增删改查新增数据批量新增数据修改数据删除批量删除查询一条数据查询列表同时获取查询数据的总量 新增数据 /// <summary> /// 新增数据 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="t"></param...
Java学习(尚硅谷)泛型类和泛型方法在数据库操作方面的应用
m0_55895641的博客
04-25 222
package java1; import java.util.List; /** * @author * @create 2022-04-25-10:00 * * DAO：Data(base) Access Object */ public class DAO <T>{//表的共性操作的DAO //添加一条记录 public void add(T t){ } //删除一条记录 public boolean remove(int inde.
学习笔记－泛型的使用：通用数据库增删改查
ligenmt的专栏
06-01 834
利用泛型，得到一个通用的数据库工具类，进行增删改查
C#基于DBContext(EF)实现通用增删改查的REST方法实例
09-04
本实例主要讲解如何利用DBContext和RESTful原则创建通用的增删改查方法，简化代码重复性，提高开发效率。 首先，我们需要创建一个基于DBContext的泛型类`GenericDBContext<T>`。这个类继承自特定的DbContext子类...
.net framework ef封装类，增删改查，批量新增，批量删除，批量修改，支持内连接，要求是范型，通用的父类，请给出源码
最新发布
10-24
它通过泛型类和抽象基类实现了数据访问的CRUD（创建(Create)、读(Retrieve)、更新(Update)和删除(Delete)）操作以及更高级的功能，如批量操作。 然而，由于GitHub上完整的源代码不是公开的一部分，通常我们在实际...
EF6增改删等常用基类
ayanamireizero的专栏
11-21 6468
using System; using System.Linq; using System.Threading.Tasks; using System.Linq.Expressions; using System.Collections.Generic; using System.Data.Entity; using System.Data.Entity.Migrations; using Fan
EF实现增删改查
10-12
EF实现简单的增删改查 开发工具：VS2013、SQL server2012、
MVC+三层架构+EF的增删改查操作（连接数据库的）.rar
10-15
一个MVC+三层架构+EF的增删改查操作（连接数据库的）的demo可以借鉴学习一下mvc+EF的增删改查操作.主要方便自己以后用的时候来看一下复习，温故而知新。
搭建三层；用EF实现数据的查看和修改
12-02
项目中搭建三层，用EF写出数据访问层；表示层里面有数据的查询和修改。 ASP.NET 项目用的是客户端的方式完成的。
mock EF DbContext DbSet
05-09
mock EF DbContext DbSet How to mock an Entity Framework DbContext and its DbSet properties
ef三层增删改查_从一个ATM购物车项目上，带你看三层架构设计
weixin_39625586的博客
12-23 266
ATM购物车项目模拟实现一个ATM + 购物商城程序。该程序实现普通用户的登录注册、提现充值还款等功能，并且支持到网上商城购物的功能。账户余额足够支付商品价格时，扣款支付；余额不足时，无法支付，商品存放个人购物车。如果用户具有管理员功能，还支持管理员身份登录。具体需求见项目需求部分。三层架构项目开发中，清晰明了的结构设计非常重要。它的重要性至少体现在三个方面：结构清晰；可维护性强；可扩展性高。常用...
ef三层增删改查_增删改查（3）
weixin_39843151的博客
12-03 244
由于我是按标准三层架构来的（前面文章有包的结构图，可以上去看一看）前面我已经完成到dao的实现类，所以下面我需要创建service层以及serviceimpl层Service层创建类MemberService（这个跟dao层有点像）package edu.uc.service; import java.util.List; import edu.uc.bean.Member; public ...
EFCore通用数据操作类
weixin_46407807的博客
04-06 542
【代码】EFCore通用数据操作类。
EFCore常见用法
气氛组，yyds
08-21 2203
EFCore常见操作
转载：优快云 mvc ef 的简单增删改查操作
weixin_30814329的博客
03-09 82
如果不是同一个实体类 自己创建的一个实体类。那么同样引用dll。 写的比较乱。细看能看明白。最后保存的时候要保存和数据库匹配的实体类。 下面是个下拉框的接口 转载于:https://www.cnblogs.com/moxiaomai/p/8532420.html...
Java高效JDBC操作封装类实现增删改查(泛型应用)
### 知识点三：Java增删改查JDBC封装类(泛型封装) 在项目中直接使用经过高度封装的增删改查JDBC类，可以大大简化数据库操作的代码量和复杂度。封装类通常会隐藏底层的数据库连接细节，并提供一个简洁的API来执行...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值