Exemple #1
0
        public void StartAnalysis()
        {
            Analysis.AnalysisState unsafeValue = this.currentState.UnsafeValue;
            if (unsafeValue.IsStarted || unsafeValue.IsCanceled)
            {
                return;
            }
            lock (this.startAnalysisLock)
            {
                Analysis.AnalysisState safeValue = this.currentState.SafeValue;
                if (safeValue.IsStarted || unsafeValue.IsCanceled)
                {
                    return;
                }
                Analysis.AnalysisState updatedValue = safeValue.SetAsStarted();
                this.currentState.Update(safeValue, updatedValue);
            }
            AnalysisProgress progress = this.currentProgress.Update(this.currentProgress.UnsafeValue, new AnalysisProgress((from x in this.AnalysisMembers
                                                                                                                            where !(x is RootAnalysisMember)
                                                                                                                            select x).Count((AnalysisMember x) => x.IsConclusion), 0));

            try
            {
                this.OnAnalysisStart();
            }
            catch (Exception inner)
            {
                this.Cancel(new CriticalException(null, inner));
            }
            EventHandler <ProgressUpdateEventArgs> progressUpdated = this.ProgressUpdated;

            if (progressUpdated != null)
            {
                progressUpdated(this, new ProgressUpdateEventArgs(progress));
            }
            List <AnalysisMember> source = (from x in this.AnalysisMembers
                                            where x.IsConclusion
                                            select x).ToList <AnalysisMember>();

            if (source.Any <AnalysisMember>())
            {
                if (this.threadMode == AnalysisThreading.Single)
                {
                    using (IEnumerator <AnalysisMember> enumerator = (from x in source
                                                                      orderby(int) x.EvaluationMode
                                                                      select x).GetEnumerator())
                    {
                        while (enumerator.MoveNext())
                        {
                            AnalysisMember analysisMember = enumerator.Current;
                            analysisMember.Start();
                        }
                        return;
                    }
                }
                using (IEnumerator <AnalysisMember> enumerator2 = (from x in this.AnalysisMembers
                                                                   where x.EvaluationMode == Evaluate.OnAnalysisStart && this.immediateEvaluationFilter(x)
                                                                   select x).GetEnumerator())
                {
                    while (enumerator2.MoveNext())
                    {
                        AnalysisMember member = enumerator2.Current;
                        Task.Factory.StartNew(delegate()
                        {
                            member.Start();
                        }, TaskCreationOptions.LongRunning);
                    }
                }
                Parallel.ForEach <AnalysisMember>((from x in this.AnalysisMembers
                                                   where x.IsConclusion && (x.EvaluationMode != Evaluate.OnAnalysisStart || !this.immediateEvaluationFilter(x))
                                                   select x).ToList <AnalysisMember>(), delegate(AnalysisMember x)
                {
                    x.Start();
                });
                return;
            }
            this.CompleteAnalysis();
        }