Use a dictionary lookup file filename to improve performance with large solutions

Kester Maddock · Kester Maddock · commit dbdae9f13c59 · 2022-10-05T15:10:07.000+13:00
diff --git a/FineCodeCoverageTests/FCCEngine_Tests.cs b/FineCodeCoverageTests/FCCEngine_Tests.cs
@@ -333,7 +333,7 @@ private void VerifyLogsReloadCoverageStatus(ReloadCoverageStatus reloadCoverageS
             mocker.Verify<ILogger>(l => l.Log(fccEngine.GetLogReloadCoverageStatusMessage(reloadCoverageStatus)));
         }
 
-        private async Task<(string reportGeneratedHtmlContent, List<CoverageLine> updatedCoverageLines)> RunToCompletion(bool noCoverageProjects)
+        private async Task<(string reportGeneratedHtmlContent, Dictionary<string, List<CoverageLine>> updatedCoverageLines)> RunToCompletion(bool noCoverageProjects)
         {
             var coverageProject = CreateSuitableProject().Object;
             var mockReportGenerator = mocker.GetMock<IReportGeneratorUtil>();
@@ -352,7 +352,10 @@ private void VerifyLogsReloadCoverageStatus(ReloadCoverageStatus reloadCoverageS
 
             var reportGeneratedHtmlContent = "<somehtml/>";
             mockReportGenerator.Setup(rg => rg.ProcessUnifiedHtml("Unified", It.IsAny<string>())).Returns(reportGeneratedHtmlContent);
-            List<CoverageLine> coverageLines = new List<CoverageLine>() { new CoverageLine() };
+            Dictionary<string, List<CoverageLine>> coverageLines = new Dictionary<string, List<CoverageLine>>()
+            {
+                { "test", new List<CoverageLine>() { new CoverageLine() } }
+            };
             mocker.GetMock<ICoberturaUtil>().Setup(coberturaUtil => coberturaUtil.ProcessCoberturaXml(It.IsAny<string>())).Returns(coverageLines);
             if (noCoverageProjects)
             {
@@ -384,8 +387,10 @@ private async Task ThrowReadingReportHtml()
                     }
                 );
 
-
-            List<CoverageLine> coverageLines = new List<CoverageLine>() { new CoverageLine() };
+            Dictionary<string, List<CoverageLine>> coverageLines = new Dictionary<string, List<CoverageLine>>()
+            {
+                { "test", new List<CoverageLine>() { new CoverageLine() } }
+            };
             mocker.GetMock<ICoberturaUtil>().Setup(coberturaUtil => coberturaUtil.ProcessCoberturaXml(It.IsAny<string>())).Returns(coverageLines);
 
             await ReloadInitializedCoverage(passedProject.Object);
diff --git a/SharedProject/Core/Cobertura/CoberturaUtil.cs b/SharedProject/Core/Cobertura/CoberturaUtil.cs
@@ -5,6 +5,8 @@
 using FineCodeCoverage.Engine.Model;
 using System.ComponentModel.Composition;
 using System.IO;
+using System.Windows.Documents;
+using System;
 
 namespace FineCodeCoverage.Engine.Cobertura
 {
@@ -67,19 +69,25 @@ private CoverageReport LoadReport(string xmlFile)
 		//	return jsonText;
 		//}
 
-		public List<CoverageLine> ProcessCoberturaXml(string xmlFile)
+		public Dictionary<string, List<CoverageLine>> ProcessCoberturaXml(string xmlFile)
 		{
-			var coverageLines = new List<CoverageLine>();
+			var coverageLines = new Dictionary<string, List<CoverageLine>>(StringComparer.OrdinalIgnoreCase);
 
 			coverageReport = LoadReport(xmlFile);
 
 			foreach (var package in coverageReport.Packages.Package)
 			{
 				foreach (var classs in package.Classes.Class)
 				{
-					foreach (var line in classs.Lines.Line)
+                    if (!coverageLines.TryGetValue(classs.Filename, out var classCoverageLines))
 					{
-						coverageLines.Add(new CoverageLine
+						classCoverageLines = new List<CoverageLine>();
+						coverageLines.Add(string.Intern(classs.Filename), classCoverageLines);
+                    }
+
+                    foreach (var line in classs.Lines.Line)
+					{
+                        classCoverageLines.Add(new CoverageLine
 						{
 							Package = package,
 							Class = classs,
diff --git a/SharedProject/Core/Cobertura/ICoberturaUtil.cs b/SharedProject/Core/Cobertura/ICoberturaUtil.cs
@@ -5,7 +5,7 @@ namespace FineCodeCoverage.Engine.Cobertura
 {
     interface ICoberturaUtil
     {
-		List<CoverageLine> ProcessCoberturaXml(string xmlFile);
+		Dictionary<string, List<CoverageLine>> ProcessCoberturaXml(string xmlFile);
 		string[] GetSourceFiles(string assemblyName, string qualifiedClassName, int file);
 	}
 }
diff --git a/SharedProject/Core/FCCEngine.cs b/SharedProject/Core/FCCEngine.cs
@@ -19,7 +19,7 @@ internal enum ReloadCoverageStatus { Start, Done, Cancelled, Error, Initializing
 
     internal class NewCoverageLinesMessage
     {
-        public List<CoverageLine> CoverageLines { get; set; }
+        public Dictionary<string, List<CoverageLine>> CoverageLines { get; set; }
     }
 
     internal class DisplayCoverageResultState
@@ -202,12 +202,12 @@ private void ClearCoverageLines()
             RaiseCoverageLines(null);
         }
 
-        private void RaiseCoverageLines(List<CoverageLine> coverageLines)
+        private void RaiseCoverageLines(Dictionary<string, List<CoverageLine>> coverageLines)
         {
             eventAggregator.SendMessage(new NewCoverageLinesMessage { CoverageLines = coverageLines});
         }
 
-        private void UpdateUI(List<CoverageLine> coverageLines, string reportHtml)
+        private void UpdateUI(Dictionary<string, List<CoverageLine>> coverageLines, string reportHtml)
         {
             RaiseCoverageLines(coverageLines);
             if (reportHtml == null)
@@ -217,18 +217,18 @@ private void UpdateUI(List<CoverageLine> coverageLines, string reportHtml)
             RaiseUpdateOutputWindow(reportHtml);
         }
 
-        private async System.Threading.Tasks.Task<(List<CoverageLine> coverageLines,string reportFilePath)> RunAndProcessReportAsync(string[] coverOutputFiles, CancellationToken vsShutdownLinkedCancellationToken)
+        private async System.Threading.Tasks.Task<(Dictionary<string, List<CoverageLine>> coverageLines,string reportFilePath)> RunAndProcessReportAsync(string[] coverOutputFiles, CancellationToken vsShutdownLinkedCancellationToken)
         {
             var reportOutputFolder = coverageOutputManager.GetReportOutputFolder();
             vsShutdownLinkedCancellationToken.ThrowIfCancellationRequested();
             var result = await reportGeneratorUtil.GenerateAsync(coverOutputFiles,reportOutputFolder,vsShutdownLinkedCancellationToken);
 
             vsShutdownLinkedCancellationToken.ThrowIfCancellationRequested();
-            logger.Log("Processing cobertura");
+            logger.Log($"Processing cobertura");
             var coverageLines = coberturaUtil.ProcessCoberturaXml(result.UnifiedXmlFile);
 
             vsShutdownLinkedCancellationToken.ThrowIfCancellationRequested();
-            logger.Log("Processing report");
+            logger.Log($"Processing report");
             string processedReport = reportGeneratorUtil.ProcessUnifiedHtml(result.UnifiedHtml, reportOutputFolder);
             return (coverageLines, processedReport);
         }
@@ -262,7 +262,7 @@ private async System.Threading.Tasks.Task PrepareCoverageProjectsAsync(List<ICov
             }
         }
 
-        private void DisplayCoverageResult(System.Threading.Tasks.Task<(List<CoverageLine> coverageLines, string reportHtml)> t, object state)
+        private void DisplayCoverageResult(System.Threading.Tasks.Task<(Dictionary<string, List<CoverageLine>> coverageLines, string reportHtml)> t, object state)
         {
             var displayCoverageResultState = (DisplayCoverageResultState)state;
             if (!IsVsShutdown)
@@ -321,7 +321,7 @@ public void RunAndProcessReport(string[] coberturaFiles, Action cleanUp = null)
         {
             RunCancellableCoverageTask(async (vsShutdownLinkedCancellationToken) =>
             {
-                List<CoverageLine> coverageLines = null;
+                Dictionary<string, List<CoverageLine>> coverageLines = null;
                 string reportHtml = null;
 
                 if (coberturaFiles.Any())
@@ -333,7 +333,7 @@ public void RunAndProcessReport(string[] coberturaFiles, Action cleanUp = null)
         }
 
         private void RunCancellableCoverageTask(
-            Func<CancellationToken,System.Threading.Tasks.Task<(List<CoverageLine>, string)>> taskCreator, Action cleanUp)
+            Func<CancellationToken,System.Threading.Tasks.Task<(Dictionary<string, List<CoverageLine>>, string)>> taskCreator, Action cleanUp)
         {
             var vsLinkedCancellationTokenSource = Reset();
             var vsShutdownLinkedCancellationToken = vsLinkedCancellationTokenSource.Token;
@@ -355,7 +355,7 @@ public void ReloadCoverage(Func<System.Threading.Tasks.Task<List<ICoverageProjec
         {
             RunCancellableCoverageTask(async (vsShutdownLinkedCancellationToken) =>
             {
-                List<CoverageLine> coverageLines = null;
+                Dictionary<string, List<CoverageLine>> coverageLines = null;
                 string reportHtml = null;
 
                 await PollInitializedStatusAsync(vsShutdownLinkedCancellationToken);
diff --git a/SharedProject/Impl/CoverageColour/GlyphMargin/CoverageLineGlyphTagger.cs b/SharedProject/Impl/CoverageColour/GlyphMargin/CoverageLineGlyphTagger.cs
@@ -8,7 +8,7 @@ namespace FineCodeCoverage.Impl
 {
 	internal class CoverageLineGlyphTagger : CoverageLineTaggerBase<CoverageLineGlyphTag>, IListener<RefreshCoverageGlyphsMessage>
 	{
-		public CoverageLineGlyphTagger(ITextBuffer textBuffer, List<CoverageLine> lastCoverageLines) : base(textBuffer, lastCoverageLines)
+		public CoverageLineGlyphTagger(ITextBuffer textBuffer, Dictionary<string, List<CoverageLine>> lastCoverageLines) : base(textBuffer, lastCoverageLines)
 		{
 		}
 
diff --git a/SharedProject/Impl/CoverageColour/GlyphMargin/CoverageLineGlyphTaggerProvider.cs b/SharedProject/Impl/CoverageColour/GlyphMargin/CoverageLineGlyphTaggerProvider.cs
@@ -41,7 +41,7 @@ protected override void NewCoverageLinesMessageReceived()
             });
         }
 
-        protected override CoverageLineGlyphTagger CreateTagger(ITextBuffer textBuffer, List<CoverageLine> lastCoverageLines)
+        protected override CoverageLineGlyphTagger CreateTagger(ITextBuffer textBuffer, Dictionary<string, List<CoverageLine>> lastCoverageLines)
         {
             return new CoverageLineGlyphTagger(textBuffer, lastCoverageLines);
         }
diff --git a/SharedProject/Impl/CoverageColour/MarginBase/CoverageLineTaggerBase.cs b/SharedProject/Impl/CoverageColour/MarginBase/CoverageLineTaggerBase.cs
@@ -11,11 +11,11 @@ namespace FineCodeCoverage.Impl
 	internal abstract class CoverageLineTaggerBase<TTag> : ICoverageLineTagger<TTag> where TTag : ITag
 	{
 		private readonly ITextBuffer _textBuffer;
-		private List<CoverageLine> coverageLines;
+		private Dictionary<string, List<CoverageLine>> coverageLines;
 
 		public event EventHandler<SnapshotSpanEventArgs> TagsChanged;
 
-		public CoverageLineTaggerBase(ITextBuffer textBuffer, List<CoverageLine> lastCoverageLines)
+		public CoverageLineTaggerBase(ITextBuffer textBuffer, Dictionary<string, List<CoverageLine>> lastCoverageLines)
 		{
 			_textBuffer = textBuffer;
 			coverageLines = lastCoverageLines;
@@ -34,9 +34,8 @@ protected virtual void RaiseTagsChanged()
 
 		private IEnumerable<CoverageLine> GetApplicableLines(string filePath, int startLineNumber, int endLineNumber)
 		{
-			return coverageLines
+			return coverageLines[filePath]
 			.AsParallel()
-			.Where(x => x.Class.Filename.Equals(filePath, StringComparison.OrdinalIgnoreCase))
 			.Where(x => x.Line.Number >= startLineNumber && x.Line.Number <= endLineNumber)
 			.ToArray();
 		}
diff --git a/SharedProject/Impl/CoverageColour/MarginBase/CoverageLineTaggerProviderBase.cs b/SharedProject/Impl/CoverageColour/MarginBase/CoverageLineTaggerProviderBase.cs
@@ -12,7 +12,7 @@ internal abstract class CoverageLineTaggerProviderBase<TTaggerListener, TTag> :
         where TTag : ITag
     {
         protected readonly IEventAggregator eventAggregator;
-        private List<CoverageLine> lastCoverageLines;
+        private Dictionary<string, List<CoverageLine>> lastCoverageLines;
 
         public CoverageLineTaggerProviderBase(
             IEventAggregator eventAggregator
@@ -29,7 +29,7 @@ public ITagger<T> CreateTagger<T>(ITextBuffer textBuffer) where T : ITag
             return tagger as ITagger<T>;
         }
 
-        protected abstract TTaggerListener CreateTagger(ITextBuffer textBuffer, List<CoverageLine> lastCoverageLines);
+        protected abstract TTaggerListener CreateTagger(ITextBuffer textBuffer, Dictionary<string, List<CoverageLine>> lastCoverageLines);
 
         public void Handle(NewCoverageLinesMessage message)
         {
diff --git a/SharedProject/Impl/CoverageColour/OverviewMargin/CoverageLineMarkTagger.cs b/SharedProject/Impl/CoverageColour/OverviewMargin/CoverageLineMarkTagger.cs
@@ -9,7 +9,7 @@ namespace FineCodeCoverage.Impl
 	internal class CoverageLineMarkTagger : CoverageLineTaggerBase<OverviewMarkTag>, IListener<CoverageMarginOptionsChangedMessage>
 	{
 		private ICoverageMarginOptions coverageMarginOptions;
-		public CoverageLineMarkTagger(ITextBuffer textBuffer, List<CoverageLine> lastCoverageLines, ICoverageMarginOptions coverageMarginOptions) : 
+		public CoverageLineMarkTagger(ITextBuffer textBuffer, Dictionary<string, List<CoverageLine>> lastCoverageLines, ICoverageMarginOptions coverageMarginOptions) : 
 			base(textBuffer, lastCoverageLines)
 		{
 			this.coverageMarginOptions = coverageMarginOptions;
diff --git a/SharedProject/Impl/CoverageColour/OverviewMargin/CoverageLineMarkTaggerProvider.cs b/SharedProject/Impl/CoverageColour/OverviewMargin/CoverageLineMarkTaggerProvider.cs
@@ -37,7 +37,7 @@ private void AppOptionsProvider_OptionsChanged(IAppOptions appOptions)
             }
         }
 
-        protected override CoverageLineMarkTagger CreateTagger(ITextBuffer textBuffer, List<CoverageLine> lastCoverageLines)
+        protected override CoverageLineMarkTagger CreateTagger(ITextBuffer textBuffer, Dictionary<string, List<CoverageLine>> lastCoverageLines)
         {
             return new CoverageLineMarkTagger(textBuffer, lastCoverageLines, coverageMarginOptions);
         }

Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,8 @@`
`5`	`5`	`using FineCodeCoverage.Engine.Model;`
`6`	`6`	`using System.ComponentModel.Composition;`
`7`	`7`	`using System.IO;`
	`8`	`+using System.Windows.Documents;`
	`9`	`+using System;`
`8`	`10`
`9`	`11`	`namespace FineCodeCoverage.Engine.Cobertura`
`10`	`12`	`{`
`@@ -67,19 +69,25 @@ private CoverageReport LoadReport(string xmlFile)`
`67`	`69`	`// return jsonText;`
`68`	`70`	`//}`
`69`	`71`
`70`		`- public List<CoverageLine> ProcessCoberturaXml(string xmlFile)`
	`72`	`+ public Dictionary<string, List<CoverageLine>> ProcessCoberturaXml(string xmlFile)`
`71`	`73`	`{`
`72`		`- var coverageLines = new List<CoverageLine>();`
	`74`	`+ var coverageLines = new Dictionary<string, List<CoverageLine>>(StringComparer.OrdinalIgnoreCase);`
`73`	`75`
`74`	`76`	`coverageReport = LoadReport(xmlFile);`
`75`	`77`
`76`	`78`	`foreach (var package in coverageReport.Packages.Package)`
`77`	`79`	`{`
`78`	`80`	`foreach (var classs in package.Classes.Class)`
`79`	`81`	`{`
`80`		`- foreach (var line in classs.Lines.Line)`
	`82`	`+ if (!coverageLines.TryGetValue(classs.Filename, out var classCoverageLines))`
`81`	`83`	`{`
`82`		`- coverageLines.Add(new CoverageLine`
	`84`	`+ classCoverageLines = new List<CoverageLine>();`
	`85`	`+ coverageLines.Add(string.Intern(classs.Filename), classCoverageLines);`
	`86`	`+ }`
	`87`	`+`
	`88`	`+ foreach (var line in classs.Lines.Line)`
	`89`	`+ {`
	`90`	`+ classCoverageLines.Add(new CoverageLine`
`83`	`91`	`{`
`84`	`92`	`Package = package,`
`85`	`93`	`Class = classs,`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ namespace FineCodeCoverage.Engine.Cobertura`
`5`	`5`	`{`
`6`	`6`	`interface ICoberturaUtil`
`7`	`7`	`{`
`8`		`- List<CoverageLine> ProcessCoberturaXml(string xmlFile);`
	`8`	`+ Dictionary<string, List<CoverageLine>> ProcessCoberturaXml(string xmlFile);`
`9`	`9`	`string[] GetSourceFiles(string assemblyName, string qualifiedClassName, int file);`
`10`	`10`	`}`
`11`	`11`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ internal enum ReloadCoverageStatus { Start, Done, Cancelled, Error, Initializing`
`19`	`19`
`20`	`20`	`internal class NewCoverageLinesMessage`
`21`	`21`	`{`
`22`		`- public List<CoverageLine> CoverageLines { get; set; }`
	`22`	`+ public Dictionary<string, List<CoverageLine>> CoverageLines { get; set; }`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`internal class DisplayCoverageResultState`
`@@ -202,12 +202,12 @@ private void ClearCoverageLines()`
`202`	`202`	`RaiseCoverageLines(null);`
`203`	`203`	`}`
`204`	`204`
`205`		`- private void RaiseCoverageLines(List<CoverageLine> coverageLines)`
	`205`	`+ private void RaiseCoverageLines(Dictionary<string, List<CoverageLine>> coverageLines)`
`206`	`206`	`{`
`207`	`207`	`eventAggregator.SendMessage(new NewCoverageLinesMessage { CoverageLines = coverageLines});`
`208`	`208`	`}`
`209`	`209`
`210`		`- private void UpdateUI(List<CoverageLine> coverageLines, string reportHtml)`
	`210`	`+ private void UpdateUI(Dictionary<string, List<CoverageLine>> coverageLines, string reportHtml)`
`211`	`211`	`{`
`212`	`212`	`RaiseCoverageLines(coverageLines);`
`213`	`213`	`if (reportHtml == null)`
`@@ -217,18 +217,18 @@ private void UpdateUI(List<CoverageLine> coverageLines, string reportHtml)`
`217`	`217`	`RaiseUpdateOutputWindow(reportHtml);`
`218`	`218`	`}`
`219`	`219`
`220`		`- private async System.Threading.Tasks.Task<(List<CoverageLine> coverageLines,string reportFilePath)> RunAndProcessReportAsync(string[] coverOutputFiles, CancellationToken vsShutdownLinkedCancellationToken)`
	`220`	`+ private async System.Threading.Tasks.Task<(Dictionary<string, List<CoverageLine>> coverageLines,string reportFilePath)> RunAndProcessReportAsync(string[] coverOutputFiles, CancellationToken vsShutdownLinkedCancellationToken)`
`221`	`221`	`{`
`222`	`222`	`var reportOutputFolder = coverageOutputManager.GetReportOutputFolder();`
`223`	`223`	`vsShutdownLinkedCancellationToken.ThrowIfCancellationRequested();`
`224`	`224`	`var result = await reportGeneratorUtil.GenerateAsync(coverOutputFiles,reportOutputFolder,vsShutdownLinkedCancellationToken);`
`225`	`225`
`226`	`226`	`vsShutdownLinkedCancellationToken.ThrowIfCancellationRequested();`
`227`		`- logger.Log("Processing cobertura");`
	`227`	`+ logger.Log($"Processing cobertura");`
`228`	`228`	`var coverageLines = coberturaUtil.ProcessCoberturaXml(result.UnifiedXmlFile);`
`229`	`229`
`230`	`230`	`vsShutdownLinkedCancellationToken.ThrowIfCancellationRequested();`
`231`		`- logger.Log("Processing report");`
	`231`	`+ logger.Log($"Processing report");`
`232`	`232`	`string processedReport = reportGeneratorUtil.ProcessUnifiedHtml(result.UnifiedHtml, reportOutputFolder);`
`233`	`233`	`return (coverageLines, processedReport);`
`234`	`234`	`}`
`@@ -262,7 +262,7 @@ private async System.Threading.Tasks.Task PrepareCoverageProjectsAsync(List<ICov`
`262`	`262`	`}`
`263`	`263`	`}`
`264`	`264`
`265`		`- private void DisplayCoverageResult(System.Threading.Tasks.Task<(List<CoverageLine> coverageLines, string reportHtml)> t, object state)`
	`265`	`+ private void DisplayCoverageResult(System.Threading.Tasks.Task<(Dictionary<string, List<CoverageLine>> coverageLines, string reportHtml)> t, object state)`
`266`	`266`	`{`
`267`	`267`	`var displayCoverageResultState = (DisplayCoverageResultState)state;`
`268`	`268`	`if (!IsVsShutdown)`
`@@ -321,7 +321,7 @@ public void RunAndProcessReport(string[] coberturaFiles, Action cleanUp = null)`
`321`	`321`	`{`
`322`	`322`	`RunCancellableCoverageTask(async (vsShutdownLinkedCancellationToken) =>`
`323`	`323`	`{`
`324`		`- List<CoverageLine> coverageLines = null;`
	`324`	`+ Dictionary<string, List<CoverageLine>> coverageLines = null;`
`325`	`325`	`string reportHtml = null;`
`326`	`326`
`327`	`327`	`if (coberturaFiles.Any())`
`@@ -333,7 +333,7 @@ public void RunAndProcessReport(string[] coberturaFiles, Action cleanUp = null)`
`333`	`333`	`}`
`334`	`334`
`335`	`335`	`private void RunCancellableCoverageTask(`
`336`		`- Func<CancellationToken,System.Threading.Tasks.Task<(List<CoverageLine>, string)>> taskCreator, Action cleanUp)`
	`336`	`+ Func<CancellationToken,System.Threading.Tasks.Task<(Dictionary<string, List<CoverageLine>>, string)>> taskCreator, Action cleanUp)`
`337`	`337`	`{`
`338`	`338`	`var vsLinkedCancellationTokenSource = Reset();`
`339`	`339`	`var vsShutdownLinkedCancellationToken = vsLinkedCancellationTokenSource.Token;`
`@@ -355,7 +355,7 @@ public void ReloadCoverage(Func<System.Threading.Tasks.Task<List<ICoverageProjec`
`355`	`355`	`{`
`356`	`356`	`RunCancellableCoverageTask(async (vsShutdownLinkedCancellationToken) =>`
`357`	`357`	`{`
`358`		`- List<CoverageLine> coverageLines = null;`
	`358`	`+ Dictionary<string, List<CoverageLine>> coverageLines = null;`
`359`	`359`	`string reportHtml = null;`
`360`	`360`
`361`	`361`	`await PollInitializedStatusAsync(vsShutdownLinkedCancellationToken);`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ namespace FineCodeCoverage.Impl`
`8`	`8`	`{`
`9`	`9`	`internal class CoverageLineGlyphTagger : CoverageLineTaggerBase<CoverageLineGlyphTag>, IListener<RefreshCoverageGlyphsMessage>`
`10`	`10`	`{`
`11`		`- public CoverageLineGlyphTagger(ITextBuffer textBuffer, List<CoverageLine> lastCoverageLines) : base(textBuffer, lastCoverageLines)`
	`11`	`+ public CoverageLineGlyphTagger(ITextBuffer textBuffer, Dictionary<string, List<CoverageLine>> lastCoverageLines) : base(textBuffer, lastCoverageLines)`
`12`	`12`	`{`
`13`	`13`	`}`
`14`	`14`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ protected override void NewCoverageLinesMessageReceived()`
`41`	`41`	`});`
`42`	`42`	`}`
`43`	`43`
`44`		`- protected override CoverageLineGlyphTagger CreateTagger(ITextBuffer textBuffer, List<CoverageLine> lastCoverageLines)`
	`44`	`+ protected override CoverageLineGlyphTagger CreateTagger(ITextBuffer textBuffer, Dictionary<string, List<CoverageLine>> lastCoverageLines)`
`45`	`45`	`{`
`46`	`46`	`return new CoverageLineGlyphTagger(textBuffer, lastCoverageLines);`
`47`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,11 +11,11 @@ namespace FineCodeCoverage.Impl`
`11`	`11`	`internal abstract class CoverageLineTaggerBase<TTag> : ICoverageLineTagger<TTag> where TTag : ITag`
`12`	`12`	`{`
`13`	`13`	`private readonly ITextBuffer _textBuffer;`
`14`		`- private List<CoverageLine> coverageLines;`
	`14`	`+ private Dictionary<string, List<CoverageLine>> coverageLines;`
`15`	`15`
`16`	`16`	`public event EventHandler<SnapshotSpanEventArgs> TagsChanged;`
`17`	`17`
`18`		`- public CoverageLineTaggerBase(ITextBuffer textBuffer, List<CoverageLine> lastCoverageLines)`
	`18`	`+ public CoverageLineTaggerBase(ITextBuffer textBuffer, Dictionary<string, List<CoverageLine>> lastCoverageLines)`
`19`	`19`	`{`
`20`	`20`	`_textBuffer = textBuffer;`
`21`	`21`	`coverageLines = lastCoverageLines;`
`@@ -34,9 +34,8 @@ protected virtual void RaiseTagsChanged()`
`34`	`34`
`35`	`35`	`private IEnumerable<CoverageLine> GetApplicableLines(string filePath, int startLineNumber, int endLineNumber)`
`36`	`36`	`{`
`37`		`- return coverageLines`
	`37`	`+ return coverageLines[filePath]`
`38`	`38`	`.AsParallel()`
`39`		`- .Where(x => x.Class.Filename.Equals(filePath, StringComparison.OrdinalIgnoreCase))`
`40`	`39`	`.Where(x => x.Line.Number >= startLineNumber && x.Line.Number <= endLineNumber)`
`41`	`40`	`.ToArray();`
`42`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ internal abstract class CoverageLineTaggerProviderBase<TTaggerListener, TTag> :`
`12`	`12`	`where TTag : ITag`
`13`	`13`	`{`
`14`	`14`	`protected readonly IEventAggregator eventAggregator;`
`15`		`- private List<CoverageLine> lastCoverageLines;`
	`15`	`+ private Dictionary<string, List<CoverageLine>> lastCoverageLines;`
`16`	`16`
`17`	`17`	`public CoverageLineTaggerProviderBase(`
`18`	`18`	`IEventAggregator eventAggregator`
`@@ -29,7 +29,7 @@ public ITagger<T> CreateTagger<T>(ITextBuffer textBuffer) where T : ITag`
`29`	`29`	`return tagger as ITagger<T>;`
`30`	`30`	`}`
`31`	`31`
`32`		`- protected abstract TTaggerListener CreateTagger(ITextBuffer textBuffer, List<CoverageLine> lastCoverageLines);`
	`32`	`+ protected abstract TTaggerListener CreateTagger(ITextBuffer textBuffer, Dictionary<string, List<CoverageLine>> lastCoverageLines);`
`33`	`33`
`34`	`34`	`public void Handle(NewCoverageLinesMessage message)`
`35`	`35`	`{`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ namespace FineCodeCoverage.Impl`
`9`	`9`	`internal class CoverageLineMarkTagger : CoverageLineTaggerBase<OverviewMarkTag>, IListener<CoverageMarginOptionsChangedMessage>`
`10`	`10`	`{`
`11`	`11`	`private ICoverageMarginOptions coverageMarginOptions;`
`12`		`- public CoverageLineMarkTagger(ITextBuffer textBuffer, List<CoverageLine> lastCoverageLines, ICoverageMarginOptions coverageMarginOptions) :`
	`12`	`+ public CoverageLineMarkTagger(ITextBuffer textBuffer, Dictionary<string, List<CoverageLine>> lastCoverageLines, ICoverageMarginOptions coverageMarginOptions) :`
`13`	`13`	`base(textBuffer, lastCoverageLines)`
`14`	`14`	`{`
`15`	`15`	`this.coverageMarginOptions = coverageMarginOptions;`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ private void AppOptionsProvider_OptionsChanged(IAppOptions appOptions)`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`
`40`		`- protected override CoverageLineMarkTagger CreateTagger(ITextBuffer textBuffer, List<CoverageLine> lastCoverageLines)`
	`40`	`+ protected override CoverageLineMarkTagger CreateTagger(ITextBuffer textBuffer, Dictionary<string, List<CoverageLine>> lastCoverageLines)`
`41`	`41`	`{`
`42`	`42`	`return new CoverageLineMarkTagger(textBuffer, lastCoverageLines, coverageMarginOptions);`
`43`	`43`	`}`