动态LINQ：运行时构建查询的魔法

于 2025-05-27 08:00:00 发布
阅读量2.1k 收藏 47
点赞数 83
分类专栏： LINQ C# 文章标签： linq c# microsoft 性能优化 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/O_____V_____O/article/details/148219625
版权

文章目录

动态 LINQ

动态 LINQ（Dynamic LINQ）是一种强大的技术，它允许开发人员在运行时动态构建 LINQ 查询，而不必在编译时就确定查询条件。这使得我们可以根据用户输入或程序状态来灵活地创建查询，大大提高了程序的灵活性和可维护性。本文将深入探讨动态 LINQ 的核心概念、实现方式以及在实际应用中的最佳实践。

1. 动态 LINQ 的基本概念

1.1 什么是动态 LINQ？

传统的 LINQ 查询通常是在编译时就确定的，代码如下：

// 传统的 LINQ 查询 - 在编译时确定
var query = from p in products
            where p.Category == "Electronics" && p.Price < 1000
            orderby p.Name
            select p;

而动态 LINQ 则允许我们使用字符串表达式来构建查询：

// 动态 LINQ 查询 - 可在运行时确定条件
string category = "Electronics"; // 可能来自用户输入
decimal price = 1000;           // 可能来自用户界面

// 使用字符串表达式构建查询
var query = products.Where($"Category == @0 && Price < @1", category, price)
                    .OrderBy("Name")
                    .Select("new(Name, Price)");

1.2 为什么需要动态 LINQ？

动态 LINQ 解决了以下几个问题：

  1. 运行时构建查询条件：可以根据用户的输入或运行时的状态动态构建查询条件。
  2. 简化复杂查询构建：减少了使用表达式树手动构建复杂查询的必要。
  3. 提高代码可维护性：将查询条件以字符串形式提取，使代码更加清晰。
  4. 支持前端到后端的查询传递：可以从前端传递查询条件到后端执行。

2. System.Linq.Dynamic.Core 库简介

2.1 库概述

System.Linq.Dynamic.Core 是一个开源库，为 .NET Core 和 .NET Standard 平台提供了动态 LINQ 查询功能。它是微软早期 .NET 4.0 动态语言功能的移植版本，支持多种 .NET 平台。

2.2 安装方法

通过 NuGet 包管理器安装:

dotnet add package System.Linq.Dynamic.Core

或使用 Package Manager Console:

Install-Package System.Linq.Dynamic.Core

2.3 基本用法

使用前需要添加命名空间:

using System.Linq.Dynamic.Core;

基本查询示例:

// 使用动态 LINQ 进行查询
var result = dbContext.Customers
    .Where("City == @0 and Orders.Count >= @1", "London", 10)
    .OrderBy("CompanyName")
    .Select("new(CompanyName as Name, Phone)");

3. 动态构建 LINQ 查询

3.1 基于字符串的查询表达式

动态 LINQ 的核心是使用字符串表达式来表示查询条件。这些表达式可以包含：

  • 属性访问（例如 Customer.Name）
  • 比较运算符（例如 ==, !=, >, <）
  • 逻辑运算符（例如 &&, ||, !）
  • 方法调用（例如 StartsWith, Contains）
  • 参数占位符（例如 @0, @1）
// 示例：使用动态 LINQ 的字符串表达式
string searchTerm = "John";
var query = customers.Where("FirstName.StartsWith(@0) || LastName.StartsWith(@0)", searchTerm);

3.2 动态排序

动态 LINQ 也支持动态排序，可以根据运行时指定的字段进行排序：

// 根据运行时确定的字段排序
string sortField = "LastName"; // 可能来自用户选择
bool ascending = true;         // 可能来自用户选择

var query = customers.OrderBy(ascending ? sortField : sortField + " DESC");

3.3 动态选择字段

可以动态选择需要返回的字段：

// 动态选择要返回的字段
string[] selectedFields = new[] { "FirstName", "LastName", "Email" }; // 可能来自用户选择
string selectExpression = string.Join(",", selectedFields);

var query = customers.Select("new(" + selectExpression + ")");

4. 表达式树和预编译查询

4.1 表达式树的基础

表达式树是 LINQ 的核心机制，它允许将 C# 代码表示为数据结构，然后可以被检查和修改。动态 LINQ 在内部使用表达式树来实现查询功能。

// 手动构建表达式树示例
ParameterExpression parameter = Expression.Parameter(typeof(Customer), "c");
Expression property = Expression.Property(parameter, "City");
Expression constant = Expression.Constant("London");
Expression equality = Expression.Equal(property, constant);

Expression<Func<Customer, bool>> lambda = Expression.Lambda<Func<Customer, bool>>(
    equality, parameter);

// 等价于: c => c.City == "London"

4.2 使用 ParseLambda 方法

System.Linq.Dynamic.Core 提供了 ParseLambda 方法，可以将字符串表达式解析为 Lambda 表达式：

// 使用 ParseLambda 方法解析字符串表达式为 Lambda 表达式
var config = new ParsingConfig {
    ResolveTypesBySimpleName = true
};

// 创建表达式: c => c.City == "London"
Expression<Func<Customer, bool>> expr = DynamicExpressionParser.ParseLambda<Customer, bool>(
    config,
    true,
    "City == @0",
    "London");

// 使用解析后的表达式
var result = customers.Where(expr);

4.3 预编译查询提升性能

动态 LINQ 查询在执行时需要解析字符串表达式，这可能会影响性能。通过预编译查询，可以提高查询执行的效率：

// 预编译动态查询以提高性能
var config = new ParsingConfig();
var parser = new ExpressionParser(config);

// 预先解析并编译查询表达式
Expression<Func<Customer, bool>> compiledExpression = parser.ParseLambda<Customer, bool>(
    "City == @0", "London");

// 保存编译后的表达式以便重复使用
var compiledQuery = customers.Where(compiledExpression).Compile();

// 多次使用编译后的查询
var results1 = compiledQuery(); 
// ... 其他操作后再次使用
var results2 = compiledQuery();

5. System.Linq.Dynamic.Core 高级特性

5.1 自定义类型提供程序

可以创建自定义类型提供程序来控制动态 LINQ 可以访问哪些类型：

// 创建自定义类型提供程序
public class CustomDynamicLinqTypeProvider : IDynamicLinkCustomTypeProvider
{
    public HashSet<Type> GetCustomTypes()
    {
        // 返回允许在动态表达式中使用的自定义类型
        return new HashSet<Type> { typeof(MyCustomClass) };
    }
}

// 在解析配置中使用自定义类型提供程序
var config = new ParsingConfig {
    CustomTypeProvider = new CustomDynamicLinqTypeProvider()
};

5.2 null 传播操作符支持

动态 LINQ 支持空条件操作符，类似于 C# 中的 ?. 操作符：

// 使用 null 传播操作符
var result = orders.Where("Customer?.Address?.City == @0", "London");

5.3 动态创建数据类

动态 LINQ 允许在运行时动态创建数据类：

// 动态创建数据类
var properties = new DynamicProperty[] {
    new DynamicProperty("Name", typeof(string)),
    new DynamicProperty("Age", typeof(int))
};

Type dynamicType = DynamicClassFactory.CreateType(properties);

// 创建动态类型的实例
dynamic instance = Activator.CreateInstance(dynamicType);
instance.Name = "John Doe";
instance.Age = 30;

6. 实际应用案例

6.1 动态筛选数据

下面是一个完整的动态筛选示例，允许用户根据不同条件筛选产品：

/// <summary>
/// 根据多种条件动态筛选产品
/// </summary>
public IQueryable<Product> FilterProducts(
    IQueryable<Product> products,
    string nameFilter = null,
    string categoryFilter = null,
    decimal? minPrice = null,
    decimal? maxPrice = null,
    bool inStockOnly = false)
{
    // 构建动态查询条件
    var conditions = new List<string>();
    var parameters = new List<object>();
    
    // 添加名称过滤条件
    if (!string.IsNullOrEmpty(nameFilter))
    {
        conditions.Add("Name.Contains(@" + parameters.Count + ")");
        parameters.Add(nameFilter);
    }
    
    // 添加类别过滤条件
    if (!string.IsNullOrEmpty(categoryFilter))
    {
        conditions.Add("Category == @" + parameters.Count);
        parameters.Add(categoryFilter);
    }
    
    // 添加最低价格过滤条件
    if (minPrice.HasValue)
    {
        conditions.Add("Price >= @" + parameters.Count);
        parameters.Add(minPrice.Value);
    }
    
    // 添加最高价格过滤条件
    if (maxPrice.HasValue)
    {
        conditions.Add("Price <= @" + parameters.Count);
        parameters.Add(maxPrice.Value);
    }
    
    // 添加库存过滤条件
    if (inStockOnly)
    {
        conditions.Add("StockQuantity > 0");
    }
    
    // 如果没有条件，返回所有产品
    if (conditions.Count == 0)
    {
        return products;
    }
    
    // 组合所有条件并执行查询
    string whereClause = string.Join(" && ", conditions);
    return products.Where(whereClause, parameters.ToArray());
}

6.2 动态排序与分页

实现通用的排序和分页功能：

/// <summary>
/// 应用动态排序和分页
/// </summary>
public IQueryable<T> ApplySortingAndPaging<T>(
    IQueryable<T> query,
    string sortField,
    bool ascending,
    int page,
    int pageSize)
{
    // 检查排序字段是否有效
    if (string.IsNullOrEmpty(sortField))
    {
        sortField = "Id"; // 默认排序字段
    }
    
    // 应用排序
    query = ascending 
        ? query.OrderBy(sortField) 
        : query.OrderBy(sortField + " DESC");
    
    // 应用分页
    // 注意：页码从1开始，需要转换为从0开始的索引
    int skip = (page - 1) * pageSize;
    return query.Skip(skip).Take(pageSize);
}

6.3 动态构建复杂查询

以下是一个更复杂的示例，展示如何动态构建包含联接、分组和聚合的查询：

/// <summary>
/// 构建复杂的动态报表查询
/// </summary>
public dynamic GenerateSalesReport(
    DateTime startDate,
    DateTime endDate,
    string groupBy,
    string[] metrics)
{
    // 验证分组字段
    if (!new[] { "Category", "Customer", "Date" }.Contains(groupBy))
    {
        throw new ArgumentException("Invalid group by field", nameof(groupBy));
    }
    
    // 构建选择字段表达式
    var selectFields = new List<string>();
    selectFields.Add(groupBy); // 添加分组字段
    
    // 添加指定的度量指标
    foreach (var metric in metrics)
    {
        switch (metric)
        {
            case "TotalSales":
                selectFields.Add("Sum(Amount) AS TotalSales");
                break;
            case "OrderCount":
                selectFields.Add("Count() AS OrderCount");
                break;
            case "AverageOrderValue":
                selectFields.Add("Sum(Amount)/Count() AS AverageOrderValue");
                break;
            default:
                throw new ArgumentException($"Invalid metric: {metric}");
        }
    }
    
    // 构建基础查询 - 过滤日期范围
    var query = dbContext.Orders
        .Where("OrderDate >= @0 && OrderDate <= @1", startDate, endDate);
    
    // 应用动态分组
    var groupedQuery = query.GroupBy($"{groupBy}", "it");
    
    // 应用选择表达式
    string selectExpression = "new(" + string.Join(", ", selectFields) + ")";
    var result = groupedQuery.Select(selectExpression);
    
    return result;
}

7. 最佳实践与性能优化

7.1 安全性考虑

使用动态 LINQ 时，需要注意以下安全问题：

// 不安全的用法 - 直接使用用户输入构建查询
var userInput = "Name == 'John' OR 1=1"; // 潜在的注入风险
var unsafeQuery = customers.Where(userInput); // 危险！

// 安全的用法 - 使用参数化查询
string name = "John";
var safeQuery = customers.Where("Name == @0", name);

// 安全的用法 - 验证排序字段
public IQueryable<T> SafeOrderBy<T>(IQueryable<T> query, string sortField)
{
    // 验证排序字段是否合法（例如，是否是实体的属性）
    var properties = typeof(T).GetProperties().Select(p => p.Name);
    if (!properties.Contains(sortField))
    {
        // 使用默认排序或抛出异常
        sortField = "Id"; // 默认排序字段
    }
    
    return query.OrderBy(sortField);
}

7.2 性能优化技巧

// 1. 缓存解析后的表达式树
private static readonly ConcurrentDictionary<string, Expression<Func<Customer, bool>>> _expressionCache = 
    new ConcurrentDictionary<string, Expression<Func<Customer, bool>>>();

public IQueryable<Customer> GetCustomersOptimized(string city)
{
    // 构建缓存键
    string cacheKey = $"City_Equals_{city}";
    
    // 尝试从缓存获取表达式
    if (!_expressionCache.TryGetValue(cacheKey, out var expression))
    {
        // 如果缓存中不存在，则创建并添加到缓存
        expression = DynamicExpressionParser.ParseLambda<Customer, bool>(
            new ParsingConfig(), true, "City == @0", city);
        
        _expressionCache[cacheKey] = expression;
    }
    
    // 使用缓存的表达式
    return _customers.Where(expression);
}

// 2. 避免不必要的字符串解析
// 不推荐：频繁解析简单的表达式
public IQueryable<T> FindById<T>(IQueryable<T> query, int id)
{
    // 对于简单且固定的条件，直接使用 lambda 表达式
    // 不要使用: return query.Where("Id == @0", id);
    return query.Where(e => EF.Property<int>(e, "Id") == id);
}

7.3 常见陷阱与解决方案

// 陷阱1：忽略数据库提供程序的限制
// 某些 LINQ 提供程序可能不支持所有的表达式
try
{
    // 可能不被所有提供程序支持的查询
    var result = dbContext.Customers
        .Where("SUBSTRING(Name, 1, 3) == @0", "Joh")
        .ToList();
}
catch (Exception ex)
{
    // 处理不支持的操作
    Console.WriteLine("数据库提供程序不支持此操作: " + ex.Message);
    
    // 替代方案：将数据加载到内存中再处理
    var result = dbContext.Customers.ToList()
        .Where(c => c.Name.Substring(0, 3) == "Joh");
}

// 陷阱2：忽略 null 值处理
// 某些数据库处理 null 值的方式可能与 .NET 不同
var nullableQuery = dbContext.Products
    // 使用 ?? 运算符处理可能的 null 值
    .Where("Description != null && Description.Contains(@0)", "keyword");

8. 动态 LINQ 与表达式树详解

8.1 表达式树可视化

表达式树结构可以被可视化为树状结构，以便更好地理解查询的构建过程：
Lambda Expression
Binary Operation '=='
Property Access 'Customer.City'
Constant 'London'
Parameter 'c'

8.2 手动构建复杂表达式树

下面展示了如何手动构建复杂的表达式树，以实现更高级的动态查询：

/// <summary>
/// 手动构建动态过滤表达式树
/// </summary>
public static Expression<Func<T, bool>> BuildFilterExpression<T>(
    string propertyName, 
    string operatorName, 
    object value)
{
    // 创建参数表达式 (x => ...)
    var parameter = Expression.Parameter(typeof(T), "x");
    
    // 创建属性访问表达式 (x.Property)
    var property = Expression.Property(parameter, propertyName);
    
    // 创建常量表达式
    var constant = Expression.Constant(value);
    
    // 确保类型匹配
    if (property.Type != constant.Type)
    {
        constant = Expression.Convert(constant, property.Type);
    }
    
    // 构建比较表达式
    Expression comparison;
    switch (operatorName.ToLower())
    {
        case "equals":
        case "==":
            comparison = Expression.Equal(property, constant);
            break;
        case "notequals":
        case "!=":
            comparison = Expression.NotEqual(property, constant);
            break;
        case "greaterthan":
        case ">":
            comparison = Expression.GreaterThan(property, constant);
            break;
        case "lessthan":
        case "<":
            comparison = Expression.LessThan(property, constant);
            break;
        case "contains":
            // 对于字符串类型的 Contains 方法
            if (property.Type == typeof(string))
            {
                var method = typeof(string).GetMethod("Contains", new[] { typeof(string) });
                comparison = Expression.Call(property, method, constant);
            }
            else
            {
                throw new NotSupportedException($"Contains operator not supported for {property.Type.Name}");
            }
            break;
        default:
            throw new NotSupportedException($"Operator {operatorName} is not supported");
    }
    
    // 构建并返回 lambda 表达式
    return Expression.Lambda<Func<T, bool>>(comparison, parameter);
}

// 使用示例
var expression = BuildFilterExpression<Customer>("City", "contains", "London");
var customers = dbContext.Customers.Where(expression);

9. 总结

动态 LINQ 是 .NET 开发中的一个强大工具，它通过允许在运行时构建查询，大大增强了应用程序的灵活性。通过 System.Linq.Dynamic.Core 库，我们可以实现字符串表达式查询、动态排序选择、预编译查询等高级功能，从而构建出更加灵活和可维护的代码。

在使用动态 LINQ 时，需要注意安全性问题，避免 SQL 注入风险；同时要关注性能优化，例如缓存表达式树、避免频繁解析等。通过深入理解表达式树和动态 LINQ 的工作原理，我们可以更好地利用这一强大的工具来构建高效的数据访问层。

动态 LINQ 在复杂的业务查询、报表生成、通用数据接口等场景中尤为有用，是每个 .NET 开发人员都应该掌握的技术。

参考资源

在这里插入图片描述

Android与PC通过USB连接通信（一）
HarunaHarunaHaruna的博客
02-22 5025
Android与PC通过USB连接通信（一） 原理 通过在Android设备与PC之间通过USB建立socket连接，以Android作为服务器，PC作为客户端，通过adb进行转发通信。 客户端代码及分析 package com.geo.main; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; ...
Android开发，通过USB手机访问本地服务器
棒棒糖的专栏
05-08 3146
在上一篇文章中，介绍了用Android模拟器与本地服务器交互时遇到问题的处理方法，可是用Android模拟器，有时反应实在是太慢，这时我们可以用真机测试。但问题来了，真机访问不了本地服务器，为什么？因为你手机和你的服务器没有在同一个局域网内。下面，就介绍下如何使手机与本地服务器在同一个局域网内：           一、台式机上，用手机访问本地Tomcat服务器              
android手机通过usb绑定与PC互联接上网(总结)
weixin_30412167的博客
08-12 1615
本文介绍了如何通过android手机的USB绑定功能，实现 手机与PC的双向共享上网。 一、手机通过USB绑定，共享PC上网资源 参考文档： http://wenku.baidu.com/view/366ea292daef5ef7ba0d3c9a.html http://wenku.baidu.com/view/33487bfc0242a8956bece46e.html ...
Android真机 usb调试 访问本地服务器（localhost）的解决方案
Elvis写代码
02-25 7317
Android模拟器访问电脑本地web服务，使用ip 10.0.2.2即可用，但手机真机通过usb连接调试时无法访问。 解决办法： 1、usb连接电脑（手机设置打开usb调试），用以打包apk到手机 2、手机用wifi与电脑连接同一个网络（若电脑为有线局域网，则可以在电脑上安装猎豹免费wifi(或者其他无线网络共享程序)，手机连wif即可与电脑在同一网络） 3、用ipconfig -all
android 读取usb 文件,android开发：手机连接电脑读取文件
weixin_33335559的博客
05-27 2026
满意答案pretty_1022013.05.16采纳率：47%等级：10已帮助：967人展开全部 一、打开手机USB调试模式 打开手机系统设置：【菜单(menu)】->【设置】->【应用程序】->【开发】->勾选【USB调试】。 如果你的手机还有一项【未知源】，也一起勾选上：二、下载驱动保存到电脑，请记住保存的位置，如：电脑的E盘。下...
PC 通过USB 与android APP 通信
01-13
在IT领域，尤其是在移动设备和桌面系统的交互中，"PC通过USB与Android APP通信"是一个常见且重要的主题。这个过程通常涉及到多个技术层面，包括USB通信协议、Android开发者选项、APP编程接口（API）以及数据传输机制...
通过USB进行PC端和Android的数据交互
06-13
在Android设备与PC的USB通信中，Android设备可以作为USB设备或USB主机，而PC通常作为USB主机。在USB通信中，主机控制数据的流向，设备则响应主机的请求。 在Android端，要实现USB服务端代码，我们需要做以下几步： ...
Android UVCCamera USB外接摄像头源码
12-07
它简化了不同制造商的USB摄像头与各种设备的兼容性，包括PC和移动设备如Android。UVC协议规定了视频流的编码、解码以及控制接口，确保设备间的一致性。 2. **Android USB访问框架**： Android自API 12起引入了USB...
Android 平板通过USB口连接小票打印机
07-25
Android 3.1及更高版本系统内核支持USB主机模式，使得平板电脑可以像PC一样连接USB设备。 1. **USB权限管理**： 在Android中，为了安全性和隐私考虑，应用程序必须先获取特定USB设备的访问权限。这需要在`...
Android USB实现远程以太网设备网络共享
当PC连接到Android设备时，PC将能够通过该设备访问互联网。这种技术在移动设备的数据连接能力高于传统以太网或Wi-Fi环境时特别有用，如在火车、飞机或移动热点等不稳定的网络环境中。 对于开发者而言，这提供了一种...
PC与Android设备通过USB建立通信连接
04-21
PC与Android设备通过USB建立通信连接,通过socket收发数据。
Android手机通过usb与PC通讯
01-10
Android手机通过usb连接手机后，通过adb进行端口映射，然后使用socket通讯，包含。本资源包含pcclient和phoneserver端。如果运行不起来，注意adb的使用，安卓开发者都懂的。
android 3.0以上对usb设备的访问USB
秦时明月
10-31 2718
android 3.0以上对usb设备的访问USB Host In this document   原文地址：http://developer.android.com/guide/topics/connectivity/usb/host.html#permission-d USB Host In this document API OverviewAndroid M
android模拟器与PC的端口映射
dengduoya4019的博客
11-04 749
一、概述 　　Android系统为实现通信将PC电脑IP设置为10.0.2.2，自身设置为127.0.0.1，而PC并没有为Android模拟器系统指定IP，所以PC电脑不能通过IP来直接访问Android模拟器，要实现PC机和Android模拟器之间的相互通信必须借助于端口重定向(redir)。 二、实现步骤 　　1、安装telnet 　　什么是telnet？ 　　Telne...
Android USB Host(Android USB 主机通讯)
chengke1138的博客
10-13 366
当你的Android手机是在USB主机模式下，它充当USB主机，开启设备，并列举已连接的USB设备。 这种模式，在Android 3.1及以上版本的支持。 API 预览 在开始学习USB Host之前，理解并掌握你所需要用到的类是很重要的。下面的表格描述了and...
android 访问本机ip
jn615的专栏
10-17 234
在android开发中， 如果使用localhost 或 127.0.0.1 来访问pc是不对的， 因为Android模拟器（simulator）把它自己作为了localhost,也就是说，代码中使用localhost或者127.0.0.1来访问，都是访问模拟器自己！ 如果你想在模拟器上面访问你的电脑，那么就使用android内置的IP 10.0.2.2 吧，10.0.2.2 是模拟器...
android手机通过usb连接pc段服务器
zhizhuodewo6的博客
07-12 1539
一、打开手机的“通过usb共享网路” 1、手机通过usb连接电脑，并且打开开发者模式。 2、在手机设置里搜索usb，可以找到通过USB共享网络。 然后打开通过USB共享网络。 3、打开连接的电脑上的网络连接的适配器，可以看到多了一个以太网2，如下图： 4、看到如上图，说明手机与电脑通过sub连接成功。 二、查看手机的ip地址 1、打开命令框，输入adb devices可以发现设备...
android模拟器 建立端口映射
jueqing007的专栏
11-19 1150
在android模拟器上调试自己写的udp服务时，出现无法正常接收的情况。在网上找到一个正解： 1、运行模拟器 2、打开window 命令行     执行：telnet localhost 5554     5554是模拟器的端口，执行之后会进入android console 3、 在console下执行：    redir add udp:2888:2888     其中，第一
Android的联通性---USB主机模式（一）
810364804
03-28 150
本文译自：http://developer.android.com/guide/topics/connectivity/usb/host.html 当你的Android设备在USB主机模式中时，它作为USB主机给从属设备供电，并会列举被连接的USB设备。USB主机模式在Android3.1以后开始被支持。 API概要 在开始之前，重要的是要理解工作中所需要的类。下表介绍了在android...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

冰茶_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值