Introduce readonly structure RegistryItems wrapper

Improves enumeration performance

Author: alex-kulakov

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

@@ -6,7 +6,6 @@
 
 using System;
 using System.Collections.Generic;
-using Xtensive.Collections;
 
 
 namespace Xtensive.Orm.Internals
@@ -19,12 +18,11 @@ 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;
 
     /// <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.
@@ -35,7 +33,7 @@ internal void Register(EntityState item)
       // Remove-create sequences fix for Issue 690
       if (item.PersistenceState == PersistenceState.New && removed.Contains(item)) {
         removed.Remove(item);
-        count--;
+        Count--;
         if (item.DifferentialTuple.Difference == null) {
           item.SetPersistenceState(PersistenceState.Synchronized);
           return;
@@ -44,57 +42,50 @@ internal void Register(EntityState item)
       }
       else if (item.PersistenceState == PersistenceState.Removed && @new.Contains(item)) {
         @new.Remove(item);
-        count--;
+        Count--;
         return;
       }
       else if (item.PersistenceState == PersistenceState.Removed && modified.Contains(item)) {
         modified.Remove(item);
-        count--;
+        Count--;
       }
 
       var container = GetContainer(item.PersistenceState);
       if (container.Add(item))
-        count++;
+        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 RegistryItems<EntityState>(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("state"),
+      };
     }
 
-    
+
     // Constructors
 
     /// <summary>

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

@@ -33,10 +33,8 @@ public void Register(EntitySetState entitySetState)
     /// Gets all registered items.
     /// </summary>
     /// <returns></returns>
-    public IEnumerable<EntitySetState> GetItems()
-    {
-      return modifiedEntitySets;
-    }
+    public RegistryItems<EntitySetState> GetItems() =>
+      new RegistryItems<EntitySetState>(modifiedEntitySets);
 
     public void Clear()
     {

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

@@ -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/ChangeRegistries/ReferenceFieldsChangesRegistry.cs

@@ -51,10 +51,7 @@ 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.

Orm/Xtensive.Orm/Orm/Internals/ChangeRegistries/RegistryItems{T}.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/Services/DirectSessionAccessor.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/Old/SessionStateAccessor.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/VersionCapturer.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