BaseDAL最牛数据层基类2

最新推荐文章于 2024-06-19 23:44:39 发布
最新推荐文章于 2024-06-19 23:44:39 发布
阅读量112 收藏
点赞数
文章标签： 数据库
原文链接：http://www.cnblogs.com/fuqiang88/p/7900490.html
版权 
using System;
using System.Data.Entity;
using System.Linq;
using System.Threading.Tasks;
using System.Linq.Expressions;
using YunEdu.Model;

namespace DAL
{
    /// <summary>
    /// EF数据库操作基类
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public partial class BaseDAL<T> where T : class, new()
    {
        /// <summary>
        /// 数据库上下文
        /// </summary>
        private DbContext dbContext = DbContextFactory.Create();

        /*
         * 2017-03-22 重新封装的方法
         * 2017-03-26 更新方法添加异步
         */

        #region    Add    添加实体

        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="isSave">是否立即保存</param>
        /// <returns>添加的记录数[isSave=true时有效]</returns>
        public virtual int Add(T entity, bool isSave = true)
        {
            dbContext.Set<T>().Add(entity);
            if (isSave) return dbContext.SaveChanges();
            else return 0;
        }

        /// <summary>
        /// 添加(异步)
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="isSave">是否立即保存</param>
        /// <returns>添加的记录数[isSave=true时有效]</returns>
        public virtual async Task<int> AddAsync(T entity, bool isSave = true)
        {
            dbContext.Set<T>().Add(entity);
            if (isSave) return await dbContext.SaveChangesAsync();
            else return 0;
        }

        /// <summary>
        /// 添加[批量]
        /// </summary>
        /// <param name="entities">实体</param>
        /// <param name="isSave">是否立即保存</param>
        /// <returns>添加的记录数[isSave=true时有效]</returns>
        public virtual int AddRange(T[] entities, bool isSave = true)
        {
            dbContext.Set<T>().AddRange(entities);
            if (isSave) return dbContext.SaveChanges();
            else return 0;
        }

        /// <summary>
        /// 添加[批量](异步)
        /// </summary>
        /// <param name="entities">实体</param>
        /// <param name="isSave">是否立即保存</param>
        /// <returns>添加的记录数[isSave=true时有效]</returns>
        public virtual async Task<int> AddRangeAsync(T[] entities, bool isSave = true)
        {
            dbContext.Set<T>().AddRange(entities);
            if (isSave) return await dbContext.SaveChangesAsync();
            else return 0;
        }

        #endregion

        #region Delete 删除实体

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="isSave">是否立即保存</param>
        /// <returns>是否删除成功[isSave=true时有效]</returns>
        public virtual bool Remove(T entity, bool isSave = true)
        {
            dbContext.Set<T>().Remove(entity);
            if (isSave) return dbContext.SaveChanges() > 0;
            else return false;
        }

        /// <summary>
        /// 删除(异步)
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="isSave">是否立即保存</param>
        /// <returns>是否删除成功[isSave=true时有效]</returns>
        public virtual async Task<bool> RemoveAsync(T entity, bool isSave = true)
        {
            dbContext.Set<T>().Remove(entity);
            if (isSave) return await dbContext.SaveChangesAsync() > 0;
            else return false;
        }


        /// <summary>
        /// 批量删除
        /// </summary>
        /// <param name="entities">实体数组</param>
        /// <param name="isSave">是否立即保存</param>
        /// <returns>成功删除的记录数</returns>
        public virtual int RemoveRange(T[] entities, bool isSave = true)
        {
            dbContext.Set<T>().RemoveRange(entities);
            if (isSave) return dbContext.SaveChanges();
            else return 0;
        }

        /// <summary>
        /// 批量删除(异步)
        /// </summary>
        /// <param name="entities">实体数组</param>
        /// <param name="isSave">是否立即保存</param>
        /// <returns>成功删除的记录数[isSave=true时有效]</returns>
        public virtual async Task<int> RemoveRangeAsync(T[] entities, bool isSave = true)
        {
            dbContext.Set<T>().RemoveRange(entities);
            if (isSave) return await dbContext.SaveChangesAsync();
            else return 0;
        }

        #endregion

        #region Update 更新实体

        /// <summary>
        /// 更新实体
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="isSave">是否立即保存</param>
        /// <returns>在“isSave”为True时返回受影响的对象的数目，为False时直接返回0</returns>
        public virtual int Update(T entity, bool isSave)
        {
            dbContext.Set<T>().Attach(entity);
            dbContext.Entry<T>(entity).State = EntityState.Modified;//将所有属性标记为修改状态
            return isSave ? dbContext.SaveChanges() : 0;
        }

        /// <summary>
        /// 更新实体(异步)
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="isSave">是否立即保存</param>
        /// <returns>在“isSave”为True时返回受影响的对象的数目，为False时直接返回0</returns>
        public async virtual Task<int> UpdateAsync(T entity, bool isSave)
        {
            dbContext.Set<T>().Attach(entity);
            dbContext.Entry<T>(entity).State = EntityState.Modified;//将所有属性标记为修改状态
            if (isSave) return await dbContext.SaveChangesAsync();
            return 0;
        }

        #endregion

        #region Find   查询实体
        /// <summary>
        /// 查找最大实体
        /// </summary>
        /// <returns></returns>
        public virtual T Max()
        {
            return dbContext.Set<T>().Max();
        }

        /// <summary>
        /// 查找最大实体(异步)
        /// </summary>
        /// <returns></returns>
        public async virtual Task<T> MaxAsync()
        {
            return await dbContext.Set<T>().MaxAsync();
        }

        /// <summary>
        /// 查找实体(根据主键值查找)
        /// </summary>
        /// <param name="ID">实体主键值</param>
        /// <returns></returns>
        public virtual T Find(int ID)
        {
            return dbContext.Set<T>().Find(ID);
        }

        /// <summary>
        /// 查找实体(根据主键值查找,异步)
        /// </summary>
        /// <param name="ID">实体主键值</param>
        /// <returns></returns>
        public async virtual Task<T> FindAsync(int ID)
        {
            return await dbContext.Set<T>().FindAsync(ID);
        }

        /// <summary>
        /// 查找(根据联合主键)
        /// </summary>
        /// <param name="keyValues">主键</param>
        /// <returns></returns>
        public virtual T Find(object[] keyValues)
        {
            return dbContext.Set<T>().Find(keyValues);
        }

        /// <summary>
        /// 查找(根据联合主键,异步)
        /// </summary>
        /// <param name="keyValues">主键</param>
        /// <returns></returns>
        public virtual async Task<T> FindAsync(object[] keyValues)
        {
            return await dbContext.Set<T>().FindAsync(keyValues);
        }

        /// <summary>
        /// 查找实体(根据Lambda表达式)
        /// </summary>
        /// <param name="where">查询Lambda表达式</param>
        /// <returns></returns>
        public virtual T FindSingle(Expression<Func<T, bool>> where)
        {
            return dbContext.Set<T>().SingleOrDefault(where);
        }

        /// <summary>
        /// 查找实体(根据Lambda表达式,异步)
        /// </summary>
        /// <param name="where">查询Lambda表达式</param>
        /// <returns></returns>
        public async virtual Task<T> FindSingleAsync(Expression<Func<T, bool>> where)
        {
            return await dbContext.Set<T>().SingleOrDefaultAsync(where);
        }
        #endregion

        #region List   查询列表

        /// <summary>
        /// 查询所有
        /// </summary>
        /// <returns></returns>
        public virtual IQueryable<T> FindList()
        {
            return dbContext.Set<T>();
        }

        /// <summary>
        /// 查询所有(异步)
        /// </summary>
        /// <returns>实体列表</returns>
        public virtual async Task<IQueryable<T>> FindListAsync()
        {
            IQueryable<T> result = dbContext.Set<T>();
            return await Task.FromResult(result);
        }

        /// <summary>
        /// 查询(根据查询条件)
        /// </summary>
        /// <param name="predicate">查询条件</param>
        /// <returns>实体列表</returns>
        public virtual IQueryable<T> FindList(Expression<Func<T, bool>> predicate)
        {
            return dbContext.Set<T>().Where(predicate);
        }

        /// <summary>
        /// 查询(根据查询条件,异步)
        /// </summary>
        /// <param name="predicate">查询条件</param>
        /// <returns>实体列表</returns>
        public virtual async Task<IQueryable<T>> FindListAsync(Expression<Func<T, bool>> predicate)
        {
            return await Task.FromResult(FindList(predicate));
        }

        /// <summary>
        /// 查询(前几条)数据(根据查询条件)
        /// </summary>
        /// <param name="number">返回记录数</param>
        /// <param name="predicate">查询条件</param>
        /// <returns>实体列表</returns>
        public virtual IQueryable<T> FindList(int number, Expression<Func<T, bool>> predicate)
        {
            var entityList = dbContext.Set<T>().Where(predicate);
            if (number > 0) return entityList.Take(number);
            else return entityList;
        }

        /// <summary>
        /// 查询(前几条)数据(根据查询条件,异步)
        /// </summary>
        /// <param name="number">返回记录数</param>
        /// <param name="predicate">查询条件</param>
        /// <returns>实体列表</returns>
        public virtual async Task<IQueryable<T>> FindListAsync(int number, Expression<Func<T, bool>> predicate)
        {
            return await Task.FromResult(FindList(number, predicate));
        }

        /// <summary>
        /// 查询(前几条)数据(根据查询条件,带排序)
        /// </summary>
        /// <param name="number">显示数量[小于等于0-不启用]</param>
        /// <typeparam name="TKey">排序字段</typeparam>
        /// <param name="predicate">查询条件</param>
        /// <param name="keySelector">排序</param>
        /// <param name="isAsc">正序</param>
        /// <returns></returns>
        public virtual IQueryable<T> FindList<TKey>(int number, Expression<Func<T, bool>> predicate, Expression<Func<T, TKey>> keySelector, bool isAsc)
        {
            var entityList = dbContext.Set<T>().Where(predicate);
            if (isAsc) entityList = entityList.OrderBy(keySelector);
            else entityList.OrderByDescending(keySelector);
            if (number > 0) return entityList.Take(number);
            else return entityList;
        }

        /// <summary>
        /// 查询(前几条)数据(根据查询条件,带排序,异步)
        /// </summary>
        /// <param name="number">显示数量[小于等于0-不启用]</param>
        /// <typeparam name="TKey">排序字段</typeparam>
        /// <param name="predicate">查询条件</param>
        /// <param name="keySelector">排序</param>
        /// <param name="isAsc">正序</param>
        /// <returns></returns>
        public virtual async Task<IQueryable<T>> FindListAsync<TKey>(int number, Expression<Func<T, bool>> predicate, Expression<Func<T, TKey>> keySelector, bool isAsc)
        {
            var entityList = dbContext.Set<T>().Where(predicate);
            if (isAsc) entityList = entityList.OrderBy(keySelector);
            else entityList.OrderByDescending(keySelector);
            if (number > 0) entityList = entityList.Take(number);
            return await Task.FromResult(entityList);
        }

        #endregion

        #region Count  查询总数

        /// <summary>
        /// 查询记录数
        /// </summary>
        /// <param name="predicate">查询条件表达式</param>
        /// <returns>记录数</returns>
        public virtual int Count(Expression<Func<T, bool>> predicate)
        {
            return dbContext.Set<T>().Count(predicate);
        }

        /// <summary>
        /// 查询记录数(异步)
        /// </summary>
        /// <param name="predicate">查询条件表达式</param>
        /// <returns>记录数</returns>
        public virtual async Task<int> CountAsync(Expression<Func<T, bool>> predicate)
        {
            return await dbContext.Set<T>().CountAsync(predicate);
        }

        #endregion

        #region Exist  是否存在

        /// <summary>
        /// 查询是否存在
        /// </summary>
        /// <param name="predicate">查询条件表达式</param>
        /// <returns>是否存在</returns>
        public virtual bool Exists(Expression<Func<T, bool>> predicate)
        {
            return dbContext.Set<T>().Any(predicate);
        }

        /// <summary>
        /// 查询是否存在(异步)
        /// </summary>
        /// <param name="predicate">查询条件表达式</param>
        /// <returns>是否存在</returns>
        public virtual async Task<bool> ExistsAsync(Expression<Func<T, bool>> predicate)
        {
            return await dbContext.Set<T>().AnyAsync(predicate);
        }

        #endregion

        #region Page   分页查询

        /// <summary>
        /// 查找分页列表(无条件,无排序)
        /// </summary>
        /// <param name="pageSize">每页记录数。必须大于1</param>
        /// <param name="pageIndex">页码。首页从1开始，页码必须大于1</param>
        /// <param name="totalNumber">总记录数</param>
        /// <returns></returns>
        public virtual IQueryable<T> FindPageList(int pageSize, int pageIndex, out int totalNumber)
        {
            OrderParam _orderParam = null;
            return FindPageList(pageSize, pageIndex, out totalNumber, _orderParam);
        }

        /// <summary>
        /// 查找分页列表(无条件,带排序)
        /// </summary>
        /// <param name="pageSize">每页记录数。必须大于1</param>
        /// <param name="pageIndex">页码。首页从1开始，页码必须大于1</param>
        /// <param name="totalNumber">总记录数</param>
        /// <param name="order">排序键</param>
        /// <param name="asc">是否正序</param>
        /// <returns></returns>
        public virtual IQueryable<T> FindPageList(int pageSize, int pageIndex, out int totalNumber, OrderParam orderParam)
        {
            return FindPageList(pageSize, pageIndex, out totalNumber, (T) => true, orderParam);
        }

        /// <summary>
        /// 查找分页列表(带条件,无排序)
        /// </summary>
        /// <param name="pageSize">每页记录数。必须大于1</param>
        /// <param name="pageIndex">页码。首页从1开始，页码必须大于1</param>
        /// <param name="totalNumber">总记录数</param>
        /// <param name="where">查询表达式</param>
        public virtual IQueryable<T> FindPageList(int pageSize, int pageIndex, out int totalNumber, Expression<Func<T, bool>> where)
        {
            OrderParam _param = null;
            return FindPageList(pageSize, pageIndex, out totalNumber, where, _param);
        }

        /// <summary>
        /// 查找分页列表(无条件,单字段排序)
        /// </summary>
        /// <param name="pageSize">每页记录数。</param>
        /// <param name="pageIndex">页码。首页从1开始</param>
        /// <param name="totalNumber">总记录数</param>
        /// <param name="where">查询表达式</param>
        /// <param name="orderParam">排序【null-不设置】</param>
        /// <returns></returns>
        public virtual IQueryable<T> FindPageList(int pageSize, int pageIndex, out int totalNumber, Expression<Func<T, bool>> where, OrderParam orderParam)
        {
            OrderParam[] _orderParams = null;
            if (orderParam != null) _orderParams = new OrderParam[] { orderParam };
            return FindPageList(pageSize, pageIndex, out totalNumber, where, _orderParams);
        }

        /// <summary>
        /// 查找分页列表(带条件,带多字段排序)
        /// </summary>
        /// <param name="pageSize">每页记录数。</param>
        /// <param name="pageIndex">页码。首页从1开始</param>
        /// <param name="totalNumber">总记录数</param>
        /// <param name="where">查询表达式</param>
        /// <param name="orderParams">排序【null-不设置】</param>
        public virtual IQueryable<T> FindPageList(int pageSize, int pageIndex, out int totalNumber, Expression<Func<T, bool>> where, OrderParam[] orderParams)
        {
            //条件过滤
            IQueryable<T> query = where == null ? dbContext.Set<T>() : dbContext.Set<T>().Where(where);

            //创建表达式变量参数
            var parameter = Expression.Parameter(typeof(T), "o");

            if (orderParams != null && orderParams.Length > 0)
            {
                for (int i = 0; i < orderParams.Length; i++)
                {
                    //根据属性名获取属性
                    var property = typeof(T).GetProperty(orderParams[i].PropertyName);
                    //创建一个访问属性的表达式
                    var propertyAccess = Expression.MakeMemberAccess(parameter, property);
                    var orderByExp = Expression.Lambda(propertyAccess, parameter);

                    string OrderName = "";
                    if (i > 0)
                    {
                        OrderName = orderParams[i].IsDesc ? "ThenByDescending" : "ThenBy";
                    }
                    else
                        OrderName = orderParams[i].IsDesc ? "OrderByDescending" : "OrderBy";

                    MethodCallExpression resultExp = Expression.Call(typeof(Queryable), OrderName, new Type[] { typeof(T), property.PropertyType }, query.Expression, Expression.Quote(orderByExp));

                    query = query.Provider.CreateQuery<T>(resultExp);
                }
            }

            totalNumber = query.Count();
            return query.Skip((pageIndex - 1) * pageSize).Take(pageSize);
        }


        /// <summary>
        /// 查找分页列表(带条件,单字段lambda表达式排序)
        /// </summary>
        /// <typeparam name="type">排序字段类型</typeparam>
        /// <param name="pageSize">每页记录数</param>
        /// <param name="pageIndex">页码,首页从1开始</param>
        /// <param name="totalNumber">输出总数</param>
        /// <param name="isAsc">是否升序</param>
        /// <param name="OrderByLambda">排序条件</param>
        /// <param name="WhereLambda">查询条件</param>
        /// <returns></returns>
        public virtual IQueryable<T> FindPageList<type>(int pageSize, int pageIndex, out int totalNumber, bool isAsc,
            Expression<Func<T, type>> OrderByLambda, Expression<Func<T, bool>> WhereLambda)
        {
            //输出记录总数
            totalNumber = dbContext.Set<T>().Where(WhereLambda).Count();
            //是否升序
            if (isAsc)
            {
                return dbContext.Set<T>().Where(WhereLambda).OrderBy(OrderByLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize);
            }
            else
            {
                return dbContext.Set<T>().Where(WhereLambda).OrderByDescending(OrderByLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize);
            }
        }
        #endregion

        #region Save   保存数据
        /// <summary>
        ///  保存数据【在Add、Upate、Delete未立即保存的情况下使用】
        /// </summary>
        /// <returns>更改的记录数</returns>
        public virtual int SaveChanges()
        {
            return dbContext.SaveChanges();
        }

        /// <summary>
        ///  保存数据【在Add、Upate、Delete未立即保存的情况下使用】(异步)
        /// </summary>
        /// <returns>更改的记录数</returns>
        public virtual async Task<int> SaveChangesAsync()
        {
            return await dbContext.SaveChangesAsync();
        }
        #endregion

        #region  扩展用 私有方法

        /// <summary>
        /// 私有方法,用于更新指定列
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="properties">要修改的属性名称</param>
        private void UpdateRe(T entity, string[] properties = null)
        {
            var entry = dbContext.Entry(entity);
            if (properties == null)
            {
                entry.State = EntityState.Modified;//将所有属性标记为修改状态
            }
            else
            {
                //Detached 对象存在，但未由对象服务跟踪。在创建实体之后、但将其添加到对象上下文之前，该实体处于此状态；
                if (entry.State == EntityState.Detached) entry.State = EntityState.Unchanged;//先将所有属性状态标记为未修改
                foreach (var property in properties)
                {
                    entry.Property(property).IsModified = true;//将要修改的属性状态标记为修改
                }
            }
        }

        #endregion






    }
}

 

转载于:https://www.cnblogs.com/fuqiang88/p/7900490.html

weixin_30764137
关注
使用SqlSugar封装的数据层基类
dengxuanxian9113的博客
06-02 3651
首先简单封装了个DbContext 1 public class DbContext 2 { 3 #region 属性字段 4 private static string _connectionString; 5 6 /// <summary> 7 /...
BaseDAL数据层基类1
weixin_30263073的博客
03-21 261
/// <summary> /// EF数据库操作基类 /// </summary> /// <typeparam name="T"></typeparam> public partial class BaseDAL<T> where T : class, new() { ...
BaseDal 中对实体进行软删除
08-10 136
public class BaseDal<T> where T:class,new() { public DbContext Db { get { return DbContextFactory.GetCurrentDbContext(); } } public bool Delete(T Entity...
C#/.Net企业级系统架构设计实战精讲教程
12-03
课程通过实际项目融入常用开发技术架构，讲授风格独特，提供详细上课日志及答疑，赠送配套的项目架构源码注释详细清晰且表达通俗，均能直接在实际项目中应用，正真的物超所值，价格实惠任务作业：综合运用《C#/.Net企业级系统架构设计实战精讲教程》课程所学知识技能设计一个学生成绩管理系统的架构。要求：1.系统基于MVC的三层架构，各层单独建不同的解决方案文件夹。2.采用Model First开发方式，设计架构时只需要设计学生表（TbStudent）和课程表（TbCourse）。学生表必须有的字段是ID、stuName、age；课程表必须有的字段是ID、courseName、content。3.数据访问层采用Entity Framework或NHibernate来实现，必须封装对上述表的增删改查方法。4.必须依赖接口编程，也就是必须要有数据访问层的接口层、业务逻辑层的接口层等接口层。层层之间必须减少依赖，可以通过简单工厂或抽象工厂。5.至少采用简单工厂、抽象工厂、Spring.Net等技术中的2种来减少层与层之间的依赖等。6.封装出DbSession类，让它拥有所有Dal层实例和SaveChanges方法。7.设计出数据访问层及业务逻辑层主要类的T4模板，以便实体增加时自动生成相应的类。8.表现层要设计相关的控制器和视图来验证设计的系统架构代码的正确性，必须含有验证增删改查的方法。9.开发平台一定要是Visual Studio平台，采用C#开发语言，数据库为SQL Server。10.提交整个系统架构的源文件及生成的数据库文件。（注意： 作业需写在CSDN博客中，请把作业链接贴在评论区，老师会定期逐个批改~~）
【Design】封装BaseDal基类
GreAmbWang的博客
08-13 597
建立简单的模型 现在编写用户信息数据库访问层UserInfoDal public class UserInfoDal { DataModelContainer db = new DataModelContainer(); /// <summary> /// 添加用户信息 /// </summary> public User...
温控系统-DAL数据层（2）BaseDAL和ProductDAL功能代码
最新发布
精通搬砖，资深技术砖家，在软件开发，人工智能，设备开发等领域都有研究。商业合作&交流学习可私信联系。
06-19 297
BaseDAL是数据层中非常重要的基类，业务DAL使用到其中一些共用方法；
自动生成数据库表映射的实体对象以及可直接调用此实体的数据访问层基类
12-12
解压后得到sp_GenerateEntity.sql在SQL Server中执行，...BaseDAL.cs是使用实体进行数据插入更新删除等操作的数据访问层基类，使用了单态模式和泛型，可以省去很多代码。 此方式使用LINQ To SQL不需要建立dbml文件。
对DAL数据访问层的封装,一个泛型接口，一个实现泛型接口的父类
03-31
在.NET开发领域，数据访问层（DAL）是应用程序与数据库交互的重要组成部分，它负责处理所有与数据相关的操作，如查询、插入、更新和删除记录。在这个特定的案例中，我们看到的是一个使用了Entity Framework（EF）...
三层架构工厂模式
05-20
7. BaseDAL：基数据访问层，为所有的具体数据访问层提供基础功能和公共方法，比如数据库连接的建立和关闭。 8. AccessDAL：如果存在，这可能是另一种数据访问层，用于访问Access数据库。它会实现IDAL接口，并在需要...
petapoco增删改查分页、BaseDAL
07-28
最后，`BaseDAL`是数据访问层的一个通用基类，它的目的是封装Petapoco的常用操作，提供一套接口供其他业务层调用。BaseDAL可以包含以下方法： - `Insert<T>`：插入一个实体。 - `Update<T>`：更新一个实体。 - `...
ASP.NET MVC和EF增删改查，分页
11-08
ASP.NET MVC和EF实现增删改查，外加分页功能。EF创建数据库，ModelFirst
C#-单元测试简单实例和封装EF_BaseDal小记
MrLsss的博客
03-11 659
VS2015创建项目使用.net版本为.net frame... 添加新的项目,选择测试中的单元测试项目...VS中有个非常有用的功能,...
.net MVC三层架构中的BaseDAL
无知的我
02-10 1859
using System; using System.Collections.Generic; using System.Linq; using System.Text; using Videoworks.VPServer.Service; using Videoworks.VPServer.Config; using MySql.Data.MySqlClient; using MySql.D
通用baseDAL类（3）
try your best 的专栏
03-19 1033
using System;using System.Collections.Generic;using System.Text;using System.Data.SqlClient;using System.Data;using System.Collections;namespace DAL{    ///     /// 数据访问抽象基础类    ///     public abstr
ASP.NET MVC 中IBaseDal接口的封装
weixin_30732487的博客
06-09 191
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace HOPU.IDAL { public interface IBaseDal<T>wh...
EntityFramework6写的数据访问框架之二BaseDAL
王翼鹏的博客
06-20 2756
using System; using System.Collections.Generic; using System.Data; using System.Data.Entity; using System.Linq; using System.Linq.Expressions; using System.Text; using LinqKit; using System.Configurat
分层架构详解：关键层设计与性能优化
数据访问层（DAL）是架构的核心，如`BaseDAL<T>`抽象基类，它实现了`IBaseDAL<T>`接口，这个接口定义了诸如查询、插入、更新和删除等常用数据库操作。泛型`T`确保了操作的类型安全，使得重用性大大提高。通过继承`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值