EF简单增删改查

一. 主要内容

1. 数据持久层框架：EF，NHibernate，ibaties(半开放的)。

2. 对象关系映射。

3. 生成外键对象。

4. T4模板。（VS里面需要装T4 Editor插件。）

5. EF上下文(EF容器)->.Context.cs。

6. EF简单的增删改查。

查询：利用部分类的特性重写方法来进行方法的扩展。

修改（SQL Serrver Profiler跟踪）：

先查询，再修改，再保存更改。

7. 延迟加载（延时查询、按需加载）和即时查询。

延迟加载的用途一：

SQL语句条件不确定，所以不能立即进行查询，延迟加载以确定所有条件完成，等开始用的时候才开始查询。

延迟加载的用途二（外键延迟）：

对于外键实体属性的延迟加载。

按需加载的缺点：

每次调用外键实体时，都会去查询数据库（EF小优化:相同的外键实体只查询一次），这时候用即使加载比较好。

8. 延迟加载二视频里面的：数据库改变，则EF实体不会对应改变，可以选择从数据库更新模型。

9. EF的连接查询

include(“User”)，通过include方法，可以告诉EF连接查询哪个外键属性。

10. EF容器（EF数据上下文）

       修改时，不用Attach方式，使用Entry方式。

11. 批处理

12. MODELFirst（实体优先）

13.  EF补充：Select方法能自动生成inner join语句。

二. 源代码

  1 using System;

  2 using System.Collections.Generic;

  3 using System.Data.Entity;

  4 using System.Data.Entity.Infrastructure;

  5 using System.Linq;

  6 using System.Text;

  7 using System.Threading.Tasks;

  8 

  9 namespace EFTest

 10 {

 11     class Program

 12     {

 13         static LeaveWordBoardEntities db = new LeaveWordBoardEntities();

 14         static void Main(string[] args)

 15         {

 16             Querry();

 17         }

 18 

 19         static Program()

 20         {

 21             //取消自动验证所跟踪的实体

 22             db.Configuration.ValidateOnSaveEnabled = false;

 23         }

 24 

 25         #region 1.0 新增

 26         /// <summary>

 27         /// 新增

 28         /// </summary>

 29         static void Add()

 30         {

 31             User uObj = new User()

 32             {

 33                 uName = "HUOAA11",

 34                 uLoginName = "a11",

 35                 uPwd = "a11",

 36                 uIsDel = false,

 37                 uAddTime = DateTime.Now

 38             };

 39             //两种不同的新增方式：本质上都是把该对象标记为新增，让EF上下文来执行新增操作。

 40             //db.Users.Add(uObj);

 41             DbEntityEntry<User> entry = db.Entry<User>(uObj);

 42             entry.State = EntityState.Added;

 43             db.SaveChanges();

 44             Console.WriteLine("新增成功！");

 45         }

 46         #endregion

 47 

 48         #region 2.0 简单查询

 49         /// <summary>

 50         /// 简单查询

 51         /// </summary>

 52         static void Querry()

 53         {

 54             //1.1 延时查询一

 55             //DbQuery<User> i = db.Users.Where(u => u.uLoginName == "HUOTENG").OrderBy(u => u.uId) as DbQuery<User>;

 56             //User user01 = i.FirstOrDefault();

 57             //Console.WriteLine(user01.uName);

 58 

 59             //1.2 延时查询二：针对于外键实体

 60             //对于外键属性而言，EF会用这个外键属性时才去查询对应的表。

 61             //IQueryable<UsersAddress> addrs = db.UsersAddresses.Where(a=>a.udUId==2);//真实返回的DBQuery对象，以接口方式返回

 62             ////a. 此时只查询了地址表

 63             //UsersAddress addr01 = addrs.FirstOrDefault();

 64             ////b. 查询地址对应的用户表

 65             //Console.WriteLine(addr01.User.uName); 

 66             //c. 按需加载的缺点:会为每次调用外键实体时，都会去查询数据库。

 67             //IQueryable<UsersAddress> addrs = db.UsersAddresses;

 68             //foreach (UsersAddress add in addrs)

 69             //{

 70             //    Console.WriteLine(add.udAddress+":userName="+add.User.uName);

 71             //}

 72             //1.3 连接查询，生成innner join

 73             //IQueryable<UsersAddress> addrs = db.UsersAddresses.Include("User");

 74             //foreach (UsersAddress add in addrs)

 75             //{

 76             //    Console.WriteLine(add.udAddress + ":userName=" + add.User.uName);

 77             //}

 78             //IQueryable<Msg> msgs = db.Msgs.Include("User").Include("User1");

 79             //foreach (Msg msg in msgs)

 80             //{

 81             //    Console.WriteLine(msg.mId + "," + msg.User.uName + "," + msg.User1.uName + "," + msg.mMsg);

 82             //}

 83             //1.4 另一种方式的连接查询Select

 84             var addrs = db.UsersAddresses.Where(a => a.udUId == 1).Select(a => new { aId = a.udUId, aAddress = a.udAddress, aUserName = a.User.uName }).ToList();

 85 

 86 

 87             //2. 变相的即时查询

 88             //List<User> list = db.Users.Where(u => u.uName == "HUOAA").ToList();

 89             //list.ForEach(u => Console.WriteLine(u.ToString()));

 90         }

 91         #endregion

 92 

 93         #region 3.0 先查询再修改

 94         /// <summary>

 95         /// 先查询再修改

 96         /// </summary>

 97         static void Edit()

 98         {

 99             User user = db.Users.Where(u => u.uId == 3).FirstOrDefault();

100             user.uName = "nihaoa2";

101             db.SaveChanges();

102             Console.WriteLine("修改成功！");

103         }

104         #endregion

105 

106         #region 4.0 直接修改

107         /// <summary>

108         /// 直接修改

109         /// </summary>

110         static void Edit2()

111         {

112             ////1. 查询出一个要修改的对象，此时返回的是一个User类的代理类对象

113             //User user = db.Users.Where(u => u.uId == 2).FirstOrDefault();

114             //Console.WriteLine("修改前："+user.ToString());

115             ////2. 如果被修改，会在EF上下文容器中标记该属性为已修改

116             //user.uName = "刘德华";

117             ////3. EF上下文进行检查，找到标记修改的属性，生成对应的UPDATE语句进行修改

118             //db.SaveChanges();

119             //Console.WriteLine("修改后："+user.ToString());

120 

121             //Entry方式修改

122             User user = new User() { uId = 2, uName = "小白", uLoginName = "xiaobai", uPwd = "13", uAddTime = DateTime.Now, uIsDel = false };

123             DbEntityEntry<User> entry = db.Entry<User>(user);

124             entry.State = EntityState.Unchanged;

125             entry.Property("uName").IsModified = true;

126             db.SaveChanges();

127             Console.WriteLine("修改成功！");

128         }

129         #endregion

130 

131         #region 5.0 删除

132         /// <summary>

133         /// 删除

134         /// </summary>

135         static void Del()

136         {

137             User u = new User() { uId = 4 };

138             db.Users.Attach(u);

139             db.Users.Remove(u);

140             /*

141              * 也可以用Entry来附加和修改

142              * DbEntityEntry<User> entry = db.Entry<User>(u);

143              * entry.State = EntityState.Deleted;

144              */

145             db.SaveChanges();

146         }

147         #endregion

148 

149         #region 6.0 批处理

150         /// <summary>

151         /// 6.0 批处理

152         /// </summary>

153         static void SaveBatched()

154         {

155             //6.1 新增

156             //User u1 = new User()

157             //{

158             //    uName = "asd",

159             //    uLoginName = "c",

160             //    uPwd = "asdf",

161             //    uIsDel = false,

162             //    uAddTime = DateTime.Now

163             //};

164             //db.Users.Add(u1);

165 

166             //6.2 修改

167             User u2 = new User() { uId = 8, uName = "小黑" };

168             DbEntityEntry<User> entry = db.Entry<User>(u2);

169             entry.State = EntityState.Unchanged;

170             entry.Property("uName").IsModified = true;

171 

172             //6.3 删除

173             //User u3 = new User() { uId=7};

174             //db.Users.Attach(u3);

175             //db.Users.Remove(u3);

176 

177             //6.4 进行统一的批处理

178             db.SaveChanges();

179             Console.WriteLine("批处理完成！");

180         }

181         #endregion

182 

183         #region 7.0 批处理添加大量数据

184         /// <summary>

185         /// 批处理添加大量数据

186         /// </summary>

187         static void BatchAdd()

188         {

189             for (int i = 0; i < 50; i++)

190             {

191                 User u = new User()

192                 {

193                     uName = "qwer" + i,

194                     uLoginName = "qwer" + i,

195                     uPwd = "qwer" + i,

196                     uIsDel = true,

197                     uAddTime = DateTime.Now

198                 };

199                 db.Users.Add(u);

200             }

201             db.SaveChanges();

202             Console.WriteLine("批处理完成！~");

203         }

204         #endregion

205     }

206 }

View Code