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

最新推荐文章于 2025-01-08 22:07:11 发布
最新推荐文章于 2025-01-08 22:07:11 发布
阅读量7.1k 收藏 1
点赞数
分类专栏： Dapper.NET框架 文章标签： linq Dapper C# NET
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/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程序集

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 3460
dapper获取集合实体 /// /// 获取表tb_sys_zhuowei全部数据 /// public IEnumerable SelectAll_tb_sys_zhuowei() { using (IDbConnection conn = OpenConnection())
Dapper ORM 框架跟我学：第七课 - Dapper QueryFirstOrDefault 方法
最新发布
caifox的博客
01-08 959
是 Dapper 提供的一个扩展方法，基于 ADO.NET 的接口。用于执行 SQL 查询并返回查询结果的第一行，如果没有找到任何记录，则返回默认值。它非常适合用于需要获取单个记录但不希望抛出异常的场景。在这节课中，我们学习了 Dapper 的方法，并掌握了如何使用它进行数据库查询，尤其是查询单个记录但不希望抛出异常的场景。我们还了解了的各个参数，学会了如何执行匿名查询、强类型查询等。通过这些知识，你可以更加灵活地操作数据库，提升开发效率。是 Dapper 提供的一个扩展方法，基于 ADO.NET 的接口。
[LINQ2Dapper]最完整Dapper To Linq框架(四)---Linq和SQL并行使用
weixin_39349390的博客
06-24 2688
目录 [LINQ2Dapper]最完整Dapper To Linq框架(一)---基础查询 [LINQ2Dapper]最完整Dapper To Linq框架(二)---动态化查询 [LINQ2Dapper]最完整Dapper To Linq框架(三)---实体类关系映射 [LINQ2Dapper]最完整Dapper To Linq框架(四)---Linq和SQL并行使用 [LINQ2Da...
Dapper.Linq 使用教程
gitblog_00365的博客
08-31 510
Dapper.Linq 使用教程 项目地址:https://gitcode.com/gh_mirrors/da/Dapper.Linq 项目介绍 Dapper.Linq 是一个基于 Dapper 的扩展库，它通过 Linq 查询提供了更高级的数据库访问功能。Dapper 是一个简单对象映射器，可以将查询结果直接映射到 .NET 对象上，而 Dapper.Linq 在此基础上增加了 Linq 支持，...
.Net使用Dapper框架(快速上手)
热门推荐
夜飞鼠的专栏
03-10 1万+
在.net6快速使用Dapper，本文从Dapper的方法使用、参数、事务和存储过程等方法，提供Dapper框架的代码使用示例使我们快速便捷地使用该ROM框架。
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文件，无需额外安装...
.Net集成Dapper
qq_27860623的博客
08-16 606
3.自己封装一个Repository类，数据库连接，增、删、查、改进行封装。1.在NuGet里面搜索Dapper，找到需要下载的组件包。2.把Dapper安裝到需要使用的类库下面。4.在配置文件里面配置好数据库连接字符串。附录：AcsdbContext类的代码。...
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的开源LINQ扩展,且支持分库分表自动生成实体
A4610A的专栏
07-07 916
LnskyDB是基于Dapper的LINQ扩展,支持按时间分库分表,也可以自定义分库分表方法.而且可以T4生成实体类免去手写实体类的烦恼. 文档地址: https://liningit.github.io/LnskyDB/ 开源地址: https://github.com/liningit/LnskyDB
.NET CORE使用Dapper操作数据库
qq_43005276的博客
04-30 848
.net core使用dapper操作数据库
[LINQ2Dapper]最完整Dapper To Linq框架---基础查询
weixin_30782293的博客
07-21 535
(一)Model实体类 实体类层需要安装Kogel.Dapper.Extension表名字段特性。[更多特性详情请点击] using Kogel.Dapper.Extension.Attributes; public class users { /// <summary> /// 用户id(特性Identity标识该字段为主键) ...
Dapper.Common基于Dapper的开源LINQ超轻量扩展
dotNET跨平台
06-18 1973
Dapper.Common　　Dapper.Common是基于Dapper的LINQ实现,支持.net core,遵循Linq语法规则、链式调用、配置简单、上手快,支持M...
探索高效数据库操作新境界：Dapper.Linq深度剖析与应用
gitblog_00054的博客
06-12 971
探索高效数据库操作新境界：Dapper.Linq深度剖析与应用 Dapper.LinqDapper.Linq项目地址:https://gitcode.com/gh_mirrors/da/Dapper.Linq 在当今快速发展的软件开发领域，数据访问层的效率和灵活性成为决定项目成功与否的关键因素之一。今天，我们将一同深入探索一款旨在提升数据操作体验的开源宝藏——Dapper.Linq，它为.NET...
深入Linq2Dapper：构建高效数据操作类库
Linq 是 Microsoft 提出的一种集成于 .NET Framework 的编程语言集成查询技术，而 Dapper 则是一个流行的 ORM（对象关系映射）工具，通常被用作 ADO.NET 的微型ORM。 描述部分提到的 "Linq2Dapper 辅助类"，暗示了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值