配置ASP.NET WebAPI

最新推荐文章于 2024-06-24 00:02:04 发布
最新推荐文章于 2024-06-24 00:02:04 发布
阅读量764 收藏 2
点赞数
分类专栏： ASP.NET WebApi 文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42727319/article/details/106833382
版权

配置ASP.NET WebAPI

1 配置路由规则

找到网站文件目录，选择“App_Start”文件夹中的WebApiConfig.cs文件并打开。如下图所示。
在这里插入图片描述
打开WebApiConfig.cs文件后，按照如下代码进行修改。修改后可以在Controller中写不同的Post方法和Get方法。

    public static class WebApiConfig
    {
        public static void Register(HttpConfiguration config)
        {
            // Web API 配置和服务

            // Web API 路由
            config.MapHttpAttributeRoutes();

            // 修改前的路由配置
            //config.Routes.MapHttpRoute(
            //    name: "DefaultApi",
            //    routeTemplate: "api/{controller}/{id}",
            //    defaults: new { id = RouteParameter.Optional }
            //);
            
            // 修改后的路由配置
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{action}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );
        }
    }

2 配置网页文档中的注释

在启动项目之后要查看接口的中文注释，需要按照如下操作进行一些配置。
右击WebAPI项目，选择属性。如下图所示。
在这里插入图片描述
选中“生成”，到最下方选中XML文档文件，复制文档路径。如下图所示。
在这里插入图片描述
到目录“Areas\HelpPage\App_Start”中，找到HelpPageConfig.cs文件并打开。如下图所示。
在这里插入图片描述
打开HelpPageConfig.cs文件后，找到Register方法，在此方法中找到如下代码进行修改。

config.SetDocumentationProvider(new XmlDocumentationProvider(HttpContext.Current.Server.MapPath("~/bin/PTL.BackEnd.xml")));

在最后的MapPath("")中将刚才复制的XML文件的路径添加进去。

3 配置并使用数据库

3.1 数据库库连接字段

在这个项目中，我使用了SQL Server作为数据库，因此这里只放SQL Server的配置方法。
找到项目的Web.config文件。在<configuration></configuration>标签中添加如下代码。

<configuration>
	<connectionStrings>
		<add name="PTL_DBConnection" connectionString="Data Source=DESKTOP-HRE7PQN\SQLEXPRESS;Initial Catalog=PalletBarcode1;User ID=root;Password=root;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False" providerName="System.Data.SqlClient" />
	</connectionStrings>
</configuration>

配置完数据库连接字段后，在.cs文件中引用时使用如下代码。

string strConnection = System.Configuration.ConfigurationManager.ConnectionStrings["PTL_DBConnection"].ConnectionString

3.2 数据库工具类

在项目目录下新建一个Tools文件夹，在文件中新建一个SqlHelper.cs文件，将如下代码复制进去。

        /// <summary>
        /// 无参同步执行语句，返回受影响的行数
        /// </summary>
        /// <param name="Sql"></param>
        /// <returns></returns>
        public int ExecuteNonQuery(string Sql)
        {
            SqlConnection sc = new SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["PTL_DBConnection"].ConnectionString);
            try
            {
                sc.Open();
                SqlCommand sqlCommand = new SqlCommand(Sql, sc);
                return sqlCommand.ExecuteNonQuery();
            }
            catch (Exception error)
            {
                throw error;
            }
            finally
            {
                sc.Close();
            }
        }
        /// <summary>
        /// 带参同步执行语句，返回受影响的行数
        /// </summary>
        /// <param name="Sql"></param>
        /// <param name="sqlParameters"></param>
        /// <returns></returns>
        public int ExecuteNonQuery(string Sql, SqlParameter[] sqlParameters)
        {
            SqlConnection sc = new SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["PTL_DBConnection"].ConnectionString);
            try
            {
                sc.Open();
                SqlCommand sqlCommand = new SqlCommand(Sql, sc);
                sqlCommand.Parameters.AddRange(sqlParameters);
                return sqlCommand.ExecuteNonQuery();
            }
            catch (Exception error)
            {
                throw error;
            }
            finally
            {
                sc.Close();
            }
        }
        /// <summary>
        /// 无参异步执行语句，返回受影响的行数
        /// </summary>
        /// <param name="Sql"></param>
        /// <returns></returns>
        public int ExecuteNonQueryAsync(string Sql)
        {
            SqlConnection sc = new SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["PTL_DBConnection"].ConnectionString);
            try
            {
                sc.Open();
                SqlCommand sqlCommand = new SqlCommand(Sql, sc);
                return sqlCommand.ExecuteNonQuery();
            }
            catch (Exception error)
            {
                throw error;
            }
            finally
            {
                sc.Close();
            }
        }
        /// <summary>
        /// 带参异步执行语句，返回受影响的行数
        /// </summary>
        /// <param name="Sql"></param>
        /// <param name="sqlParameters"></param>
        /// <returns></returns>
        public async Task<int> ExecuteNonQueryAsync(string Sql, SqlParameter[] sqlParameters)
        {
            SqlConnection sc = new SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["PTL_DBConnection"].ConnectionString);
            try
            {
                sc.Open();
                SqlCommand sqlCommand = new SqlCommand(Sql, sc);
                sqlCommand.Parameters.AddRange(sqlParameters);
                return await sqlCommand.ExecuteNonQueryAsync();
            }
            catch (Exception error)
            {
                throw error;
            }
            finally
            {
                sc.Close();
            }
        }

        /// <summary>
        /// 无参同步执行语句，返回DataTable
        /// </summary>
        /// <param name="Sql"></param>
        /// <returns></returns>
        public DataTable Query(string Sql)
        {
            SqlConnection sc = new SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["PTL_DBConnection"].ConnectionString);
            try
            {
                sc.Open();
                SqlCommand sqlCommand = new SqlCommand(Sql, sc);

                SqlDataReader sdr = sqlCommand.ExecuteReader();
                DataTable result = ConvertDataReaderToDataTable(sdr);
                return result;
            }
            catch (Exception error)
            {
                throw error;
            }
            finally
            {
                sc.Close();
            }
        }

        /// <summary>
        /// 带参同步执行语句，返回DataTable
        /// </summary>
        /// <param name="Sql"></param>
        /// <param name="sqlParameters"></param>
        /// <returns></returns>
        public DataTable Query(string Sql, SqlParameter[] sqlParameters)
        {
            SqlConnection sc = new SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["PTL_DBConnection"].ConnectionString);
            try
            {
                sc.Open();
                SqlCommand sqlCommand = new SqlCommand(Sql, sc);
                sqlCommand.Parameters.AddRange(sqlParameters);
                SqlDataReader sdr = sqlCommand.ExecuteReader();
                DataTable result = ConvertDataReaderToDataTable(sdr);
                return result;
            }
            catch (Exception error)
            {
                throw error;
            }
            finally
            {
                sc.Close();
            }
        }

        /// <summary>
        /// 无参异步执行语句，返回DataTable
        /// </summary>
        /// <param name="Sql"></param>
        /// <returns></returns>
        public async Task<DataTable> QueryAsync(string Sql)
        {
            SqlConnection sc = new SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["PTL_DBConnection"].ConnectionString);
            try
            {
                sc.Open();
                SqlCommand sqlCommand = new SqlCommand(Sql, sc);

                SqlDataReader sdr = await sqlCommand.ExecuteReaderAsync();
                DataTable result = ConvertDataReaderToDataTable(sdr);
                return result;
            }
            catch (Exception error)
            {
                throw error;
            }
            finally
            {
                sc.Close();
            }
        }

        /// <summary>
        /// 带参异步执行语句，返回DataTable
        /// </summary>
        /// <param name="Sql"></param>
        /// <param name="sqlParameters"></param>
        /// <returns></returns>
        public async Task<DataTable> QueryAsync(string Sql, SqlParameter[] sqlParameters)
        {
            SqlConnection sc = new SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["PTL_DBConnection"].ConnectionString);
            try
            {
                sc.Open();
                SqlCommand sqlCommand = new SqlCommand(Sql, sc);
                sqlCommand.Parameters.AddRange(sqlParameters);
                SqlDataReader sdr = await sqlCommand.ExecuteReaderAsync();
                DataTable result = ConvertDataReaderToDataTable(sdr);
                return result;
            }
            catch (Exception error)
            {
                throw error;
            }
            finally
            {
                sc.Close();
            }
        }

        /// <summary>
        /// 无参同步执行语句，返回首行首列
        /// </summary>
        /// <param name="Sql"></param>
        /// <param name="sqlParameters"></param>
        /// <returns></returns>
        public object ExecuteScalar(string Sql)
        {
            SqlConnection sc = new SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["PTL_DBConnection"].ConnectionString);
            try
            {
                sc.Open();
                SqlCommand sqlCommand = new SqlCommand(Sql, sc);

                return sqlCommand.ExecuteScalar();
            }
            catch (Exception error)
            {
                throw error;
            }
            finally
            {
                sc.Close();
            }
        }

        /// <summary>
        /// 带参同步执行语句，返回首行首列
        /// </summary>
        /// <param name="Sql"></param>
        /// <param name="sqlParameters"></param>
        /// <returns></returns>
        public object ExecuteScalar(string Sql, SqlParameter[] sqlParameters)
        {
            SqlConnection sc = new SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["PTL_DBConnection"].ConnectionString);
            try
            {
                sc.Open();
                SqlCommand sqlCommand = new SqlCommand(Sql, sc);
                sqlCommand.Parameters.AddRange(sqlParameters);
                return sqlCommand.ExecuteScalar();
            }
            catch (Exception error)
            {
                throw error;
            }
            finally
            {
                sc.Close();
            }
        }

        /// <summary>
        /// 无参异步执行语句，返回首行首列
        /// </summary>
        /// <param name="Sql"></param>
        /// <param name="sqlParameters"></param>
        /// <returns></returns>
        public object ExecuteScalarAsync(string Sql)
        {
            SqlConnection sc = new SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["PTL_DBConnection"].ConnectionString);
            try
            {
                sc.Open();
                SqlCommand sqlCommand = new SqlCommand(Sql, sc);

                return sqlCommand.ExecuteScalarAsync();
            }
            catch (Exception error)
            {
                throw error;
            }
            finally
            {
                sc.Close();
            }
        }

        /// <summary>
        /// 带参异步执行语句，返回首行首列
        /// </summary>
        /// <param name="Sql"></param>
        /// <param name="sqlParameters"></param>
        /// <returns></returns>
        public async Task<object> ExecuteScalarAsync(string Sql, SqlParameter[] sqlParameters)
        {
            SqlConnection sc = new SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["PTL_DBConnection"].ConnectionString);
            sc.Open();
            SqlTransaction st = sc.BeginTransaction();
            try
            {
                SqlCommand sqlCommand = new SqlCommand(Sql, sc);
                sqlCommand.Parameters.AddRange(sqlParameters);

                sqlCommand.Transaction = st;
                object result = await sqlCommand.ExecuteScalarAsync();
                st.Commit();
                return result;
            }
            catch (Exception error)
            {
                st.Rollback();
                throw error;
            }
            finally
            {
                sc.Close();
            }
        }
        /// <summary>
        /// 执行存储过程，返回DataSet
        /// </summary>
        /// <param name="procName">存储过程名</param>
        /// <param name="parameters">存储过程参数</param>
        /// <param name="tableName">DataSet结果中的表名</param>
        /// <param name="Times">超时时间</param>
        /// <returns>DataSet</returns>
        public static DataSet RunProcedure(string procName, IDataParameter[] parameters, string tableName, int Times = 30)
        {
            using (SqlConnection sc = new SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["PTL_DBConnection"].ConnectionString))
            {
                DataSet dataSet = new DataSet();
                sc.Open();
                SqlDataAdapter sqlDA = new SqlDataAdapter();
                sqlDA.SelectCommand = BuildQueryCommand(sc, procName, parameters);
                sqlDA.SelectCommand.CommandTimeout = Times;
                sqlDA.Fill(dataSet, tableName);
                sc.Close();
                return dataSet;
            }
        }
        /// <summary>
        /// 构建SqlCommand对象
        /// </summary>
        /// <param name="connection">数据库连接字符</param>
        /// <param name="procName">存储过程名</param>
        /// <param name="parameters">存储过程参数</param>
        /// <returns>SqlCommand</returns>
        private static SqlCommand BuildQueryCommand(SqlConnection connection, string procName, IDataParameter[] parameters)
        {
            SqlCommand command = new SqlCommand(procName, connection);
            command.CommandType = CommandType.StoredProcedure;
            if (parameters != null && parameters.Length > 0)
            {
                foreach (SqlParameter parameter in parameters)
                {
                    if (parameter != null)
                    {
                        // 未赋值的参数，赋值为DBNull.Value
                        if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input)
                            && (parameter.Value == null))
                        {
                            parameter.Value = DBNull.Value;
                        }
                        command.Parameters.Add(parameter);
                    }
                }
            }
            return command;
        }

        protected static DataTable ConvertDataReaderToDataTable(SqlDataReader reader)
        {
            try
            {
                DataTable objDataTable = new DataTable();
                int intFieldCount = reader.FieldCount;
                for (int intCounter = 0; intCounter < intFieldCount; ++intCounter)
                {
                    objDataTable.Columns.Add(reader.GetName(intCounter), reader.GetFieldType(intCounter));
                }
                objDataTable.BeginLoadData();

                object[] objValues = new object[intFieldCount];
                while (reader.Read())
                {
                    reader.GetValues(objValues);
                    objDataTable.LoadDataRow(objValues, true);
                }
                reader.Close();
                objDataTable.EndLoadData();

                return objDataTable;

            }
            catch (Exception ex)
            {
                throw new Exception("转换出错!", ex);
            }
        }
        
        protected static DataTable DataReaderToDataTable(SqlDataReader sdr)
        {
            try
            {

                DataTable result = new DataTable();
                for (int i = 0; i < sdr.FieldCount; i++)
                {
                    DataColumn dc = new DataColumn(sdr.GetName(i), sdr.GetFieldType(i));
                    result.Columns.Add(dc);
                }
                while (sdr.Read())
                {
                    DataRow dr = result.NewRow();
                    for (int i = 0; i < sdr.FieldCount; i++)
                    {
                        dr[i] = sdr[i];
                    }
                }
                return result;
            }
            catch (Exception ex)
            {
                throw new Exception("转换出错!", ex);
            }
        }

在项目中，需要读取数据库时，使用这个SqlHelper中的读取方法就能获取到数据库的信息。

4 请求返回Model

这里新建了一个Model来存放请求返回的数据和一些信息。

在Models文件夹中，新建一个ResultModel.cs类。内容为如下代码：

/// <summary>
    /// 返回到前端的Model
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class ResultModel<T>
    {
        /// <summary>
        /// 请求成功
        /// </summary>
        public Boolean Success { get; set; }
        /// <summary>
        /// 请求成功的数据
        /// </summary>
        public T ResultData { get; set; }
        /// <summary>
        /// 请求成功返回的数据数量
        /// </summary>
        public int ResultCount { get; set; }
        /// <summary>
        /// 请求失败时的错误信息
        /// </summary>
        public string ErrorMessage { get; set; }
    }

5 WebApi跨域请求

这是我在开发Vue的时候碰到的一个跨域的问题。网上搜下来发现这种方法是可用的，具体原理我暂时还不清楚。

在Web.config文件中找到<system.webServer></system.webServer>标签下，添加如下代码。

<httpProtocol>
    <customHeaders>
        <add name="Access-Control-Allow-Origin" value="*"/>
        <add name="Access-Control-Allow-Headers" value="*"/>
        <add name="Access-Control-Allow-Methods" value="GET, POST, PUT, DELETE"/>
    </customHeaders>
</httpProtocol>

按照如上方法进行配置后，WebApi项目基本能够正常使用了。

灰羊驼丶
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ASP.NET Web API简单学习
机械键盘侠博客
07-05 548
Web API 简介 Web API可以返回 json、xml类型的数据，对于数据的增删改查，提供了对应的资源操作，按照要求的类型进行处理，主要包括：Get（查），Post（增），Put（改），Delete（删），这些都是Http协议支持的请求方式。 Web API的请求方式：根据路由规则请求。 WebService 和 Web API两种Web服务的比较...
ASP.NET WebAPI连接数据库的方法
10-18
首先，需要了解的是WebAPI项目的基本创建流程，即通过Visual Studio创建一个新的*** Web Application (.NET Framework)项目，选择WebAPI作为项目模板。创建项目后，我们会在项目中看到一个名为ValuesController的...
WebApi 连接SqlServer
Yuhang_Zhou的博客
10-08 527
webapi中连接sqlserver进行查询
ASP.Net.WebAPI和工具PostMan
最新发布
星河队长
06-24 1224
WebAPI 是一种传统的方式，用于构建和暴露 RESTUI风格的Web服务。它提供了丰富的功能和灵活性，可以处理各种HTTP请求，并支持各种数据格式，如JSON、XML等。WebAPI使用控制器(Controllers)和动作方法(ActionMethods)的概念、通过路由配置将请求映射到相应的方法上。开发人员可以使用各种属性和过滤器来处理请求、控制访问权限、验证数据等。Postman是一款API测试和开发环境的软件，旨在简化API开发过程、测试和文档编制。
ASP.NET for WebApi
weixin_33834679的博客
05-27 98
WebApi，听说过吧？呵呵。 感觉比WebService，WCF要强。尤其是那个啥WCF，啥鬼东西，真难懂。真难搞。真难用。 说比WebService要强，是因为不用在本地先生成个代理。而且XML也显得过于庞大。 用ASP.NET 编写 WebApi 的话，跟MVC差不多。生成的项目也有控制器，视图之类。只不过，其控制器继承的是ApiController。 还有一个不...
【ASP.NET Web API教程】3.2 通过.NET客户端调用Web API（C#）
weixin_34293246的博客
11-20 587
注：本文是【ASP.NET Web API系列教程】的一部分，如果您是第一次看本博客文章，请先看前面的内容。 3.2 Calling a Web API From a .NET Client (C#) 3.2 通过.NET客户端调用Web API（C#） 本文引自：http://www.asp.net/web-api/overview/web-api-clients/calling-a-we...
Asp.net WebApi WebApiConfig.cs（Web API 配置和服务）
极客神殿
01-29 916
public static void Register(HttpConfiguration config) { //............................... var jsonSettings = config.Formatters.JsonFormatter.SerializerSettings; //获取或设置在序列化和反序列化期间如何处理空值。 jsonSettings.NullValueHandling = NullValueHandling.Ignore;//在序列化和反序列化
初试Asp.Net Web Api
weixin_33890499的博客
06-01 66
　　自Asp.Net Web Api问世以来，一直没有去体验下，有些惭愧。不过在说Web Api之前还是要提一下Rest，Rest的英文全称是:Representational State Transfer，翻译过来就是“表征状态转移”。不过在看到这译过来的6个字，我也迷迷糊糊的，名字为什么这么怪？它是Roy Fielding在2000年的时候在他的论文里面提出的一种软件架构风格。 　　REST...
asp.net webapi2 基于token令牌的身份验证
03-27
本文将深入探讨ASP.NET WebAPI2如何实现基于Token的令牌身份验证。 首先，我们需要理解Token的身份验证原理。这种机制下，用户登录后，服务器会生成一个唯一的Token，这个Token包含了一些关于用户的信息，经过加密...
创建一个完整的ASP.NET Web API项目
01-20
在本文中，我们将深入探讨如何创建一个完整的ASP.NET Web API项目，并介绍该框架的一些关键特性。 首先，我们来创建一个Web API项目。在Visual Studio 2013中，选择“新建项目”，然后在项目模板中找到"ASP.NET Web...
asp.net webApi
03-08
在描述中提到的"webapi技术小demo"是一个示例项目，旨在帮助学习者理解和实践如何使用ASP.NET WebAPI来开发接口。这样的项目通常包含了从创建控制器、定义路由到处理HTTP请求和返回响应的完整流程。 1. **控制器...
Pro ASP.NET Web API
11-28
使用 asp.net web api 开发 web services 的同学，可以看看。用来入门是不错的。
asp.net webapi例子 可自己扩展
05-31
asp.net webapi例子 有增加 删除 修改 查询等例子 代码详细有注释 自己可扩展
ASP.NET Web API 简介
weixin_33924220的博客
03-19 180
ASP.NET MVC 4 包含了 ASP.NET Web API， 这是一个创建可以连接包括浏览器、移动设备等多种客户端的 Http 服务的新框架， ASP.NET Web API 也是构建 RESTful 服务的理想平台。 ASP.NET Web API 特性 ASP.NET Web API 包含下列特性： 先进的 HTTP 编程模型： 使用新的强类型的 HTTP 对象模型直接操作...
ASP.NET-WebAPI
耀的专栏
07-09 346
ASP.NET-WebAPI 官方文档： https://msdn.microsoft.com/zh-cn/library/hh833994(v=vs.108).aspx 一、相关概念和简单API的使用 1、什么是ASP.NET-WebAPI? ASP.NET WebAPI是一种框架，用于轻松构建可以访问多种客户端（包括浏览器和移动设备）的HTTP服务。ASP.NET WebAPI是一种用于在.NET Framework上构建RESTful应用程序的理想平台 2.关于RESTful的理解 ...
ASP.NET WEBApi
坚持奋斗，曙光终现
10-13 639
1.在MVC4.0中引入了WebAPI,纯Http通信，轻巧方便，也可以用webservice和wcf来开发，有点笨重，如果tcp和udp通信协议，走wcf Get：一般用作查询，多次操作得到结果一致  Post：一般用于修改、添加多次重复操作得到结果不一致。  Put：一般用于修改，多次操作得到结果一致。 Delete：一般用于删除数据，多次操作得到结果一致。 public c
ASP.NET WebAPI
qq_41834086的博客
05-11 3692
一、什么是WebAPI？ 1.1-什么是WebAPI？ WebAPI是一种用开发系统间接口、设备接口API的技术，基于Http协议，请求和返回格式默认是Json格式。比WCF简单、跟更通用；比WebService更节省流量，更简洁。 1.2-WebAPI的特点？ Action方法直接返回对象，专注于数据 更符合Restful的风格 有利于独立于IIS部署 Action可以直接声明为async 二、什么是Restful？ 2.1-传统的Http接口怎么设计？ 2....
ASP.NET Web API 之 WebApiConfig
ddxshf的博客
03-03 8017
WebApiConfig位于WebAPI项目顶层目录App_Start下，并声明了它的WebApiConfig类。WebApiConfig只包含一个Register方法，由global.asax中的Application_Start()方法调用代码。 正如WebApiConfig类的名字表明的，这个类可用于注册Web API配置的各个方面。默认情况下，项目模板生成的主要配置代码会注册一个
ASP.NET --WebAPI学习
qq_39173779的博客
05-04 342
创建一个项目 创建 Product 类 在该类中添加属性， public int Id { get; set; } public string Name { get; set; } public string Category { get; set; } public decimal Price { get; set; } 如下图： 完整代码： using System; using S...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值