Entity FrameWork(EF)6.0.2 增删修读（READ）的操作实现

最新推荐文章于 2023-01-11 21:15:00 发布
最新推荐文章于 2023-01-11 21:15:00 发布
阅读量3k 收藏 2
点赞数
分类专栏： C# 设计模式 文章标签： entity framework entity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zyf1203/article/details/20912769
版权

第一步：首先创建一个接口，用以暴露其操作的方法

 public interface IOperate<TEntity>
    {
        List<TEntity> FindAll();
       // TEntity FindByKey(object key);
        int Add(TEntity entity);
        int AddRange(IEnumerable<TEntity> entities);
        int Delete(TEntity entity);
       // int DeleteByKey(object key);
      //  int ChangeStatus(object key, object status);
        int DeleteRange(IEnumerable<TEntity> entities);
        int Update(TEntity entity);
       // int Save(TEntity entity);
        int ExecuteSql(string cmdStr, object[] paras);
        List<TEntity> SqlQuery(string queryCmdStr, object[] paras);
    }

 

第二部：实现接口，也就是用EF实现数据库的操作

 public class EfOperate<TEntity> : IOperate<TEntity> where TEntity : class
    {
        private VehicleCheckDBEntities _module;
        private static readonly object LockHelper = new object();

        public List<TEntity> SqlQuery(string queryCmdStr, object[] paras)
        {
            try
            {
                using (_module = new VehicleCheckDBEntities())
                {
                    return paras == null ? _module.Database.SqlQuery<TEntity>(queryCmdStr).ToList() : _module.Database.SqlQuery<TEntity>(queryCmdStr, paras).ToList();
                }
            }
            catch (Exception error)
            {

                throw new Exception(error.Message);
            }

        }

        /// <summary>
        /// 执行Sql语句
        /// </summary>
        /// <returns></returns>
        public int ExecuteSql(string cmdStr, object[] paras)
        {
            /*
            const string cmdStr = "update students set name=@name where id<=@id";
            var paras = new object[]
                {
                    new SqlParameter("@name","哈哈"),
                     new SqlParameter("@id",3)
                };
            */
          
            DbContextTransaction transaction = null;

            try
            {
                lock (LockHelper)
                {
                    using (_module = new VehicleCheckDBEntities())
                    {
                        using (transaction = _module.Database.BeginTransaction())
                        {
                            int rtnNUmber = paras == null
                                       ? _module.Database.ExecuteSqlCommand(cmdStr)
                                       : _module.Database.ExecuteSqlCommand(cmdStr, paras);
                            _module.SaveChanges();
                            transaction.Commit();
                            return rtnNUmber;
                        }
                    }
                }
              
            }
            catch (Exception error)
            {
                if (transaction != null)
                    transaction.Rollback();
                throw new Exception(error.Message);
            }

        }

        protected DbSet<TEntity> DbSet
        {

            get
            {
                try
                {
                    using (_module = new VehicleCheckDBEntities())
                    {
                        return _module.Set<TEntity>();
                    }
                }
                catch (Exception error)
                {
                    throw new Exception(error.Message);
                }

            }
        }

        public List<TEntity> FindAll()
        {
            try
            {
                using (_module = new VehicleCheckDBEntities())
                {
                    return _module.Set<TEntity>().ToList();
                }
            }
            catch (Exception error)
            {
                throw new Exception(error.Message);
            }
        }

 

        /// <summary>
        /// 添加记录
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public int Add(TEntity entity)
        {
            #region 方法一 已测试
#if ceshi
            using (module = new EfModule())
            {
                var entry = module.Entry(entity);
                if (entry.State == EntityState.Detached)
                {
                    entry.State = EntityState.Added;
                }
                return module.SaveChanges();

            }
#endif
            #endregion

            #region 方法二 已测试

            DbContextTransaction transaction = null;
            try
            {
                using (_module = new VehicleCheckDBEntities())
                {
                    using (transaction = _module.Database.BeginTransaction())
                    {
                        _module.Set<TEntity>().Add(entity);
                        int rtnNumber = _module.SaveChanges();
                        transaction.Commit();
                        return rtnNumber;
                    }
                }
            }
            catch (Exception error)
            {
                if (transaction != null)
                    transaction.Rollback();
                throw new Exception(error.Message);
            }

            #endregion
        }

        /// <summary>
        /// 添加多条记录
        /// </summary>
        /// <param name="entities"></param>
        /// <returns></returns>
        public int AddRange(IEnumerable<TEntity> entities)
        {
            DbContextTransaction transaction = null;
            try
            {
                using (_module = new VehicleCheckDBEntities())
                {
                    using (transaction = _module.Database.BeginTransaction())
                    {
                        _module.Set<TEntity>().AddRange(entities);
                        int rtnNumber = _module.SaveChanges();
                        transaction.Commit();
                        return rtnNumber;
                    }
                }
            }
            catch (Exception error)
            {
                if (transaction != null)
                    transaction.Rollback();
                throw new Exception(error.Message);
            }

        }

        /// <summary>
        /// 修改记录
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public int Update(TEntity entity)
        {
            //修改不像Add或Remove有直接的方法，所以必须更改记录在上下文的状态为EntityState.Modified
            DbContextTransaction transaction = null;
            try
            {
                lock (LockHelper)
                {
                using (_module = new VehicleCheckDBEntities())
                {

                    using (transaction = _module.Database.BeginTransaction())
                    {

                        var entry = _module.Entry(entity);
                        if (entry.State == EntityState.Detached)
                        {
                            _module.Set<TEntity>().Attach(entity);
                            entry.State = EntityState.Modified;
                        }

                        int rtnNumber = _module.SaveChanges();
                        transaction.Commit();
                        return rtnNumber;
                    }
                      
                    }

                }
            }
            catch (Exception error)
            {
                if (transaction != null)
                    transaction.Rollback();
                throw new Exception(error.Message);
            }

        }

        /// <summary>
        /// 删除记录
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public int Delete(TEntity entity)
        {
            #region 方法一 已测试 优点：使用任何类；不足之处是要手动更改记录在上下文的状态为 EntityState.Deleted，与修改原理一样

            //using (module = new EfModule())
            //{
            //    var entry = module.Entry(entity);
            //    if (entry.State == EntityState.Detached)
            //    {
            //        entry.State = EntityState.Deleted;
            //    }
            //    return module.SaveChanges();

            //}

            #endregion

            #region 方法2 已测试  直接删除，缺点： 只能使用Student类
            //using (EfModule module = new EfModule())
            //{
            //    var info = module.Students.Where(o => o.Id == 7).First();//若检索到的对象是在using外面生成的，则会报错
            //   module.Set<Student>().Remove(info);   //  module.Students.Remove(info); 两者都可以
            //   return module.SaveChanges();
            //}
            #endregion

            #region 方法3 已测试  直接删除，优点：使用任何类，把记录直接添加到上下文中，当Remove时会把状态自动改为Deleted
            DbContextTransaction transaction = null;
            try
            {
                using (_module = new VehicleCheckDBEntities())
                {
                    using (transaction = _module.Database.BeginTransaction())
                    {
                        //if (_module.Set<TEntity>().Any(o => o.Id == entity.Id))
                        //{
                        _module.Set<TEntity>().Attach(entity);
                        _module.Set<TEntity>().Remove(entity);
                        int rtnNumber = _module.SaveChanges();
                        transaction.Commit();
                        return rtnNumber;
                        //}
                        //return 0;
                    }
                }
            }
            catch (Exception error)
            {
                if (transaction != null)
                    transaction.Rollback();
                throw new Exception(error.Message);
            }

            #endregion
        }

        /// <summary>
        /// 删除多条记录
        /// </summary>
        /// <param name="entities"></param>
        /// <returns></returns>
        public int DeleteRange(IEnumerable<TEntity> entities)
        {
            DbContextTransaction transaction = null;
            try
            {
                using (_module = new VehicleCheckDBEntities())
                {
                    using (transaction = _module.Database.BeginTransaction())
                    {
                        foreach (var entity in entities)
                        {
                            //if (_module.Set<TEntity>().Any(o => o.Id == entity.Id))
                            //{
                            var entry = _module.Entry(entity);
                            if (entry.State == EntityState.Detached)
                            {
                                entry.State = EntityState.Deleted;
                            }
                            //}
                        }
                        int rtnNumber = _module.SaveChanges();
                        transaction.Commit();
                        return rtnNumber;

                    }
                }
            }
            catch (Exception error)
            {
                if (transaction != null)
                    transaction.Rollback();
                throw new Exception(error.Message);
            }

        }

    }

 

第三步：创建对象


        private static readonly IOperate<Device> DeviceOperate = new EfOperate<Device>();//创建操作表Device的对象
        public static readonly IOperate<DeviceDeny> DeviceDenyOperate = new EfOperate<DeviceDeny>();//创建操作表DeviceDeny的对象

 

第四步：调用对象的方法

  public int SaveDeviceDeny(DeviceDeny deviceDeny)
        {
            try
            {
                return deviceDeny.Id > 0 ? DeviceDenyOperate.Update(deviceDeny) : DeviceDenyOperate.Add(deviceDeny);
            }
            catch (Exception error)
            {
                throw new Exception(error.Message);
            }
        }
        public int ChangeStatus(int key, int status)
        {
            const string cmdStr = "update device set status=@status where id=@id";
            var paras = new object[]
                {
                    new SqlParameter("@status",status),
                     new SqlParameter("@id",key)
                };
            try
            {
                return DeviceOperate.ExecuteSql(cmdStr, paras);
            }
            catch (Exception error)
            {
                throw new Exception(error.Message);
            }
        
        }

        public int DeleteDevice(int key)
        {
             string cmdStr =string.Format( "delete device where id={0}",key);
            try
            {
                return DeviceOperate.ExecuteSql(cmdStr, null);
            }
            catch (Exception error)
            {
                throw new Exception(error.Message);
            }
          
        }

   public int SaveDevice(Device device)
        {
            if (device == null)
                return -1;
          
            try
            {
                if (device.Id > 0)
                {
                    const string cmdStr = "  update device set UsedTimes=isnull(UsedTimes,0)+1, LastUsingIp=@lastip,LastUsingDate=@lastdate ,LastUsingUserID=@userId where id=@id  ";
                    //var parameter = new object[]
                    //    {
                    //        new SqlParameter("@times", device.UsedTimes),
                    //        new SqlParameter("@lastip", device.LastUsingIp),
                    //        new SqlParameter("@lastdate", device.LastUsingDate),
                    //        new SqlParameter("@userId", device.LastUsingUserID),
                    //        new SqlParameter("@id", device.Id)

                    //    };
                    //return DeviceOperate.ExecuteSql(cmdStr, parameter);

                    var parameter = new DbParameter[]
                     {
                        new SqlParameter("@times", device.UsedTimes),
                         new SqlParameter("@lastip", device.LastUsingIp),
                         new SqlParameter("@lastdate", device.LastUsingDate),
                         new SqlParameter("@userId", device.LastUsingUserID),
                         new SqlParameter("@id", device.Id)

                     };
                    return DbHelper.ExecuteNonQuery(CommandType.Text, cmdStr, parameter);
                }
                return DeviceOperate.Add(device);
               
            }
            catch (Exception error)
            {
                throw new Exception(error.Message);
            }
        }

 

实践心得:

首先说一下不足之处，就是在修改方法的实现还是不尽人意，当并发调用的时候，程序会报错，大体的意思是当实体类里加载了一条记录时，修改的时候可能由于对这条数据加了锁，无法进行修改；第二个错误就是实体对象模型connection已经关闭，无法对其进行操作，但是ADD方法与Delete方法不会出现此错误，所以我在Update方法中加了Lock，错误便不会出现。也即下面代码：

    /// <summary>
        /// 修改记录
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public int Update(TEntity entity)
        {
            //修改不像Add或Remove有直接的方法，所以必须更改记录在上下文的状态为EntityState.Modified
            DbContextTransaction transaction = null;
            try
            {
                lock (LockHelper)
                {
                using (_module = new VehicleCheckDBEntities())
                {

                    using (transaction = _module.Database.BeginTransaction())
                    {

                        var entry = _module.Entry(entity);
                        if (entry.State == EntityState.Detached)
                        {
                            _module.Set<TEntity>().Attach(entity);
                            entry.State = EntityState.Modified;
                        }

                        int rtnNumber = _module.SaveChanges();
                        transaction.Commit();
                        return rtnNumber;
                    }
                      
                    }

                }
            }
            catch (Exception error)
            {
                if (transaction != null)
                    transaction.Rollback();
                throw new Exception(error.Message);
            }

        }

 

PS：另如果有更优化方案，望请指点，知识用来分享，从而才能在知识中得到乐趣！
风雨无阻1203
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
EF6.0+WCF+CodeFirst+SqlServer 对初学者帮助很大
04-12
EF6.0+WCF+CodeFirst+SqlServer 对初学者帮助很大
EntityFrameWork增删改查应用
05-05
在这个“EntityFrameWork增删改查应用”中，我们将深入探讨如何利用EF进行数据操作。 首先，EF的核心概念是实体（Entity）和上下文（DbContext）。实体代表数据库中的表，而DbContext则作为与数据库交互的主要接口...
EntityFramework实现增删改查
weixin_34004576的博客
02-23 281
17-2-23 EF数据库表一定要有主键 【EF实现修改和删除】 ctx.Entry<UserInfoTable>(user).State = System.Data.Entity.EntityState.Modified; #region 增加操作 /* ...
EF6.0 学习(一)
lee576的专栏
02-08 9816
首次使用EF并学习，决定使用EF + SQLite 来开刀程序员多半是“懒人”，这就是我为什么用SQLite的原因，懒得装Sql Server 这样的数据库，又占硬盘空间，又占资源（一堆后台服务），安装时间又长。在网上看到一个EF的重要概念“Code First”学习Entity Framework 中的Code FirstEF-CodeFirst创建步骤在网上找了很久，貌似EF的Code Fir
EF 6.0
weixin_30420305的博客
02-26 112
最近又开始研究EF框架了 哎 搞的东西太杂了 网上的参考了一篇博客 但是他是基于EF 4.0之前做的 所以自己基于他的博客来构造EF 6.0的使用基础 命名空间不同： 旧版本：using System.Data.Objects; 新版本System.Data.Entity 入门看看就行了 概念： 在.Net Framework SP1微软包含一个实体框架（Entity Frame...
关于EF6.0整理
天马3798
12-30 2718
一、EntityFramework实体框架 官方文档：https://msdn.microsoft.com/en-us/library/aa937723(v=vs.113).aspx https://msdn.microsoft.com/en-us/library/ee712907(v=vs.113).aspx CodePlex源代码地址： https://entityframewor
Entity Framework 增删改查实例
04-03
这个"Entity Framework 增删改查实例"显然是一个专门为初学者设计的学习资源，旨在通过实际操作帮助他们掌握EF的基本用法，包括数据的添加（Add）、修改（Update）、删除（Delete）以及查询（Query）。 首先，我们...
EF.rar_ENTITY FRAMEWORK_Framework_ef
09-14
Entity Framework (EF) 是微软提供的一款强大的对象关系映射（ORM）框架，它允许开发者使用.NET语言（如C#或VB.NET）来操作数据库，而无需编写大量的SQL语句。EF简化了数据访问层的开发，使得应用程序可以更加专注于...
EntityFramework6.0.2资料
02-26
EntityFramework6.0.2资料 偏重CodeFirst。网上资源整理并加入一些调试心得和注解
ef6-6.4.4_ENTITYFRAMEWORK_
09-28
Entity Framework 6 (EF6) is a tried and tested object-relational mapper (O/RM) for .NET with many years of feature development and stabilization.
EntityFramework.6.0.0
08-21
这是一个 .net 实体框架开发技术的类库
EF 6.0命令语法
chenhaishi的博客
03-25 1445
dotnet ef migrations add 名称 --创建table的一些脚本 dotnet ef database update 更新到数据库 创建table dotnet ef database update 名称 --回滚到版本 dotnet ef migrations remove移除迁移(删除最近的一次迁移) 运行 dotnet restore dotnet run ...
ef6.0增删改查操作
weixin_30933531的博客
11-03 242
案例代码如下： Model1Container ef = new Model1Container(); //查询 var liuyan = ef.LiuYan.Where(m => m.BH == "1").FirstOrDefault(); //查询后更新 liuyan.QQ = "1183816...
配置使用EF6.0常见的一些问题及解决方案
weixin_30780221的博客
11-09 247
前言 最近做了个winform小项目，为方便快速开发，后台框架使用了ef6.0+sqlserver2008架构,遇到各种问题，真是伤脑筋。现将遇到问题和解决方案写下来，方便查阅 提示未注册，找不到驱动程序 No Entity Framework provider found for the ADO.NET provider with invariant name 'System.Data.S...
EF6.0新特性-DbCommandInterceptor实现非SQL端读写分离
weixin_30706691的博客
03-09 326
前几天看了一个基于sqlserver的负载均衡与读写分离的软件Moebius,实现的方式还是不错的，这使得用sqlserver数据库的同学时有机会对数据库进行更有效的优化了 看着人有做的东西，自己也想用ＥＦ来实现一个读写分离，所以就有了本篇文章，仓储大叔读写分离的思路是： 1　　用sqlserver自带的发布、订阅实现主，从数据库的结构，同步这事由sql帮我们完成 2　　...
删除EF Core6中的所有行
寒冰屋的专栏
01-11 1002
我们可能需要使用EF Core从表中删除所有记录。在本文中，我们将检查替代选项，例如运行截断/删除命令和单元测试选项。
清空数据库表结构的几种方式
热门推荐
liufangbaishi2014的博客
08-10 1万+
一、SQL中的语法    1、drop table 表名称                         eg: drop table  dbo.Sys_Test    2、truncate table 表名称                     eg: truncate  table dbo.Sys_Test                      3、delete fro
WinForm中使用EF6增删查改
qq_40091720的博客
03-26 4709
form1.cs using System; using System.Windows.Forms; namespace WinformAboutEF { public partial class create : Form { public create() { InitializeComponent(); ...
EntityFramework学习要点记一
ahe82105的博客
10-08 131
一、Entity的注解属性（Annotations）不管是code first还是db first，都需要用到注解属性，至于用System.ComponentModel.DataAnnotations命名空间提供的，还是EntityFramework程序集提供的，现在来做个总结。（EntityFramework程序集using不进来，不知道什么原因，暂时先总结System.Compone...
entity framework增删改查
最新发布
04-06
使用 Entity Framework，我们可以以面向对象的方式操作数据库。这包括添加、删除、修改和查询数据。 具体来说，增加（Create）操作可以通过在上下文中创建新实体并将其添加到数据库集合中来完成。 删除（Delete）...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值