Exemplo n.º 1
0
        /// <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");

                    // 获取序列号.
                    decimal newSeq = sequence.SEQUENCE_NUMBER;

                    // 更新序列号表.
                    sequence.SEQUENCE_NUMBER++;

                    Console.WriteLine("sequence = " + newSeq);


                    
                    // 注意: 这里修改了数据以后, 并没有  context.SaveChanges();  提交保存.
                    // 将循环回去, 再做 FirstOrDefault 查询.
                }


                Console.WriteLine("测试多次重复更改/查询 Finish! (本方法未执行 context.SaveChanges() )");
            }

        }
Exemplo n.º 2
0
        /// <summary>
        /// 测试.
        /// </summary>
        public static void DoTest()
        {

            Console.WriteLine("测试 直接执行 SQL 语句!");

            using (TestEntities context = new TestEntities())
            {


                // 通过下面这种方式, 执行一个 SQL 语句.
                // 要求 SQL 查询返回的结果形式, 要是一个 Entity类。
                // 这里的做法是, 根据查询的结果字段, 去数据库建一个空的表,然后导入到 EntityFramework 的 edmx 文件中.
                var query =
                    context.ExecuteStoreQuery<QUERY_RESULT_MAIN_AND_SUB>(testSql);


                foreach (QUERY_RESULT_MAIN_AND_SUB result in query)
                {
                    Console.WriteLine(
                        "直接执行 SQL 语句结果:MainVal = {0}, SubVal = {1} ",
                        result.MAIN_VALUE, 
                        result.SUB_VALUE );
                }


            }

            Console.WriteLine("测试 直接执行 SQL 语句 结束!");
            Console.WriteLine();
        }
Exemplo n.º 3
0
        static void DoTestConcurrency()
        {
            using (TestEntities context = new TestEntities())
            {
                Console.WriteLine("Start!");
                // 取得 数据库的序列号数据.
                TEST_SEQUENCE sequence = context.TEST_SEQUENCE.FirstOrDefault(p => p.TABLE_NAME == "test_main");
                // 获取序列号.
                decimal 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>
        /// 测试 不 调用 SaveChanges 方法。
        /// 调用存储过程, 是否会更新数据。
        /// </summary>
        private static void TestWithOutSaveChanges()
        {

            Console.WriteLine("测试调用存储过程!");

            using (TestEntities context = new TestEntities())
            {

                Console.WriteLine("调用插入数据的存储过程!");
                context.TestInsertMainSub("procMain2", "procSub2");                
            }

            Console.WriteLine("查询数据!  看看在调用存储过程后, 没有执行 SaveChanges, 是否实际更新了数据!");



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

            }


        }
        /// <summary>
        /// 测试 不 调用 SaveChanges 方法。
        /// 调用存储过程, 是否会更新数据。
        /// </summary>
        private static void TestWithOutSaveChanges()
        {
            Console.WriteLine("测试调用存储过程!");

            using (TestEntities context = new TestEntities())
            {
                Console.WriteLine("调用插入数据的存储过程!");
                context.TestInsertMainSub("procMain2", "procSub2");
            }

            Console.WriteLine("查询数据!  看看在调用存储过程后, 没有执行 SaveChanges, 是否实际更新了数据!");



            decimal 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);
                }
            }
        }
        // 在 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("调用删除数据的存储过程!");

                decimal 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("调用删除数据的存储过程!");

                decimal 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();
            }
        }
Exemplo n.º 8
0
        /// <summary>
        /// 测试 正常的调用 + 存储过程调用
        /// </summary>
        private static void TestCallProc()
        {
            Console.WriteLine();
            Console.WriteLine("开始测试 事务处理 (先调用存储过程, 后添加数据)...");



            // 注意: 运行的时候,可能会提示。
            // 无法启动此程序,因为计算机中丢失 MSVCRTD.dll
            // 忽略对话框, 直接按确定按钮以后, 程序可正常执行。


            // 在某些有 VC ++ 开发工具的计算机上面, 可以找到这个 MSVCRTD.dll  文件.
            // 从那些机器上复制下来,粘贴到 C:\Windows\system32  ( 64 位系统,复制到  C:\Windows\SysWOW64 )
            // 然后再运行,将没有上面的问题。

            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(false);

                        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 的 数据。");
                    }



                    decimal 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();
        }
Exemplo n.º 9
0
        /// <summary>
        /// 正常的测试.
        /// </summary>
        private static void TestNormal()
        {
            Console.WriteLine();
            Console.WriteLine("开始测试 事务处理...");

            try
            {
                // 这里用于 模拟2个 Context , 执行同样的操作。
                // 导致 异常, 最后 回滚数据修改的处理.
                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 的 数据。");
                    }
                }
            }
        }
Exemplo n.º 10
0
        /// <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("### 开始测试 多对多 的延迟加载! ###");

                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();
                Console.WriteLine("Include 方式查询 test_main!");
                // 这里使用 贪婪加载.
                foreach (TEST_MAIN m in context.TEST_MAIN.Include("TEST_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();
                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);
                }
            }
        }
Exemplo n.º 11
0
        /// <summary>
        /// 正常的测试.
        /// </summary>
        private static void TestNormal()
        {


            Console.WriteLine();
            Console.WriteLine("开始测试 事务处理...");

            try
            {

                // 这里用于 模拟2个 Context , 执行同样的操作。
                // 导致 异常, 最后 回滚数据修改的处理.
                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 的 数据。");
                    }

                }

            }


        }
Exemplo n.º 12
0
        /// <summary>
        /// 测试 正常的调用 + 存储过程调用
        /// </summary>
        private static void TestCallProc()
        {


            Console.WriteLine();
            Console.WriteLine("开始测试 事务处理 (先调用存储过程, 后添加数据)...");


            
            // 注意: 运行的时候,可能会提示。
            // 无法启动此程序,因为计算机中丢失 MSVCRTD.dll 
            // 忽略对话框, 直接按确定按钮以后, 程序可正常执行。

            
            // 在某些有 VC ++ 开发工具的计算机上面, 可以找到这个 MSVCRTD.dll  文件.
            // 从那些机器上复制下来,粘贴到 C:\Windows\system32  ( 64 位系统,复制到  C:\Windows\SysWOW64 )
            // 然后再运行,将没有上面的问题。

            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(false);

                        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 的 数据。");
                    }




                    decimal 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();

        }
Exemplo n.º 13
0
        /// <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("### 开始测试 多对多 的延迟加载! ###");

                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();
                Console.WriteLine("Include 方式查询 test_main!");
                // 这里使用 贪婪加载.
                foreach (TEST_MAIN m in context.TEST_MAIN.Include("TEST_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();
                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);
                }

            }
        }