devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

八、Sqlsugar 通用方法整理

作者：很楠不爱3 | 2024-02-23 07:50:26

赞

踩

sqlsugar

一、新建泛型辅助类SqlSugarHelper.cs,用于创建数据库连接

  1.     /// <summary>
  2.     /// SqlSugar的辅助方法
  3.     /// </summary>
  4.     /// <typeparam name="T"></typeparam>
  5.     public class SqlSugarHelper<T> where T : class, new()
  6.     {
  7.         //注意：不能写成静态的
  8.         public SqlSugarClient Db;//用来处理事务多表查询和复杂的操作
  9.         //public SimpleClient<T> CurrentDb { get { return new SimpleClient<T>(Db); } }//用来操作当前表的数据
  10.  
  11.         public SqlSugarHelper()
  12.         {
  13.             Db = new SqlSugarClient(new ConnectionConfig()
  14.             {
  15.                 ConnectionString = AppSettingFun.GetConnectionStr(),//数据库链接字符串
  16.                 DbType = DbType.SqlServer,//指定数据库类型
  17.                 IsAutoCloseConnection = true,//链接使用完后是否自动释放
  18.                 InitKeyType = InitKeyType.Attribute//从实体特性中读取主键自增列信息
  19.             });
  20.  
  21.             //调式代码 用来打印SQL 
  22.             Db.Aop.OnLogExecuting = (sql, pars) =>
  23.             {
  24.                 Console.WriteLine(sql + "\r\n" +
  25.                     Db.Utilities.SerializeObject(pars.ToDictionary(it => it.ParameterName, it => it.Value)));
  26.                 Console.WriteLine();
  27.             };
  28.         }
  29.     }

二、整理数据库方法整理

  1. public class SqlSugarFun<T> : SqlSugarHelper<T> where T : class, new()
  2.     {
  3.         public SqlSugarClient db;
  4.         public SqlSugarFun()
  5.         {
  6.             db = Db;
  7.         }
  8.  
  9.         #region 保存(新增或更新)
  10.         /// <summary>
  11.         /// 保存(新增或更新)
  12.         /// </summary>
  13.         /// <param name="model">实体数据</param>
  14.         /// <returns></returns>
  15.         public async Task<bool> Save(T model)
  16.         {
  17.             return await Task.Run(() => db.Storageable(model).ExecuteCommandAsync()) > 0;
  18.         }
  19.  
  20.         /// <summary>
  21.         /// 保存数据集(新增或更新)
  22.         /// </summary>
  23.         /// <param name="model">实体数据集</param>
  24.         /// <returns></returns>
  25.         public async Task<int> Save(List<T> model)
  26.         {
  27.             return await Task.Run(() => db.Storageable(model).ExecuteCommandAsync());
  28.         }
  29.         #endregion
  30.  
  31.         #region 新增
  32.         #region 新增
  33.  
  34.         /// <summary>
  35.         /// 插入数据
  36.         /// </summary>
  37.         /// <param name="model">实体数据</param>
  38.         /// <returns>是否成功</returns>
  39.         public async Task<bool> AddModel(T model)
  40.         {
  41.             return await Task.Run(() => db.Insertable(model).ExecuteCommandAsync()) > 0;
  42.         }
  43.  
  44.         /// <summary>
  45.         ///多数据插入
  46.         /// </summary>
  47.         /// <param name="lst">实体集合数据</param>
  48.         /// <returns>影响行数</returns>
  49.         public async Task<int> AddModel(List<T> lst)
  50.         {
  51.             return await Task.Run(() => db.Insertable(lst).ExecuteCommandAsync());
  52.         }
  53.  
  54.         /// <summary>
  55.         /// 写入实体数据并返回最新实体
  56.         /// </summary>
  57.         /// <param name="model">实体数据</param>
  58.         /// <returns>最新实体</returns>
  59.         public async Task<T> AddbackEntity(T model)
  60.         {
  61.             return await Task.Run(() => db.Insertable(model).ExecuteReturnEntityAsync());
  62.         }
  63.  
  64.         /// <summary>
  65.         /// 写入实体数据并返回自增列
  66.         /// </summary>
  67.         /// <param name="model">实体数据</param>
  68.         /// <returns>主键</returns>
  69.         public async Task<int> AddbackIdentity(T model)
  70.         {
  71.             return await Task.Run(() => db.Insertable(model).ExecuteReturnIdentityAsync());
  72.         }
  73.  
  74.         /// <summary>
  75.         /// 单条插入返回雪花ID
  76.         /// </summary>
  77.         /// <param name="model">实体数据</param>
  78.         /// <returns>雪花ID</returns>
  79.         public async Task<long> AddbackSnowflakeid(T model)
  80.         {
  81.             return await Task.Run(() => db.Insertable(model).ExecuteReturnSnowflakeIdAsync());
  82.         }
  83.  
  84.         /// <summary>
  85.         /// 多条插入批量返回,比自增好用
  86.         /// </summary>
  87.         /// <param name="lst">实体集合数据</param>
  88.         /// <returns>雪花ID集合</returns>
  89.         public async Task<List<long>> AddbackSnowflakeid(List<T> lst)
  90.         {
  91.             return await Task.Run(() => db.Insertable(lst).ExecuteReturnSnowflakeIdListAsync());
  92.         }
  93.         #endregion
  94.  
  95.         #region 大数据新增
  96.         /// <summary>
  97.         /// 参数化内部分页插入（建议500行以下）
  98.         /// </summary>
  99.         /// <param name="model_lst">实体数据集合</param>
  100.         /// <returns>影响行数</returns>
  101.         public async Task<int> AddListParam(List<T> model_lst)
  102.         {
  103.             return await Task.Run(() => db.Insertable(model_lst).UseParameter().ExecuteCommandAsync());
  104.         }
  105.  
  106.         /// <summary>
  107.         /// 大数据写入（特色功能：大数据处理上比所有框架都要快30%）
  108.         /// </summary>
  109.         /// <param name="model_lst">实体数据集合</param>
  110.         /// <returns>影响行数</returns>
  111.         public async Task<int> AddListMax(List<T> model_lst)
  112.         {
  113.             return await Task.Run(() => db.Fastest<T>().BulkCopyAsync(model_lst));
  114.         }
  115.         #endregion
  116.         #endregion
  117.  
  118.         #region 删除
  119.         #region 删除
  120.         /// <summary>
  121.         /// 根据主键删除
  122.         /// </summary>
  123.         /// <param name="id">主键</param>
  124.         /// <returns>是否成功</returns>
  125.         public async Task<bool> Delete(object id)
  126.         {
  127.             return await Task.Run(() => db.Deleteable<T>().In(id).ExecuteCommandHasChangeAsync());
  128.         }
  129.  
  130.         /// <summary>
  131.         /// 根据主键数组批量删除
  132.         /// </summary>
  133.         /// <param name="ids">主键数组</param>
  134.         /// <returns>影响行数</returns>
  135.         public async Task<int> Delete(object[] ids)
  136.         {
  137.             return await Task.Run(() => db.Deleteable<T>().In(ids).ExecuteCommandAsync());
  138.         }
  139.  
  140.         /// <summary>
  141.         /// 根据实体删除
  142.         /// </summary>
  143.         /// <param name="model">实体数据,有主键就行</param>
  144.         /// <returns>是否成功</returns>
  145.         public async Task<bool> Delete(T model)
  146.         {
  147.             return await Task.Run(() => db.Deleteable<T>().Where(model).ExecuteCommandHasChangeAsync());
  148.         }
  149.  
  150.         /// <summary>
  151.         /// 批量删除实体
  152.         /// </summary>
  153.         /// <param name="lst">实体集合数据,有主键就行</param>
  154.         /// <returns>影响行数</returns>
  155.         public async Task<int> Delete(List<T> lst)
  156.         {
  157.             return await Task.Run(() => db.Deleteable<T>(lst).ExecuteCommandAsync());
  158.         }
  159.  
  160.         /// <summary>
  161.         /// 根据条件删除
  162.         /// </summary>
  163.         /// <param name="where"></param>
  164.         /// <returns>是否成功</returns>
  165.         public async Task<bool> Delete(Expression<Func<T, bool>> where)
  166.         {
  167.             return await Task.Run(() => db.Deleteable<T>().Where(where).ExecuteCommandHasChangeAsync());
  168.         }
  169.         #endregion
  170.  
  171.         #region 假删除
  172.         /// <summary>
  173.         /// 根据主键假删除, 要求实体属性中必须有isdelete或者isdeleted
  174.         /// </summary>
  175.         /// <param name="id">主键</param>
  176.         /// <returns>是否成功</returns>
  177.         public async Task<bool> DeleteLogic(object id)
  178.         {
  179.             return await Task.Run(() => db.Deleteable<T>().In(id).IsLogic().ExecuteCommandAsync()) > 0;
  180.         }
  181.  
  182.         /// <summary>
  183.         /// 根据主键指定属性假删除
  184.         /// </summary>
  185.         /// <param name="id">主键</param>
  186.         /// <param name="name">属性名称</param>
  187.         /// <returns>是否成功</returns>
  188.         public async Task<bool> DeleteLogic(object id, string name)
  189.         {
  190.             return await Task.Run(() => db.Deleteable<T>().In(id).IsLogic().ExecuteCommandAsync(name)) > 0;
  191.         }
  192.  
  193.         /// <summary>
  194.         /// 根据主键数组批量假删除
  195.         /// </summary>
  196.         /// <param name="ids">主键数组</param>
  197.         /// <returns>影响行数</returns>
  198.         public async Task<int> DeleteLogic(object[] ids)
  199.         {
  200.             return await Task.Run(() => db.Deleteable<T>().In(ids).IsLogic().ExecuteCommandAsync());
  201.         }
  202.  
  203.         /// <summary>
  204.         /// 根据主键数组指定属性批量假删除
  205.         /// </summary>
  206.         /// <param name="ids">主键数组</param>
  207.         /// <returns>影响行数</returns>
  208.         public async Task<int> DeleteLogic(object[] ids, string name)
  209.         {
  210.             return await Task.Run(() => db.Deleteable<T>().In(ids).IsLogic().ExecuteCommandAsync(name));
  211.         }
  212.  
  213.         /// <summary>
  214.         /// 根据条件指定属性假删除
  215.         /// </summary>
  216.         /// <param name="where">条件表达式</param>
  217.         /// <param name="name">删除字段名称</param>
  218.         /// <returns>影响行数</returns>
  219.         public async Task<int> DeleteLogic(Expression<Func<T, bool>> where, string delcol)
  220.         {
  221.             return await Task.Run(() => db.Deleteable<T>().Where(where).IsLogic().ExecuteCommandAsync(delcol));
  222.         }
  223.  
  224.         /// <summary>
  225.         /// 根据主键删除并更新操作时间
  226.         /// </summary>
  227.         /// <param name="id">主键</param>
  228.         /// <param name="delcol">删除标记字段</param>
  229.         /// <param name="datecol">时间标记字段</param>
  230.         /// <returns>是否成功</returns>
  231.         public async Task<bool> DeleteLogic(object id, string delcol, string datecol)
  232.         {
  233.             return await Task.Run(() => db.Deleteable<T>().In(id).IsLogic().ExecuteCommand(delcol, DateTime.Now, datecol)) > 0;
  234.         }
  235.  
  236.         /// <summary>
  237.         /// 根据主键批量删除并更新操作时间
  238.         /// </summary>
  239.         /// <param name="id">主键</param>
  240.         /// <param name="delcol">删除标记字段</param>
  241.         /// <param name="datecol">时间标记字段</param>
  242.         /// <returns>影响行数</returns>
  243.         public async Task<int> DeleteLogic(object[] ids, string delcol, string datecol)
  244.         {
  245.             return await Task.Run(() => db.Deleteable<T>().In(ids).IsLogic().ExecuteCommand(delcol, DateTime.Now, datecol));
  246.         }
  247.         #endregion
  248.         #endregion
  249.  
  250.         #region 更新
  251.         /// <summary>
  252.         /// 更新实体数据
  253.         /// </summary>
  254.         /// <param name="model">实体数据</param>
  255.         /// <returns>是否成功</returns>
  256.         public async Task<bool> Update(T model)
  257.         {
  258.             //这种方式会以主键为条件
  259.             return await Task.Run(() => db.Updateable(model).ExecuteCommandHasChange());
  260.         }
  261.  
  262.         /// <summary>
  263.         /// 批量更新实体数据
  264.         /// 数据超过50条时启用大数据更新
  265.         /// </summary>
  266.         /// <param name="lst">实体集合</param>
  267.         /// <returns>影响行数</returns>
  268.         public async Task<int> Update(List<T> lst)
  269.         {
  270.             if (lst.Count > 50)
  271.             {
  272.                 return await Task.Run(() => db.Fastest<T>().BulkUpdateAsync(lst));
  273.             }
  274.             //这种方式会以主键为条件
  275.             return await Task.Run(() => db.Updateable(lst).ExecuteCommandAsync());
  276.         }
  277.  
  278.         /// <summary>
  279.         /// 按条件指定更新列
  280.         /// </summary>
  281.         /// <param name="newObject">t=>t.更新列==值 表达式</param>
  282.         /// <param name="where">条件表达式</param>
  283.         /// <returns>影响行数</returns>
  284.         public async Task<int> Update(Expression<Func<T, bool>> newObject, Expression<Func<T, bool>> where)
  285.         {
  286.             return await Task.Run(() => db.Updateable<T>().SetColumns(newObject).Where(where).ExecuteCommandAsync());
  287.         }
  288.  
  289.         /// <summary>
  290.         /// 按条件指定更新列
  291.         /// </summary>
  292.         /// <param name="newObject">t=> new T(){更新列=值} 表达式</param>
  293.         /// <param name="where">条件表达式</param>
  294.         /// <returns>影响行数</returns>
  295.         public async Task<int> Update(Expression<Func<T, T>> newObject, Expression<Func<T, bool>> where)
  296.         {
  297.             return await Task.Run(() => db.Updateable<T>().SetColumns(newObject).Where(where).ExecuteCommandAsync());
  298.         }
  299.  
  300.         /// <summary>
  301.         /// 更新并启用启用验证
  302.         /// 需要有Timestamp字段呼应
  303.         /// </summary>
  304.         /// <param name="model"></param>
  305.         /// <returns></returns>
  306.         public async Task<bool> UpdateVer(T model)
  307.         {
  308.             return await Task.Run(() => db.Updateable(model).IsEnableUpdateVersionValidation().ExecuteCommandHasChange());
  309.         }
  310.         #endregion
  311.  
  312.         #region 查询
  313.  
  314.         #region 基础查询
  315.         /// <summary>
  316.         /// 获取所有数据
  317.         /// </summary>
  318.         /// <returns></returns>
  319.         public async Task<List<T>> GetAll()
  320.         {
  321.             return await Task.Run(() => db.Queryable<T>().ToList());
  322.         }
  323.  
  324.         /// <summary>
  325.         /// 根据主键获取数据
  326.         /// </summary>
  327.         /// <param name="objId"></param>
  328.         /// <returns></returns>
  329.         public async Task<T> QueryByID(object objId)
  330.         {
  331.             return await Task.Run(() => db.Queryable<T>().InSingleAsync(objId));
  332.         }
  333.  
  334.         /// <summary>
  335.         /// 根据条件查询数据
  336.         /// var exp= Expressionable.Create<Student>();
  337.         /// exp.OrIF(条件,it=>it.Id==1);//.OrIf 是条件成立才会拼接OR
  338.         /// exp.Or(it =>it.Name.Contains("jack"));//拼接OR
  339.         /// var list =db.Queryable<Student>().Where(exp.ToExpression()).ToList();
  340.         /// </summary>
  341.         /// <param name="expression"></param>
  342.         /// <returns></returns>
  343.         public async Task<T> QueryByWhere(Expression<Func<T, bool>> where)
  344.         {
  345.             return await Task.Run(() => db.Queryable<T>().Where(where).First());
  346.         }
  347.  
  348.         /// <summary>
  349.         /// 查询是否存在
  350.         /// </summary>
  351.         /// <param name="where"></param>
  352.         /// <returns></returns>
  353.         public async Task<bool> Any(Expression<Func<T, bool>> where)
  354.         {
  355.             return await Task.Run(() => db.Queryable<T>().AnyAsync(where));
  356.         }
  357.  
  358.         /// <summary>
  359.         /// 获取正序数据集合
  360.         /// </summary>
  361.         /// <param name="where"></param>
  362.         /// <returns></returns>
  363.         public async Task<List<T>> GetListByAsc(Expression<Func<T, bool>> where, Expression<Func<T, object>> order)
  364.         {
  365.             return await Task.Run(() => db.Queryable<T>().Where(where).OrderBy(order).ToList());
  366.         }
  367.  
  368.         /// <summary>
  369.         /// 获取反序数据集合
  370.         /// </summary>
  371.         /// <param name="where"></param>
  372.         /// <returns></returns>
  373.         public async Task<List<T>> GetListByDesc(Expression<Func<T, bool>> where, Expression<Func<T, object>> order)
  374.         {
  375.             return await Task.Run(() => db.Queryable<T>().Where(where).OrderBy(order, OrderByType.Desc).ToList());
  376.         }
  377.         #endregion
  378.  
  379.         #region 分页查询
  380.         /// <summary>
  381.         /// 分页正序查询
  382.         /// SqlSever2012分页  把  ToPageList 换成  ToOffsetPage   //offest分页
  383.         /// </summary>
  384.         /// <param name="where"></param>
  385.         /// <param name="order"></param>
  386.         /// <param name="pageindex"></param>
  387.         /// <param name="pagerow"></param>
  388.         /// <param name="count"></param>
  389.         /// <returns></returns>
  390.         public List<T> GetPageListByAsc(Expression<Func<T, bool>> where, Expression<Func<T, object>> order, int pageindex, int pagerow, ref int count)
  391.         {
  392.             return db.Queryable<T>().Where(where).OrderBy(order).ToPageList(pageindex, pagerow, ref count);
  393.         }
  394.  
  395.         /// <summary>
  396.         /// 分页反序查询
  397.         /// </summary>
  398.         /// <param name="where"></param>
  399.         /// <param name="order"></param>
  400.         /// <param name="pageindex"></param>
  401.         /// <param name="pagerow"></param>
  402.         /// <param name="count"></param>
  403.         /// <returns></returns>
  404.         public List<T> GetPageListByDesc(Expression<Func<T, bool>> where, Expression<Func<T, object>> order, int pageindex, int pagerow, ref int count)
  405.         {
  406.             return db.Queryable<T>().Where(where).OrderBy(order, OrderByType.Desc).ToPageList(pageindex, pagerow, ref count);
  407.         }
  408.  
  409.         /// <summary>
  410.         /// 分页正序查询
  411.         /// SqlSever2012分页  把  ToPageList 换成  ToOffsetPage   //offest分页
  412.         /// </summary>
  413.         /// <param name="where"></param>
  414.         /// <param name="order"></param>
  415.         /// <param name="select"></param>
  416.         /// <param name="pageindex"></param>
  417.         /// <param name="pagerow"></param>
  418.         /// <param name="count"></param>
  419.         /// <returns></returns>
  420.         public List<object> GetPageListByAsc(Expression<Func<T, bool>> where, Expression<Func<T, object>> order, Expression<Func<T, object>> select, int pageindex, int pagerow, ref int count)
  421.         {
  422.             return db.Queryable<T>().Where(where).OrderBy(order).Select(select).ToPageList(pageindex, pagerow, ref count);
  423.         }
  424.  
  425.         /// <summary>
  426.         /// 分页反序查询
  427.         /// </summary>
  428.         /// <param name="where"></param>
  429.         /// <param name="order"></param>
  430.         /// <param name="select"></param>
  431.         /// <param name="pageindex"></param>
  432.         /// <param name="pagerow"></param>
  433.         /// <param name="count"></param>
  434.         /// <returns></returns>
  435.         public List<object> GetPageListByDesc(Expression<Func<T, bool>> where, Expression<Func<T, object>> order, Expression<Func<T, object>> select, int pageindex, int pagerow, ref int count)
  436.         {
  437.             return db.Queryable<T>().Where(where).OrderBy(order, OrderByType.Desc).Select(select).ToPageList(pageindex, pagerow, ref count);
  438.         }
  439.  
  440.         /// <summary>
  441.         /// 获取数据总页数
  442.         /// </summary>
  443.         /// <param name="where"></param>
  444.         /// <param name="pageIndex"></param>
  445.         /// <param name="pageSize"></param>
  446.         /// <returns></returns>
  447.         public int GetPageTotle(int count, int pagerow)
  448.         {
  449.             int total = count;
  450.             if (total % pagerow > 0)
  451.                 total = total / pagerow + 1;
  452.             else
  453.                 total /= pagerow;
  454.             return total;
  455.         }
  456.         #endregion
  457.  
  458.         #endregion
  459.  
  460.         #region 其它方法
  461.         /// <summary>
  462.         /// 获取数据库时间
  463.         /// </summary>
  464.         /// <returns></returns>
  465.         public async Task<DateTime> GetdbDate()
  466.         {
  467.             return await Task.Run(() => db.GetDate());
  468.         }
  469.  
  470.         /// <summary>
  471.         /// 执行SQL查询
  472.         /// </summary>
  473.         /// <param name="sql"></param>
  474.         /// <returns></returns>
  475.         public async Task<dynamic> SqlQuery(string sql)
  476.         {
  477.             return await Task.Run(() => db.Ado.SqlQuery<dynamic>(sql));
  478.         }
  479.  
  480.         /// <summary>
  481.         /// 执行sql语句（查询除外）
  482.         /// </summary>
  483.         /// <param name="sql"></param>
  484.         /// <returns></returns>
  485.         public async Task<bool> SqlExec(string sql)
  486.         {
  487.             return await Task.Run(() => db.Ado.ExecuteCommand(sql)) > 0;
  488.         }
  489.  
  490.         /// <summary>
  491.         /// 获取新的雪花ID
  492.         /// </summary>
  493.         /// <returns></returns>
  494.         public async Task<long> GetSnowFlakeID()
  495.         {
  496.             return await Task.Run(() => SnowFlakeSingle.Instance.NextId());
  497.         }
  498.  
  499.         /// <summary>
  500.         /// 初始化表
  501.         /// 表中数据全部清空，清除，自增初始化
  502.         /// </summary>
  503.         /// <returns>是否成功</returns>
  504.         public async Task<bool> Truncate()
  505.         {
  506.             return await Task.Run(() => db.DbMaintenance.TruncateTable<T>());
  507.         }
  508.         #endregion
  509.     }

三、调用实例

  1. //数据库实体 Entity
  2. public class OrderService : SqlSugarFun<Entity>
  3. {
  4.         /// <summary>
  5.         /// 多删
  6.         /// </summary>
  7.         /// <param name="id"></param>
  8.         /// <param name="accountID"></param>
  9.         /// <param name="businessUserID"></param>
  10.         /// <returns></returns>
  11.         public async Task<string> DelOrder(object[] id)
  12.         {
  13.             
  14.             var od = await Task.Run(() => GetListByAsc(t => id.Contains(t.FID), t => t.FID));
  15.             if (od == null)
  16.             {
  17.                 return "找不到";
  18.             }
  19.             var b = await Task.Run(() => Delete(od)) > 0;
  20.             if (b)
  21.                 return result.Success("操作成功");
  22.             return result.Error("操作失败");
  23.         }
  24.  
  25.         /// <summary>
  26.         /// 数据库联查
  27.         /// </summary>
  28.         /// <param name="year"></param>
  29.         /// <param name="month"></param>
  30.         /// <param name="accountID"></param>
  31.         /// <param name="private_key"></param>
  32.         /// <returns></returns>
  33.         public async Task<Object> GroupPerformanceRanking(int year, int month, long accountID)
  34.         {
  35.             DateTime start = Convert.ToDateTime($@"{year}-{month}-01 00:00:00");
  36.             DateTime end = start.AddMonths(1);
  37.  
  38.             var lst = await Task.Run(() => db.Queryable<tOrder, tGroup>((o, g) => new JoinQueryInfos(
  39.                 JoinType.Left, o.FGroupID.Equals(g.FID)
  40.                 ))
  41.             .Where((o, g) => o.FAccounID.Equals(accountID) && o.FOrderDate > start && o.FOrderDate < end)
  42.             .Select((o, g) => new
  43.             {
  44.                 g.FGroupName,
  45.                 g.FGroupLogo,
  46.                 o.FDollar,
  47.                 o.FRMB,
  48.             }).MergeTable().GroupBy(g => new
  49.             {
  50.                 g.FGroupName,
  51.                 g.FGroupLogo
  52.             }).Select(t => new
  53.             {
  54.                 t.FGroupName,
  55.                 FDollar = SqlFunc.AggregateSum(t.FDollar),
  56.                 FRMB = SqlFunc.AggregateSum(t.FRMB)
  57.             }).OrderBy(t => t.FRMB, OrderByType.Desc).ToList());
  58.  
  59.             return result.Success(lst);
  60.         }
  61. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/134822
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号