protected Result(AnalysisMember source, Result parent, Exception exception, ExDateTime startTime, ExDateTime stopTime)
{
this.source = source;
this.parent = parent;
this.exception = exception;
this.startTime = startTime;
this.stopTime = stopTime;
}
public Results <T> RelativeResults(Result relativeTo)
{
HashSet <AnalysisMember> @object = new HashSet <AnalysisMember>(base.AncestorsAndSelf());
AnalysisMember commonAncestor = relativeTo.Source.AncestorsAndSelf().First(new Func <AnalysisMember, bool>(@object.Contains));
Result result = relativeTo.AncestorsAndSelf().First((Result x) => x.Source == commonAncestor);
return(result.DescendantsOfType <T>(this));
}
public IEnumerable <AnalysisMember> AncestorsAndSelf()
{
for (AnalysisMember current = this; current != null; current = current.Parent)
{
yield return(current);
}
yield break;
}
public Result <T> AncestorOfType <T>(AnalysisMember <T> ancestor)
{
Result result = this.AncestorsAndSelf().FirstOrDefault((Result x) => x.Source == ancestor);
if (ancestor != null)
{
return((Result <T>)result);
}
throw new AnalysisException(this.Source, Strings.ResultAncestorNotFound(ancestor.Name));
}
protected virtual void OnComplete()
{
AnalysisMember analysisMember = this as AnalysisMember;
if (analysisMember == null || analysisMember is RootAnalysisMember)
{
return;
}
try
{
this.analysis.OnAnalysisMemberStop(analysisMember);
}
catch (Exception inner)
{
this.analysis.Cancel(new CriticalException(analysisMember, inner));
}
bool isAnalysisComplete = false;
if (analysisMember.IsConclusion)
{
AnalysisProgress unsafeValue = this.analysis.currentProgress.UnsafeValue;
AnalysisProgress updatedProgress = new AnalysisProgress(unsafeValue.TotalConclusions, unsafeValue.CompletedConclusions + 1);
isAnalysisComplete = (updatedProgress.CompletedConclusions == updatedProgress.TotalConclusions);
this.analysis.currentProgress.Update(unsafeValue, updatedProgress, delegate(AnalysisProgress original, AnalysisProgress current, AnalysisProgress updated)
{
isAnalysisComplete = (updatedProgress.CompletedConclusions == updatedProgress.TotalConclusions);
return(new AnalysisProgress(current.TotalConclusions, current.CompletedConclusions + 1));
});
EventHandler <ProgressUpdateEventArgs> progressUpdated = this.analysis.ProgressUpdated;
if (progressUpdated != null)
{
try
{
progressUpdated(this.analysis, new ProgressUpdateEventArgs(updatedProgress));
}
catch (Exception inner2)
{
this.analysis.Cancel(new CriticalException(analysisMember, inner2));
}
}
}
if (isAnalysisComplete)
{
this.analysis.CompleteAnalysis();
}
}
protected virtual void OnEvaluate(Result result)
{
AnalysisMember analysisMember = this as AnalysisMember;
if (analysisMember == null || analysisMember is RootAnalysisMember)
{
return;
}
try
{
this.analysis.OnAnalysisMemberEvaluate(analysisMember, result);
}
catch (Exception inner)
{
this.analysis.Cancel(new CriticalException(analysisMember, inner));
}
}
protected virtual void OnStart()
{
AnalysisMember analysisMember = this as AnalysisMember;
if (analysisMember == null || analysisMember is RootAnalysisMember)
{
return;
}
try
{
this.analysis.OnAnalysisMemberStart(analysisMember);
}
catch (Exception inner)
{
this.analysis.Cancel(new CriticalException(analysisMember, inner));
}
}
private TConclusion BuildConclusion(Analysis analysis, Result result)
{
if (result.Source == null)
{
result = new Result <object>((Result <object>)result, analysis.RootAnalysisMember, null, ExDateTime.Now, ExDateTime.Now);
}
AnalysisMember source = result.Source;
if (source == analysis.RootAnalysisMember || (source.GetType().IsGenericType&& source.GetType().GetGenericTypeDefinition() == typeof(Setting <>)))
{
return((TConclusion)((object)this.BuildSettingConclusion(result)));
}
if (source is Rule)
{
return((TConclusion)((object)this.BuildRuleConclusion((RuleResult)result)));
}
return(default(TConclusion));
}
internal RuleResult(RuleResult toCopy, AnalysisMember source, Result parent, ExDateTime startTime, ExDateTime stopTime) : base(toCopy, source, parent, startTime, stopTime)
{
this.Severity = toCopy.Severity;
}
public AccessedFailedResultException(AnalysisMember source, Exception inner) : base(source, Strings.AccessedFailedResult, inner)
{
}
protected override void OnAnalysisMemberEvaluate(Microsoft.Exchange.Management.Deployment.Analysis.AnalysisMember member, Microsoft.Exchange.Management.Deployment.Analysis.Result result)
{
}
public MultipleResultsException(AnalysisMember source) : base(source, Strings.AccessedValueWhenMultipleResults)
{
}
public CriticalException(AnalysisMember source, Exception inner) : base(source, Strings.CriticalMessage, inner)
{
}
public EmptyResultsException(AnalysisMember source) : base(source, Strings.EmptyResults)
{
}
protected abstract void OnAnalysisMemberEvaluate(AnalysisMember member, Result result);
protected abstract void OnAnalysisMemberStop(AnalysisMember member);
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();
}
public Result(Result <T> toCopy, AnalysisMember source, Result parent, ExDateTime startTime, ExDateTime stopTime) : base(source, parent, toCopy.Exception, startTime, stopTime)
{
this.value = toCopy.ValueOrDefault;
}
public AnalysisException(AnalysisMember source)
{
this.AnalysisMemberSource = source;
}
public FilteredException(AnalysisMember source, Result filteredResult) : base(source, Strings.FilteredResult)
{
this.filteredResult = filteredResult;
}
public AnalysisException(AnalysisMember source, string message, Exception inner) : base(message, inner)
{
this.AnalysisMemberSource = source;
}
public FailureException(AnalysisMember source, string message) : base(source, message)
{
}
public Results <T> DescendantsOfType <T>(AnalysisMember <T> analysisMemeber)
{
return(new Results <T>(analysisMemeber, from x in analysisMemeber.Results
where x.AncestorsAndSelf().Contains(this)
select x));
}
protected override void OnAnalysisMemberStop(Microsoft.Exchange.Management.Deployment.Analysis.AnalysisMember member)
{
}
public CriticalException(AnalysisMember source, string message, Exception inner) : base(source, message, inner)
{
}
private IEnumerator <Result <T> > CreateProducerEnumerator()
{
AnalysisMember parent = base.Features.GetFeature <ForEachResultFeature>().ForEachResultFunc();
if (parent == null)
{
this.OnStart();
Result <T> rootResult = base.Analysis.RootAnalysisMember.UntypedResults.Single <Result>() as Result <T>;
this.results = this.results.Add(rootResult);
this.OnEvaluate(rootResult);
yield return(rootResult);
this.OnComplete();
}
else
{
Func <Result, IEnumerable <Result> > resultFunc = base.Features.GetFeature <ResultsFeature>().ResultFunc;
Func <FeatureSet, Result, bool> func;
if (!base.Features.HasFeature <FilterFeature>())
{
func = ((FeatureSet fs, Result r) => true);
}
else
{
func = base.Features.GetFeature <FilterFeature>().FilterFunc;
}
Func <FeatureSet, Result, bool> filterFunc = func;
this.OnStart();
foreach (Result parentResult in parent.UntypedResults)
{
if (!parentResult.HasException)
{
ExDateTime startTime = ExDateTime.Now;
Stopwatch stopWatch = Stopwatch.StartNew();
foreach (Result result in resultFunc(parentResult))
{
Result <T> producerResult = (Result <T>)result;
if (base.IsAnalysisCanceled)
{
yield break;
}
stopWatch.Stop();
ExDateTime stopTime = startTime + stopWatch.Elapsed;
if (producerResult.HasException)
{
if (producerResult.Exception is AnalysisException)
{
AnalysisException ex = (AnalysisException)producerResult.Exception;
ex.AnalysisMemberSource = this;
}
if (producerResult.Exception is CriticalException)
{
base.CancelAnalysis((CriticalException)producerResult.Exception);
}
}
Result <T> filterResult = producerResult;
try
{
if (!filterFunc(base.Features, producerResult))
{
filterResult = new Result <T>(new FilteredException(this, producerResult));
}
}
catch (Exception inner)
{
base.CancelAnalysis(new CriticalException(this, inner));
}
Result <T> consumerResult;
if (filterResult is RuleResult)
{
RuleResult toCopy = filterResult as RuleResult;
RuleResult ruleResult = new RuleResult(toCopy, this, parentResult, startTime, stopTime);
consumerResult = (ruleResult as Result <T>);
}
else
{
consumerResult = new Result <T>(filterResult, this, parentResult, startTime, stopTime);
}
this.results = this.results.Add(consumerResult);
this.OnEvaluate(consumerResult);
yield return(consumerResult);
startTime = stopTime;
stopWatch.Restart();
}
}
}
this.results = this.results.AsCompleted();
this.OnComplete();
}
yield break;
}
