/// <summary> /// 测试多次重复查询. /// </summary> public static void DoTest() { using (TestEntities context = new TestEntities()) { Console.WriteLine("测试多次重复更改/查询 Start!"); for (int i = 0; i < 10; i++) { // 取得 数据库的序列号数据. test_sequence sequence = context.test_sequence.FirstOrDefault(p => p.table_name == "test_main"); // 获取序列号. int newSeq = sequence.sequence_number; // 更新序列号表. sequence.sequence_number++; Console.WriteLine("sequence = " + newSeq); // 注意: 这里修改了数据以后, 并没有 context.SaveChanges(); 提交保存. // 将循环回去, 再做 FirstOrDefault 查询. } Console.WriteLine("测试多次重复更改/查询 Finish! (本方法未执行 context.SaveChanges() )"); } }
static void DoTestConcurrency() { using (TestEntities context = new TestEntities()) { Console.WriteLine("Start!"); // 取得 数据库的序列号数据. test_sequence sequence = context.test_sequence.FirstOrDefault(p => p.table_name == "test_main"); // 获取序列号. int newSeq = sequence.sequence_number; // 更新序列号表. sequence.sequence_number++; Console.WriteLine("sequence = " + newSeq); // 模拟一个长时间操作. Thread.Sleep(1000); // 插入数据. test_main testData = new test_main() { id = newSeq, value = "Main" + newSeq }; context.test_main.AddObject(testData); // 提交保存. context.SaveChanges(); Console.WriteLine("Finish!"); } }
/// <summary> /// 测试 identity 在系统中,是否会影响 EF 的运作。 /// </summary> public static void DoTest() { using (TestEntities context = new TestEntities()) { Console.WriteLine(); Console.WriteLine("测试 identity Start!"); Console.WriteLine("首先测试 执行插入处理!"); try { test_Identity_tab test1 = new test_Identity_tab() { value = "测试" }; context.test_Identity_tab.AddObject(test1); context.SaveChanges(); Console.WriteLine("执行插入成功!"); Console.WriteLine("数据库那里产生了自增的 identity 数值, 同时更新到当前这个字段上."); Console.WriteLine("test1 的 id = {0}", test1.id); Console.WriteLine("尝试再检索."); var query = from data in context.test_Identity_tab where data.value == "测试" select data; foreach (test_Identity_tab t in query) { Console.WriteLine("id = {0}; value = {1} ", t.id, t.value); context.test_Identity_tab.DeleteObject(t); } context.SaveChanges(); Console.WriteLine("执行删除成功!"); } catch (Exception ex) { Console.WriteLine("执行失败!"); Console.WriteLine(ex.Message); } Console.WriteLine("测试 identity Finish!"); Console.WriteLine(); } }
/// <summary> /// 测试 不 调用 SaveChanges 方法。 /// 调用存储过程, 是否会更新数据。 /// </summary> private static void TestWithOutSaveChanges() { Console.WriteLine("测试调用存储过程!"); using (TestEntities context = new TestEntities()) { Console.WriteLine("调用插入数据的存储过程!"); context.TestInsertMainSub("procMain2", "procSub2"); } Console.WriteLine("查询数据! 看看在调用存储过程后, 没有执行 SaveChanges, 是否实际更新了数据!"); int mainID = 0; using (TestEntities context = new TestEntities()) { test_main mainData = context.test_main.FirstOrDefault(p => p.value == "procMain2"); if (mainData != null) { mainID = mainData.id; Console.WriteLine("Main: ID = {0}; VALUE = {1}", mainData.id, mainData.value); } else { Console.WriteLine("Main 数据不存在!"); } test_sub subData = context.test_sub.FirstOrDefault(p => p.value == "procSub2"); if (subData != null) { Console.WriteLine("SUB: ID = {0}; VALUE = {1}", subData.id, subData.value); } else { Console.WriteLine("Sub 数据不存在!"); } if (mainID != 0) { // 没有 SaveChanges // 但是数据还是更新了. context.TestRemoveMainSub(mainID); } } Console.WriteLine(); }
/// <summary> /// 测试 identity 在系统中,是否会影响 EF 的运作。 /// </summary> public static void DoTest() { using (TestEntities context = new TestEntities()) { Console.WriteLine(); Console.WriteLine("测试 identity Start!"); Console.WriteLine("首先测试 执行插入处理!"); try { test_Identity_tab test1 = new test_Identity_tab() { value = "测试" }; context.test_Identity_tab.AddObject(test1); context.SaveChanges(); Console.WriteLine("执行插入成功!"); Console.WriteLine("数据库那里产生了自增的 identity 数值, 同时更新到当前这个字段上."); Console.WriteLine("test1 的 id = {0}", test1.id); Console.WriteLine("尝试再检索."); var query = from data in context.test_Identity_tab where data.value == "测试" select data; foreach (test_Identity_tab t in query) { Console.WriteLine("id = {0}; value = {1} ", t.id, t.value); context.test_Identity_tab.DeleteObject(t); } context.SaveChanges(); Console.WriteLine("执行删除成功!"); } catch (Exception ex) { Console.WriteLine("执行失败!"); Console.WriteLine(ex.Message); } Console.WriteLine("测试 identity Finish!"); Console.WriteLine(); } }
// 在 EF 中使用存储过程的操作步骤如下: // 1. 首先, 在数据库中,创建好 存储过程,并 编译通过。 // 2. 在 edmx 中,选择 “从数据库更新模型”, 将数据库中的存储过程导入 // 3. 在 edmx 空白区域 鼠标右键, 弹出菜单中选择 “添加 -- 函数导入” // 4. 保存 edmx 后, 在 生成的代码中,应该包含新增的 存储过程. /// <summary> /// 正常的测试. /// </summary> private static void TestNormal() { Console.WriteLine("测试调用存储过程!"); using (TestEntities context = new TestEntities()) { Console.WriteLine("调用插入数据的存储过程!"); context.TestInsertMainSub("procMain", "procSub"); Console.WriteLine("查询数据,查看存储过程是否成功执行!"); test_main mainData = context.test_main.FirstOrDefault(p => p.value == "procMain"); Console.WriteLine("Main: ID = {0}; VALUE = {1}", mainData.id, mainData.value); test_sub subData = context.test_sub.FirstOrDefault(p => p.value == "procSub"); Console.WriteLine("SUB: ID = {0}; VALUE = {1}", subData.id, subData.value); Console.WriteLine(); Console.WriteLine("调用删除数据的存储过程!"); int mainID = mainData.id; context.TestRemoveMainSub(mainID); Console.WriteLine("查询数据,查看存储过程是否成功执行!"); mainData = context.test_main.FirstOrDefault(p => p.id == mainID); if (mainData == null) { Console.WriteLine("Main 数据已被删除!"); } subData = context.test_sub.FirstOrDefault(p => p.main_id == mainID); if (subData == null) { Console.WriteLine("Sub 数据已被删除!"); } context.SaveChanges(); } }
// 在 EF 中使用存储过程的操作步骤如下: // 1. 首先, 在数据库中,创建好 存储过程,并 编译通过。 // 2. 在 edmx 中,选择 “从数据库更新模型”, 将数据库中的存储过程导入 // 3. 在 edmx 空白区域 鼠标右键, 弹出菜单中选择 “添加 -- 函数导入” // 4. 保存 edmx 后, 在 生成的代码中,应该包含新增的 存储过程. /// <summary> /// 正常的测试. /// </summary> private static void TestNormal() { Console.WriteLine("测试调用存储过程!"); using (TestEntities context = new TestEntities()) { Console.WriteLine("调用插入数据的存储过程!"); context.TestInsertMainSub("procMain", "procSub"); Console.WriteLine("查询数据,查看存储过程是否成功执行!"); test_main mainData = context.test_main.FirstOrDefault(p => p.value == "procMain"); Console.WriteLine("Main: ID = {0}; VALUE = {1}", mainData.id, mainData.value); test_sub subData = context.test_sub.FirstOrDefault(p => p.value == "procSub"); Console.WriteLine("SUB: ID = {0}; VALUE = {1}", subData.id, subData.value); Console.WriteLine(); Console.WriteLine("调用删除数据的存储过程!"); int mainID = mainData.id; context.TestRemoveMainSub(mainID); Console.WriteLine("查询数据,查看存储过程是否成功执行!"); mainData = context.test_main.FirstOrDefault(p => p.id == mainID); if (mainData == null) { Console.WriteLine("Main 数据已被删除!"); } subData = context.test_sub.FirstOrDefault(p => p.main_id == mainID); if (subData == null) { Console.WriteLine("Sub 数据已被删除!"); } context.SaveChanges(); } }
/// <summary> /// 测试 不 调用 SaveChanges 方法。 /// 调用存储过程, 是否会更新数据。 /// </summary> private static void TestWithOutSaveChanges() { Console.WriteLine("测试调用存储过程!"); using (TestEntities context = new TestEntities()) { Console.WriteLine("调用插入数据的存储过程!"); context.TestInsertMainSub("procMain2", "procSub2"); } Console.WriteLine("查询数据! 看看在调用存储过程后, 没有执行 SaveChanges, 是否实际更新了数据!"); int mainID = 0; using (TestEntities context = new TestEntities()) { test_main mainData = context.test_main.FirstOrDefault(p => p.value == "procMain2"); if (mainData != null) { mainID = mainData.id; Console.WriteLine("Main: ID = {0}; VALUE = {1}", mainData.id, mainData.value); } else { Console.WriteLine("Main 数据不存在!"); } test_sub subData = context.test_sub.FirstOrDefault(p => p.value == "procSub2"); if (subData != null) { Console.WriteLine("SUB: ID = {0}; VALUE = {1}", subData.id, subData.value); } else { Console.WriteLine("Sub 数据不存在!"); } if (mainID != 0) { // 没有 SaveChanges // 但是数据还是更新了. context.TestRemoveMainSub(mainID); } } Console.WriteLine(); }
/// <summary> /// 正常的测试. /// </summary> private static void TestNormal() { Console.WriteLine(); Console.WriteLine("开始测试 事务处理..."); try { // 这里用于 模拟2个 Context , 执行同样的操作。 // 导致 异常, 最后 回滚数据修改的处理. // 构造一个事务的相关参数,参考下面的文档. // http://msdn.microsoft.com/zh-cn/library/vstudio/ms172152(v=vs.90).aspx using (TransactionScope scope = new TransactionScope()) { TestEntities context1 = new TestEntities(); TestEntities context2 = new TestEntities(); test_main testData = new test_main() { id = 99, value = "测试事务处理." }; context1.test_main.AddObject(testData); context2.test_main.AddObject(testData); // 注意, 这里 调用 SaveChanges 方法时, 传入的参数是 // "在保存更改后,调用 AcceptAllChangesAfterSave() 方法,该方法会在 ObjectStateManager 中重置更改跟踪。 " . context1.SaveChanges(System.Data.Objects.SaveOptions.AcceptAllChangesAfterSave); // Save Changes but don't discard yet context2.SaveChanges(System.Data.Objects.SaveOptions.AcceptAllChangesAfterSave); scope.Complete(); // 调用 AcceptAllChanges 意味着 真正地更新了数据库的数据. context1.AcceptAllChanges(); context2.AcceptAllChanges(); } } catch { Console.WriteLine("异常发生了,数据更改回滚!"); Console.WriteLine("当前数据库中,TEST_MAIN 表应当没有 ID = 99 的 数据。"); using (TestEntities context = new TestEntities()) { test_main mainData = context.test_main.FirstOrDefault(p => p.id == 99); if (mainData == null) { Console.WriteLine("数据核对成功,TEST_MAIN 表没有 ID = 99 的 数据。"); } else { Console.WriteLine("数据核对失败,TEST_MAIN 表有 ID = 99 的 数据。"); } } } }
/// <summary> /// 测试 正常的调用 + 存储过程调用 /// </summary> private static void TestCallProc() { Console.WriteLine(); Console.WriteLine("开始测试 事务处理 (先调用存储过程, 后添加数据)..."); // 注意: 运行的时候 // 如果是 Oracle 数据库, 会提示 // 无法启动此程序,因为计算机中丢失 MSVCRTD.dll // 忽略对话框, 直接按确定按钮以后, 程序可正常执行。 // 对于 SQL Server 数据库来说, 则没有这个问题. try { using (TransactionScope scope = new TransactionScope()) { using (TestEntities context = new TestEntities()) { Console.WriteLine("调用插入数据的存储过程!"); context.TestInsertMainSub("procMain2", "procSub2"); test_main testData = new test_main() { id = 99, value = "测试事务处理." }; context.test_main.AddObject(testData); context.test_main.AddObject(testData); // 注意, 这里 调用 SaveChanges 方法时, 传入的参数是 false. context.SaveChanges(System.Data.Objects.SaveOptions.AcceptAllChangesAfterSave); scope.Complete(); // 调用 AcceptAllChanges 意味着 真正地更新了数据库的数据. context.AcceptAllChanges(); } } } catch { Console.WriteLine("异常发生了,数据更改回滚!"); Console.WriteLine("当前数据库中,TEST_MAIN 表应当没有 ID = 99 的 数据。"); using (TestEntities context = new TestEntities()) { test_main mainData = context.test_main.FirstOrDefault(p => p.id == 99); if (mainData == null) { Console.WriteLine("数据核对成功,TEST_MAIN 表没有 ID = 99 的 数据。"); } else { Console.WriteLine("数据核对失败,TEST_MAIN 表有 ID = 99 的 数据。"); } int mainID = 0; mainData = context.test_main.FirstOrDefault(p => p.value == "procMain2"); if (mainData != null) { mainID = mainData.id; Console.WriteLine("Main: ID = {0}; VALUE = {1}", mainData.id, mainData.value); } else { Console.WriteLine("Main 数据不存在!"); } test_sub subData = context.test_sub.FirstOrDefault(p => p.value == "procSub2"); if (subData != null) { Console.WriteLine("SUB: ID = {0}; VALUE = {1}", subData.id, subData.value); } else { Console.WriteLine("Sub 数据不存在!"); } if (mainID != 0) { // 没有 SaveChanges // 但是数据还是更新了. context.TestRemoveMainSub(mainID); } } } Console.WriteLine(); }
/// <summary> /// 测试. /// </summary> public static void DoTest() { using (TestEntities context = new TestEntities()) { Console.WriteLine("测试 使用 延迟加载!"); // 使用 延迟加载. context.ContextOptions.LazyLoadingEnabled = true; Console.WriteLine("### 开始测试 一对多 的延迟加载! ###"); // 这里主动查询 test_main foreach (test_main m in context.test_main.Where(p=>p.id < 100)) { Console.WriteLine("Main = {0}:{1}", m.id, m.value); // 下面使用 延迟加载, 自动取查询 test_sub if (m.test_sub != null) { foreach (test_sub s in m.test_sub) { Console.WriteLine("----- Sub = {0}:{1}", s.id, s.value); } } Console.WriteLine("========================================"); // 测试三层的. if (m.test_sub_s != null) { foreach (test_sub_s s in m.test_sub_s) { Console.WriteLine("----- Sub_S = {0}:{1}", s.id, s.value); if (s.test_sub_of_sub != null) { foreach (test_sub_of_sub ss in s.test_sub_of_sub) { Console.WriteLine("---------- Sub_S = {0}:{1}", ss.id, ss.value); } } } } } Console.WriteLine("### 开始测试 多对多 的延迟加载! ###"); foreach (test_student m in context.test_student) { Console.WriteLine("学生 = {0}:{1}", m.student_code, m.student_name); // 下面使用 延迟加载, 自动取查询 test_score if (m.test_score != null) { foreach (test_score s in m.test_score) { Console.WriteLine("----- 成绩 = {0}:{1}:{2}", s.course_code, s.test_course.course_name, s.score_value ); } } } } Console.WriteLine(); using (TestEntities context = new TestEntities()) { Console.WriteLine("测试 不使用 延迟加载!"); // 不使用 延迟加载. context.ContextOptions.LazyLoadingEnabled = false; Console.WriteLine("普通方式查询 test_main!"); // 这里主动查询 test_main foreach (test_main m in context.test_main.Where(p => p.id < 100)) { Console.WriteLine("Main = {0}:{1}", m.id, m.value); if (m.test_sub != null) { // 注意: // 使用 非延迟加载的, 结果不是 NULL, 是一个空白列表. foreach (test_sub s in m.test_sub) { Console.WriteLine("----- Sub = {0}:{1}", s.id, s.value); } } else { Console.WriteLine("m.test_sub is null..."); } // 三层的这里就不测试了...... Console.WriteLine("测试 IsLoaded 的判断"); // 在 不使用 延迟加载 的情况下, // 可以通过 IsLoaded / Load 来手动加载. if (!m.test_sub.IsLoaded) { m.test_sub.Load(); foreach (test_sub s in m.test_sub) { Console.WriteLine("----- Sub = {0}:{1}", s.id, s.value); } } // 三层的这里就不测试了...... } Console.WriteLine(); Console.WriteLine("Include 方式查询 test_main!"); // 这里使用 贪婪加载. // 请注意: // 1、如果一个 主表, 同时关联有很多套子表, 那么可以通过 Include("子表1").Include("子表2").Include("子表3") 的方式, 来进行加载. // 2、当表的层级结构是多层的时候,例如 爷爷-父亲-孙子 , 那么需要通过 爷爷.Include("父亲.孙子") 的方式来处理。 foreach (test_main m in context.test_main.Include("test_sub").Include("test_sub_s.test_sub_of_sub").Where(p => p.id < 100)) { Console.WriteLine("Main = {0}:{1}", m.id, m.value); if (m.test_sub != null) { foreach (test_sub s in m.test_sub) { Console.WriteLine("----- Sub = {0}:{1}", s.id, s.value); } } else { Console.WriteLine("m.test_sub is null..."); } Console.WriteLine("========================================"); // 测试三层的. if (m.test_sub_s != null) { foreach (test_sub_s s in m.test_sub_s) { Console.WriteLine("----- Sub_S = {0}:{1}", s.id, s.value); if (s.test_sub_of_sub != null) { foreach (test_sub_of_sub ss in s.test_sub_of_sub) { Console.WriteLine("---------- Sub_S = {0}:{1}", ss.id, ss.value); } } } } } Console.WriteLine(); Console.WriteLine("多对多关系,Include 多层次 查询!"); foreach (test_student m in context.test_student.Include("test_score.test_course")) { Console.WriteLine("学生 = {0}:{1}", m.student_code, m.student_name); // 下面使用 延迟加载, 自动取查询 test_score if (m.test_score != null) { foreach (test_score s in m.test_score) { Console.WriteLine("----- 成绩 = {0}:{1}:{2}", s.course_code, s.test_course.course_name, s.score_value); } } } Console.WriteLine(); Console.WriteLine("多对多关系,Include 多表 查询!"); foreach (test_score s in context.test_score.Include("test_student").Include("test_course")) { Console.WriteLine("学生 = {0} 课程 = {1} 成绩 = {2} ", s.test_student.student_name, s.test_course.course_name, s.score_value); } } }
/// <summary> /// 测试 正常的调用 + 存储过程调用 /// </summary> private static void TestCallProc() { Console.WriteLine(); Console.WriteLine("开始测试 事务处理 (先调用存储过程, 后添加数据)..."); // 注意: 运行的时候 // 如果是 Oracle 数据库, 会提示 // 无法启动此程序,因为计算机中丢失 MSVCRTD.dll // 忽略对话框, 直接按确定按钮以后, 程序可正常执行。 // 对于 SQL Server 数据库来说, 则没有这个问题. try { using (TransactionScope scope = new TransactionScope()) { using (TestEntities context = new TestEntities()) { Console.WriteLine("调用插入数据的存储过程!"); context.TestInsertMainSub("procMain2", "procSub2"); test_main testData = new test_main() { id = 99, value = "测试事务处理." }; context.test_main.AddObject(testData); context.test_main.AddObject(testData); // 注意, 这里 调用 SaveChanges 方法时, 传入的参数是 false. context.SaveChanges(System.Data.Objects.SaveOptions.AcceptAllChangesAfterSave); scope.Complete(); // 调用 AcceptAllChanges 意味着 真正地更新了数据库的数据. context.AcceptAllChanges(); } } } catch { Console.WriteLine("异常发生了,数据更改回滚!"); Console.WriteLine("当前数据库中,TEST_MAIN 表应当没有 ID = 99 的 数据。"); using (TestEntities context = new TestEntities()) { test_main mainData = context.test_main.FirstOrDefault(p => p.id == 99); if (mainData == null) { Console.WriteLine("数据核对成功,TEST_MAIN 表没有 ID = 99 的 数据。"); } else { Console.WriteLine("数据核对失败,TEST_MAIN 表有 ID = 99 的 数据。"); } int mainID = 0; mainData = context.test_main.FirstOrDefault(p => p.value == "procMain2"); if (mainData != null) { mainID = mainData.id; Console.WriteLine("Main: ID = {0}; VALUE = {1}", mainData.id, mainData.value); } else { Console.WriteLine("Main 数据不存在!"); } test_sub subData = context.test_sub.FirstOrDefault(p => p.value == "procSub2"); if (subData != null) { Console.WriteLine("SUB: ID = {0}; VALUE = {1}", subData.id, subData.value); } else { Console.WriteLine("Sub 数据不存在!"); } if (mainID != 0) { // 没有 SaveChanges // 但是数据还是更新了. context.TestRemoveMainSub(mainID); } } } Console.WriteLine(); }
/// <summary> /// 正常的测试. /// </summary> private static void TestNormal() { Console.WriteLine(); Console.WriteLine("开始测试 事务处理..."); try { // 这里用于 模拟2个 Context , 执行同样的操作。 // 导致 异常, 最后 回滚数据修改的处理. // 构造一个事务的相关参数,参考下面的文档. // http://msdn.microsoft.com/zh-cn/library/vstudio/ms172152(v=vs.90).aspx using (TransactionScope scope = new TransactionScope()) { TestEntities context1 = new TestEntities(); TestEntities context2 = new TestEntities(); test_main testData = new test_main() { id = 99, value = "测试事务处理." }; context1.test_main.AddObject(testData); context2.test_main.AddObject(testData); // 注意, 这里 调用 SaveChanges 方法时, 传入的参数是 // "在保存更改后,调用 AcceptAllChangesAfterSave() 方法,该方法会在 ObjectStateManager 中重置更改跟踪。 " . context1.SaveChanges(System.Data.Objects.SaveOptions.AcceptAllChangesAfterSave); // Save Changes but don't discard yet context2.SaveChanges(System.Data.Objects.SaveOptions.AcceptAllChangesAfterSave); scope.Complete(); // 调用 AcceptAllChanges 意味着 真正地更新了数据库的数据. context1.AcceptAllChanges(); context2.AcceptAllChanges(); } } catch { Console.WriteLine("异常发生了,数据更改回滚!"); Console.WriteLine("当前数据库中,TEST_MAIN 表应当没有 ID = 99 的 数据。"); using (TestEntities context = new TestEntities()) { test_main mainData = context.test_main.FirstOrDefault(p => p.id == 99); if (mainData == null) { Console.WriteLine("数据核对成功,TEST_MAIN 表没有 ID = 99 的 数据。"); } else { Console.WriteLine("数据核对失败,TEST_MAIN 表有 ID = 99 的 数据。"); } } } }
/// <summary> /// 测试. /// </summary> public static void DoTest() { using (TestEntities context = new TestEntities()) { Console.WriteLine("测试 使用 延迟加载!"); // 使用 延迟加载. context.ContextOptions.LazyLoadingEnabled = true; Console.WriteLine("### 开始测试 一对多 的延迟加载! ###"); // 这里主动查询 test_main foreach (test_main m in context.test_main.Where(p => p.id < 100)) { Console.WriteLine("Main = {0}:{1}", m.id, m.value); // 下面使用 延迟加载, 自动取查询 test_sub if (m.test_sub != null) { foreach (test_sub s in m.test_sub) { Console.WriteLine("----- Sub = {0}:{1}", s.id, s.value); } } Console.WriteLine("========================================"); // 测试三层的. if (m.test_sub_s != null) { foreach (test_sub_s s in m.test_sub_s) { Console.WriteLine("----- Sub_S = {0}:{1}", s.id, s.value); if (s.test_sub_of_sub != null) { foreach (test_sub_of_sub ss in s.test_sub_of_sub) { Console.WriteLine("---------- Sub_S = {0}:{1}", ss.id, ss.value); } } } } } Console.WriteLine("### 开始测试 多对多 的延迟加载! ###"); foreach (test_student m in context.test_student) { Console.WriteLine("学生 = {0}:{1}", m.student_code, m.student_name); // 下面使用 延迟加载, 自动取查询 test_score if (m.test_score != null) { foreach (test_score s in m.test_score) { Console.WriteLine("----- 成绩 = {0}:{1}:{2}", s.course_code, s.test_course.course_name, s.score_value); } } } } Console.WriteLine(); using (TestEntities context = new TestEntities()) { Console.WriteLine("测试 不使用 延迟加载!"); // 不使用 延迟加载. context.ContextOptions.LazyLoadingEnabled = false; Console.WriteLine("普通方式查询 test_main!"); // 这里主动查询 test_main foreach (test_main m in context.test_main.Where(p => p.id < 100)) { Console.WriteLine("Main = {0}:{1}", m.id, m.value); if (m.test_sub != null) { // 注意: // 使用 非延迟加载的, 结果不是 NULL, 是一个空白列表. foreach (test_sub s in m.test_sub) { Console.WriteLine("----- Sub = {0}:{1}", s.id, s.value); } } else { Console.WriteLine("m.test_sub is null..."); } // 三层的这里就不测试了...... Console.WriteLine("测试 IsLoaded 的判断"); // 在 不使用 延迟加载 的情况下, // 可以通过 IsLoaded / Load 来手动加载. if (!m.test_sub.IsLoaded) { m.test_sub.Load(); foreach (test_sub s in m.test_sub) { Console.WriteLine("----- Sub = {0}:{1}", s.id, s.value); } } // 三层的这里就不测试了...... } Console.WriteLine(); Console.WriteLine("Include 方式查询 test_main!"); // 这里使用 贪婪加载. // 请注意: // 1、如果一个 主表, 同时关联有很多套子表, 那么可以通过 Include("子表1").Include("子表2").Include("子表3") 的方式, 来进行加载. // 2、当表的层级结构是多层的时候,例如 爷爷-父亲-孙子 , 那么需要通过 爷爷.Include("父亲.孙子") 的方式来处理。 foreach (test_main m in context.test_main.Include("test_sub").Include("test_sub_s.test_sub_of_sub").Where(p => p.id < 100)) { Console.WriteLine("Main = {0}:{1}", m.id, m.value); if (m.test_sub != null) { foreach (test_sub s in m.test_sub) { Console.WriteLine("----- Sub = {0}:{1}", s.id, s.value); } } else { Console.WriteLine("m.test_sub is null..."); } Console.WriteLine("========================================"); // 测试三层的. if (m.test_sub_s != null) { foreach (test_sub_s s in m.test_sub_s) { Console.WriteLine("----- Sub_S = {0}:{1}", s.id, s.value); if (s.test_sub_of_sub != null) { foreach (test_sub_of_sub ss in s.test_sub_of_sub) { Console.WriteLine("---------- Sub_S = {0}:{1}", ss.id, ss.value); } } } } } Console.WriteLine(); Console.WriteLine("多对多关系,Include 多层次 查询!"); foreach (test_student m in context.test_student.Include("test_score.test_course")) { Console.WriteLine("学生 = {0}:{1}", m.student_code, m.student_name); // 下面使用 延迟加载, 自动取查询 test_score if (m.test_score != null) { foreach (test_score s in m.test_score) { Console.WriteLine("----- 成绩 = {0}:{1}:{2}", s.course_code, s.test_course.course_name, s.score_value); } } } Console.WriteLine(); Console.WriteLine("多对多关系,Include 多表 查询!"); foreach (test_score s in context.test_score.Include("test_student").Include("test_course")) { Console.WriteLine("学生 = {0} 课程 = {1} 成绩 = {2} ", s.test_student.student_name, s.test_course.course_name, s.score_value); } } }