Read interface IList.Count once rather than per iteration (#9962)

benaadams · rynowak · commit 19c9010c2fc4 · 2019-05-04T17:54:12.000-07:00
diff --git a/src/Http/Routing/src/Patterns/RoutePattern.cs b/src/Http/Routing/src/Patterns/RoutePattern.cs
@@ -139,9 +139,12 @@ public RoutePatternParameterPart GetParameter(string name)
                 throw new ArgumentNullException(nameof(name));
             }
 
-            for (var i = 0; i < Parameters.Count; i++)
+            var parameters = Parameters;
+            // Read interface .Count once rather than per iteration
+            var parametersCount = parameters.Count;
+            for (var i = 0; i < parametersCount; i++)
             {
-                var parameter = Parameters[i];
+                var parameter = parameters[i];
                 if (string.Equals(parameter.Name, name, StringComparison.OrdinalIgnoreCase))
                 {
                     return parameter;
diff --git a/src/Http/Routing/src/Template/TemplateBinder.cs b/src/Http/Routing/src/Template/TemplateBinder.cs
@@ -521,16 +521,20 @@ private bool TryBindValuesCore(UriBuildingContext context, RouteValueDictionary
                 }
             }
 
-            for (var i = 0; i < _pattern.PathSegments.Count; i++)
+            var segments = _pattern.PathSegments;
+            // Read interface .Count once rather than per iteration
+            var segmentsCount = segments.Count;
+            for (var i = 0; i < segmentsCount; i++)
             {
                 Debug.Assert(context.BufferState == SegmentState.Beginning);
                 Debug.Assert(context.UriState == SegmentState.Beginning);
 
-                var segment = _pattern.PathSegments[i];
-
-                for (var j = 0; j < segment.Parts.Count; j++)
+                var parts = segments[i].Parts;
+                // Read interface .Count once rather than per iteration
+                var partsCount = parts.Count;
+                for (var j = 0; j < partsCount; j++)
                 {
-                    var part = segment.Parts[j];
+                    var part = parts[j];
 
                     if (part is RoutePatternLiteralPart literalPart)
                     {
@@ -581,7 +585,7 @@ private bool TryBindValuesCore(UriBuildingContext context, RouteValueDictionary
                             // for format, so we remove '.' and generate 5.
                             if (!context.Accept(converted, parameterPart.EncodeSlashes))
                             {
-                                if (j != 0 && parameterPart.IsOptional && (separatorPart = segment.Parts[j - 1] as RoutePatternSeparatorPart) != null)
+                                if (j != 0 && parameterPart.IsOptional && (separatorPart = parts[j - 1] as RoutePatternSeparatorPart) != null)
                                 {
                                     context.Remove(separatorPart.Content);
                                 }
diff --git a/src/Http/Routing/src/Tree/LinkGenerationDecisionTree.cs b/src/Http/Routing/src/Tree/LinkGenerationDecisionTree.cs
@@ -113,14 +113,20 @@ private void Walk(
         {
             // Any entries in node.Matches have had all their required values satisfied, so add them
             // to the results.
-            for (var i = 0; i < node.Matches.Count; i++)
+            var matches = node.Matches;
+            // Read interface .Count once rather than per iteration
+            var matchesCount = matches.Count;
+            for (var i = 0; i < matchesCount; i++)
             {
-                results.Add(new OutboundMatchResult(node.Matches[i], isFallbackPath));
+                results.Add(new OutboundMatchResult(matches[i], isFallbackPath));
             }
 
-            for (var i = 0; i < node.Criteria.Count; i++)
+            var criteria = node.Criteria;
+            // Read interface .Count once rather than per iteration
+            var criteriaCount = criteria.Count;
+            for (var i = 0; i < criteriaCount; i++)
             {
-                var criterion = node.Criteria[i];
+                var criterion = criteria[i];
                 var key = criterion.Key;
 
                 if (values.TryGetValue(key, out var value))
diff --git a/src/Mvc/Mvc.Core/src/Filters/DefaultFilterProvider.cs b/src/Mvc/Mvc.Core/src/Filters/DefaultFilterProvider.cs
@@ -21,10 +21,12 @@ public void OnProvidersExecuting(FilterProviderContext context)
 
             if (context.ActionContext.ActionDescriptor.FilterDescriptors != null)
             {
-                // Perf: Avoid allocations
-                for (var i = 0; i < context.Results.Count; i++)
+                var results = context.Results;
+                // Perf: Avoid allocating enumerator and read interface .Count once rather than per iteration
+                var resultsCount = results.Count;
+                for (var i = 0; i < resultsCount; i++)
                 {
-                    ProvideFilter(context, context.Results[i]);
+                    ProvideFilter(context, results[i]);
                 }
             }
         }
diff --git a/src/Mvc/Mvc.Razor/src/RazorViewEngine.cs b/src/Mvc/Mvc.Razor/src/RazorViewEngine.cs
@@ -249,15 +249,18 @@ private ViewLocationCacheResult LocatePageFromViewLocations(
                 isMainPage);
             Dictionary<string, string> expanderValues = null;
 
-            if (_options.ViewLocationExpanders.Count > 0)
+            var expanders = _options.ViewLocationExpanders;
+            // Read interface .Count once rather than per iteration
+            var expandersCount = expanders.Count;
+            if (expandersCount > 0)
             {
                 expanderValues = new Dictionary<string, string>(StringComparer.Ordinal);
                 expanderContext.Values = expanderValues;
 
                 // Perf: Avoid allocations
-                for (var i = 0; i < _options.ViewLocationExpanders.Count; i++)
+                for (var i = 0; i < expandersCount; i++)
                 {
-                    _options.ViewLocationExpanders[i].PopulateValues(expanderContext);
+                    expanders[i].PopulateValues(expanderContext);
                 }
             }
 
@@ -350,9 +353,12 @@ private ViewLocationCacheResult OnCacheMiss(
         {
             var viewLocations = GetViewLocationFormats(expanderContext);
 
-            for (var i = 0; i < _options.ViewLocationExpanders.Count; i++)
+            var expanders = _options.ViewLocationExpanders;
+            // Read interface .Count once rather than per iteration
+            var expandersCount = expanders.Count;
+            for (var i = 0; i < expandersCount; i++)
             {
-                viewLocations = _options.ViewLocationExpanders[i].ExpandViewLocations(expanderContext, viewLocations);
+                viewLocations = expanders[i].ExpandViewLocations(expanderContext, viewLocations);
             }
 
             ViewLocationCacheResult cacheResult = null;
@@ -404,9 +410,12 @@ internal ViewLocationCacheResult CreateCacheResult(
             var viewDescriptor = factoryResult.ViewDescriptor;
             if (viewDescriptor?.ExpirationTokens != null)
             {
-                for (var i = 0; i < viewDescriptor.ExpirationTokens.Count; i++)
+                var viewExpirationTokens = viewDescriptor.ExpirationTokens;
+                // Read interface .Count once rather than per iteration
+                var viewExpirationTokensCount = viewExpirationTokens.Count;
+                for (var i = 0; i < viewExpirationTokensCount; i++)
                 {
-                    expirationTokens.Add(viewDescriptor.ExpirationTokens[i]);
+                    expirationTokens.Add(viewExpirationTokens[i]);
                 }
             }
 
diff --git a/src/Mvc/Mvc.Razor/src/TagHelpers/UrlResolutionTagHelper.cs b/src/Mvc/Mvc.Razor/src/TagHelpers/UrlResolutionTagHelper.cs
@@ -156,9 +156,12 @@ protected void ProcessUrlAttribute(string attributeName, TagHelperOutput output)
                 throw new ArgumentNullException(nameof(output));
             }
 
-            for (var i = 0; i < output.Attributes.Count; i++)
+            var attributes = output.Attributes;
+            // Read interface .Count once rather than per iteration
+            var attributesCount = attributes.Count;
+            for (var i = 0; i < attributesCount; i++)
             {
-                var attribute = output.Attributes[i];
+                var attribute = attributes[i];
                 if (!string.Equals(attribute.Name, attributeName, StringComparison.OrdinalIgnoreCase))
                 {
                     continue;
@@ -170,7 +173,7 @@ protected void ProcessUrlAttribute(string attributeName, TagHelperOutput output)
                     string resolvedUrl;
                     if (TryResolveUrl(stringValue, resolvedUrl: out resolvedUrl))
                     {
-                        output.Attributes[i] = new TagHelperAttribute(
+                        attributes[i] = new TagHelperAttribute(
                             attribute.Name,
                             resolvedUrl,
                             attribute.ValueStyle);
@@ -199,15 +202,15 @@ protected void ProcessUrlAttribute(string attributeName, TagHelperOutput output)
                         IHtmlContent resolvedUrl;
                         if (TryResolveUrl(stringValue, resolvedUrl: out resolvedUrl))
                         {
-                            output.Attributes[i] = new TagHelperAttribute(
+                            attributes[i] = new TagHelperAttribute(
                                 attribute.Name,
                                 resolvedUrl,
                                 attribute.ValueStyle);
                         }
                         else if (htmlString == null)
                         {
                             // Not a ~/ URL. Just avoid re-encoding the attribute value later.
-                            output.Attributes[i] = new TagHelperAttribute(
+                            attributes[i] = new TagHelperAttribute(
                                 attribute.Name,
                                 new HtmlString(stringValue),
                                 attribute.ValueStyle);
diff --git a/src/Mvc/Mvc.TagHelpers/src/AttributeMatcher.cs b/src/Mvc/Mvc.TagHelpers/src/AttributeMatcher.cs
@@ -44,13 +44,20 @@ public static bool TryDetermineMode<TMode>(
             }
 
             var foundResult = false;
-            result = default(TMode);
+            result = default;
 
             // Perf: Avoid allocating enumerator
-            for (var i = 0; i < modeInfos.Count; i++)
+            var modeInfosCount = modeInfos.Count;
+            var allAttributes = context.AllAttributes;
+            // Read interface .Count once rather than per iteration
+            var allAttributesCount = allAttributes.Count;
+            for (var i = 0; i < modeInfosCount; i++)
             {
                 var modeInfo = modeInfos[i];
-                if (!HasMissingAttributes(context, modeInfo.Attributes) &&
+                var requiredAttributes = modeInfo.Attributes;
+                // If there are fewer attributes present than required, one or more of them must be missing.
+                if (allAttributesCount >= requiredAttributes.Length && 
+                    !HasMissingAttributes(allAttributes, requiredAttributes) &&
                     compare(result, modeInfo.Mode) <= 0)
                 {
                     foundResult = true;
@@ -61,19 +68,13 @@ public static bool TryDetermineMode<TMode>(
             return foundResult;
         }
 
-        private static bool HasMissingAttributes(TagHelperContext context, string[] requiredAttributes)
+        private static bool HasMissingAttributes(ReadOnlyTagHelperAttributeList allAttributes, string[] requiredAttributes)
         {
-            if (context.AllAttributes.Count < requiredAttributes.Length)
-            {
-                // If there are fewer attributes present than required, one or more of them must be missing.
-                return true;
-            }
-
             // Check for all attribute values
             // Perf: Avoid allocating enumerator
             for (var i = 0; i < requiredAttributes.Length; i++)
             {
-                if (!context.AllAttributes.TryGetAttribute(requiredAttributes[i], out var attribute))
+                if (!allAttributes.TryGetAttribute(requiredAttributes[i], out var attribute))
                 {
                     // Missing attribute.
                     return true;
diff --git a/src/Mvc/Mvc.TagHelpers/src/LinkTagHelper.cs b/src/Mvc/Mvc.TagHelpers/src/LinkTagHelper.cs
@@ -381,8 +381,9 @@ private void BuildFallbackBlock(TagHelperAttributeList attributes, TagHelperCont
 
             builder.AppendHtml(", \"");
 
-            // Perf: Avoid allocating enumerator
-            for (var i = 0; i < attributes.Count; i++)
+            // Perf: Avoid allocating enumerator and read interface .Count once rather than per iteration
+            var attributesCount = attributes.Count;
+            for (var i = 0; i < attributesCount; i++)
             {
                 var attribute = attributes[i];
                 if (string.Equals(attribute.Name, HrefAttributeName, StringComparison.OrdinalIgnoreCase))
@@ -440,8 +441,10 @@ private void AppendFallbackHrefs(TagHelperContent builder, IReadOnlyList<string>
         {
             builder.AppendHtml("[");
             var firstAdded = false;
-            // Perf: Avoid allocating enumerator
-            for (var i = 0; i < fallbackHrefs.Count; i++)
+
+            // Perf: Avoid allocating enumerator and read interface .Count once rather than per iteration
+            var fallbackHrefsCount = fallbackHrefs.Count;
+            for (var i = 0; i < fallbackHrefsCount; i++)
             {
                 if (firstAdded)
                 {
@@ -498,8 +501,9 @@ private void BuildLinkTag(string href, TagHelperAttributeList attributes, TagHel
 
             var addHref = true;
 
-            // Perf: Avoid allocating enumerator
-            for (var i = 0; i < attributes.Count; i++)
+            // Perf: Avoid allocating enumerator and read interface .Count once rather than per iteration
+            var attributesCount = attributes.Count;
+            for (var i = 0; i < attributesCount; i++)
             {
                 var attribute = attributes[i];
 
diff --git a/src/Mvc/Mvc.TagHelpers/src/ScriptTagHelper.cs b/src/Mvc/Mvc.TagHelpers/src/ScriptTagHelper.cs
@@ -331,8 +331,9 @@ private void BuildFallbackBlock(TagHelperAttributeList attributes, TagHelperCont
 
                     var addSrc = true;
 
-                    // Perf: Avoid allocating enumerator
-                    for (var i = 0; i < attributes.Count; i++)
+                    // Perf: Avoid allocating enumerator and read interface .Count once rather than per iteration
+                    var attributesCount = attributes.Count;
+                    for (var i = 0; i < attributesCount; i++)
                     {
                         var attribute = attributes[i];
                         if (!attribute.Name.Equals(SrcAttributeName, StringComparison.OrdinalIgnoreCase))
@@ -434,8 +435,9 @@ private void BuildScriptTag(
 
             var addSrc = true;
 
-            // Perf: Avoid allocating enumerator
-            for (var i = 0; i < attributes.Count; i++)
+            // Perf: Avoid allocating enumerator and read interface .Count once rather than per iteration
+            var attributesCount = attributes.Count;
+            for (var i = 0; i < attributesCount; i++)
             {
                 var attribute = attributes[i];
                 if (!attribute.Name.Equals(SrcAttributeName, StringComparison.OrdinalIgnoreCase))
diff --git a/src/Mvc/Mvc.TagHelpers/src/TagHelperOutputExtensions.cs b/src/Mvc/Mvc.TagHelpers/src/TagHelperOutputExtensions.cs
@@ -321,13 +321,14 @@ private static void CopyHtmlAttribute(
             TagHelperOutput tagHelperOutput,
             TagHelperContext context)
         {
-            var existingAttribute = context.AllAttributes[allAttributeIndex];
+            var allAttributes = context.AllAttributes;
+            var existingAttribute = allAttributes[allAttributeIndex];
 
             // Move backwards through context.AllAttributes from the provided index until we find a familiar attribute
             // in tagHelperOutput where we can insert the copied value after the familiar one.
             for (var i = allAttributeIndex - 1; i >= 0; i--)
             {
-                var previousName = context.AllAttributes[i].Name;
+                var previousName = allAttributes[i].Name;
                 var index = IndexOfFirstMatch(previousName, tagHelperOutput.Attributes);
                 if (index != -1)
                 {
@@ -336,11 +337,13 @@ private static void CopyHtmlAttribute(
                 }
             }
 
+            // Read interface .Count once rather than per iteration
+            var allAttributesCount = allAttributes.Count;
             // Move forward through context.AllAttributes from the provided index until we find a familiar attribute in
             // tagHelperOutput where we can insert the copied value.
-            for (var i = allAttributeIndex + 1; i < context.AllAttributes.Count; i++)
+            for (var i = allAttributeIndex + 1; i < allAttributesCount; i++)
             {
-                var nextName = context.AllAttributes[i].Name;
+                var nextName = allAttributes[i].Name;
                 var index = IndexOfFirstMatch(nextName, tagHelperOutput.Attributes);
                 if (index != -1)
                 {
@@ -355,7 +358,9 @@ private static void CopyHtmlAttribute(
 
         private static int IndexOfFirstMatch(string name, TagHelperAttributeList attributes)
         {
-            for (var i = 0; i < attributes.Count; i++)
+            // Read interface .Count once rather than per iteration
+            var attributesCount = attributes.Count;
+            for (var i = 0; i < attributesCount; i++)
             {
                 if (string.Equals(name, attributes[i].Name, StringComparison.OrdinalIgnoreCase))
                 {
diff --git a/src/Razor/Razor.Runtime/ref/Microsoft.AspNetCore.Razor.Runtime.netcoreapp3.0.cs b/src/Razor/Razor.Runtime/ref/Microsoft.AspNetCore.Razor.Runtime.netcoreapp3.0.cs
@@ -93,7 +93,6 @@ public void Reinitialize(string tagName, Microsoft.AspNetCore.Razor.TagHelpers.T
     public partial class TagHelperRunner
     {
         public TagHelperRunner() { }
-        [System.Diagnostics.DebuggerStepThroughAttribute]
         public System.Threading.Tasks.Task RunAsync(Microsoft.AspNetCore.Razor.Runtime.TagHelpers.TagHelperExecutionContext executionContext) { throw null; }
     }
     public partial class TagHelperScopeManager
diff --git a/src/Razor/Razor.Runtime/src/Runtime/TagHelpers/TagHelperRunner.cs b/src/Razor/Razor.Runtime/src/Runtime/TagHelpers/TagHelperRunner.cs
diff --git a/src/Razor/Razor/src/TagHelpers/ReadOnlyTagHelperAttributeList.cs b/src/Razor/Razor/src/TagHelpers/ReadOnlyTagHelperAttributeList.cs
diff --git a/src/Razor/Razor/src/TagHelpers/TagHelperOutput.cs b/src/Razor/Razor/src/TagHelpers/TagHelperOutput.cs

Original file line number	Diff line number	Diff line change
`@@ -139,9 +139,12 @@ public RoutePatternParameterPart GetParameter(string name)`
`139`	`139`	`throw new ArgumentNullException(nameof(name));`
`140`	`140`	`}`
`141`	`141`
`142`		`- for (var i = 0; i < Parameters.Count; i++)`
	`142`	`+ var parameters = Parameters;`
	`143`	`+ // Read interface .Count once rather than per iteration`
	`144`	`+ var parametersCount = parameters.Count;`
	`145`	`+ for (var i = 0; i < parametersCount; i++)`
`143`	`146`	`{`
`144`		`- var parameter = Parameters[i];`
	`147`	`+ var parameter = parameters[i];`
`145`	`148`	`if (string.Equals(parameter.Name, name, StringComparison.OrdinalIgnoreCase))`
`146`	`149`	`{`
`147`	`150`	`return parameter;`
Original file line number	Diff line number	Diff line change
`@@ -521,16 +521,20 @@ private bool TryBindValuesCore(UriBuildingContext context, RouteValueDictionary`
`521`	`521`	`}`
`522`	`522`	`}`
`523`	`523`
`524`		`- for (var i = 0; i < _pattern.PathSegments.Count; i++)`
	`524`	`+ var segments = _pattern.PathSegments;`
	`525`	`+ // Read interface .Count once rather than per iteration`
	`526`	`+ var segmentsCount = segments.Count;`
	`527`	`+ for (var i = 0; i < segmentsCount; i++)`
`525`	`528`	`{`
`526`	`529`	`Debug.Assert(context.BufferState == SegmentState.Beginning);`
`527`	`530`	`Debug.Assert(context.UriState == SegmentState.Beginning);`
`528`	`531`
`529`		`- var segment = _pattern.PathSegments[i];`
`530`		`-`
`531`		`- for (var j = 0; j < segment.Parts.Count; j++)`
	`532`	`+ var parts = segments[i].Parts;`
	`533`	`+ // Read interface .Count once rather than per iteration`
	`534`	`+ var partsCount = parts.Count;`
	`535`	`+ for (var j = 0; j < partsCount; j++)`
`532`	`536`	`{`
`533`		`- var part = segment.Parts[j];`
	`537`	`+ var part = parts[j];`
`534`	`538`
`535`	`539`	`if (part is RoutePatternLiteralPart literalPart)`
`536`	`540`	`{`
`@@ -581,7 +585,7 @@ private bool TryBindValuesCore(UriBuildingContext context, RouteValueDictionary`
`581`	`585`	`// for format, so we remove '.' and generate 5.`
`582`	`586`	`if (!context.Accept(converted, parameterPart.EncodeSlashes))`
`583`	`587`	`{`
`584`		`- if (j != 0 && parameterPart.IsOptional && (separatorPart = segment.Parts[j - 1] as RoutePatternSeparatorPart) != null)`
	`588`	`+ if (j != 0 && parameterPart.IsOptional && (separatorPart = parts[j - 1] as RoutePatternSeparatorPart) != null)`
`585`	`589`	`{`
`586`	`590`	`context.Remove(separatorPart.Content);`
`587`	`591`	`}`
Original file line number	Diff line number	Diff line change
`@@ -113,14 +113,20 @@ private void Walk(`
`113`	`113`	`{`
`114`	`114`	`// Any entries in node.Matches have had all their required values satisfied, so add them`
`115`	`115`	`// to the results.`
`116`		`- for (var i = 0; i < node.Matches.Count; i++)`
	`116`	`+ var matches = node.Matches;`
	`117`	`+ // Read interface .Count once rather than per iteration`
	`118`	`+ var matchesCount = matches.Count;`
	`119`	`+ for (var i = 0; i < matchesCount; i++)`
`117`	`120`	`{`
`118`		`- results.Add(new OutboundMatchResult(node.Matches[i], isFallbackPath));`
	`121`	`+ results.Add(new OutboundMatchResult(matches[i], isFallbackPath));`
`119`	`122`	`}`
`120`	`123`
`121`		`- for (var i = 0; i < node.Criteria.Count; i++)`
	`124`	`+ var criteria = node.Criteria;`
	`125`	`+ // Read interface .Count once rather than per iteration`
	`126`	`+ var criteriaCount = criteria.Count;`
	`127`	`+ for (var i = 0; i < criteriaCount; i++)`
`122`	`128`	`{`
`123`		`- var criterion = node.Criteria[i];`
	`129`	`+ var criterion = criteria[i];`
`124`	`130`	`var key = criterion.Key;`
`125`	`131`
`126`	`132`	`if (values.TryGetValue(key, out var value))`
Original file line number	Diff line number	Diff line change
`@@ -21,10 +21,12 @@ public void OnProvidersExecuting(FilterProviderContext context)`
`21`	`21`
`22`	`22`	`if (context.ActionContext.ActionDescriptor.FilterDescriptors != null)`
`23`	`23`	`{`
`24`		`- // Perf: Avoid allocations`
`25`		`- for (var i = 0; i < context.Results.Count; i++)`
	`24`	`+ var results = context.Results;`
	`25`	`+ // Perf: Avoid allocating enumerator and read interface .Count once rather than per iteration`
	`26`	`+ var resultsCount = results.Count;`
	`27`	`+ for (var i = 0; i < resultsCount; i++)`
`26`	`28`	`{`
`27`		`- ProvideFilter(context, context.Results[i]);`
	`29`	`+ ProvideFilter(context, results[i]);`
`28`	`30`	`}`
`29`	`31`	`}`
`30`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -249,15 +249,18 @@ private ViewLocationCacheResult LocatePageFromViewLocations(`
`249`	`249`	`isMainPage);`
`250`	`250`	`Dictionary<string, string> expanderValues = null;`
`251`	`251`
`252`		`- if (_options.ViewLocationExpanders.Count > 0)`
	`252`	`+ var expanders = _options.ViewLocationExpanders;`
	`253`	`+ // Read interface .Count once rather than per iteration`
	`254`	`+ var expandersCount = expanders.Count;`
	`255`	`+ if (expandersCount > 0)`
`253`	`256`	`{`
`254`	`257`	`expanderValues = new Dictionary<string, string>(StringComparer.Ordinal);`
`255`	`258`	`expanderContext.Values = expanderValues;`
`256`	`259`
`257`	`260`	`// Perf: Avoid allocations`
`258`		`- for (var i = 0; i < _options.ViewLocationExpanders.Count; i++)`
	`261`	`+ for (var i = 0; i < expandersCount; i++)`
`259`	`262`	`{`
`260`		`- _options.ViewLocationExpanders[i].PopulateValues(expanderContext);`
	`263`	`+ expanders[i].PopulateValues(expanderContext);`
`261`	`264`	`}`
`262`	`265`	`}`
`263`	`266`
`@@ -350,9 +353,12 @@ private ViewLocationCacheResult OnCacheMiss(`
`350`	`353`	`{`
`351`	`354`	`var viewLocations = GetViewLocationFormats(expanderContext);`
`352`	`355`
`353`		`- for (var i = 0; i < _options.ViewLocationExpanders.Count; i++)`
	`356`	`+ var expanders = _options.ViewLocationExpanders;`
	`357`	`+ // Read interface .Count once rather than per iteration`
	`358`	`+ var expandersCount = expanders.Count;`
	`359`	`+ for (var i = 0; i < expandersCount; i++)`
`354`	`360`	`{`
`355`		`- viewLocations = _options.ViewLocationExpanders[i].ExpandViewLocations(expanderContext, viewLocations);`
	`361`	`+ viewLocations = expanders[i].ExpandViewLocations(expanderContext, viewLocations);`
`356`	`362`	`}`
`357`	`363`
`358`	`364`	`ViewLocationCacheResult cacheResult = null;`
`@@ -404,9 +410,12 @@ internal ViewLocationCacheResult CreateCacheResult(`
`404`	`410`	`var viewDescriptor = factoryResult.ViewDescriptor;`
`405`	`411`	`if (viewDescriptor?.ExpirationTokens != null)`
`406`	`412`	`{`
`407`		`- for (var i = 0; i < viewDescriptor.ExpirationTokens.Count; i++)`
	`413`	`+ var viewExpirationTokens = viewDescriptor.ExpirationTokens;`
	`414`	`+ // Read interface .Count once rather than per iteration`
	`415`	`+ var viewExpirationTokensCount = viewExpirationTokens.Count;`
	`416`	`+ for (var i = 0; i < viewExpirationTokensCount; i++)`
`408`	`417`	`{`
`409`		`- expirationTokens.Add(viewDescriptor.ExpirationTokens[i]);`
	`418`	`+ expirationTokens.Add(viewExpirationTokens[i]);`
`410`	`419`	`}`
`411`	`420`	`}`
`412`	`421`
Original file line number	Diff line number	Diff line change
`@@ -156,9 +156,12 @@ protected void ProcessUrlAttribute(string attributeName, TagHelperOutput output)`
`156`	`156`	`throw new ArgumentNullException(nameof(output));`
`157`	`157`	`}`
`158`	`158`
`159`		`- for (var i = 0; i < output.Attributes.Count; i++)`
	`159`	`+ var attributes = output.Attributes;`
	`160`	`+ // Read interface .Count once rather than per iteration`
	`161`	`+ var attributesCount = attributes.Count;`
	`162`	`+ for (var i = 0; i < attributesCount; i++)`
`160`	`163`	`{`
`161`		`- var attribute = output.Attributes[i];`
	`164`	`+ var attribute = attributes[i];`
`162`	`165`	`if (!string.Equals(attribute.Name, attributeName, StringComparison.OrdinalIgnoreCase))`
`163`	`166`	`{`
`164`	`167`	`continue;`
`@@ -170,7 +173,7 @@ protected void ProcessUrlAttribute(string attributeName, TagHelperOutput output)`
`170`	`173`	`string resolvedUrl;`
`171`	`174`	`if (TryResolveUrl(stringValue, resolvedUrl: out resolvedUrl))`
`172`	`175`	`{`
`173`		`- output.Attributes[i] = new TagHelperAttribute(`
	`176`	`+ attributes[i] = new TagHelperAttribute(`
`174`	`177`	`attribute.Name,`
`175`	`178`	`resolvedUrl,`
`176`	`179`	`attribute.ValueStyle);`
`@@ -199,15 +202,15 @@ protected void ProcessUrlAttribute(string attributeName, TagHelperOutput output)`
`199`	`202`	`IHtmlContent resolvedUrl;`
`200`	`203`	`if (TryResolveUrl(stringValue, resolvedUrl: out resolvedUrl))`
`201`	`204`	`{`
`202`		`- output.Attributes[i] = new TagHelperAttribute(`
	`205`	`+ attributes[i] = new TagHelperAttribute(`
`203`	`206`	`attribute.Name,`
`204`	`207`	`resolvedUrl,`
`205`	`208`	`attribute.ValueStyle);`
`206`	`209`	`}`
`207`	`210`	`else if (htmlString == null)`
`208`	`211`	`{`
`209`	`212`	`// Not a ~/ URL. Just avoid re-encoding the attribute value later.`
`210`		`- output.Attributes[i] = new TagHelperAttribute(`
	`213`	`+ attributes[i] = new TagHelperAttribute(`
`211`	`214`	`attribute.Name,`
`212`	`215`	`new HtmlString(stringValue),`
`213`	`216`	`attribute.ValueStyle);`
Original file line number	Diff line number	Diff line change
`@@ -321,13 +321,14 @@ private static void CopyHtmlAttribute(`
`321`	`321`	`TagHelperOutput tagHelperOutput,`
`322`	`322`	`TagHelperContext context)`
`323`	`323`	`{`
`324`		`- var existingAttribute = context.AllAttributes[allAttributeIndex];`
	`324`	`+ var allAttributes = context.AllAttributes;`
	`325`	`+ var existingAttribute = allAttributes[allAttributeIndex];`
`325`	`326`
`326`	`327`	`// Move backwards through context.AllAttributes from the provided index until we find a familiar attribute`
`327`	`328`	`// in tagHelperOutput where we can insert the copied value after the familiar one.`
`328`	`329`	`for (var i = allAttributeIndex - 1; i >= 0; i--)`
`329`	`330`	`{`
`330`		`- var previousName = context.AllAttributes[i].Name;`
	`331`	`+ var previousName = allAttributes[i].Name;`
`331`	`332`	`var index = IndexOfFirstMatch(previousName, tagHelperOutput.Attributes);`
`332`	`333`	`if (index != -1)`
`333`	`334`	`{`
`@@ -336,11 +337,13 @@ private static void CopyHtmlAttribute(`
`336`	`337`	`}`
`337`	`338`	`}`
`338`	`339`
	`340`	`+ // Read interface .Count once rather than per iteration`
	`341`	`+ var allAttributesCount = allAttributes.Count;`
`339`	`342`	`// Move forward through context.AllAttributes from the provided index until we find a familiar attribute in`
`340`	`343`	`// tagHelperOutput where we can insert the copied value.`
`341`		`- for (var i = allAttributeIndex + 1; i < context.AllAttributes.Count; i++)`
	`344`	`+ for (var i = allAttributeIndex + 1; i < allAttributesCount; i++)`
`342`	`345`	`{`
`343`		`- var nextName = context.AllAttributes[i].Name;`
	`346`	`+ var nextName = allAttributes[i].Name;`
`344`	`347`	`var index = IndexOfFirstMatch(nextName, tagHelperOutput.Attributes);`
`345`	`348`	`if (index != -1)`
`346`	`349`	`{`
`@@ -355,7 +358,9 @@ private static void CopyHtmlAttribute(`
`355`	`358`
`356`	`359`	`private static int IndexOfFirstMatch(string name, TagHelperAttributeList attributes)`
`357`	`360`	`{`
`358`		`- for (var i = 0; i < attributes.Count; i++)`
	`361`	`+ // Read interface .Count once rather than per iteration`
	`362`	`+ var attributesCount = attributes.Count;`
	`363`	`+ for (var i = 0; i < attributesCount; i++)`
`359`	`364`	`{`
`360`	`365`	`if (string.Equals(name, attributes[i].Name, StringComparison.OrdinalIgnoreCase))`
`361`	`366`	`{`
Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,6 @@ public void Reinitialize(string tagName, Microsoft.AspNetCore.Razor.TagHelpers.T`
`93`	`93`	`public partial class TagHelperRunner`
`94`	`94`	`{`
`95`	`95`	`public TagHelperRunner() { }`
`96`		`- [System.Diagnostics.DebuggerStepThroughAttribute]`
`97`	`96`	`public System.Threading.Tasks.Task RunAsync(Microsoft.AspNetCore.Razor.Runtime.TagHelpers.TagHelperExecutionContext executionContext) { throw null; }`
`98`	`97`	`}`
`99`	`98`	`public partial class TagHelperScopeManager`