Dispose service properties when context is disposed or returned to th…

…e pool

Fixes #25486

src/EFCore/ChangeTracking/ChangeTracker.cs

@@ -609,7 +609,7 @@ Task IResettableService.ResetStateAsync(CancellationToken cancellationToken)
     ///     </para>
     /// </remarks>
     public virtual void Clear()
-        => StateManager.Clear();
+        => StateManager.Clear(resetting: false);
 
     /// <summary>
     ///     <para>

src/EFCore/ChangeTracking/Internal/IStateManager.cs

@@ -457,7 +457,7 @@ IEnumerable<IUpdateEntry> GetDependentsUsingRelationshipSnapshot(
     ///     any release. You should only use it directly in your code with extreme caution and knowing that
     ///     doing so can result in application failures when updating to a new Entity Framework Core release.
     /// </summary>
-    void Unsubscribe();
+    void Unsubscribe(bool resetting);
 
     /// <summary>
     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
@@ -584,5 +584,5 @@ void SetEvents(
     ///     any release. You should only use it directly in your code with extreme caution and knowing that
     ///     doing so can result in application failures when updating to a new Entity Framework Core release.
     /// </summary>
-    void Clear();
+    void Clear(bool resetting);
 }

src/EFCore/ChangeTracking/Internal/InternalEntityEntry.cs

@@ -470,26 +470,29 @@ private void FireStateChanged(EntityState oldState)
 
     private void SetServiceProperties(EntityState oldState, EntityState newState)
     {
-        if (oldState == EntityState.Detached)
+        if (EntityType.HasServiceProperties())
         {
-            foreach (var serviceProperty in EntityType.GetServiceProperties())
+            if (oldState == EntityState.Detached)
             {
-                this[serviceProperty] = (this[serviceProperty] is IInjectableService injectableService
-                        ? injectableService.Attaching(Context, Entity, injectableService)
-                        : null)
-                    ?? serviceProperty
-                        .ParameterBinding
-                        .ServiceDelegate(new MaterializationContext(ValueBuffer.Empty, Context), EntityType, Entity);
+                foreach (var serviceProperty in EntityType.GetServiceProperties())
+                {
+                    this[serviceProperty] = (this[serviceProperty] is IInjectableService injectableService
+                            ? injectableService.Attaching(Context, Entity, injectableService)
+                            : null)
+                        ?? serviceProperty
+                            .ParameterBinding
+                            .ServiceDelegate(new MaterializationContext(ValueBuffer.Empty, Context), EntityType, Entity);
+                }
             }
-        }
-        else if (newState == EntityState.Detached)
-        {
-            foreach (var serviceProperty in EntityType.GetServiceProperties())
+            else if (newState == EntityState.Detached)
             {
-                if (!(this[serviceProperty] is IInjectableService detachable)
-                    || detachable.Detaching(Context, Entity))
+                foreach (var serviceProperty in EntityType.GetServiceProperties())
                 {
-                    this[serviceProperty] = null;
+                    if (!(this[serviceProperty] is IInjectableService detachable)
+                        || detachable.Detaching(Context, Entity))
+                    {
+                        this[serviceProperty] = null;
+                    }
                 }
             }
         }
@@ -2030,6 +2033,11 @@ public bool IsLoaded(INavigationBase navigation)
 
     private ILazyLoader? GetLazyLoader()
     {
+        if (!EntityType.HasServiceProperties())
+        {
+            return null;
+        }
+
         var lazyLoaderProperty = EntityType.GetServiceProperties().FirstOrDefault(p => p.ClrType == typeof(ILazyLoader));
         return lazyLoaderProperty != null ? (ILazyLoader?)this[lazyLoaderProperty] : null;
     }

src/EFCore/ChangeTracking/Internal/StateManager.cs

@@ -22,6 +22,7 @@ public class StateManager : IStateManager
     private IIdentityMap? _identityMap1;
     private Dictionary<IKey, IIdentityMap>? _identityMaps;
     private bool _needsUnsubscribe;
+    private bool _hasServiceProperties;
     private IChangeDetector? _changeDetector;
 
     private readonly IDiagnosticsLogger<DbLoggerCategory.ChangeTracking> _changeTrackingLogger;
@@ -361,6 +362,11 @@ public virtual InternalEntityEntry StartTrackingFromQuery(
             _needsUnsubscribe = true;
         }
 
+        if (newEntry.EntityType.HasServiceProperties())
+        {
+            _hasServiceProperties = true;
+        }
+
         return newEntry;
     }
 
@@ -600,6 +606,11 @@ public virtual InternalEntityEntry StartTracking(InternalEntityEntry entry)
             _needsUnsubscribe = true;
         }
 
+        if (entry.EntityType.HasServiceProperties())
+        {
+            _hasServiceProperties = true;
+        }
+
         return entry;
     }
 
@@ -661,7 +672,7 @@ public virtual void StopTracking(InternalEntityEntry entry, EntityState oldState
     ///     any release. You should only use it directly in your code with extreme caution and knowing that
     ///     doing so can result in application failures when updating to a new Entity Framework Core release.
     /// </summary>
-    public virtual void Unsubscribe()
+    public virtual void Unsubscribe(bool resetting)
     {
         if (_needsUnsubscribe)
         {
@@ -670,6 +681,27 @@ public virtual void Unsubscribe()
                 _internalEntityEntrySubscriber.Unsubscribe(entry);
             }
         }
+
+        if (_hasServiceProperties)
+        {
+            foreach (var entry in Entries)
+            {
+                foreach (var serviceProperty in entry.EntityType.GetServiceProperties())
+                {
+                    var service = entry[serviceProperty];
+                    if (resetting
+                        && service is IDisposable disposable)
+                    {
+                        disposable.Dispose();
+                    }
+                    else if (!(service is IInjectableService detachable)
+                             || detachable.Detaching(Context, entry.Entity))
+                    {
+                        entry[serviceProperty] = null;
+                    }
+                }
+            }
+        }
     }
 
     /// <summary>
@@ -680,7 +712,7 @@ public virtual void Unsubscribe()
     /// </summary>
     public virtual void ResetState()
     {
-        Clear();
+        Clear(resetting: true);
         Dependencies.NavigationFixer.AbortDelayedFixup();
         _changeDetector?.ResetState();
 
@@ -696,9 +728,9 @@ public virtual void ResetState()
     ///     any release. You should only use it directly in your code with extreme caution and knowing that
     ///     doing so can result in application failures when updating to a new Entity Framework Core release.
     /// </summary>
-    public virtual void Clear()
+    public virtual void Clear(bool resetting)
     {
-        Unsubscribe();
+        Unsubscribe(resetting);
         ChangedCount = 0;
         _entityReferenceMap.Clear();
         _referencedUntrackedEntities = null;
@@ -708,6 +740,7 @@ public virtual void Clear()
         _identityMap1?.Clear();
 
         _needsUnsubscribe = false;
+        _hasServiceProperties = false;
 
         SavingChanges = false;
 

src/EFCore/DbContext.cs

@@ -1092,7 +1092,7 @@ private bool DisposeSync(bool leaseActive, bool contextShouldBeDisposed)
 
             _disposed = true;
 
-            _dbContextDependencies?.StateManager.Unsubscribe();
+            _dbContextDependencies?.StateManager.Unsubscribe(resetting: true);
 
             _dbContextDependencies = null;
             _changeTracker = null;

src/EFCore/Internal/EntityFinder.cs

@@ -447,7 +447,7 @@ public virtual void Load(INavigation navigation, InternalEntityEntry entry, bool
                 {
                     if (stateManager != _stateManager)
                     {
-                        stateManager.ResetState();
+                        stateManager.Clear(resetting: false);
                     }
                 }
             }
@@ -509,7 +509,7 @@ public virtual async Task LoadAsync(
                 {
                     if (stateManager != _stateManager)
                     {
-                        await stateManager.ResetStateAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
+                        stateManager.Clear(resetting: false);
                     }
                 }
             }

src/EFCore/Internal/ManyToManyLoader.cs

@@ -61,7 +61,7 @@ public virtual void Load(InternalEntityEntry entry, bool forceIdentityResolution
                 {
                     if (stateManager != entry.StateManager)
                     {
-                        stateManager.ResetState();
+                        stateManager.Clear(resetting: false);
                     }
                 }
             }
@@ -106,7 +106,7 @@ public virtual async Task LoadAsync(
                 {
                     if (stateManager != entry.StateManager)
                     {
-                        await stateManager.ResetStateAsync(cancellationToken).ConfigureAwait(false);
+                        stateManager.Clear(resetting: false);
                     }
                 }
             }

src/EFCore/Metadata/Conventions/ServicePropertyDiscoveryConvention.cs

@@ -81,7 +81,8 @@ void DiscoverServiceProperties(IEnumerable<MemberInfo> members)
                 }
 
                 var memberType = memberInfo.GetMemberType();
-                if (entityType.GetServiceProperties().Any(p => p.ClrType == memberType))
+                if (entityType.HasServiceProperties()
+                    && entityType.GetServiceProperties().Any(p => p.ClrType == memberType))
                 {
                     continue;
                 }

src/EFCore/Metadata/IReadOnlyEntityType.cs

@@ -741,6 +741,12 @@ IReadOnlyProperty GetProperty(string name)
     /// <returns>Derived service properties.</returns>
     IEnumerable<IReadOnlyServiceProperty> GetDerivedServiceProperties();
 
+    /// <summary>
+    ///     Checks whether or not this entity type has any <see cref="IServiceProperty" /> defined.
+    /// </summary>
+    /// <returns><see langword="true"/> if there are any service properties defined on this entity type or base types.</returns>
+    bool HasServiceProperties();
+
     /// <summary>
     ///     Gets all the <see cref="IReadOnlyServiceProperty" /> defined on this entity type.
     /// </summary>

src/EFCore/Metadata/Internal/EntityType.cs

@@ -2939,6 +2939,15 @@ public virtual ServiceProperty RemoveServiceProperty(ServiceProperty property)
         return property;
     }
 
+    /// <summary>
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+    /// </summary>
+    public virtual bool HasServiceProperties()
+        => _serviceProperties.Count != 0 || _baseType != null && _baseType.HasServiceProperties();
+
     /// <summary>
     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
     ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
@@ -5252,6 +5261,16 @@ IEnumerable<IServiceProperty> IEntityType.GetDeclaredServiceProperties()
     IEnumerable<IReadOnlyServiceProperty> IReadOnlyEntityType.GetDerivedServiceProperties()
         => GetDerivedServiceProperties();
 
+    /// <summary>
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+    /// </summary>
+    [DebuggerStepThrough]
+    bool IReadOnlyEntityType.HasServiceProperties()
+        => HasServiceProperties();
+
     /// <summary>
     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
     ///     the same compatibility standards as public APIs. It may be changed or removed without notice in

src/EFCore/Metadata/RuntimeEntityType.cs

@@ -763,6 +763,9 @@ public virtual RuntimeServiceProperty AddServiceProperty(
             ? property
             : null;
 
+    private bool HasServiceProperties()
+        => _serviceProperties.Count != 0 || _baseType != null && _baseType.HasServiceProperties();
+
     private IEnumerable<RuntimeServiceProperty> GetServiceProperties()
         => _baseType != null
             ? _serviceProperties.Count == 0
@@ -1395,6 +1398,11 @@ IEnumerable<IServiceProperty> IEntityType.GetDeclaredServiceProperties()
     IEnumerable<IReadOnlyServiceProperty> IReadOnlyEntityType.GetDerivedServiceProperties()
         => GetDerivedServiceProperties();
 
+    /// <inheritdoc />
+    [DebuggerStepThrough]
+    bool IReadOnlyEntityType.HasServiceProperties()
+        => HasServiceProperties();
+
     /// <inheritdoc />
     [DebuggerStepThrough]
     IEnumerable<IReadOnlyServiceProperty> IReadOnlyEntityType.GetServiceProperties()

test/EFCore.Cosmos.FunctionalTests/TestUtilities/CosmosTestStore.cs

@@ -512,6 +512,9 @@ public IEnumerable<IReadOnlyProperty> GetDerivedProperties()
         public IEnumerable<IReadOnlyServiceProperty> GetDerivedServiceProperties()
             => throw new NotImplementedException();
 
+        public bool HasServiceProperties()
+            => throw new NotImplementedException();
+
         public IEnumerable<IReadOnlySkipNavigation> GetDerivedSkipNavigations()
             => throw new NotImplementedException();