/// <summary>
        /// 返回试卷中所有试题外部信息ID,插入试卷引用的试题表有用,全部保存成功才插入
        /// </summary>     
        public List<Guid> 保存下载试卷(LoveKaoExamEntities db, List<string> listBelongSort)
        {
            //全部试题的外部信息ID
            List<Guid> listProblemOutsideId = new List<Guid>();
            //新题的外部信息ID集合
            List<Guid> listNewProblemOutsideId = new List<Guid>();
            //把试卷中所有的试题内容ID,试题外部信息ID取出来
            List<Guid> listProblemContentId = new List<Guid>();
            foreach (试卷中大题 testType in this.试卷中大题集合)
            {
                foreach (试卷大题中试题 testProblem in testType.试卷大题中试题集合)
                {
                    listProblemContentId.Add(testProblem.试题内容ID);
                    JObject bo = JObject.Parse(testProblem.试题内容Json);
                    string problemOutsideIdStr = bo["content"]["试题外部信息ID"].ToString();
                    problemOutsideIdStr = problemOutsideIdStr.Replace("\"", "");
                    Guid problemOutsideId = new Guid(problemOutsideIdStr);
                    listProblemOutsideId.Add(problemOutsideId);
                    string subJsonStr = string.Empty;
                    //若是复合题,则把子小题的Json加入到复合题的Json
                    if (testProblem.子小题集合 != null)
                    {
                        foreach (试卷大题中试题 subTestProblem in testProblem.子小题集合)
                        {
                            JObject subBo = JObject.Parse(subTestProblem.试题内容Json);
                            string subJson = subBo["content"].ToString();
                            subJsonStr += subJson+",";
                        }
                        if (subJsonStr.Length > 0)
                        {
                            subJsonStr = subJsonStr.Remove(subJsonStr.Length - 1);
                        }
                    }
                    subJsonStr = "\"子小题集合\":[" + subJsonStr + "]";
                    testProblem.试题内容Json = testProblem.试题内容Json
                        .Replace("" + testProblem.试题内容ID + "\",", "" + testProblem.试题内容ID + "\","+subJsonStr+",");
                }
            }
            //查询已存在的试题,已存在的则不必插入了
            List<试题内容表> listExistProblemContent = db.试题内容表.Where(a => listProblemContentId.Contains(a.爱考网ID)
                && a.操作人ID == 用户信息.CurrentUser.用户ID).ToList();
            List<Guid> listExistProblemContentLoveKaoId = listExistProblemContent.Select(a => a.爱考网ID).ToList();
            List<Guid> listNotExistProblemContentId = listProblemContentId.Except(listExistProblemContentLoveKaoId).ToList();
             //查询已存在的试题外部信息ID,若试题外部信息存在,而试题内容不存在,则只需添加试题内容即可
            List<Guid> listExistProblemOutsideId = db.试题外部信息表.Where(a => listProblemOutsideId.Contains(a.爱考网ID)
                &&a.创建人ID==用户信息.CurrentUser.用户ID).Select(a => a.爱考网ID).ToList();
            试卷内容表 testContent = new 试卷内容表();
            testContent.ID = this.ID;
            testContent.名称 = this.名称;
            testContent.试卷外部信息ID = this.试卷外部信息ID;
            testContent.说明 = "";
            testContent.提交备注 = "";
            testContent.提交人ID = 用户信息.CurrentUser.用户ID;
            testContent.提交时间 = DateTime.Now;
            //随机一个秒数,使创建时间不在同一秒
            Random random = new Random();
            DateTime time = DateTime.Now;
            //记录随机的秒数,以避免重复
            List<int> listSeconds = new List<int>();
            for (int i = 0; i < this.试卷中大题集合.Count; i++)
            {
                试卷中大题表 type = new 试卷中大题表();
                type.ID = Guid.NewGuid();
                type.多选题评分策略 = 0;
                type.名称 = this.试卷中大题集合[i].名称;
                type.顺序 = Convert.ToByte(i);
                type.说明 = "";
                for (int j = 0; j < this.试卷中大题集合[i].试卷大题中试题集合.Count; j++)
                {
                    int seconds = random.Next(0, 300);
                    if (listSeconds.Contains(seconds))
                    {
                        seconds = random.Next(0, 300);
                    }
                    listSeconds.Add(seconds);
                    试题外部信息 outside = new 试题外部信息();
                    outside.创建时间=time.AddSeconds(seconds);
                    outside.最新更新时间=time.AddSeconds(seconds);

                    试卷大题中试题表 problem = new 试卷大题中试题表();
                    problem.ID = Guid.NewGuid();
                    problem.每小题分值 = this.试卷中大题集合[i].试卷大题中试题集合[j].每小题分值;

                    string 试题Json = this.试卷中大题集合[i].试卷大题中试题集合[j].试题内容Json;
                    Guid contentId = this.试卷中大题集合[i].试卷大题中试题集合[j].试题内容ID;
                    JObject bo = JObject.Parse(试题Json);
                    string problemOutsideIdStr = bo["content"]["试题外部信息ID"].ToString();
                    problemOutsideIdStr = problemOutsideIdStr.Replace("\"", "");
                    Guid problemOutsideId = new Guid(problemOutsideIdStr);
                    //若是不存在的新题,插入新题
                    if (listNotExistProblemContentId.Contains(contentId))
                    {
                        Dictionary<Guid,Guid> dic=new Dictionary<Guid,Guid>();
                        listNewProblemOutsideId.Add(problemOutsideId);
                        试题Json = 试题外部信息.替换试题图片路径(试题Json,用户信息.CurrentUser.用户名);
                        if (listExistProblemOutsideId.Contains(problemOutsideId))
                        {
                            outside.爱考网ID = problemOutsideId;
                            dic=试题外部信息.保存下载试卷中试题(outside, 试题Json, listBelongSort, true, db);
                            contentId = dic.Where(a => a.Key == contentId).First().Value;
                        }
                        else
                        {
                            dic =试题外部信息.保存下载试卷中试题(outside, 试题Json, listBelongSort, false, db);
                            contentId = dic.Where(a => a.Key == contentId).First().Value;
                        }
                        if (this.试卷中大题集合[i].试卷大题中试题集合[j].子小题集合 != null)
                        {
                            for (int m = 0; m < this.试卷中大题集合[i].试卷大题中试题集合[j].子小题集合.Count; m++)
                            {
                                Guid subContentId = dic.Where(a => a.Key == this.试卷中大题集合[i].试卷大题中试题集合[j]
                                    .子小题集合[m].试题内容ID).First().Value;
                                试卷大题中试题表 subProblem = new 试卷大题中试题表();
                                subProblem.ID = Guid.NewGuid();
                                subProblem.每小题分值 = this.试卷中大题集合[i].试卷大题中试题集合[j].子小题集合[m].每小题分值;
                                subProblem.试题内容ID = subContentId;
                                subProblem.顺序 = Convert.ToByte(m);
                                type.试卷大题中试题表.Add(subProblem);
                            }
                        }

                        listNotExistProblemContentId.Remove(contentId);
                    }
                    else
                    {
                        contentId = listExistProblemContent.First(a => a.爱考网ID == contentId).ID;
                    }
                    problem.试题内容ID = contentId;
                    problem.顺序 = Convert.ToByte(j);
                    type.试卷大题中试题表.Add(problem);

                }
                testContent.试卷中大题表.Add(type);
            }
            db.试卷内容表.AddObject(testContent);
            db.SaveChanges();
            return listProblemOutsideId;
        }
 /// <summary>
 /// 用于向 试卷中大题表 EntitySet 添加新对象的方法,已弃用。请考虑改用关联的 ObjectSet&lt;T&gt; 属性的 .Add 方法。
 /// </summary>
 public void AddTo试卷中大题表(试卷中大题表 试卷中大题表)
 {
     base.AddObject("试卷中大题表", 试卷中大题表);
 }
        public void 保存(LoveKaoExamEntities db, Guid 试卷内容ID)
        {
            试卷内容表 testContent = new 试卷内容表();
            testContent.ID = 试卷内容ID;
            testContent.名称 = this.名称;
            testContent.试卷外部信息ID = this.试卷外部信息ID;
            testContent.说明 = this.说明;
            testContent.提交备注 = this.提交备注;
            testContent.提交人ID = this.提交人ID;
            testContent.提交时间 = DateTime.Now;

            for (int i = 0; i < this.试卷中大题集合.Count; i++)
            {
                试卷中大题表 type = new 试卷中大题表();
                type.ID = Guid.NewGuid();
                type.多选题评分策略 = this.试卷中大题集合[i].多选题评分策略;
                type.名称 = this.试卷中大题集合[i].名称;
                type.顺序 = Convert.ToByte(i);
                type.说明 = this.试卷中大题集合[i].说明;

                for (int j = 0; j < this.试卷中大题集合[i].试卷大题中试题集合.Count; j++)
                {
                    if (this.试卷中大题集合[i].试卷大题中试题集合[j].子小题集合 != null)
                    {
                        foreach (试卷大题中试题 testProblem in this.试卷中大题集合[i].试卷大题中试题集合[j].子小题集合)
                        {
                            试卷大题中试题表 dbTestProblem = new 试卷大题中试题表();
                            dbTestProblem.ID = Guid.NewGuid();
                            dbTestProblem.每小题分值 = testProblem.每小题分值;
                            dbTestProblem.试题内容ID = testProblem.试题内容ID;
                            type.试卷大题中试题表.Add(dbTestProblem);
                        }
                    }

                    试卷大题中试题表 problem = new 试卷大题中试题表();
                    problem.ID = Guid.NewGuid();
                    problem.每小题分值 = this.试卷中大题集合[i].试卷大题中试题集合[j].每小题分值;
                    problem.试题内容ID = this.试卷中大题集合[i].试卷大题中试题集合[j].试题内容ID;
                    problem.顺序 = Convert.ToByte(j);
                    type.试卷大题中试题表.Add(problem);

                }
                testContent.试卷中大题表.Add(type);
            }
            db.试卷内容表.AddObject(testContent);
            db.SaveChanges();
        }
 /// <summary>
 /// 创建新的 试卷中大题表 对象。
 /// </summary>
 /// <param name="id">ID 属性的初始值。</param>
 /// <param name="试卷内容ID">试卷内容ID 属性的初始值。</param>
 /// <param name="名称">名称 属性的初始值。</param>
 /// <param name="说明">说明 属性的初始值。</param>
 /// <param name="顺序">顺序 属性的初始值。</param>
 /// <param name="多选题评分策略">多选题评分策略 属性的初始值。</param>
 public static 试卷中大题表 Create试卷中大题表(global::System.Guid id, global::System.Guid 试卷内容ID, global::System.String 名称, global::System.String 说明, global::System.Int16 顺序, global::System.Decimal 多选题评分策略)
 {
     试卷中大题表 试卷中大题表 = new 试卷中大题表();
     试卷中大题表.ID = id;
     试卷中大题表.试卷内容ID = 试卷内容ID;
     试卷中大题表.名称 = 名称;
     试卷中大题表.说明 = 说明;
     试卷中大题表.顺序 = 顺序;
     试卷中大题表.多选题评分策略 = 多选题评分策略;
     return 试卷中大题表;
 }