Applies SessionScope/Scope changes from master

Author: alex-kulakov

Orm/Xtensive.Orm/Core/Scope.cs

@@ -143,36 +143,37 @@ protected virtual void Dispose(bool disposing)
     /// <exception cref="InvalidOperationException">Current scope differs from this one.</exception>
     public void Dispose()
     {
-      bool bStop = false;
       Exception error = null;
-      while (!bStop) {
-        try {
-          if (currentScopeAsync==null) {
-            bStop = true;
-            throw new InvalidOperationException(Strings.ExScopeCantBeDisposed);
-          }
-          else if (currentScopeAsync.Value==this) {
-            bStop = true;
-            currentScopeAsync.Value.Dispose(true);
-          }
-          else {
-            currentScopeAsync.Value.Dispose();
+      try {
+        while (true) {
+          try {
+            var currentScope = currentScopeAsync.Value;
+            if (currentScope == null) {
+              throw new InvalidOperationException(Strings.ExScopeCantBeDisposed);
+            }
+
+            if (currentScope == this) {
+              currentScope.Dispose(true);
+              break;
+            }
+
+            currentScope.Dispose();
           }
-        }
-        catch (Exception e) {
-          if (error==null)
+          catch (Exception e) {
             error = e;
-          try {
             CoreLog.Error(e, Strings.LogScopeDisposeError);
+            break;
           }
-          catch {}
         }
       }
-      currentScopeAsync.Value = outerScope;
-      context = null;
-      outerScope = null;
-      if (error!=null)
-        throw error;
+      finally {
+        currentScopeAsync.Value = outerScope;
+        context = null;
+        outerScope = null;
+        if (error != null) {
+          throw error;
+        }
+      }
     }
   }
 }

Orm/Xtensive.Orm/Orm/Domain.cs

@@ -326,11 +326,22 @@ public Task<Session> OpenSessionAsync(SessionType type, CancellationToken cancel
     /// <seealso cref="Session"/>
     public Task<Session> OpenSessionAsync(SessionConfiguration configuration, CancellationToken cancellationToken = default)
     {
-      return OpenSessionInternalAsync(configuration, null,
-        configuration.Supports(SessionOptions.AutoActivation), cancellationToken);
+      ArgumentValidator.EnsureArgumentNotNull(configuration, nameof(configuration));
+
+      SessionScope sessionScope = null;
+      try {
+        if (configuration.Supports(SessionOptions.AutoActivation)) {
+          sessionScope = new SessionScope();
+        }
+        return OpenSessionInternalAsync(configuration, null, sessionScope, cancellationToken);
+      }
+      catch {
+        sessionScope?.Dispose();
+        throw;
+      }
     }
 
-    internal async Task<Session> OpenSessionInternalAsync(SessionConfiguration configuration, StorageNode storageNode, bool activate, CancellationToken cancellationToken)
+    internal async Task<Session> OpenSessionInternalAsync(SessionConfiguration configuration, StorageNode storageNode, SessionScope sessionScope, CancellationToken cancellationToken)
     {
       ArgumentValidator.EnsureArgumentNotNull(configuration, nameof(configuration));
 
@@ -358,10 +369,13 @@ internal async Task<Session> OpenSessionInternalAsync(SessionConfiguration confi
         // connection become opened.
         session = new Session(this, storageNode, configuration, false);
         try {
-          await ((SqlSessionHandler)session.Handler).OpenConnectionAsync(cancellationToken).ContinueWith((t) => {
-            if (activate)
-              session.ActivateInternally();
-          }, TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.ExecuteSynchronously).ConfigureAwait(false);
+          await ((SqlSessionHandler) session.Handler).OpenConnectionAsync(cancellationToken)
+            .ContinueWith(t => {
+              if (sessionScope != null) {
+                session.AttachToScope(sessionScope);
+              }
+            }, TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.ExecuteSynchronously)
+            .ConfigureAwait(false);
         }
         catch (OperationCanceledException) {
           session.DisposeSafely();

Orm/Xtensive.Orm/Orm/Session.cs

@@ -234,9 +234,10 @@ internal void EnsureNotDisposed()
         throw new ObjectDisposedException(Strings.ExSessionIsAlreadyDisposed);
     }
 
-    internal void ActivateInternally()
+    internal void AttachToScope(SessionScope sessionScope)
     {
-      disposableSet.Add(new SessionScope(this));
+      sessionScope.Session = this;
+      _ = disposableSet.Add(sessionScope);
     }
 
     internal EnumerationContext CreateEnumerationContext()
@@ -582,8 +583,9 @@ internal Session(Domain domain, StorageNode selectedStorageNode, SessionConfigur
       disableAutoSaveChanges = !configuration.Supports(SessionOptions.AutoSaveChanges);
 
       // Perform activation
-      if (activate)
-        ActivateInternally();
+      if (activate) {
+        AttachToScope(new SessionScope());
+      }
 
       // Query endpoint
       SystemQuery = Query = new QueryEndpoint(new QueryProvider(this));

Orm/Xtensive.Orm/Orm/SessionScope.cs

@@ -4,41 +4,93 @@
 // Created by: Dmitri Maximov
 // Created:    2007.08.29
 
+using System;
+using System.Threading;
 using Xtensive.Core;
 
 namespace Xtensive.Orm
 {
   /// <summary>
   /// <see cref="Session"/> activation scope. 
   /// </summary>
-  public sealed class SessionScope : Scope<Session>
+  public sealed class SessionScope : IDisposable // : Scope<Session>
   {
+    private static readonly AsyncLocal<SessionScope> currentScopeAsync = new AsyncLocal<SessionScope>();
+
+    private enum State
+    {
+      New,
+      Active,
+      Disposed
+    }
+
+    private readonly SessionScope outerScope;
+    private Session session;
+    private State state;
+
     /// <summary>
     /// Gets the current <see cref="Session"/>.
     /// </summary>
-    public static Session CurrentSession
-    {
-      get { return CurrentContext; }
-    }
+    public static Session CurrentSession => currentScopeAsync.Value?.Session;
 
     /// <summary>
     /// Gets the context of this scope.
     /// </summary>
     public Session Session
     {
-      get { return Context; }
+      get => state == State.Active ? session : outerScope?.Session;
+      internal set {
+        if (state != State.New) {
+          throw new InvalidOperationException(Strings.ExCantModifyActiveOrDisposedScope);
+        }
+
+        state = State.Active;
+        session = value;
+      }
     }
 
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+      if (state == State.Disposed) {
+        return;
+      }
+
+      var currentScope = currentScopeAsync.Value;
+
+      while (currentScope != null) {
+        if (currentScope == this) {
+          currentScopeAsync.Value = outerScope;
+          state = State.Disposed;
+          session = null;
+          return;
+        }
+
+        currentScope = currentScope.outerScope;
+      }
+
+      throw new InvalidOperationException(Strings.ExScopeCantBeDisposed);
+    }
 
     // Constructors
 
-    /// <summary>
-    ///   Initializes a new instance of this class.
-    /// </summary>
-    /// <param name="session">The session to activate.</param>
-    public SessionScope(Session session)
-      : base(session)
+    internal SessionScope()
+    {
+      state = State.New;
+
+      outerScope = currentScopeAsync.Value;
+      while (outerScope != null && outerScope.state != State.Active) {
+        outerScope = outerScope.outerScope;
+      }
+
+      currentScopeAsync.Value = this;
+    }
+
+    internal SessionScope(Session session)
+      : this()
     {
+      this.session = session;
+      state = State.Active;
     }
   }
 }

Orm/Xtensive.Orm/Orm/StorageNode.cs

@@ -96,10 +96,17 @@ public Task<Session> OpenSessionAsync(SessionConfiguration configuration, Cancel
     {
       ArgumentValidator.EnsureArgumentNotNull(configuration, nameof(configuration));
 
-      return domain.OpenSessionInternalAsync(configuration,
-        this,
-        configuration.Supports(SessionOptions.AllowSwitching),
-        cancellationToken);
+      SessionScope sessionScope = null;
+      try {
+        if (configuration.Supports(SessionOptions.AutoActivation)) {
+          sessionScope = new SessionScope();
+        }
+        return domain.OpenSessionInternalAsync(configuration, this, sessionScope, cancellationToken);
+      }
+      catch {
+        sessionScope?.Dispose();
+        throw;
+      }
     }
 
     // Constructors

Orm/Xtensive.Orm/Strings.Designer.cs

@@ -3464,4 +3464,7 @@ Error: {1}</value>
   <data name="ExUnableToPrepareCommandNoPartsRegistered" xml:space="preserve">
     <value>Unable to prepare command: no parts registered.</value>
   </data>
-</root>
+  <data name="ExCantModifyActiveOrDisposedScope" xml:space="preserve">
+    <value>Can't modify Active or Disposed scope.</value>
+  </data>
+</root>