Use StateLifetimeToken to control results cached in QueryResult

Also fix session's lifetime token immortality issue

Author: alex-kulakov

Orm/Xtensive.Orm/Orm/Linq/Materialization/Materializer.cs

@@ -16,7 +16,7 @@ public QueryResult<T> Invoke<T>(RecordSetReader recordSetReader, Session session
     {
       var reader = (IMaterializingReader<T>)
         materializeMethod.Invoke(recordSetReader, session, parameterContext);
-      return new QueryResult<T>(reader);
+      return new QueryResult<T>(reader, session.GetLifetimeToken());
     }
 
     public Materializer(Func<RecordSetReader,Session,ParameterContext,object> materializeMethod)

Orm/Xtensive.Orm/Orm/QueryResult.cs

@@ -2,6 +2,7 @@
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using Xtensive.Orm.Linq.Materialization;
@@ -29,32 +30,47 @@ public EnumerableReader(IEnumerable<TItem> items)
     }
 
     private readonly IMaterializingReader<TItem> reader;
+    private readonly StateLifetimeToken lifetimeToken;
 
     /// <inheritdoc/>
     IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
     /// <inheritdoc/>
-    public IEnumerator<TItem> GetEnumerator() => reader.AsEnumerator();
+    public IEnumerator<TItem> GetEnumerator()
+    {
+      EnsureResultsAlive();
+      return reader.AsEnumerator();
+    }
 
     /// <summary>
     /// Transforms <see cref="QueryResult{TItem}"/> to an <see cref="IAsyncEnumerable{T}"/> sequence.
     /// </summary>
     public async IAsyncEnumerable<TItem> AsAsyncEnumerable()
     {
+      EnsureResultsAlive();
       var enumerator = reader.AsAsyncEnumerator();
       while (await enumerator.MoveNextAsync().ConfigureAwait(false)) {
         yield return enumerator.Current;
       }
     }
 
-    internal QueryResult(IMaterializingReader<TItem> reader)
+    private void EnsureResultsAlive()
+    {
+      if (lifetimeToken != null && !lifetimeToken.IsActive) {
+        throw new InvalidOperationException(Strings.ExThisInstanceIsExpiredDueToTransactionBoundaries);
+      }
+    }
+
+    internal QueryResult(IMaterializingReader<TItem> reader, StateLifetimeToken lifetimeToken)
     {
       this.reader = reader;
+      this.lifetimeToken = lifetimeToken;
     }
 
     internal QueryResult(IEnumerable<TItem> items)
     {
       reader = new EnumerableReader(items);
+      this.lifetimeToken = default;
     }
   }
 }

Orm/Xtensive.Orm/Orm/Session.cs

@@ -585,6 +585,8 @@ private async ValueTask DisposeImpl(bool isAsync)
         return;
       }
 
+      sessionLifetimeToken.Expire();
+
       try {
         if (IsDebugEventLoggingEnabled) {
           OrmLog.Debug(Strings.LogSessionXDisposing, this);