protected internal void AddQuestionOption(QuestionOption QO)
 {
     this.QuestionOptions.Add(QO);
 }
        private void InitQuestionOptions()
        {
            if (this.uQuestion == null)
                return;
            List<UDT.QuestionOption> uQOs = DataPool.GetQuestionOptionsByQuestionID(this.uQuestion.UID);

            uQOs.ForEach((x) =>
            {
                QuestionOption QO = new QuestionOption(x);

                this.AddQuestionOption(QO);
            });
        }
        private List<Question> CalcQuestionScore()
        {
            if (this.Survey == null)
                return new List<Question>();

            foreach (Question Q in this.Survey.Questions)
            {
                //  問答題不需計算
                if (Q.uQuestion.Type == "問答題")
                    continue;

                //  不列入評鑑值計算者不需計算
                //if (Q.uQuestion.IsNoneCalculated)
                //    continue;

                List<QuestionOption> Qos = Q.QuestionOptions;
                Dictionary<string, QuestionOption> dicQuestionOptions = new Dictionary<string, QuestionOption>();
                if (Qos.Count == 0)
                    continue;
                foreach (QuestionOption Qo in Qos)
                {
                    if (!dicQuestionOptions.ContainsKey(Qo.uQuestionOption.Title))
                        dicQuestionOptions.Add(Qo.uQuestionOption.Title, Qo);
                }

                List<Answer> Answers = new List<Answer>();
                foreach (Reply reply in this.Replys)
                {
                    Question QQ = reply.GetQuestionByID(Q.uQuestion.UID);
                    if (QQ != null)
                        Answers.AddRange(QQ.Answers);
                }
                foreach (Answer answer in Answers)
                {
                    if (answer.Case != null)
                    {
                        Q.AddCase(answer.Case);
                    }
                    if (dicQuestionOptions.ContainsKey(answer.Content))
                        dicQuestionOptions[answer.Content].AnswerCount += 1;
                }
                List<Case> qCases = Q.Cases;
                foreach (Case Case in qCases)
                {
                    List<QuestionOption> cQuestionOptions = new List<QuestionOption>();
                    foreach (QuestionOption Qo in Qos)
                    {
                        QuestionOption nQuestionOption = new QuestionOption(Qo.uQuestionOption);
                        cQuestionOptions.Add(nQuestionOption);
                    }
                    Case.SetQuestionOptions(cQuestionOptions);
                }
                foreach (Answer answer in Answers)
                {
                    if (answer.Case == null)
                        continue;

                    if (answer.Case.uCase == null)
                        continue;

                    Case Case = Q.GetCaseByID(answer.Case.uCase.UID);
                    if (Case == null)
                        continue;
                    foreach (QuestionOption Qo in Case.GetQuestionOptions())
                    {
                        if (Qo.Content == answer.Content)
                            Qo.AnswerCount += 1;
                    }
                }
                if (Q.uQuestion.IsCase)
                {
                    List<Case> Cases = Q.Cases;
                    decimal tAnswerCounts = 0;
                    decimal tSumScores = 0;
                    foreach (Case cazz in Cases)
                    {
                        decimal AnswerCounts = 0;
                        decimal SumScores = 0;
                        cazz.GetQuestionOptions().ForEach((x) =>
                        {
                            AnswerCounts += x.AnswerCount;
                            SumScores += x.No * x.AnswerCount;
                            tAnswerCounts += x.AnswerCount;
                            tSumScores += x.No * x.AnswerCount;
                        });
                        if (AnswerCounts > 0)
                            cazz.Score = Math.Round(SumScores / AnswerCounts, 2, MidpointRounding.AwayFromZero);
                    }
                    if (tAnswerCounts > 0)
                        Q.Score = Math.Round(tSumScores / tAnswerCounts, 2, MidpointRounding.AwayFromZero);
                }
                else
                {
                    decimal AnswerCounts = 0;
                    decimal SumScores = 0;
                    Qos.ForEach((x) =>
                    {
                        AnswerCounts += x.AnswerCount;
                        SumScores += x.No * x.AnswerCount;
                    });
                    if (AnswerCounts > 0)
                        Q.Score = Math.Round(SumScores / AnswerCounts, 2, MidpointRounding.AwayFromZero);
                }
            }

            return this.Survey.Questions;
        }