Use ref struct as disposable instance to avoid allocation. Also avoids closure allocation

Author: AlexUstinov

Orm/Xtensive.Orm/Collections/BindingCollection.cs

@@ -8,7 +8,6 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
-using Xtensive.Core;
 
 
 namespace Xtensive.Collections
@@ -21,8 +20,50 @@ namespace Xtensive.Collections
   /// </summary>
   [Serializable]
   [DebuggerDisplay("Count = {Count}")]
-  public class BindingCollection<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>
+  public class BindingCollection<TKey, TValue> : IReadOnlyCollection<KeyValuePair<TKey, TValue>>
   {
+    public readonly ref struct BindingScope
+    {
+      public static BindingScope Empty => new BindingScope();
+
+      private readonly BindingCollection<TKey, TValue> owner;
+      private readonly TKey key;
+      private readonly TValue prevValue;
+      private readonly bool prevValueExists;
+
+      public void Dispose()
+      {
+        if (owner == null) {
+          return;
+        }
+
+        if (prevValueExists) {
+          if (!owner.permanentBindings.Contains(key)) {
+            owner.bindings[key] = prevValue;
+          }
+        }
+        else {
+          if (!owner.permanentBindings.Contains(key)) {
+            owner.bindings.Remove(key);
+          }
+        }
+      }
+
+      public BindingScope(BindingCollection<TKey, TValue> owner, TKey key) : this()
+      {
+        this.owner = owner;
+        this.key = key;
+      }
+
+      public BindingScope(BindingCollection<TKey, TValue> owner, TKey key, TValue prevValue)
+      {
+        this.owner = owner;
+        this.key = key;
+        this.prevValue = prevValue;
+        prevValueExists = true;
+      }
+    }
+
     [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
     private readonly Dictionary<TKey, TValue> bindings = new Dictionary<TKey, TValue>();
     private readonly HashSet<TKey> permanentBindings = new HashSet<TKey>();
@@ -32,7 +73,7 @@ public class BindingCollection<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TV
     /// </summary>
     public virtual int Count {
       [DebuggerStepThrough]
-      get { return bindings.Count; }
+      get => bindings.Count;
     }
 
     /// <summary>
@@ -41,7 +82,7 @@ public virtual int Count {
     /// <value></value>
     public virtual TValue this[TKey key] {
       [DebuggerStepThrough]
-      get { return bindings[key]; }
+      get => bindings[key];
     }
 
     /// <summary>
@@ -51,24 +92,15 @@ public virtual TValue this[TKey key] {
     /// <param name="value">The value to bind.</param>
     /// <returns>Disposable object that will 
     /// destroy the binding on its disposal.</returns>
-    public virtual IDisposable Add(TKey key, TValue value)
+    public virtual BindingScope Add(TKey key, TValue value)
     {
-      TValue previous;
-
-      if (bindings.TryGetValue(key, out previous)) {
+      if (bindings.TryGetValue(key, out var previous)) {
         bindings[key] = value;
-        return new Disposable(isDisposing => {
-          if (!permanentBindings.Contains(key))
-            bindings[key] = previous;
-        });
-      }
-      else {
-        bindings.Add(key, value);
-        return new Disposable(isDisposing => {
-          if (!permanentBindings.Contains(key))
-            bindings.Remove(key);
-        });
+        return new BindingScope(this, key, previous);
       }
+
+      bindings.Add(key, value);
+      return new BindingScope(this, key);
     }
 
     /// <summary>
@@ -80,8 +112,9 @@ public virtual IDisposable Add(TKey key, TValue value)
     public virtual void PermanentAdd(TKey key, TValue value)
     {
       bindings[key] = value;
-      if (!permanentBindings.Contains(key))
+      if (!permanentBindings.Contains(key)) {
         permanentBindings.Add(key);
+      }
     }
 
     /// <summary>
@@ -92,8 +125,10 @@ public virtual void PermanentAdd(TKey key, TValue value)
     /// <exception cref="KeyNotFoundException">Key isn't found.</exception>
     public virtual void ReplaceBound(TKey key, TValue value)
     {
-      if (!bindings.ContainsKey(key))
+      if (!bindings.ContainsKey(key)) {
         throw new KeyNotFoundException();
+      }
+
       bindings[key] = value;
     }
 
@@ -108,45 +143,27 @@ public virtual void ReplaceBound(TKey key, TValue value)
     /// contains an element with the specified key;
     /// otherwise, <see langword="false" />.</returns>
     [DebuggerStepThrough]
-    public virtual bool TryGetValue(TKey key, out TValue value)
-    {
-      return bindings.TryGetValue(key, out value);
-    }
+    public virtual bool TryGetValue(TKey key, out TValue value) => bindings.TryGetValue(key, out value);
 
     /// <summary>
     /// Gets the sequence of bound keys.
     /// </summary>
     /// <returns>The sequence of bound keys.</returns>
     public virtual IEnumerable GetKeys()
     {
-      foreach (var key in bindings.Keys)
+      foreach (var key in bindings.Keys) {
         yield return key;
+      }
     }
 
     #region IEnumerable<...> methods
 
     /// <inheritdoc/>
-    public virtual IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
-    {
-      return bindings.GetEnumerator();
-    }
+    public virtual IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() => bindings.GetEnumerator();
 
     /// <inheritdoc/>
-    IEnumerator IEnumerable.GetEnumerator()
-    {
-      return GetEnumerator();
-    }
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
     #endregion
-
-
-    // Constructors
-
-    /// <summary>
-    /// Initializes new instance of this type.
-    /// </summary>
-    public BindingCollection()
-    {
-    }
   }
 }

Orm/Xtensive.Orm/Orm/Linq/LinqBindingCollection.cs

@@ -19,10 +19,13 @@ internal class LinqBindingCollection : BindingCollection<ParameterExpression, Pr
     private readonly Dictionary<ParameterExpression, IEnumerable<ParameterExpression>> linkedParameters
       = new Dictionary<ParameterExpression, IEnumerable<ParameterExpression>>();
 
-    public override IDisposable Add(ParameterExpression key, ProjectionExpression value)
+    public override BindingScope Add(ParameterExpression key, ProjectionExpression value)
     {
-      if (!key.Type.IsAssignableFrom(value.ItemProjector.Type))
-        throw new ArgumentException(Strings.ExParameterExpressionMustHaveSameTypeAsProjectionExpressionItemProjector, "key");
+      if (!key.Type.IsAssignableFrom(value.ItemProjector.Type)) {
+        throw new ArgumentException(
+          Strings.ExParameterExpressionMustHaveSameTypeAsProjectionExpressionItemProjector, nameof(key));
+      }
+
       return base.Add(key, value);
     }
 

Orm/Xtensive.Orm/Orm/Linq/Translator.Queryable.cs

@@ -1072,7 +1072,7 @@ private ProjectionExpression VisitSelectMany(Expression source, LambdaExpression
       var visitedSource = Visit(source);
       var sequence = VisitSequence(visitedSource);
 
-      IDisposable indexBinding = null;
+      var indexBinding = BindingCollection<ParameterExpression, ProjectionExpression>.BindingScope.Empty;
       if (collectionSelector.Parameters.Count==2) {
         var indexProjection = GetIndexBinding(collectionSelector, ref sequence);
         indexBinding = context.Bindings.Add(collectionSelector.Parameters[1], indexProjection);
@@ -1191,7 +1191,7 @@ private ProjectionExpression VisitWhere(Expression expression, LambdaExpression
     {
       var parameter = le.Parameters[0];
       ProjectionExpression visitedSource = VisitSequence(expression);
-      IDisposable indexBinding = null;
+      var indexBinding = BindingCollection<ParameterExpression, ProjectionExpression>.BindingScope.Empty;
       if (le.Parameters.Count==2) {
         var indexProjection = GetIndexBinding(le, ref visitedSource);
         indexBinding = context.Bindings.Add(le.Parameters[1], indexProjection);