EF 通用数据层父类方法小结

最新推荐文章于 2022-09-16 11:55:13 发布
最新推荐文章于 2022-09-16 11:55:13 发布
阅读量805 收藏 1
点赞数
分类专栏： Entity Framework

MSSql 数据库 数据层 父类

增删改查：

using System;

using System.Collections.Generic;

using System.Data;

using System.Data.Entity;

using System.Data.Entity.Infrastructure;

using System.Linq;

using System.Linq.Expressions;

using System.Reflection;

using System.Text;

　　 /// <summary>
  /// 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
改 
#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
查单个model 
#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
查List 
#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
分页 
    }
}

注：该数据层方法为小弟平时项目所用方法，特此贡献出来，各位如有疑问或者好的建议可以提出来，大家一起成长！！！

-------大家好才是真的好(*^__^*)

my98800
关注
专栏目录
爬虫：Ajax数据爬取
二十四桥明月夜
01-03 8868
目录 1、什么是Ajax 1.1 实例的引入 1.2 基本原理 2、Ajax分析方法 1、查看请求 2、过滤请求 3、Ajax结果提取 1、分析请求 2、分析响应 3、例子 我们在用 requests 抓取页面的时候，得到的结果可能和在浏览器中看到的不一样：在浏览器中可以看到正常显示的页面数据，但是使用 requests 得到的结果并没有， 这是因为 requests 获取的 都是原始的 HTML 文档，而浏览器中的页面则是经过 JavaScript 处理数据后生成的结果，这些数据的.
大数据技术之_19_Spark学习_07_Spark 性能调优 + 数据倾斜调优 + 运行资源调优 + 程序开发调优 + Shuffle 调优 + GC 调优 + Spark 企业应用案例
黑泽君
05-04 2055
大数据技术之_19_Spark学习_07_Spark 性能调优 + 数据倾斜调优 + 运行资源调优 + 程序开发调优 + Shuffle 调优 + GC 调优 + Spark 企业应用案例
动态拼接lambda
飞天灵狐
04-10 675
PredicateBuilder的UML类图 public static class PredicateBuilder { public static Expression&lt;Func&lt;T, bool&gt;&gt; True&lt;T&gt;() { return f =&gt; true; } public static Expression...
EF学习笔记——通用增删改查方案
weixin_33724570的博客
05-10 325
我刚接触EF未久，还不知道它有什么强大之处，但看上去，EF提供了一般的增删改查功能。以往用过一些ORM方法，尽管有代码生成器，但代码量总的来说比较多。这次采用EF，我就想，能不能尽量写出一些通用的方法，以后添加表、实体类，只需做很少的改动，就能拥有基本的增删改查功能呢？方案如下：1、分为几个部分：BLL、DAL、Model、Interface。其中，EF生成的代码放在Model。因为不想由BL...
EF 通用数据层类
weixin_34319817的博客
03-09 314
EF 通用数据层父类方法小结 转载：http://www.cnblogs.com/yq-Hua/p/4165344.html MSSql 数据库 数据层 父类 增删改查：   using System; using System.Collections.Generic; using System.Data; using System.Data.Entity; using ...
关于在EF中通用方法
weixin_30239339的博客
11-14 164
关于在EF中通用方法 在EF中有时需要用到一些通用类，在后端模型和前端模型在某些场合需要模型分离， 例如数据模型和试图模型中用到的增删改功能 public class DBHelper<V, T> where V : class ,new() where T : class ,new() {...
多级菜单(父子)结构组装或课程多级分类(父子)结构组装的思路
快敲代码去
02-19 1233
这里以课程多级分类为例来实现父子结构的组装 先看数据库中的存储 仔细看pid和path一栏可以发现有多级结构 存在子中还有子的情况 详细代码 使用的框架：mybatis-plus 需要注意的地方： //实体类添加了字段后，需要加上下面注解，告诉mybatis-plus框架，表中没有这个字段，否则会报错 @TableField(exist = false) //这里最好是直接new出来，否则后面代码...
ef foreach删除
mihaw的博客
06-09 220
Java知识点概览
qq_48403611的博客
08-03 3377
java后端开发常见面试题总结
面试框架题整理
热门推荐
Jenius87v5的博客
04-15 2万+
面试题总结 一基础部分 1.1 集合 1.1.1 fail-fast 与 fail-safe 机制有什么区别 1.1.2 说出ArrayList,Vector, LinkedList的存储性能和特性 ArrayList 采用的是数组形式来保存对象的，这种方式将对象放在连续的位置中，所以最大的缺点就是插入删除时非常麻烦 LinkedList 采用的将对象存放在独立的空间中，而且在每个空间中还保存下一个链接的索引 但是缺点就是查找非常麻烦 要丛第一个索引开始 ArrayList和Vector都是用数组方
JAVA继承和多态详细讲解
weixin_45536242的博客
07-08 3305
面向对象编程的重要知识：继承和多态。通过类的继承机制，可以使用已有的类为基础派生出新类，无需编写重复的程序代码，很好地实现程序代码复用。多态是面向对象编程中继封装和继承之后的另一大特征，它具体是指同一个行为具有多个不同表现形式或形态的能力。使用多态机制，可以提高程序的抽象程度和简洁性，最大程度地降低类和程序模块间的耦合性，并提高程序的可扩展性和可维护性。从Java语言的底层逻辑上看，封装和继承是为实现多态做准备的。6.1 类的继承继承描述了类的所属关系，多个类通过继承可形成一个关系体系，进而在原有类的基础上
EF Core 报错：“A second operation started on this context” List.ForEach和Foreach（var item in List）不同
weixin_41986839的博客
01-07 1558
EF Core 报错："A second operation started on this context before a previous operation completed" 一般这是由于异步问题，导致同时访问数据库报错，在检查了所有await依旧报错后，发现List.ForEach并没有完成异步 在异步方法中，ForEach会根据await排队执行，而List.ForEach则会不等待直接同步执行容易报错 ...
.NetCore 扩展封装 Expression<Func<T, bool>> 查询条件遇到的问题
weixin_30318645的博客
08-09 804
前面的文章封装了查询条件 自己去组装条件，但是对 And Or 这种组合支持很差，但是也不是不能支持，只是要写更多的代码看起来很臃肿 根据 Where(Expression<Func<T, bool>>) 我们直接来处理这个，在处理这个之前其实看了下 Expression这个对象的处理，本生里面是包含了 AndAlso 、 Or 的处理 先来看看这个会遇到什么问...
Expression与Func的区别（Expression与反射的结合使用，生成自定义报表）
naruto2017的博客
09-16 272
【代码】Expression与Func的区别（Expression与反射的结合使用）
C#使用foreach循环的注意点
DHZYKN
06-10 7378
1.不能在在循环内部删除或增加元素； 可能原因是，在执行foreach循环时，集合内部有一个变量用于记录集合中元素的个数，每次遍历时会检测这个变量有无发生变化，如果发生变化，则抛出异常。 2.不能在循环内部修改元素(无论值类型还是引用类型)； 原因是，在遍历IEnumerator&lt;T&gt;的过程中，把当前的元素(即Current)暴露为只读属性。 3.可以在循环内部修改对象的属性。...
EF中一种简单的多条件动态查询方法
echoshinian100的专栏
04-24 1万+
多条件动态查询是任何一个数据系统都会处理的问题。如果使用纯SQL和数据库进行交互，可以使用SQLHepler之类的工具根据用户输入来动态生成SQL语句。在EF框架下，使用lambda表达式来进行多条件动态查询颇为麻烦。举个例子来说明吧。           数据模型类： class Person { public string Name; pu
forEach 方法遍历数组：
weixin_33861800的博客
10-09 938
2019独角兽企业重金招聘Python工程师标准>>> ...
简单的反射实例以及for循环和foreach差别
ID_Dexter的博客
05-25 526
重点：1.反射判断值类型          2.关于for循环和foreach的区别for循环可以修改循环中元素属性，而foreach不能，更不能对集合进行add和delete，原因是collection中返回的IEmumator设置其元素为只读属性，所以即使元素是int值类型也不能修改。这时最好使用for循环...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值