Example #1
0
 internal AutomatedAnalysisExecutionContext(TraceLog traceLog, TextWriter textLog, SymbolReader symbolReader, AutomatedAnalysisIssueCollection issues)
 {
     TraceLog     = traceLog;
     TextLog      = textLog;
     SymbolReader = symbolReader;
     Issues       = issues;
 }
        public List <AutomatedAnalysisRule> ExecuteRules()
        {
            Issues = new AutomatedAnalysisIssueCollection();

            List <AutomatedAnalysisRule>           allRules        = new List <AutomatedAnalysisRule>();
            List <AutomatedAnalysisPerProcessRule> perProcessRules = new List <AutomatedAnalysisPerProcessRule>();

            // Run global rules, deferring per-process rules.
            AutomatedAnalysisExecutionContext executionContext = new AutomatedAnalysisExecutionContext(_trace, _textLog, Issues);

            foreach (AutomatedAnalysisRule rule in AutomatedAnalysisRuleResolver.GetRules())
            {
                // Create a list of all executed rules so that they can be written into the report.
                allRules.Add(rule);

                if (rule is AutomatedAnalysisPerProcessRule)
                {
                    // Defer per-process rules.
                    perProcessRules.Add((AutomatedAnalysisPerProcessRule)rule);
                }
                else
                {
                    // Execute the rule.
                    try
                    {
                        rule.RunRule(executionContext, null);
                    }
                    catch (Exception ex)
                    {
                        _textLog.WriteLine($"Error while executing rule '{rule.GetType().FullName}': {ex}");
                    }
                }
            }

            // Run per-process rules.
            foreach (AutomatedAnalysisTraceProcess process in executionContext.Trace.Processes)
            {
                if (process.ContainsManagedCode)
                {
                    // Create the process context.
                    ProcessContext processContext = new ProcessContext(executionContext, process);

                    foreach (AutomatedAnalysisPerProcessRule rule in perProcessRules)
                    {
                        try
                        {
                            rule.RunRule(executionContext, processContext);
                        }
                        catch (Exception ex)
                        {
                            _textLog.WriteLine($"Error while executing rule '{rule.GetType().FullName}': {ex}");
                        }
                    }
                }
            }

            return(allRules);
        }
        internal AutomatedAnalysisExecutionContext(IAutomatedAnalysisTrace trace, TextWriter textLog, AutomatedAnalysisIssueCollection issues)
        {
            Trace   = trace;
            TextLog = textLog;
            Issues  = issues;

            AutomatedAnalysisTraceLog traceLog = trace as AutomatedAnalysisTraceLog;

            if (traceLog != null)
            {
                TraceLog     = traceLog.TraceLog;
                SymbolReader = traceLog.SymbolReader;
            }
        }