Flow through FeatureReference removal

Author: benaadams

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

@@ -15,22 +15,55 @@ namespace Microsoft.AspNet.Http.Authentication.Internal
     public class DefaultAuthenticationManager : AuthenticationManager
     {
         private readonly IFeatureCollection _features;
-        private FeatureReference<IHttpAuthenticationFeature> _authentication = FeatureReference<IHttpAuthenticationFeature>.Default;
-        private FeatureReference<IHttpResponseFeature> _response = FeatureReference<IHttpResponseFeature>.Default;
+        private int _cachedFeaturesRevision = -1;
+
+        private IHttpAuthenticationFeature _authentication;
+        private IHttpResponseFeature _response;
 
         public DefaultAuthenticationManager(IFeatureCollection features)
         {
             _features = features;
         }
 
+        void CheckFeaturesRevision()
+        {
+            if (_cachedFeaturesRevision != _features.Revision)
+            {
+                _authentication = null;
+                _response = null;
+                _cachedFeaturesRevision = _features.Revision;
+            }
+        }
+
         private IHttpAuthenticationFeature HttpAuthenticationFeature
         {
-            get { return _authentication.Fetch(_features) ?? _authentication.Update(_features, new HttpAuthenticationFeature()); }
+            get
+            {
+                CheckFeaturesRevision();
+                if (_authentication == null)
+                {
+                    _authentication = _features.Get<IHttpAuthenticationFeature>();
+                    if (_authentication == null)
+                    {
+                        _authentication = new HttpAuthenticationFeature();
+                        _features.Set(_authentication);
+                    }
+                }
+                return _authentication;
+            }
         }
 
         private IHttpResponseFeature HttpResponseFeature
         {
-            get { return _response.Fetch(_features); }
+            get
+            {
+                CheckFeaturesRevision();
+                if (_response == null)
+                {
+                    _response = _features.Get<IHttpResponseFeature>();
+                }
+                return _response;
+            }
         }
 
         public override IEnumerable<AuthenticationDescription> GetAuthenticationSchemes()

src/Microsoft.AspNet.Http/DefaultConnectionInfo.cs

@@ -13,23 +13,66 @@ namespace Microsoft.AspNet.Http.Internal
     public class DefaultConnectionInfo : ConnectionInfo
     {
         private readonly IFeatureCollection _features;
+        private int _cachedFeaturesRevision = -1;
 
-        private FeatureReference<IHttpConnectionFeature> _connection = FeatureReference<IHttpConnectionFeature>.Default;
-        private FeatureReference<ITlsConnectionFeature> _tlsConnection = FeatureReference<ITlsConnectionFeature>.Default;
+        private IHttpConnectionFeature _connection;
+        private ITlsConnectionFeature _tlsConnection;
 
         public DefaultConnectionInfo(IFeatureCollection features)
         {
             _features = features;
         }
 
+        void CheckFeaturesRevision()
+        {
+            if (_cachedFeaturesRevision != _features.Revision)
+            {
+                _connection = null;
+                _tlsConnection = null;
+                _cachedFeaturesRevision = _features.Revision;
+            }
+        }
+
         private IHttpConnectionFeature HttpConnectionFeature
         {
-            get { return _connection.Fetch(_features) ?? _connection.Update(_features, new HttpConnectionFeature()); }
+            get
+            {
+                CheckFeaturesRevision();
+
+                var connection = _connection;
+                if (connection == null)
+                {
+                    connection = _features.Get<IHttpConnectionFeature>();
+                    if (connection == null)
+                    {
+                        connection = new HttpConnectionFeature();
+                        _features.Set(connection);
+                    }
+                    _connection = connection;
+                }
+                return connection;
+            }
         }
 
         private ITlsConnectionFeature TlsConnectionFeature
         {
-            get { return _tlsConnection.Fetch(_features) ?? _tlsConnection.Update(_features, new TlsConnectionFeature()); }
+            get
+            {
+                CheckFeaturesRevision();
+
+                var tlsConnection = _tlsConnection;
+                if (tlsConnection == null)
+                {
+                    tlsConnection = _features.Get<ITlsConnectionFeature>();
+                    if (tlsConnection == null)
+                    {
+                        tlsConnection = new TlsConnectionFeature();
+                        _features.Set(tlsConnection);
+                    }
+                    _tlsConnection = tlsConnection;
+                }
+                return tlsConnection;
+            }
         }
 
         public override IPAddress RemoteIpAddress

src/Microsoft.AspNet.Http/DefaultHttpContext.cs

@@ -21,13 +21,15 @@ public class DefaultHttpContext : HttpContext
         private readonly ConnectionInfo _connection;
         private readonly AuthenticationManager _authenticationManager;
 
-        private FeatureReference<IItemsFeature> _items;
-        private FeatureReference<IServiceProvidersFeature> _serviceProviders;
-        private FeatureReference<IHttpAuthenticationFeature> _authentication;
-        private FeatureReference<IHttpRequestLifetimeFeature> _lifetime;
-        private FeatureReference<ISessionFeature> _session;
+        private IItemsFeature _items;
+        private IServiceProvidersFeature _serviceProviders;
+        private IHttpAuthenticationFeature _authentication;
+        private IHttpRequestLifetimeFeature _lifetime;
+        private ISessionFeature _session;
         private WebSocketManager _websockets;
+
         private IFeatureCollection _features;
+        private int _cachedFeaturesRevision = -1;
 
         public DefaultHttpContext()
             : this(new FeatureCollection())
@@ -43,37 +45,122 @@ public DefaultHttpContext(IFeatureCollection features)
             _response = new DefaultHttpResponse(this, features);
             _connection = new DefaultConnectionInfo(features);
             _authenticationManager = new DefaultAuthenticationManager(features);
+        }
 
-            _items = FeatureReference<IItemsFeature>.Default;
-            _serviceProviders = FeatureReference<IServiceProvidersFeature>.Default;
-            _authentication = FeatureReference<IHttpAuthenticationFeature>.Default;
-            _lifetime = FeatureReference<IHttpRequestLifetimeFeature>.Default;
-            _session = FeatureReference<ISessionFeature>.Default;
+        void CheckFeaturesRevision()
+        {
+            if (_cachedFeaturesRevision !=_features.Revision)
+            {
+                _items = null;
+                _serviceProviders = null;
+                _authentication = null;
+                _lifetime = null;
+                _session = null;
+                _cachedFeaturesRevision = _features.Revision;
+            }
         }
 
         IItemsFeature ItemsFeature
         {
-            get { return _items.Fetch(_features) ?? _items.Update(_features, new ItemsFeature()); }
+            get
+            {
+                CheckFeaturesRevision();
+
+                var items = _items;
+                if (items == null)
+                {
+                    items = _features.Get<IItemsFeature>();
+                    if (items == null)
+                    {
+                        items = new ItemsFeature();
+                        _features.Set(items);
+                    }
+                    _items = items;
+                }
+                return items;
+            }
         }
 
         IServiceProvidersFeature ServiceProvidersFeature
         {
-            get { return _serviceProviders.Fetch(_features) ?? _serviceProviders.Update(_features, new ServiceProvidersFeature()); }
+            get
+            {
+                CheckFeaturesRevision();
+
+                var serviceProviders = _serviceProviders;
+                if (serviceProviders == null)
+                {
+                    serviceProviders = _features.Get<IServiceProvidersFeature>();
+                    if (serviceProviders == null)
+                    {
+                        serviceProviders = new ServiceProvidersFeature();
+                        _features.Set(serviceProviders);
+                        _serviceProviders = serviceProviders;
+                    }
+                }
+                return serviceProviders;
+            }
         }
 
         private IHttpAuthenticationFeature HttpAuthenticationFeature
         {
-            get { return _authentication.Fetch(_features) ?? _authentication.Update(_features, new HttpAuthenticationFeature()); }
+            get
+            {
+                CheckFeaturesRevision();
+
+                var authentication = _authentication;
+                if (authentication == null)
+                {
+                    authentication = _features.Get<IHttpAuthenticationFeature>();
+                    if (authentication == null)
+                    {
+                        authentication = new HttpAuthenticationFeature();
+                        _features.Set(authentication);
+                    }
+                    _authentication = authentication;
+                }
+                return authentication;
+            }
         }
 
         private IHttpRequestLifetimeFeature LifetimeFeature
         {
-            get { return _lifetime.Fetch(_features) ?? _lifetime.Update(_features, new HttpRequestLifetimeFeature()); }
+            get
+            {
+                CheckFeaturesRevision();
+
+                var lifetime = _lifetime;
+                if (lifetime == null)
+                {
+                    lifetime = _features.Get<IHttpRequestLifetimeFeature>();
+                    if (lifetime == null)
+                    {
+                        lifetime = new HttpRequestLifetimeFeature();
+                        _features.Set(lifetime);
+                    }
+                    _lifetime = lifetime;
+                }
+                return lifetime;
+            }
         }
 
         private ISessionFeature SessionFeature
         {
-            get { return _session.Fetch(_features); }
+            get
+            {
+                CheckFeaturesRevision();
+
+                if (_session == null)
+                {
+                    _session = _features.Get<ISessionFeature>();
+                }
+                return _session;
+            }
+            set
+            {
+                _features.Set(value);
+                _session = value;
+            }
         }
 
         public override IFeatureCollection Features { get { return _features; } }
@@ -142,8 +229,8 @@ public override ISession Session
                 var feature = SessionFeature;
                 if (feature == null)
                 {
-                    feature = new DefaultSessionFeature();
-                    _session.Update(_features, feature);
+                    SessionFeature = new DefaultSessionFeature();
+                    feature = SessionFeature;
                 }
                 feature.Session = value;
             }