Merge pull request #283 from DataObjects-NET/master-faster-registry-enumerations

XxxChangeRegistry.GetItems() methods' results are faster to enumerate

Author: alex-kulakov

ChangeLog/7.1.0-Beta-2-dev.txt

@@ -12,6 +12,9 @@
 [main] SqlCustomFunctionCall and SqlFunctionCall share one base type
 [main] SqlFunctionCall.Arguments property is IReadOnlyList now and parameters can't be changed after instance creation
 [main] Xtensive.Sql.Dml.Extensions.IsNullReference() extension method is marked obsolete, use 'is null' operator instead
+[main] DirectSessionAccessor.GetChangedEntities() result type changed to improve enumeration
+[main] EntityChangeRegistry.GetItems(PersistenceState) changed result type to improve enumeration
+[main] EntitySetChangeRegistry.GetItems() changed result type to improve enumeration
 [main] IgnoreRule now has only one public constructor - parameterless
 [main] IgnoreRule supports indexes
 [main] BitFaster.Caching package reference is updated to 1.0.7

Orm/Xtensive.Orm/Orm/Internals/EntityChangeRegistry.cs renamed to Orm/Xtensive.Orm/Orm/Internals/ChangeRegistries/EntityChangeRegistry.cs

@@ -1,12 +1,11 @@
-// Copyright (C) 2008-2020 Xtensive LLC.
+// Copyright (C) 2008-2022 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 // Created by: Dmitri Maximov
 // Created:    2008.11.03
 
 using System;
 using System.Collections.Generic;
-using Xtensive.Collections;
 
 
 namespace Xtensive.Orm.Internals
@@ -16,15 +15,14 @@ namespace Xtensive.Orm.Internals
   /// </summary>
   public sealed class EntityChangeRegistry : SessionBound
   {
-    private readonly HashSet<EntityState> @new = new HashSet<EntityState>();
-    private readonly HashSet<EntityState> modified = new HashSet<EntityState>();
-    private readonly HashSet<EntityState> removed = new HashSet<EntityState>();
-    private int count;
+    private readonly HashSet<EntityState> @new = new();
+    private readonly HashSet<EntityState> modified = new();
+    private readonly HashSet<EntityState> removed = new();
 
     /// <summary>
     /// Gets the number of registered entities.
     /// </summary>
-    public int Count { get { return count; } }
+    public int Count { get; private set; }
 
     /// <summary>
     /// Registers the specified item.
@@ -34,67 +32,61 @@ internal void Register(EntityState item)
     {
       // Remove-create sequences fix for Issue 690
       if (item.PersistenceState == PersistenceState.New && removed.Contains(item)) {
-        removed.Remove(item);
-        count--;
+        _ = removed.Remove(item);
+        Count--;
         if (item.DifferentialTuple.Difference == null) {
           item.SetPersistenceState(PersistenceState.Synchronized);
           return;
         }
         item.SetPersistenceState(PersistenceState.Modified);
       }
       else if (item.PersistenceState == PersistenceState.Removed && @new.Contains(item)) {
-        @new.Remove(item);
-        count--;
+        _ = @new.Remove(item);
+        Count--;
         return;
       }
       else if (item.PersistenceState == PersistenceState.Removed && modified.Contains(item)) {
-        modified.Remove(item);
-        count--;
+        _ = modified.Remove(item);
+        Count--;
       }
 
       var container = GetContainer(item.PersistenceState);
-      if (container.Add(item))
-        count++;
+      if (container.Add(item)) {
+        Count++;
+      }
     }
 
     /// <summary>
     /// Gets the items with specified <paramref name="state"/>.
     /// </summary>
     /// <param name="state">The state of items to get.</param>
     /// <returns>The sequence of items with specified state.</returns>
-    public IEnumerable<EntityState> GetItems(PersistenceState state)
-    {
-      foreach (var item in GetContainer(state))
-        yield return item;
-    }
+    public RegistryItems<EntityState> GetItems(in PersistenceState state) =>
+      new(GetContainer(state));
 
     /// <summary>
     /// Clears the registry.
     /// </summary>
     public void Clear()
     {
-      count = 0;
+      Count = 0;
       @new.Clear();
       modified.Clear();
       removed.Clear();
     }
 
     /// <exception cref="ArgumentOutOfRangeException"><paramref name="state"/> is out of range.</exception>
-    private HashSet<EntityState> GetContainer(PersistenceState state)
+    private HashSet<EntityState> GetContainer(in PersistenceState state)
     {
-      switch (state) {
-      case PersistenceState.New:
-        return @new;
-      case PersistenceState.Modified:
-        return modified;
-      case PersistenceState.Removed:
-        return removed;
-      default:
-        throw new ArgumentOutOfRangeException("state");
-      }
+      return state switch {
+        PersistenceState.New => @new,
+        PersistenceState.Modified => modified,
+        PersistenceState.Removed => removed,
+        _ => throw new ArgumentOutOfRangeException(nameof(state)),
+      };
     }
 
-    
+
     // Constructors
 
     /// <summary>

Orm/Xtensive.Orm/Orm/Internals/EntitySetChangeRegistry.cs renamed to Orm/Xtensive.Orm/Orm/Internals/ChangeRegistries/EntitySetChangeRegistry.cs

@@ -1,6 +1,6 @@
-// Copyright (C) 2014 Xtensive LLC.
-// All rights reserved.
-// For conditions of distribution and use, see license.
+// Copyright (C) 2014-2022 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
 // Created by: Alexey Kulakov
 // Created:    2014.03.27
 
@@ -13,7 +13,7 @@ namespace Xtensive.Orm.Internals
   /// </summary>
   public sealed class EntitySetChangeRegistry : SessionBound
   {
-    private readonly HashSet<EntitySetState> modifiedEntitySets = new HashSet<EntitySetState>();
+    private readonly HashSet<EntitySetState> modifiedEntitySets = new();
 
     /// <summary>
     /// Count of registered <see cref="EntitySetState"/>.
@@ -24,24 +24,18 @@ public sealed class EntitySetChangeRegistry : SessionBound
     /// Register the specified <see cref="EntitySetState"/>.
     /// </summary>
     /// <param name="entitySetState"><see cref="EntitySetState"/> to bound.</param>
-    public void Register(EntitySetState entitySetState)
-    {
-      modifiedEntitySets.Add(entitySetState);
-    }
+    public void Register(EntitySetState entitySetState) => modifiedEntitySets.Add(entitySetState);
 
     /// <summary>
     /// Gets all registered items.
     /// </summary>
     /// <returns></returns>
-    public IEnumerable<EntitySetState> GetItems()
-    {
-      return modifiedEntitySets;
-    }
+    public RegistryItems<EntitySetState> GetItems() => new(modifiedEntitySets);
 
-    public void Clear()
-    {
-      modifiedEntitySets.Clear();
-    }
+    /// <summary>
+    /// Clears the registry.
+    /// </summary>
+    public void Clear() => modifiedEntitySets.Clear();
 
     /// <summary>
     /// Initializes a new instance of this class.

Orm/Xtensive.Orm/Orm/Internals/NonPairedReferenceChangesRegistry.cs renamed to Orm/Xtensive.Orm/Orm/Internals/ChangeRegistries/NonPairedReferenceChangesRegistry.cs

@@ -1,6 +1,6 @@
-// Copyright (C) 2014 Xtensive LLC.
-// All rights reserved.
-// For conditions of distribution and use, see license.
+// Copyright (C) 2014-2022 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
 // Created by: Alexey Kulakov
 // Created:    2014.04.07
 
@@ -16,22 +16,22 @@ internal sealed class ReferenceFieldChangeInfo
     /// <summary>
     /// Gets key of entity that owns the <see cref="ReferenceFieldChangeInfo.Field"/>.
     /// </summary>
-    public Key FieldOwner { get; private set; }
+    public Key FieldOwner { get; }
 
     /// <summary>
     /// Gets value of field which was set.
     /// </summary>
-    public Key FieldValue { get; private set; }
+    public Key FieldValue { get; }
 
     /// <summary>
     /// Gets field which was set.
     /// </summary>
-    public FieldInfo Field { get; private set; }
+    public FieldInfo Field { get; }
 
     /// <summary>
     /// Auxiliary entity which associated with <see cref="EntitySet{T}"/>.
     /// </summary>
-    public Key AuxiliaryEntity { get; private set; }
+    public Key AuxiliaryEntity { get; }
 
     public ReferenceFieldChangeInfo(Key fieldOwner, Key fieldValue, FieldInfo field)
     {

Orm/Xtensive.Orm/Orm/Internals/ReferenceFieldChangeInfo.cs renamed to Orm/Xtensive.Orm/Orm/Internals/ChangeRegistries/ReferenceFieldChangeInfo.cs

@@ -1,6 +1,6 @@
-// Copyright (C) 2014 Xtensive LLC.
-// All rights reserved.
-// For conditions of distribution and use, see license.
+// Copyright (C) 2014-2022 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
 // Created by: Alexey Kulakov
 // Created:    2014.04.07
 
@@ -15,7 +15,7 @@ namespace Xtensive.Orm.Internals
   /// </summary>
   internal sealed class ReferenceFieldsChangesRegistry : SessionBound
   {
-    private readonly HashSet<ReferenceFieldChangeInfo> changes = new HashSet<ReferenceFieldChangeInfo>();
+    private readonly HashSet<ReferenceFieldChangeInfo> changes = new ();
 
     /// <summary>
     /// Registrates information about field which value was set.
@@ -51,23 +51,14 @@ public void Register(Key fieldOwner, Key fieldValue, Key auxiliaryEntity, FieldI
     /// Gets all registered items.
     /// </summary>
     /// <returns>All registered items.</returns>
-    public IEnumerable<ReferenceFieldChangeInfo> GetItems()
-    {
-      return changes;
-    }
+    public RegistryItems<ReferenceFieldChangeInfo> GetItems() => new(changes);
 
     /// <summary>
     /// Removes all registered items.
     /// </summary>
-    public void Clear()
-    {
-      changes.Clear();
-    }
+    public void Clear() => changes.Clear();
 
-    private void Register(ReferenceFieldChangeInfo fieldChangeInfo)
-    {
-      changes.Add(fieldChangeInfo);
-    }
+    private void Register(ReferenceFieldChangeInfo fieldChangeInfo) => changes.Add(fieldChangeInfo);
 
     public ReferenceFieldsChangesRegistry(Session session)
       : base(session)

Orm/Xtensive.Orm/Orm/Internals/ReferenceFieldsChangesRegistry.cs renamed to Orm/Xtensive.Orm/Orm/Internals/ChangeRegistries/ReferenceFieldsChangesRegistry.cs

@@ -0,0 +1,42 @@
+// Copyright (C) 2022 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
+
+using System.Collections;
+using System.Collections.Generic;
+
+
+namespace Xtensive.Orm.Internals
+{
+  /// <summary>
+  /// Items of registry (e.g. <see cref="EntityChangeRegistry"/> or <see cref="EntitySetChangeRegistry"/>)
+  /// </summary>
+  public readonly struct RegistryItems<T> : IReadOnlyCollection<T>
+  {
+    private readonly HashSet<T> hashSet;
+
+    /// <inheritdoc/>
+    public int Count => hashSet.Count;
+
+    /// <summary>
+    /// Gets bare enumerator of internal collection so faster
+    /// enumeration is available
+    /// </summary>
+    /// <returns><see cref="HashSet{T}.Enumerator"/>.</returns>
+    public HashSet<T>.Enumerator GetEnumerator()
+      => hashSet.GetEnumerator();
+
+    /// <inheritdoc/>
+    IEnumerator<T> IEnumerable<T>.GetEnumerator()
+      => hashSet.GetEnumerator();
+
+    /// <inheritdoc/>
+    IEnumerator IEnumerable.GetEnumerator()
+      => hashSet.GetEnumerator();
+
+    public RegistryItems(HashSet<T> hashset)
+    {
+      hashSet = hashset;
+    }
+  }
+}

Orm/Xtensive.Orm/Orm/Internals/ChangeRegistries/RegistryItems{T}.cs

@@ -8,6 +8,7 @@
 using System.Collections.Generic;
 using Xtensive.Core;
 using Xtensive.IoC;
+using Xtensive.Orm.Internals;
 using Xtensive.Orm.Providers;
 
 namespace Xtensive.Orm.Services
@@ -76,7 +77,7 @@ public IDisposable NullifySessionTransaction()
     /// </summary>
     /// <param name="persistenceState">Type of entity change.</param>
     /// <returns><see cref="EntityState"/>s with the specified <paramref name="persistenceState"/>.</returns>
-    public IEnumerable<EntityState> GetChangedEntities(PersistenceState persistenceState)
+    public RegistryItems<EntityState> GetChangedEntities(PersistenceState persistenceState)
     {
       return Session.EntityChangeRegistry.GetItems(persistenceState);
     }

Orm/Xtensive.Orm/Orm/Services/DirectSessionAccessor.cs

@@ -58,7 +58,7 @@ public Entity this[Key key] {
     /// </summary>
     public void Invalidate()
     {
-      if (Session.EntityChangeRegistry.GetItems(PersistenceState.New).Any())
+      if (Session.EntityChangeRegistry.GetItems(PersistenceState.New).Count > 0)
         throw new InvalidOperationException(Strings.UnableToInvalidateSessionStateNewlyCreatedEntitiesAreAttachedToSession);
       Session.Invalidate();
     }

Orm/Xtensive.Orm/Orm/Services/Old/SessionStateAccessor.cs

@@ -67,13 +67,21 @@ private void TransactionOpened(object sender, TransactionEventArgs transactionEv
     private void Persisting(object sender, EventArgs eventArgs)
     {
       var registry = Session.EntityChangeRegistry;
-      var modifiedStates = registry.GetItems(PersistenceState.Modified)
-        .Concat(registry.GetItems(PersistenceState.New));
-      foreach (var state in modifiedStates) {
-        var versionTuple = state.Type.VersionExtractor.Apply(TupleTransformType.Tuple, state.Tuple);
-        modifiedVersions.Add(state.Key, new VersionInfo(versionTuple), true);
+      //two foreach operators are faster than one concat because of bare hashset enumerator
+      foreach(var state in registry.GetItems(PersistenceState.Modified)) {
+        AddModifiedVersion(state);
+      }
+      foreach (var state in registry.GetItems(PersistenceState.New)) {
+        AddModifiedVersion(state);
       }
+       
       removedKeys.AddRange(registry.GetItems(PersistenceState.Removed).Select(s => s.Key));
+
+      void AddModifiedVersion(EntityState state)
+      {
+        var versionTuple = state.Type.VersionExtractor.Apply(TupleTransformType.Tuple, state.Tuple);
+        _ = modifiedVersions.Add(state.Key, new VersionInfo(versionTuple), true);
+      }
     }
 
     #endregion