Reduce Revision check calls via interface

Author: benaadams

src/Microsoft.AspNetCore.Http.Features/FeatureReferences.cs

@@ -26,34 +26,39 @@ public FeatureReferences(IFeatureCollection collection)
         public TFeature Fetch<TFeature, TState>(
             ref TFeature cached,
             TState state,
-            Func<TState, TFeature> factory)
+            Func<TState, TFeature> factory) where TFeature : class
         {
-            var cleared = false;
-            if (Revision != Collection.Revision)
+            var revision = Collection.Revision;
+            if (Revision == revision)
             {
-                cleared = true;
-                Cache = default(TCache);
-                Revision = Collection.Revision;
+                // collection unchanged, use cached
+                return cached ?? UpdateCached(ref cached, state, factory);
             }
 
-            var feature = cached;
-            if (feature == null || cleared)
-            {
-                feature = Collection.Get<TFeature>();
-                if (feature == null)
-                {
-                    feature = factory(state);
+            // collection changed, clear cache
+            Cache = default(TCache);
+            // empty cache is current revision
+            Revision = revision;
 
-                    Collection.Set(feature);
+            return UpdateCached(ref cached, state, factory);
+        }
 
-                    Revision = Collection.Revision;
-                }
-                cached = feature;
+        private TFeature UpdateCached<TFeature, TState>(ref TFeature cached, TState state, Func<TState, TFeature> factory) where TFeature : class
+        {
+            cached = Collection.Get<TFeature>();
+            if (cached == null)
+            {
+                // create if item not in collection
+                cached = factory(state);
+                Collection.Set(cached);
+                // Revision changed by .Set, update revision
+                Revision = Collection.Revision;
             }
-            return feature;
+
+            return cached;
         }
 
-        public TFeature Fetch<TFeature>(ref TFeature cached, Func<IFeatureCollection, TFeature> factory) =>
-            Fetch(ref cached, Collection, factory);
+        public TFeature Fetch<TFeature>(ref TFeature cached, Func<IFeatureCollection, TFeature> factory)
+            where TFeature : class => Fetch(ref cached, Collection, factory);
     }
 }