Fix #638 (#643)

gfs · web-flow · commit 40072595ef85 · 2022-03-10T15:24:39.000-08:00
diff --git a/Cli/AttackSurfaceAnalyzerClient.cs b/Cli/AttackSurfaceAnalyzerClient.cs
@@ -262,17 +262,17 @@ private static ASA_ERROR RunExportGuidedCommand(ExportGuidedCommandOptions opts)
             return ExportCompareResults(results, exportOptions, AsaHelpers.MakeValidFileName($"{first}_vs_{second}"), analysesHash, options.AnalysesFile.Rules);
         }
 
-        static ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>> AnalyzeGuided(GuidedModeCommandOptions opts, RuleFile analysisFile)
+        static ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>> AnalyzeGuided(GuidedModeCommandOptions opts, RuleFile analysisFile)
         {
             if (opts.RunId is null)
             {
                 Log.Warning(Strings.Get("Err_RunIdNull"));
-                return new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>>();
+                return new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>>();
             }
             if (!analysisFile.Rules.Any())
             {
                 Log.Warning(Strings.Get("Err_NoRules"));
-                return new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>>();
+                return new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>>();
             }
 
             var firstCollectRunId = GuidedRunIdToFirstCollectRunId(opts.RunId);
@@ -318,22 +318,22 @@ private static ASA_ERROR RunExportGuidedCommand(ExportGuidedCommandOptions opts)
             return results;
         }
 
-        public static ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>> AnalyzeMonitored(CompareCommandOptions opts)
+        public static ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>> AnalyzeMonitored(CompareCommandOptions opts)
         {
             if (DatabaseManager is null)
             {
                 Log.Error("Err_DatabaseManagerNull", "InsertCompareResults");
-                return new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>>();
+                return new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>>();
             }
-            if (opts is null || opts.SecondRunId is null) { return new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>>(); }
+            if (opts is null || opts.SecondRunId is null) { return new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>>(); }
             var analyzer = new AsaAnalyzer(new AnalyzerOptions(opts.RunScripts));
             return AnalyzeMonitored(opts, analyzer, DatabaseManager.GetMonitorResults(opts.SecondRunId), opts.AnalysesFile ?? throw new ArgumentNullException(nameof(opts.AnalysesFile)));
         }
 
-        public static ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>> AnalyzeMonitored(CompareCommandOptions opts, AsaAnalyzer analyzer, IEnumerable<MonitorObject> collectObjects, RuleFile ruleFile)
+        public static ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>> AnalyzeMonitored(CompareCommandOptions opts, AsaAnalyzer analyzer, IEnumerable<MonitorObject> collectObjects, RuleFile ruleFile)
         {
-            if (opts is null) { return new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>>(); }
-            var results = new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>>();
+            if (opts is null) { return new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>>(); }
+            var results = new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>>();
             var analysesHash = ruleFile.GetHash();
             Parallel.ForEach(collectObjects, monitorResult =>
             {
@@ -362,7 +362,7 @@ private static ASA_ERROR RunExportGuidedCommand(ExportGuidedCommandOptions opts)
                 }
 
                 shellResult.Analysis = shellResult.Rules.Count > 0 ? shellResult.Rules.Max(x => ((AsaRule)x).Flag) : ruleFile.GetDefaultLevel(shellResult.ResultType);
-                results.TryAdd((monitorResult.ResultType, monitorResult.ChangeType), new List<CompareResult>());
+                results.TryAdd((monitorResult.ResultType, monitorResult.ChangeType), new ConcurrentBag<CompareResult>());
                 results[(monitorResult.ResultType, monitorResult.ChangeType)].Add(shellResult);
             });
             return results;
@@ -389,7 +389,7 @@ private static ASA_ERROR RunVerifyRulesCommand(VerifyOptions opts)
             return ASA_ERROR.NONE;
         }
 
-        internal static void InsertCompareResults(ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>> results, string? FirstRunId, string SecondRunId, string AnalysesHash)
+        internal static void InsertCompareResults(ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>> results, string? FirstRunId, string SecondRunId, string AnalysesHash)
         {
             if (DatabaseManager is null)
             {
@@ -399,9 +399,9 @@ internal static void InsertCompareResults(ConcurrentDictionary<(RESULT_TYPE, CHA
             DatabaseManager.InsertCompareRun(FirstRunId, SecondRunId, AnalysesHash, RUN_STATUS.RUNNING);
             foreach (var key in results.Keys)
             {
-                if (results.TryGetValue(key, out List<CompareResult>? obj))
+                if (results.TryGetValue(key, out ConcurrentBag<CompareResult>? obj))
                 {
-                    if (obj is List<CompareResult> Queue)
+                    if (obj is ConcurrentBag<CompareResult> Queue)
                     {
                         foreach (var result in Queue)
                         {
@@ -627,7 +627,7 @@ private static ASA_ERROR RunExportCollectCommand(ExportCollectCommandOptions opt
             return ExportCompareResults(results, opts, AsaHelpers.MakeValidFileName(opts.FirstRunId + "_vs_" + opts.SecondRunId), analysesHash, ruleFile.Rules);
         }
 
-        internal static ASA_ERROR ExportCompareResults(ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>> resultsIn, ExportOptions opts, string baseFileName, string analysesHash, IEnumerable<AsaRule> rules)
+        internal static ASA_ERROR ExportCompareResults(ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>> resultsIn, ExportOptions opts, string baseFileName, string analysesHash, IEnumerable<AsaRule> rules)
         {
             var results = resultsIn.Select(x => new KeyValuePair<string, object>($"{x.Key.Item1}_{x.Key.Item2}", x.Value)).ToDictionary(x => x.Key, x => x.Value);
             JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()
@@ -1125,7 +1125,7 @@ public static List<BaseCompare> GetComparators()
             return comparators;
         }
 
-        public static ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>> CompareRuns(CompareCommandOptions opts)
+        public static ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>> CompareRuns(CompareCommandOptions opts)
         {
             if (opts is null)
             {
@@ -1134,7 +1134,7 @@ public static List<BaseCompare> GetComparators()
             if (DatabaseManager is null)
             {
                 Log.Error("Err_DatabaseManagerNull", "CompareRuns");
-                return new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>>();
+                return new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>>();
             }
             comparators = new List<BaseCompare>();
 
@@ -1177,8 +1177,12 @@ public static List<BaseCompare> GetComparators()
                         {
                             foreach ((RESULT_TYPE, CHANGE_TYPE) key in c.Results.Keys)
                             {
-                                if (c.Results[key] is List<CompareResult> queue)
+                                if (c.Results[key] is IEnumerable<CompareResult> queue)
                                 {
+                                    if (queue.Any(x => x is null))
+                                    {
+                                        Console.WriteLine("found em");
+                                    }
                                     IEnumerable<AsaRule> platformRules = opts.AnalysesFile.Rules.Where(rule => rule.Platforms == null || rule.Platforms.Contains(platform));
                                     if (opts.SingleThreadAnalysis)
                                     {
@@ -1200,6 +1204,10 @@ void PopulateAnalysisForResult(CompareResult res)
                                         var selectedRules = platformRules.Where((rule) =>
                                             (rule.ChangeTypes == null || rule.ChangeTypes.Contains(res.ChangeType))
                                                 && (rule.ResultType == res.ResultType));
+                                        if (res is null)
+                                        {
+                                            return;
+                                        }
                                         Log.Verbose("Type: {0}", res.ResultType);
                                         Log.Verbose("Base: {0}", JsonConvert.SerializeObject(res.Base));
                                         Log.Verbose("Compare: {0}", JsonConvert.SerializeObject(res.Compare));
diff --git a/Cli/Components/States/Results.razor b/Cli/Components/States/Results.razor
@@ -195,7 +195,7 @@ else
     {
         if (AttackSurfaceAnalyzerClient.DatabaseManager is null) { return; }
         var iterationSize = 1000;
-        var results = new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>>();
+        var results = new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>>();
         foreach(var resultType in foundResultTypes)
         {
             for (int i = 0; i < resultType.Value; i += iterationSize)
@@ -207,7 +207,7 @@ else
                         {
                             if (!results.ContainsKey((result.ResultType, result.ChangeType)))
                             {
-                                results[(result.ResultType, result.ChangeType)] = new List<CompareResult>();
+                                results[(result.ResultType, result.ChangeType)] = new ConcurrentBag<CompareResult>();
                             }
                             results[(result.ResultType, result.ChangeType)].Add(result);
                         }
@@ -217,7 +217,7 @@ else
                         {
                             if (!results.ContainsKey((result.ResultType, result.ChangeType)))
                             {
-                                results[(result.ResultType, result.ChangeType)] = new List<CompareResult>();
+                                results[(result.ResultType, result.ChangeType)] = new ConcurrentBag<CompareResult>();
                             }
                             results[(result.ResultType, result.ChangeType)].Add(result);
                         }
diff --git a/Cli/Properties/launchSettings.json b/Cli/Properties/launchSettings.json
@@ -24,6 +24,14 @@
       },
       "applicationUrl": "https://localhost:7280;http://localhost:5280",
       "dotnetRunMessages": true
+    },
+    "Export-collect last 2": {
+      "commandName": "Project",
+      "commandLineArgs": "export-collect"
+    },
+    "Export-monitor": {
+      "commandName": "Project",
+      "commandLineArgs": "export-monitor"
     }
   }
 }
diff --git a/Lib/Collectors/BaseCompare.cs b/Lib/Collectors/BaseCompare.cs
@@ -11,6 +11,7 @@
 using System.Linq;
 using System.Reflection;
 using Tpm2Lib;
+using System.Diagnostics;
 
 namespace Microsoft.CST.AttackSurfaceAnalyzer.Collectors
 {
@@ -21,20 +22,20 @@ public class BaseCompare
     {
         public BaseCompare()
         {
-            Results = new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>>();
+            Results = new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>>();
             foreach (RESULT_TYPE? result_type in Enum.GetValues(typeof(RESULT_TYPE)))
             {
                 foreach (CHANGE_TYPE? change_type in Enum.GetValues(typeof(CHANGE_TYPE)))
                 {
                     if (result_type is RESULT_TYPE r && change_type is CHANGE_TYPE c)
                     {
-                        Results[(r, c)] = new List<CompareResult>();
+                        Results[(r, c)] = new ConcurrentBag<CompareResult>();
                     }
                 }
             }
         }
 
-        public ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>> Results { get; }
+        public ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>> Results { get; }
 
         public void Compare(IEnumerable<CollectObject> FirstRunObjects, IEnumerable<CollectObject> SecondRunObjects, string? firstRunId, string secondRunId)
         {

Original file line number	Diff line number	Diff line change
`@@ -262,17 +262,17 @@ private static ASA_ERROR RunExportGuidedCommand(ExportGuidedCommandOptions opts)`
`262`	`262`	`return ExportCompareResults(results, exportOptions, AsaHelpers.MakeValidFileName($"{first}_vs_{second}"), analysesHash, options.AnalysesFile.Rules);`
`263`	`263`	`}`
`264`	`264`
`265`		`- static ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>> AnalyzeGuided(GuidedModeCommandOptions opts, RuleFile analysisFile)`
	`265`	`+ static ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>> AnalyzeGuided(GuidedModeCommandOptions opts, RuleFile analysisFile)`
`266`	`266`	`{`
`267`	`267`	`if (opts.RunId is null)`
`268`	`268`	`{`
`269`	`269`	`Log.Warning(Strings.Get("Err_RunIdNull"));`
`270`		`- return new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>>();`
	`270`	`+ return new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>>();`
`271`	`271`	`}`
`272`	`272`	`if (!analysisFile.Rules.Any())`
`273`	`273`	`{`
`274`	`274`	`Log.Warning(Strings.Get("Err_NoRules"));`
`275`		`- return new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>>();`
	`275`	`+ return new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>>();`
`276`	`276`	`}`
`277`	`277`
`278`	`278`	`var firstCollectRunId = GuidedRunIdToFirstCollectRunId(opts.RunId);`
`@@ -318,22 +318,22 @@ private static ASA_ERROR RunExportGuidedCommand(ExportGuidedCommandOptions opts)`
`318`	`318`	`return results;`
`319`	`319`	`}`
`320`	`320`
`321`		`- public static ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>> AnalyzeMonitored(CompareCommandOptions opts)`
	`321`	`+ public static ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>> AnalyzeMonitored(CompareCommandOptions opts)`
`322`	`322`	`{`
`323`	`323`	`if (DatabaseManager is null)`
`324`	`324`	`{`
`325`	`325`	`Log.Error("Err_DatabaseManagerNull", "InsertCompareResults");`
`326`		`- return new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>>();`
	`326`	`+ return new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>>();`
`327`	`327`	`}`
`328`		`- if (opts is null \|\| opts.SecondRunId is null) { return new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>>(); }`
	`328`	`+ if (opts is null \|\| opts.SecondRunId is null) { return new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>>(); }`
`329`	`329`	`var analyzer = new AsaAnalyzer(new AnalyzerOptions(opts.RunScripts));`
`330`	`330`	`return AnalyzeMonitored(opts, analyzer, DatabaseManager.GetMonitorResults(opts.SecondRunId), opts.AnalysesFile ?? throw new ArgumentNullException(nameof(opts.AnalysesFile)));`
`331`	`331`	`}`
`332`	`332`
`333`		`- public static ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>> AnalyzeMonitored(CompareCommandOptions opts, AsaAnalyzer analyzer, IEnumerable<MonitorObject> collectObjects, RuleFile ruleFile)`
	`333`	`+ public static ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>> AnalyzeMonitored(CompareCommandOptions opts, AsaAnalyzer analyzer, IEnumerable<MonitorObject> collectObjects, RuleFile ruleFile)`
`334`	`334`	`{`
`335`		`- if (opts is null) { return new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>>(); }`
`336`		`- var results = new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>>();`
	`335`	`+ if (opts is null) { return new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>>(); }`
	`336`	`+ var results = new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>>();`
`337`	`337`	`var analysesHash = ruleFile.GetHash();`
`338`	`338`	`Parallel.ForEach(collectObjects, monitorResult =>`
`339`	`339`	`{`
`@@ -362,7 +362,7 @@ private static ASA_ERROR RunExportGuidedCommand(ExportGuidedCommandOptions opts)`
`362`	`362`	`}`
`363`	`363`
`364`	`364`	`shellResult.Analysis = shellResult.Rules.Count > 0 ? shellResult.Rules.Max(x => ((AsaRule)x).Flag) : ruleFile.GetDefaultLevel(shellResult.ResultType);`
`365`		`- results.TryAdd((monitorResult.ResultType, monitorResult.ChangeType), new List<CompareResult>());`
	`365`	`+ results.TryAdd((monitorResult.ResultType, monitorResult.ChangeType), new ConcurrentBag<CompareResult>());`
`366`	`366`	`results[(monitorResult.ResultType, monitorResult.ChangeType)].Add(shellResult);`
`367`	`367`	`});`
`368`	`368`	`return results;`
`@@ -389,7 +389,7 @@ private static ASA_ERROR RunVerifyRulesCommand(VerifyOptions opts)`
`389`	`389`	`return ASA_ERROR.NONE;`
`390`	`390`	`}`
`391`	`391`
`392`		`- internal static void InsertCompareResults(ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>> results, string? FirstRunId, string SecondRunId, string AnalysesHash)`
	`392`	`+ internal static void InsertCompareResults(ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>> results, string? FirstRunId, string SecondRunId, string AnalysesHash)`
`393`	`393`	`{`
`394`	`394`	`if (DatabaseManager is null)`
`395`	`395`	`{`
`@@ -399,9 +399,9 @@ internal static void InsertCompareResults(ConcurrentDictionary<(RESULT_TYPE, CHA`
`399`	`399`	`DatabaseManager.InsertCompareRun(FirstRunId, SecondRunId, AnalysesHash, RUN_STATUS.RUNNING);`
`400`	`400`	`foreach (var key in results.Keys)`
`401`	`401`	`{`
`402`		`- if (results.TryGetValue(key, out List<CompareResult>? obj))`
	`402`	`+ if (results.TryGetValue(key, out ConcurrentBag<CompareResult>? obj))`
`403`	`403`	`{`
`404`		`- if (obj is List<CompareResult> Queue)`
	`404`	`+ if (obj is ConcurrentBag<CompareResult> Queue)`
`405`	`405`	`{`
`406`	`406`	`foreach (var result in Queue)`
`407`	`407`	`{`
`@@ -627,7 +627,7 @@ private static ASA_ERROR RunExportCollectCommand(ExportCollectCommandOptions opt`
`627`	`627`	`return ExportCompareResults(results, opts, AsaHelpers.MakeValidFileName(opts.FirstRunId + "_vs_" + opts.SecondRunId), analysesHash, ruleFile.Rules);`
`628`	`628`	`}`
`629`	`629`
`630`		`- internal static ASA_ERROR ExportCompareResults(ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>> resultsIn, ExportOptions opts, string baseFileName, string analysesHash, IEnumerable<AsaRule> rules)`
	`630`	`+ internal static ASA_ERROR ExportCompareResults(ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>> resultsIn, ExportOptions opts, string baseFileName, string analysesHash, IEnumerable<AsaRule> rules)`
`631`	`631`	`{`
`632`	`632`	`var results = resultsIn.Select(x => new KeyValuePair<string, object>($"{x.Key.Item1}_{x.Key.Item2}", x.Value)).ToDictionary(x => x.Key, x => x.Value);`
`633`	`633`	`JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings()`
`@@ -1125,7 +1125,7 @@ public static List<BaseCompare> GetComparators()`
`1125`	`1125`	`return comparators;`
`1126`	`1126`	`}`
`1127`	`1127`
`1128`		`- public static ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>> CompareRuns(CompareCommandOptions opts)`
	`1128`	`+ public static ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>> CompareRuns(CompareCommandOptions opts)`
`1129`	`1129`	`{`
`1130`	`1130`	`if (opts is null)`
`1131`	`1131`	`{`
`@@ -1134,7 +1134,7 @@ public static List<BaseCompare> GetComparators()`
`1134`	`1134`	`if (DatabaseManager is null)`
`1135`	`1135`	`{`
`1136`	`1136`	`Log.Error("Err_DatabaseManagerNull", "CompareRuns");`
`1137`		`- return new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>>();`
	`1137`	`+ return new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>>();`
`1138`	`1138`	`}`
`1139`	`1139`	`comparators = new List<BaseCompare>();`
`1140`	`1140`
`@@ -1177,8 +1177,12 @@ public static List<BaseCompare> GetComparators()`
`1177`	`1177`	`{`
`1178`	`1178`	`foreach ((RESULT_TYPE, CHANGE_TYPE) key in c.Results.Keys)`
`1179`	`1179`	`{`
`1180`		`- if (c.Results[key] is List<CompareResult> queue)`
	`1180`	`+ if (c.Results[key] is IEnumerable<CompareResult> queue)`
`1181`	`1181`	`{`
	`1182`	`+ if (queue.Any(x => x is null))`
	`1183`	`+ {`
	`1184`	`+ Console.WriteLine("found em");`
	`1185`	`+ }`
`1182`	`1186`	`IEnumerable<AsaRule> platformRules = opts.AnalysesFile.Rules.Where(rule => rule.Platforms == null \|\| rule.Platforms.Contains(platform));`
`1183`	`1187`	`if (opts.SingleThreadAnalysis)`
`1184`	`1188`	`{`
`@@ -1200,6 +1204,10 @@ void PopulateAnalysisForResult(CompareResult res)`
`1200`	`1204`	`var selectedRules = platformRules.Where((rule) =>`
`1201`	`1205`	`(rule.ChangeTypes == null \|\| rule.ChangeTypes.Contains(res.ChangeType))`
`1202`	`1206`	`&& (rule.ResultType == res.ResultType));`
	`1207`	`+ if (res is null)`
	`1208`	`+ {`
	`1209`	`+ return;`
	`1210`	`+ }`
`1203`	`1211`	`Log.Verbose("Type: {0}", res.ResultType);`
`1204`	`1212`	`Log.Verbose("Base: {0}", JsonConvert.SerializeObject(res.Base));`
`1205`	`1213`	`Log.Verbose("Compare: {0}", JsonConvert.SerializeObject(res.Compare));`
Original file line number	Diff line number	Diff line change
`@@ -195,7 +195,7 @@ else`
`195`	`195`	`{`
`196`	`196`	`if (AttackSurfaceAnalyzerClient.DatabaseManager is null) { return; }`
`197`	`197`	`var iterationSize = 1000;`
`198`		`- var results = new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>>();`
	`198`	`+ var results = new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>>();`
`199`	`199`	`foreach(var resultType in foundResultTypes)`
`200`	`200`	`{`
`201`	`201`	`for (int i = 0; i < resultType.Value; i += iterationSize)`
`@@ -207,7 +207,7 @@ else`
`207`	`207`	`{`
`208`	`208`	`if (!results.ContainsKey((result.ResultType, result.ChangeType)))`
`209`	`209`	`{`
`210`		`- results[(result.ResultType, result.ChangeType)] = new List<CompareResult>();`
	`210`	`+ results[(result.ResultType, result.ChangeType)] = new ConcurrentBag<CompareResult>();`
`211`	`211`	`}`
`212`	`212`	`results[(result.ResultType, result.ChangeType)].Add(result);`
`213`	`213`	`}`
`@@ -217,7 +217,7 @@ else`
`217`	`217`	`{`
`218`	`218`	`if (!results.ContainsKey((result.ResultType, result.ChangeType)))`
`219`	`219`	`{`
`220`		`- results[(result.ResultType, result.ChangeType)] = new List<CompareResult>();`
	`220`	`+ results[(result.ResultType, result.ChangeType)] = new ConcurrentBag<CompareResult>();`
`221`	`221`	`}`
`222`	`222`	`results[(result.ResultType, result.ChangeType)].Add(result);`
`223`	`223`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,14 @@`
`24`	`24`	`},`
`25`	`25`	`"applicationUrl": "https://localhost:7280;http://localhost:5280",`
`26`	`26`	`"dotnetRunMessages": true`
	`27`	`+ },`
	`28`	`+ "Export-collect last 2": {`
	`29`	`+ "commandName": "Project",`
	`30`	`+ "commandLineArgs": "export-collect"`
	`31`	`+ },`
	`32`	`+ "Export-monitor": {`
	`33`	`+ "commandName": "Project",`
	`34`	`+ "commandLineArgs": "export-monitor"`
`27`	`35`	`}`
`28`	`36`	`}`
`29`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@`
`11`	`11`	`using System.Linq;`
`12`	`12`	`using System.Reflection;`
`13`	`13`	`using Tpm2Lib;`
	`14`	`+using System.Diagnostics;`
`14`	`15`
`15`	`16`	`namespace Microsoft.CST.AttackSurfaceAnalyzer.Collectors`
`16`	`17`	`{`
`@@ -21,20 +22,20 @@ public class BaseCompare`
`21`	`22`	`{`
`22`	`23`	`public BaseCompare()`
`23`	`24`	`{`
`24`		`- Results = new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>>();`
	`25`	`+ Results = new ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>>();`
`25`	`26`	`foreach (RESULT_TYPE? result_type in Enum.GetValues(typeof(RESULT_TYPE)))`
`26`	`27`	`{`
`27`	`28`	`foreach (CHANGE_TYPE? change_type in Enum.GetValues(typeof(CHANGE_TYPE)))`
`28`	`29`	`{`
`29`	`30`	`if (result_type is RESULT_TYPE r && change_type is CHANGE_TYPE c)`
`30`	`31`	`{`
`31`		`- Results[(r, c)] = new List<CompareResult>();`
	`32`	`+ Results[(r, c)] = new ConcurrentBag<CompareResult>();`
`32`	`33`	`}`
`33`	`34`	`}`
`34`	`35`	`}`
`35`	`36`	`}`
`36`	`37`
`37`		`- public ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), List<CompareResult>> Results { get; }`
	`38`	`+ public ConcurrentDictionary<(RESULT_TYPE, CHANGE_TYPE), ConcurrentBag<CompareResult>> Results { get; }`
`38`	`39`
`39`	`40`	`public void Compare(IEnumerable<CollectObject> FirstRunObjects, IEnumerable<CollectObject> SecondRunObjects, string? firstRunId, string secondRunId)`
`40`	`41`	`{`