Streamlining feature cache and object re-initialiation code paths

samples/SampleApp/PooledHttpContext.cs

@@ -0,0 +1,54 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using Microsoft.AspNet.Http;
+using Microsoft.AspNet.Http.Features;
+using Microsoft.AspNet.Http.Internal;
+
+namespace SampleApp
+{
+    public class PooledHttpContext : DefaultHttpContext
+    {
+        DefaultHttpRequest _pooledHttpRequest;
+        DefaultHttpResponse _pooledHttpResponse;
+
+        public PooledHttpContext(IFeatureCollection featureCollection) : 
+            base(featureCollection)
+        {
+        }
+
+        protected override HttpRequest InitializeHttpRequest()
+        {
+            if (_pooledHttpRequest != null)
+            {
+                _pooledHttpRequest.Initialize(this, Features);
+                return _pooledHttpRequest;
+            }
+
+            return new DefaultHttpRequest(this, Features);
+        }
+
+        protected override void UninitializeHttpRequest(HttpRequest instance)
+        {
+            _pooledHttpRequest = instance as DefaultHttpRequest;
+            _pooledHttpRequest?.Uninitialize();
+        }
+
+        protected override HttpResponse InitializeHttpResponse()
+        {
+            if (_pooledHttpResponse != null)
+            {
+                _pooledHttpResponse.Initialize(this, Features);
+                return _pooledHttpResponse;
+            }
+
+            return new DefaultHttpResponse(this, Features);
+        }
+
+        protected override void UninitializeHttpResponse(HttpResponse instance)
+        {
+            _pooledHttpResponse = instance as DefaultHttpResponse;
+            _pooledHttpResponse?.Uninitialize();
+        }
+    }
+}

samples/SampleApp/PooledHttpContextFactory.cs

@@ -0,0 +1,65 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using Microsoft.AspNet.Http;
+using Microsoft.AspNet.Http.Features;
+
+namespace SampleApp
+{
+    public class PooledHttpContextFactory : IHttpContextFactory
+    {
+        private readonly IHttpContextAccessor _httpContextAccessor;
+        private readonly Stack<PooledHttpContext> _pool = new Stack<PooledHttpContext>();
+
+        public PooledHttpContextFactory(IHttpContextAccessor httpContextAccessor)
+        {
+            _httpContextAccessor = httpContextAccessor;
+        }
+
+        public HttpContext Create(IFeatureCollection featureCollection)
+        {
+            PooledHttpContext httpContext = null;
+            lock (_pool)
+            {
+                if (_pool.Count != 0)
+                {
+                    httpContext = _pool.Pop();
+                }
+            }
+
+            if (httpContext == null)
+            {
+                httpContext = new PooledHttpContext(featureCollection);
+            }
+            else
+            {
+                httpContext.Initialize(featureCollection);
+            }
+
+            if (_httpContextAccessor != null)
+            {
+                _httpContextAccessor.HttpContext = httpContext;
+            }
+            return httpContext;
+        }
+
+        public void Dispose(HttpContext httpContext)
+        {
+            if (_httpContextAccessor != null)
+            {
+                _httpContextAccessor.HttpContext = null;
+            }
+
+            var pooled = httpContext as PooledHttpContext;
+            if (pooled != null)
+            {
+                pooled.Uninitialize();
+                lock (_pool)
+                {
+                    _pool.Push(pooled);
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,62 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+
+namespace Microsoft.AspNet.Http.Features
+{
+    public struct FeatureReferences<TCache>
+    {
+        public FeatureReferences(IFeatureCollection collection)
+        {
+            Collection = collection;
+            Cache = default(TCache);
+            Revision = collection.Revision;
+        }
+
+        public IFeatureCollection Collection { get; private set; }
+        public int Revision { get; private set; }
+
+        // cache is a public field because the code calling Fetch must
+        // be able to pass ref values that "dot through" the TCache struct memory, 
+        // if it was a Property then that getter would return a copy of the memory
+        // preventing the use of "ref"
+        public TCache Cache; 
+
+        public TFeature Fetch<TFeature, TState>(
+            ref TFeature cached,
+            TState state,
+            Func<TState, TFeature> factory)
+        {
+            var cleared = false;
+            if (Revision != Collection.Revision)
+            {
+                cleared = true;
+                Cache = default(TCache);
+                Revision = Collection.Revision;
+            }
+
+            var feature = cached;
+            if (feature == null)
+            {
+                feature = Collection.Get<TFeature>();
+                if (feature == null)
+                {
+                    feature = factory(state);
+
+                    Collection.Set(feature);
+                    if (!cleared)
+                    {
+                        Cache = default(TCache);
+                    }
+                    Revision = Collection.Revision;
+                }
+                cached = feature;
+            }
+            return feature;
+        }
+
+        public TFeature Fetch<TFeature>(ref TFeature cached, Func<IFeatureCollection, TFeature> factory) =>
+            Fetch(ref cached, Collection, factory);
+    }
+}

src/Microsoft.AspNet.Http/Authentication/DefaultAuthenticationManager.cs

@@ -12,56 +12,27 @@
 
 namespace Microsoft.AspNet.Http.Authentication.Internal
 {
-    public class DefaultAuthenticationManager : AuthenticationManager, IFeatureCache
+    public class DefaultAuthenticationManager : AuthenticationManager
     {
-        private IFeatureCollection _features;
-        private int _cachedFeaturesRevision = -1;
-
-        private IHttpAuthenticationFeature _authentication;
+        private FeatureReferences<IHttpAuthenticationFeature> _features;
 
         public DefaultAuthenticationManager(IFeatureCollection features)
         {
-            _features = features;
-            ((IFeatureCache)this).SetFeaturesRevision();
-        }
-
-        void IFeatureCache.CheckFeaturesRevision()
-        {
-            if (_cachedFeaturesRevision != _features.Revision)
-            {
-                ResetFeatures();
-            }
-        }
-
-        void IFeatureCache.SetFeaturesRevision()
-        {
-            _cachedFeaturesRevision = _features.Revision;
+            Initialize(features);
         }
 
-        public void UpdateFeatures(IFeatureCollection features)
+        public virtual void Initialize(IFeatureCollection features)
         {
-            _features = features;
-            ResetFeatures();
+            _features = new FeatureReferences<IHttpAuthenticationFeature>(features);
         }
 
-        private void ResetFeatures()
+        public virtual void Uninitialize()
         {
-            _authentication = null;
-
-            ((IFeatureCache)this).SetFeaturesRevision();
+            _features = default(FeatureReferences<IHttpAuthenticationFeature>);
         }
 
-        private IHttpAuthenticationFeature HttpAuthenticationFeature
-        {
-            get
-            {
-                return FeatureHelpers.GetOrCreateAndCache(
-                    this, 
-                    _features, 
-                    () => new HttpAuthenticationFeature(), 
-                    ref _authentication);
-            }
-        }
+        private IHttpAuthenticationFeature HttpAuthenticationFeature =>
+            _features.Fetch(ref _features.Cache, f => new HttpAuthenticationFeature());
 
         public override IEnumerable<AuthenticationDescription> GetAuthenticationSchemes()
         {

src/Microsoft.AspNet.Http/DefaultConnectionInfo.cs

@@ -10,70 +10,30 @@
 
 namespace Microsoft.AspNet.Http.Internal
 {
-    public class DefaultConnectionInfo : ConnectionInfo, IFeatureCache
+    public class DefaultConnectionInfo : ConnectionInfo
     {
-        private IFeatureCollection _features;
-        private int _cachedFeaturesRevision = -1;
-
-        private IHttpConnectionFeature _connection;
-        private ITlsConnectionFeature _tlsConnection;
+        private FeatureReferences<FeatureInterfaces> _features;
 
         public DefaultConnectionInfo(IFeatureCollection features)
         {
-            _features = features;
-            ((IFeatureCache)this).SetFeaturesRevision();
-        }
-
-        void IFeatureCache.CheckFeaturesRevision()
-        {
-            if (_cachedFeaturesRevision != _features.Revision)
-            {
-                ResetFeatures();
-            }
+            Initialize(features);
         }
 
-        void IFeatureCache.SetFeaturesRevision()
+        public virtual void Initialize( IFeatureCollection features)
         {
-            _cachedFeaturesRevision = _features.Revision;
+            _features = new FeatureReferences<FeatureInterfaces>(features);
         }
 
-        public void UpdateFeatures(IFeatureCollection features)
+        public virtual void Uninitialize()
         {
-            _features = features;
-            ResetFeatures();
+            _features = default(FeatureReferences<FeatureInterfaces>);
         }
 
-        private void ResetFeatures()
-        {
-            _connection = null;
-            _tlsConnection = null;
+        private IHttpConnectionFeature HttpConnectionFeature =>
+            _features.Fetch(ref _features.Cache.Connection, f => new HttpConnectionFeature());
 
-            ((IFeatureCache)this).SetFeaturesRevision();
-        }
-
-        private IHttpConnectionFeature HttpConnectionFeature
-        {
-            get
-            {
-                return FeatureHelpers.GetOrCreateAndCache(
-                    this, 
-                    _features, 
-                    () => new HttpConnectionFeature(), 
-                    ref _connection);
-            }
-        }
-
-        private ITlsConnectionFeature TlsConnectionFeature
-        {
-            get
-            {
-                return FeatureHelpers.GetOrCreateAndCache(
-                    this, 
-                    _features,
-                    () => new TlsConnectionFeature(),
-                    ref _tlsConnection);
-            }
-        }
+        private ITlsConnectionFeature TlsConnectionFeature=>
+            _features.Fetch(ref _features.Cache.TlsConnection, f => new TlsConnectionFeature());
 
         public override IPAddress RemoteIpAddress
         {
@@ -115,5 +75,11 @@ public override X509Certificate2 ClientCertificate
         {
             return TlsConnectionFeature.GetClientCertificateAsync(cancellationToken);
         }
+
+        struct FeatureInterfaces
+        {
+            public IHttpConnectionFeature Connection;
+            public ITlsConnectionFeature TlsConnection;
+        }
     }
 }