/// <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);
}
}
}