EF扩展，EF和ado的连接融合，事务融合以及EF+ado的联合事务控制

最新推荐文章于 2023-08-05 12:54:38 发布
最新推荐文章于 2023-08-05 12:54:38 发布
阅读量865 收藏
点赞数
分类专栏： C#/.NET
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37886901/article/details/102627336
版权

话不多说，直接上码：

using ConsoleAppTestEF.Model;
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Entity;
using System.Data.SqlClient;
using System.Linq;

namespace ConsoleAppTestEF
{
    public class CpcRepository
    {
        #region Execute

        //普通执行
        public static void Execute(Action<LingbugCpcContext> action)
        {
            using (var dbContext = new LingbugCpcContext())
            {
                action.Invoke(dbContext);
            }
        }

        //事务执行
        public static void Execute(Action<LingbugCpcContext> action, bool isDefaultTranLevel, IsolationLevel transactionLevel = IsolationLevel.Unspecified)
        {
            using (var dbContext = new LingbugCpcContext())
            {
                using (var transaction = isDefaultTranLevel ? dbContext.Database.BeginTransaction() : dbContext.Database.BeginTransaction(transactionLevel))
                {
                    try
                    {
                        action.Invoke(dbContext);
                        transaction.Commit();
                    }
                    catch (Exception e)
                    {
                        transaction.Rollback();
                        throw;
                    }
                }
            }
        }

        //EF事务在ado.net事务融合执行
        public static void Execute(Action<LingbugCpcContext, SqlTransaction> action, bool isDefaultTranLevel, IsolationLevel transactionLevel = IsolationLevel.Unspecified)
        {
            using (var connection = new SqlConnection(GetConnectionString()))
            {
                OpenConnection(connection);
                using (var transaction = isDefaultTranLevel ? connection.BeginTransaction() : connection.BeginTransaction(transactionLevel))
                {
                    using (var dbContext = new LingbugCpcContext(connection, false))
                    {
                        dbContext.Database.UseTransaction(transaction);
                        try
                        {
                            action.Invoke(dbContext, transaction);
                            transaction.Commit();
                        }
                        catch (Exception e)
                        {
                            transaction.Rollback();
                            throw;
                        }
                    }
                }
            }
        }

        #endregion

        #region 修改

        //修改（对外提供的接口）
        public static int Update<T>(T updateModel, LingbugCpcContext dbContext = null) where T : BaseModel
        {
            int count = 0;

            if (dbContext == null)
            {
                Execute(dbctx => count = UpdateMain(updateModel, dbctx));
            }
            else
            {
                count = UpdateMain(updateModel, dbContext);
            }
            return count;
        }

        //修改（核心）
        private static int UpdateMain<T>(T model, LingbugCpcContext dbContext) where T : BaseModel
        {
            dbContext.Entry(model).State = EntityState.Modified;
            foreach (var name in model.GetUnChanged())
            {
                dbContext.Entry(model).Property(name).IsModified = false;
            }
            return dbContext.SaveChanges();
        }

        #endregion

        #region 查询

        //使用ado.net查询DataTable（对外提供接口）
        public static DataTable QueryDataTable(string sql, Dictionary<string, object> dicParameter = null, SqlTransaction transaction = null)
        {
            var dataContainer = new DataTable();
            if (transaction == null)
            {
                using (var connection = new SqlConnection(GetConnectionString()))
                {
                    QueryFromSql(connection, null, sql, dicParameter, da => da.Fill(dataContainer));
                }
            }
            else
            {
                QueryFromSql(GetConnectionByTransaction(transaction), transaction, sql, dicParameter, da => da.Fill(dataContainer));
            }
            return dataContainer;
        }

        //使用ado.net查询DataSet（对外提供接口）
        public static DataSet QueryDataSet(string sql, Dictionary<string, object> dicParameter = null, SqlTransaction transaction = null)
        {
            var dataContainer = new DataSet();
            if (transaction == null)
            {
                using (var connection = new SqlConnection(GetConnectionString()))
                {
                    QueryFromSql(connection, null, sql, dicParameter, da => da.Fill(dataContainer));
                }
            }
            else
            {
                QueryFromSql(GetConnectionByTransaction(transaction), transaction, sql, dicParameter, da => da.Fill(dataContainer));
            }
            return dataContainer;
        }

        #endregion

        #region 私有方法

        //通过事务获取到数据库连接
        private static SqlConnection GetConnectionByTransaction(SqlTransaction transaction)
        {
            return transaction.Connection;
        }

        //通过EF获取到数据库连接
        private static string GetConnectionString()
        {
            string connectionString = null;
            Execute(dbContext => connectionString = dbContext.Database.Connection.ConnectionString);
            return connectionString;
        }

        //使用ado.net执行sql（核心）
        private static void QueryFromSql(SqlConnection connection, SqlTransaction transaction, string sql, Dictionary<string, object> dicParameter, Action<SqlDataAdapter> action)
        {
            OpenConnection(connection);
            using (var command = new SqlCommand())
            {
                InitCommand(command, connection, transaction);
                command.CommandText = sql;
                command.Parameters.Clear();
                if (dicParameter != null && dicParameter.Any())
                {
                    foreach (var dicItem in dicParameter)
                    {
                        command.Parameters.Add(new SqlParameter(GetParameterName(dicItem.Key), dicItem.Value));
                    }
                }
                using (var da = new SqlDataAdapter(command))
                {
                    action.Invoke(da);
                }
            }
        }

        //获取到参数名称（自动增加前缀@）
        private static string GetParameterName(string parameterName)
        {
            return parameterName.StartsWith("@") ? parameterName : "@" + parameterName;
        }

        //初始化ado.net的命令对象
        private static void InitCommand(SqlCommand command, SqlConnection connection, SqlTransaction transaction)
        {
            command.Connection = connection;
            if (transaction != null)
            {
                command.Transaction = transaction;
            }
            command.CommandType = CommandType.Text;
        }

        //打开数据库连接
        private static void OpenConnection(SqlConnection connection)
        {
            if (connection.State != ConnectionState.Open)
            {
                connection.Open();
            }
        }

        #endregion
    }
}

 

测试代码：

普通测试：

private static void TestEfHelperNew()
        {
            var updateModel = new TestUpdateWithFlagModel()
            {
                Id = "c8b8566a-db7c-4eeb-a5f5-24ff8d0abd12",
                Name = "TestEfHelperNewUpdate",
                UpdateDate = DateTime.Now
            };
            Console.WriteLine("修改结果为：" + EfHelperNew.Update(updateModel));

            var dtTask = EfHelperNew.QueryDataTable("SELECT * FROM dbo.Task WHERE ProjectName = @ProjectName", new Dictionary<string, object>() { { "@ProjectName", "Ling、bug任务" } });
            Console.WriteLine("共查询出{0}条数据", dtTask.Rows.Count);
            int rowIndex = 0;
            foreach (DataRow dr in dtTask.Rows)
            {
                Console.WriteLine("第{0}个：{1}", ++rowIndex, dr["ProjectName"].ToString());
            }

            var ds = EfHelperNew.QueryDataSet("SELECT * FROM dbo.TestUpdateWithFlagInfo;SELECT * FROM dbo.Task");
            Console.WriteLine("共查询出{0}个table", ds.Tables.Count);
            int tableIndex = 0;
            foreach (DataTable dtItem in ds.Tables)
            {
                Console.WriteLine("第{0}个table名字是：{1}，有{2}行数据", ++tableIndex, dtItem.TableName, dtItem.Rows.Count);
            }
        }

测试结果：

测试事务以及事务隔离级别：

private static void TestEfHelperNewTransaction()
        {
            var task1 = Task.Run(() =>
            {
                EfHelperNew.Execuse((dbContext, conn, tran) =>
                {
                    //查询操作
                    var dt = EfHelperNew.QueryDataTable("SELECT * FROM dbo.TestUpdateWithFlagInfo", null, conn, tran);
                    Console.WriteLine("查询出{0}条数据", dt.Rows.Count);
                    int i = 1;
                    //模拟耗时操作
                    Console.WriteLine("开始模拟耗时操作");
                    for (i = 1; i <= 5; i++)
                    {
                        Console.WriteLine(i);
                        Thread.Sleep(1000);
                    }
                    Console.WriteLine("开始事务内部修改操作");
                    //修改数据
                    var updateCount = dbContext.Database.ExecuteSqlCommand("UPDATE dbo.TestUpdateWithFlagInfo SET Name = '6666',UpdateDate = GETDATE() WHERE Id = '2fdbc379-def0-4f18-a34b-f3997c86587b'");
                    //提示修改结果
                    Console.WriteLine("事务内部修改完毕，count = " + updateCount);
                    Console.WriteLine("继续耗时操作");
                    for (i = 6; i <= 10; i++)
                    {
                        Console.WriteLine(i);
                        Thread.Sleep(1000);
                    }

                }, false, IsolationLevel.Serializable);
            });
            var task2 = Task.Run(() =>
            {
                Thread.Sleep(3000);
                Console.WriteLine("事务外部准备进行修改操作");
                EfHelperNew.Execuse(dbContext =>
                {
                    //不使用事务，修改数据
                    var count = dbContext.Database.ExecuteSqlCommand(string.Format(@"UPDATE dbo.TestUpdateWithFlagInfo SET Name = '线程{0}在修改',UpdateDate = GETDATE() WHERE Id = '5707d129-6b25-4be9-9665-02a53bcddff2'", Thread.CurrentThread.ManagedThreadId));
                    Console.WriteLine("事务外部修改完毕，count = " + count);
                });
            });
            var task3 = Task.Run(() =>
            {
                Thread.Sleep(3000);
                Console.WriteLine("事务外部准备进行新增操作");
                EfHelperNew.Execuse(dbContext =>
                {
                    //不使用事务，新增数据
                    dbContext.TestUpdateWithFlag.Add(new TestUpdateWithFlagModel()
                    {
                        Id = Guid.NewGuid().ToString(),
                        Name = "线程" + Thread.CurrentThread.ManagedThreadId + "在新增",
                        Password = "123456",
                        Status = true,
                        CreateDate = DateTime.Now
                    });
                    var count = dbContext.SaveChanges();
                    Console.WriteLine("事务外部新增完毕，count = " + count);
                });
            });
        }

测试结果：

 

2020-4-29修改了一版，增加了一些扩展方法，代码如下：

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Data;
using System.Data.Entity;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using LevoxCpc.Core;
using LevoxCpc.Model;

namespace LevoxCpc.Dao
{
    /// <summary>
    /// 此类是EF扩展使用类，请勿改动此类，如有需要，请自己建立扩展类去扩展
    /// </summary>
    public class EfDepositoryExtension
    {
        #region Execuse

        public static void Execuse(Action<LevoxCpcDbContext> action)
        {
            using (var dbContext = new LevoxCpcDbContext())
            {
                action.Invoke(dbContext);
            }
        }

        public static void Execuse(Action<LevoxCpcDbContext> action, bool isDefaultTranLevel, IsolationLevel transactionLevel = IsolationLevel.Unspecified)
        {
            using (var dbContext = new LevoxCpcDbContext())
            {
                using (var transaction = isDefaultTranLevel ? dbContext.Database.BeginTransaction() : dbContext.Database.BeginTransaction(transactionLevel))
                {
                    try
                    {
                        action.Invoke(dbContext);
                        transaction.Commit();
                    }
                    catch (Exception e)
                    {
                        transaction.Rollback();
                        throw;
                    }
                }
            }
        }

        public static void Execuse(Action<LevoxCpcDbContext, SqlTransaction> action, bool isDefaultTranLevel, IsolationLevel transactionLevel = IsolationLevel.Unspecified)
        {
            using (var connection = new SqlConnection(GetConnectionString()))
            {
                OpenConnection(connection);
                using (var transaction = isDefaultTranLevel ? connection.BeginTransaction() : connection.BeginTransaction(transactionLevel))
                {
                    using (var dbContext = new LevoxCpcDbContext(connection, false))
                    {
                        dbContext.Database.UseTransaction(transaction);
                        try
                        {
                            action.Invoke(dbContext, transaction);
                            transaction.Commit();
                        }
                        catch (Exception e)
                        {
                            transaction.Rollback();
                            throw;
                        }
                    }
                }
            }
        }

        #endregion

        #region 修改

        public static int Update<T>(T updateModel, LevoxCpcDbContext dbContext = null) where T : BaseDbModel
        {
            int count = 0;

            if (dbContext == null)
            {
                Execuse(dbctx => count = UpdateMain(updateModel, dbctx));
            }
            else
            {
                count = UpdateMain(updateModel, dbContext);
            }
            return count;
        }

        private static int UpdateMain<T>(T model, LevoxCpcDbContext dbContext) where T : BaseDbModel
        {
            var entryModel = dbContext.Entry(model);

            entryModel.State = EntityState.Modified;
            foreach (var name in model.GetUnChanged())
            {
                entryModel.Property(name).IsModified = false;
            }
            return dbContext.SaveChanges();
        }

        #endregion

        #region 查询

        public static DataTable QueryDataTable(string sql, Dictionary<string, object> dicParameter = null, SqlTransaction transaction = null)
        {
            var dataContainer = new DataTable();
            if (transaction == null)
            {
                using (var connection = new SqlConnection(GetConnectionString()))
                {
                    QueryFromSql(connection, null, sql, dicParameter, da => da.Fill(dataContainer));
                }
            }
            else
            {
                QueryFromSql(GetConnectionByTransaction(transaction), transaction, sql, dicParameter, da => da.Fill(dataContainer));
            }
            return dataContainer;
        }

        public static DataSet QueryDataSet(string sql, Dictionary<string, object> dicParameter = null, SqlTransaction transaction = null)
        {
            var dataContainer = new DataSet();
            if (transaction == null)
            {
                using (var connection = new SqlConnection(GetConnectionString()))
                {
                    QueryFromSql(connection, null, sql, dicParameter, da => da.Fill(dataContainer));
                }
            }
            else
            {
                QueryFromSql(GetConnectionByTransaction(transaction), transaction, sql, dicParameter, da => da.Fill(dataContainer));
            }
            return dataContainer;
        }

        public static List<T> QueryList<T>(string sql, Dictionary<string, object> dicParameter = null, SqlTransaction transaction = null)
        {
            return QueryDataTable(sql, dicParameter, transaction).ToList<T>();
        }

        public static int QueryCountForPage(string sql, Dictionary<string, object> dicParameter = null, SqlTransaction transaction = null)
        {
            var dt = QueryDataTable(sql, dicParameter, transaction);
            return dt.Rows[0][0].ToInt32();
        }

        #endregion

        #region 私有方法

        private static SqlConnection GetConnectionByTransaction(SqlTransaction transaction)
        {
            return transaction.Connection;
        }

        private static string GetConnectionString()
        {
            string connectionString = null;
            Execuse(dbContext => connectionString = dbContext.Database.Connection.ConnectionString);
            return connectionString;
        }

        private static void QueryFromSql(SqlConnection connection, SqlTransaction transaction, string sql, Dictionary<string, object> dicParameter, Action<SqlDataAdapter> action)
        {
            OpenConnection(connection);
            using (var command = new SqlCommand())
            {
                command.Connection = connection;
                if (transaction != null) command.Transaction = transaction;
                command.CommandType = CommandType.Text;

                command.CommandText = sql;
                command.Parameters.Clear();
                CreateSqlParameterListByDicPara(dicParameter).LingbugFor(r => command.Parameters.Add(r));

                using (var da = new SqlDataAdapter(command))
                {
                    action.Invoke(da);
                }
            }
        }

        private static SqlParameter[] CreateSqlParameterListByDicPara(Dictionary<string, object> dicPara)
        {
            return dicPara.IsNullOrEmpty() ? new SqlParameter[0] : dicPara.Select(r =>
            {
                string key = r.Key.StartsWith("@") ? r.Key : "@" + r.Key;
                return new SqlParameter(key, r.Value);
            }).ToArray();
        }


        private static void OpenConnection(SqlConnection connection)
        {
            if (connection.State != ConnectionState.Open) connection.Open();
        }

        #endregion

        #region 其他扩展方法

        public static int DeleteDataMain<T>(DeleteDataRequestModel requestModel) where T : BaseDbModel
        {
            if (requestModel.Ids.IsNullOrEmpty()) throw new LevoxCpcException("没有需要删除的数据！");

            var efData = GetTableInfo<T>();

            string sql = string.Format(@"UPDATE dbo.{0} SET IsDel = 1,LastUpdateDate = GETDATE(),LastUpdateUserId = {1} WHERE {2} IN ({3})", efData.TableName, requestModel.CurrentUserId, efData.PrimaryKeyName, requestModel.Ids.LingbugJoin());

            int count = 0;
            Execuse(dbContext => count = dbContext.Database.ExecuteSqlCommand(sql));
            return count.ValidateExecuteResultCount();
        }

        private static EfTableInfo GetTableInfo<T>() where T : BaseDbModel
        {
            var t = typeof(T);
            var tName = t.FullName;

            var primaryKeyProcList = t.GetProperties().Where(r => r.GetAttribute<KeyAttribute>() != null).ToArray();
            if (primaryKeyProcList.IsNullOrEmpty()) throw new LevoxCpcException(string.Format("未找到类型{0}的主键信息！", tName));
            if (primaryKeyProcList.Length > 1) throw new LevoxCpcException(string.Format("类型{0}的主键不唯一，有{1}个：{2}", tName, primaryKeyProcList.Length, primaryKeyProcList.Select(r => r.Name).LingbugJoin()));

            var tableInfo = t.GetAttribute<TableAttribute>();
            if (tableInfo == null) throw new LevoxCpcException(string.Format("未找到类型{0}的表名信息！", tName));

            var data = new EfTableInfo()
            {
                TableName = tableInfo.Name,
                PrimaryKeyName = primaryKeyProcList[0].Name,
                Schema = tableInfo.Schema
            };

            LogTestService.Info("GetTableInfo - Result", data.SerializeObject());

            return data;
        }

        public static TResult QuerySingleById<TTable, TResult>(int? id, SqlTransaction transaction) where TTable : BaseDbModel
        {
            if (!id.HasValue) return CoreService.GetDefaultValue<TResult>();
            var efData = GetTableInfo<TTable>();
            string sql = string.Format(@"SELECT * FROM dbo.{0} a WHERE a.IsDel = 0 AND a.{1} = {2}", efData.TableName, efData.PrimaryKeyName, id.Value);
            var dataList = QueryList<TResult>(sql, null, transaction);
            return dataList.FirstOrDefault();
        }

        public static List<TResult> QueryListByIds<TTable, TResult>(int[] ids, SqlTransaction transaction, bool isCanNoSqlwhere) where TTable : BaseDbModel
        {
            if (ids.IsNullOrEmpty() && !isCanNoSqlwhere) return new List<TResult>();

            var efData = GetTableInfo<TTable>();
            var sb = new StringBuilder(string.Format(@"SELECT * FROM dbo.{0} a WHERE a.IsDel = 0", efData.TableName));
            if (!ids.IsNullOrEmpty()) sb.AppendFormat(@" AND a.{0} IN ({1}) ", efData.PrimaryKeyName, ids.LingbugJoin());

            string sql = sb.ToString();

            return QueryList<TResult>(sql, null, transaction);
        }

        #endregion
    }
}

 

Ending~

Lingbug
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ADO.NET EF不方便之处（BUG）收集帖
01-15 2238
考虑在项目中使用ADO.NET EF，但是怎么都用不顺手，甚至比L2S少了很多关键功能。我先列几个让我很郁闷的（只用了不到5小时就遇到这么多问题）：1）存储过程自动封装是一个很常用的功能，在ADO.NET EF中可以和L2S一样对基本的INSERT/UPDATE/DELETE映射存储过程。也可以对存储过程自动封装，把返回值是结果集的存储过程和实体进行关联，但是很吃惊的是：
EF操作-事务
高级项目经理、专注于技术架构、分享项目管理及职场心得
06-09 1668
在软件开发过程中，我们经常会遇到这样的场景，主从表，主表添加一条记录（主键自动增长），从表添加多条记录，同时从表需要用到刚刚添加的主表的自动增长的主键id,接下来我们就演示一下在EF中怎么实现事务，我们假设TUsers表与TUsersExtInfo表，代码如下： class Program { static void Main(string[] args) {
老派Sql之必要，逆天，我在ef core中使用ado.net！
最新发布
jine1987的专栏
08-05 277
老派SQL之必要，逆天，我在ef core中使用ado.net！
EF添加ADO.NET实体模型，添加Oracle数据源链接
Hulk的博客
01-07 421
EF添加ADO.NET实体模型时添加Oracle数据驱动
EF框架和Ado.Net的使用比较
SeedWJ的博客
05-08 1195
1、性能上（运行效率） Ado.Net的性能更高些，直接使用SQLHelper的Command、Connection等命令通过写SQL语句对数据库进行操作。（EF的实体模型，性能上肯定要损失些！！） 2、方便性上（开发效率） EF使用起来更方便，原因是开发人员不用关心如何访问数据库了。 3、适用性上 EF适合较大型的项目，数据量也较大些；而Ado.Net适用于小型项目（执行效率高些）。 4、灵活性...
visual studio 2019 + mysql + ef + ado.net实体数据模型.rar
07-22
用visual studio 2019 + mysql 数据库，部署ef的环境中，总是出现各种问题，导致不能生成ado.net实体数据模型，要么闪退，要么不显示等。以前公司要求使用oralce数据库的，现在部分换成mysql数据库，这几天在部署...
ASP.MVC5+EF6+ADO，网站实例
11-13
控制器是连接模型和视图的桥梁。 4. **路由（Routing）**: ASP.NET MVC使用路由系统来解析URL并将其映射到控制器方法。开发者可以自定义路由规则以实现灵活的URL结构。 5. **身份验证和授权**: MVC5引入了基于Owin...
ADO.NET sql、LINQ to sql、ADO.NET Entity Framework(EF)数据库连接性能比较
11-05
本文将深入探讨三种常见的.NET框架下的数据库访问技术：ADO.NET SQL、LINQ to SQL以及ADO.NET Entity Framework（EF），并重点分析它们在数据库连接性能上的差异，特别是在插入和读取操作，包括模糊检索方面的表现。...
EF,ADO.NET,MVC餐馆菜品订购管理系统.7z
07-04
这是一个餐馆菜品订购系统，前端用的是原生的html+css，框架用的是asp.net mvc5,数据库的访问使用了两种方式来实现，第一种是原生的ado.net，第二种是Orm框架...为了减少压缩包的体积，我把bin和Obj都删除了，望理解。
VS2017+EF6连接Mysql（所有安装文件和项目）
12-14
总之，VS2017与EF6结合使用可以有效地管理MySQL数据库，而关键在于正确安装MySQL的数据提供者和配置好连接字符串。通过使用Code First的方法，开发者能够轻松地创建数据库模型并进行数据操作，大大简化了数据库相关...
EF的BeginTransaction 用法
weixin_34056162的博客
06-06 641
public ActionResult _Function21Update(string id) { GEN_PARAMETER parameter = db.GEN_PARAMETER.Find(id); if (TryUpdateModel(parameter)) { if ...
EF性能优化-有人说EF性能低，我想说：EF确实不如ADO.NET
weixin_34203426的博客
09-16 1533
十年河东，十年河西，莫欺少年穷。 EF就如同那个少年，ADO.NET则是一位壮年。毕竟ADO.NET出生在EF之前，而EF所走的路属于应用ADO.NET。 也就是说：你所写的LINQ查询，最后还是要转化为ADO.NET的SQL语句，转化过程中无形降低了EF的执行效率。 但是，使用EF的一个好处就是系统便于维护，减少了系统开发时间，降低了生成成本。 OK，上述只是做个简单的对比，那么在实际编...
Entity Framework Extended Library （EF扩展类库，支持批量更新、删除、合并多个查询等）...
weixin_33692284的博客
05-31 217
今天乍一看，园子里居然没有关于这个类库的文章，实在是意外毕竟已经有很多介绍EF使用的文章了。 E文好的可以直接看https://github.com/loresoft/EntityFramework.Extended 也可以在nuget上直接安装这个包，它的说明有点过时了，最新版本已经改用对IQueryable&lt;T&gt;的扩展，而不是DbSet&lt;T&gt;（已经标记为弃用）,所以...
C# EF技术
Cocksuck的博客
05-22 4927
目录 EF简介 ORM的概念 ORM技术的优势 .NET中的ORM框架 EF的本质 Object Services EDM实体数据模型 Entity Client实体代理 ADO.NET Provider Entity Client和ADO.NET EF应用程序有以下优点 EF框架的搭建 EF的创建 三种创建的区别 DataBase First EDM元数据 实体文件 数据库上下文类 使用EF查询单表数据 使用EF实现CRUD Code First EF简介...
ADO的数据泵
01-24 485
{*******************************************************}{                                                       }{       ADO数据泵                                       }{                               
关于ASP.NET MVC+EF报错提示“不支持关键字: "data source......meta data"之类的
gongjing457
08-29 5227
常见错误： 不支持关键字: "data source=(local);initial catalog". 不支持关键字“meta data” 网上大多解决办法是： 1.data source之间需要插入一个空格或者都是一些低级的拼写错误造成的， 2.或者通过把data source改成server解决的 ............ 本人遇到的问题，以上均无法解决，最后经过分析后，发...
EF和ADO的增删改查方法总结
weixin_30455023的博客
10-31 213
lEF添加 DbContext db=new DbContext (); 1.db.对象.Add() db.SaveChanges() 2.SqlParameter[]参数化 db.DataBase.ExecuteSqlCommand("sql语句/存储过程"，“参数”) 3.db.Set<对象>.Add()(不用反射的添加) db.SaveChang...
ado.net EF与ado.net区别比较、在EF中使用执行sql语句
热门推荐
ydm东方旭日的专栏
03-30 2万+
EF作为微软的一个ORM框架，通过实体、关系型数据库表之间的映射，使开发人员可以通过操作表实体而间接的操作数据库，大大的提高了开发效率。 这样一来，.net平台下，我们与底层数据库的交互就有两种选择了（这句话说得不是很准确，微软.net 框架下还是有其他的ORM框架的）：EF、 那相对于我们之前的 相信不少使用EF的同志们已经知道如何在EF中运行SQL命令了。我在这里简单总结下，希望对大家学
EntityFramework与Ado.net的对比——EF优势何在？
u011878310的博客
07-27 1万+
更准确的说法是EF对比SqlHelper ado.net public class SqlHelper { public static readonly string connstr = "Server=.;Database=PhoneBook;Uid=sa;Pwd=********;"; //params 长度可变
ef和ado.net有什么区别吗
07-12
EF（Entity Framework）和 ADO.NET 是两种不同的数据访问技术。 ADO.NET 是一种传统的数据访问技术，它提供了一组用于与关系数据库进行交互的类和方法。ADO.NET 通常使用连接、命令、数据适配器和数据集等对象来...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值