Brand new concept of Web extension

- takes into account features of AspNetCore
- passes instances of session/transaction scope directly to Controller/Action/RazorPage
 depending on user configures it. User have full control of session and transaction.
- fair amount of castomization in Filter and Middleware. User can define his own
behavior through override of certain virtual methods

Author: alex-kulakov

Extensions/Xtensive.Orm.Web/ApplicationBuilderExtensions.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2019-2020 Xtensive LLC.
+// Copyright (C) 2019-2020 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 
@@ -18,6 +18,7 @@ public static class ApplicationBuilderExtensions
     /// </summary>
     /// <param name="builder"><see cref="IApplicationBuilder"/> instance.</param>
     /// <returns><paramref name="builder"/> with <see cref="SessionManager"/>.</returns>
+    [Obsolete]
     public static IApplicationBuilder UseSessionManager(this IApplicationBuilder builder)
     {
       return builder.UseMiddleware<SessionManager>();
@@ -29,6 +30,7 @@ public static IApplicationBuilder UseSessionManager(this IApplicationBuilder bui
     /// <param name="builder"><see cref="IApplicationBuilder"/> instance.</param>
     /// <param name="sessionProvider">User-defined session provider which will be used instead of built-in provider.</param>
     /// <returns><paramref name="builder"/> with <see cref="SessionManager"/>.</returns>
+    [Obsolete]
     public static IApplicationBuilder UseSessionManager(this IApplicationBuilder builder, Func<Pair<Session, System.IDisposable>> sessionProvider)
     {
       SessionManager.SessionProvider = sessionProvider;

Extensions/Xtensive.Orm.Web/DomainBuilder.cs

@@ -0,0 +1,125 @@
+// Copyright (C) 2021 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
+
+using System;
+using Microsoft.AspNetCore.Http;
+using System.Threading.Tasks;
+using System.Runtime.ExceptionServices;
+
+namespace Xtensive.Orm.Web
+{
+
+  /// <summary>
+  /// DataObjects.Net Session providing middleware.
+  /// </summary>
+  public class OpenSessionMiddlewere
+  {
+    private readonly RequestDelegate next;
+
+    /// <summary>
+    /// Opens session and puts it to registered <see cref="SessionAccessor"/> service before
+    /// next middleware execution and releases resources when execution returns.
+    /// </summary>
+    /// <param name="context">The <see cref="HttpContext"/>.</param>
+    /// <returns>Task perfroming this operation.</returns>
+    public async Task Invoke(HttpContext context)
+    {
+      var sessionAccessor = (SessionAccessor) context.RequestServices.GetService(WellKnownTypes.SessionAccessorType);
+      if (sessionAccessor != null) {
+        var domain = GetDomainFromServices(context);
+        var session = await OpenSessionAsync(domain, context);
+        var transaction = await OpenTransactionAsync(session, context);
+        BindResourcesToContext(session, transaction, context);
+
+        using (sessionAccessor.BindHttpContext(context)) {
+          try {
+            await next.Invoke(context);
+          }
+          catch(Exception exception) {
+            // if we caught exception here then
+            // 1) it is unhendeled exception
+            // or
+            // 2) it was thrown intentionally
+            if(CompleteTransactionOnException(exception, context)) {
+              transaction.Complete();
+            }
+            if(RethrowException(exception, context)) {
+              ExceptionDispatchInfo.Throw(exception);
+            }
+          }
+          finally {
+            RemoveResourcesFromContext(context);
+            await transaction.DisposeAsync();
+            await session.DisposeAsync();
+          }
+        }
+      }
+      else {
+        await next.Invoke(context);
+      }
+    }
+
+    /// <summary>
+    /// Opens session asynchronously.
+    /// </summary>
+    /// <param name="domain">Domain instance</param>
+    /// <param name="context">Action executing context</param>
+    /// <returns>Instance of <see cref="Session"/>.</returns>
+    protected virtual Task<Session> OpenSessionAsync(Domain domain, HttpContext context) => domain.OpenSessionAsync();
+
+    /// <summary>
+    /// Opens transaction scope asynchronously.
+    /// </summary>
+    /// <param name="session">Domain instance.</param>
+    /// <param name="context">Action executing context.</param>
+    /// <returns>Instance of <see cref="TransactionScope"/>.</returns>
+    protected virtual async Task<TransactionScope> OpenTransactionAsync(Session session, HttpContext context) =>
+      await session.OpenTransactionAsync();
+
+    /// <summary>
+    /// Determines whether transaction should be completed even though exception appeared.
+    /// </summary>
+    /// <param name="thrownException">Thrown exception instance.</param>
+    /// <param name="context">The <see cref="HttpContext"/>.</param>
+    /// <returns><see langword="true"/>if transaction should be rollbacked, otherwise, <see langword="false"/>.</returns>
+    protected virtual bool CompleteTransactionOnException(Exception thrownException, HttpContext context) => false;
+
+    /// <summary>
+    /// Determines whether exception should be re-thrown.
+    /// </summary>
+    /// <param name="thrownException">Thrown exception instance.</param>
+    /// <param name="context">The <see cref="HttpContext"/>.</param>
+    /// <returns><see langword="true"/>if the exception should be re-thrown, otherwise, <see langword="false"/>.</returns>
+    protected virtual bool RethrowException(Exception thrownException, HttpContext context) => true;
+
+    private static void BindResourcesToContext(Session session, TransactionScope transactionScope, HttpContext context)
+    {
+      context.Items[SessionAccessor.SessionIdentifier] = session;
+      context.Items[SessionAccessor.ScopeIdentifier] = transactionScope;
+    }
+
+    private static void RemoveResourcesFromContext(HttpContext context)
+    {
+      _ = context.Items.Remove(SessionAccessor.ScopeIdentifier);
+      _ = context.Items.Remove(SessionAccessor.SessionIdentifier);
+    }
+
+    private static Domain GetDomainFromServices(HttpContext context)
+    {
+      var domain = (Domain) context.RequestServices.GetService(WellKnownTypes.DomainType);
+      return domain == null
+        ? throw new InvalidOperationException("Domain is not found among registered services.")
+        : domain;
+    }
+
+    /// <summary>
+    /// Creates an instance of <see cref="OpenSessionMiddlewere"/>
+    /// </summary>
+    /// <param name="next"></param>
+    public OpenSessionMiddlewere(RequestDelegate next)
+    {
+      this.next = next;
+    }
+  }
+}

Extensions/Xtensive.Orm.Web/OpenSessionMiddlewere.cs

@@ -0,0 +1,48 @@
+// Copyright (C) 2021 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
+
+using System;
+using Xtensive.Core;
+using Microsoft.AspNetCore.Http;
+
+namespace Xtensive.Orm.Web
+{
+  /// <summary>
+  /// A wrapper that provides access <see cref="Xtensive.Orm.Session">Session</see>
+  /// and <see cref="Xtensive.Orm.TransactionScope">TransactionScope</see>.
+  /// </summary>
+  public sealed class SessionAccessor
+  {
+    internal static readonly object SessionIdentifier = new object();
+    internal static readonly object ScopeIdentifier = new object();
+
+    private HttpContext context;
+
+    /// <summary>
+    /// Provides session from bound to <see cref="HttpContext"/>.
+    /// </summary>
+    public Session Session =>
+      context != null && context.Items.TryGetValue(SessionIdentifier, out var instance)
+        ? (Session) instance
+        : null;
+
+    /// <summary>
+    /// Provides opened transaction scope bound to <see cref="HttpContext"/>.
+    /// </summary>
+    public TransactionScope TransactionScope =>
+      context != null && context.Items.TryGetValue(TransactionScope, out var instance)
+        ? (TransactionScope) instance
+        : null;
+
+    internal bool ContextIsBound => context != null;
+
+    internal IDisposable BindHttpContext(HttpContext context)
+    {
+      this.context = context;
+      return new Disposable(NullTheContext);
+    }
+
+    private void NullTheContext(bool disposing) => context = null;
+  }
+}

Extensions/Xtensive.Orm.Web/SessionAccessor.cs

@@ -3,17 +3,20 @@
 // See the License.txt file in the project root for more information.
 
 using System;
+using System.Linq;
 using Xtensive.Core;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Builder;
 using System.Threading.Tasks;
 using System.Threading;
+using Microsoft.AspNetCore.Mvc.Filters;
 
 namespace Xtensive.Orm.Web
 {
   /// <summary>
   /// Provides access to current <see cref="Session"/>.
   /// </summary>
+  [Obsolete]
   public class SessionManager
   {
     private static SessionManager current;
@@ -105,6 +108,22 @@ public bool HasErrors
     /// <returns>Task</returns>
     public async Task Invoke(HttpContext context)
     {
+      var accessor = (SessionAccessor)context.RequestServices.GetService(typeof(SessionAccessor));
+      using (accessor.BindHttpContext(context)) {
+        BeforeActions(context);
+        try {
+          await nextMiddlewareRunner.Invoke(context);
+        }
+        catch (Exception) {
+          var 
+          HasErrors = true;
+          throw;
+        }
+        finally {
+          AfterActions(context);
+        }
+
+      }
       BeforeActions(context);
 
       try
@@ -208,4 +227,26 @@ public SessionManager(RequestDelegate next)
       current = this;
     }
   }
+
+
+  public class CustomActionFilter : IActionFilter
+  {
+    
+
+    public void OnActionExecuted(ActionExecutedContext context)
+    {
+      
+    }
+
+    public void OnActionExecuting(ActionExecutingContext context)
+    {
+      var sessionParameter = context.ActionDescriptor.Parameters.FirstOrDefault(p => p.ParameterType == typeof(Session));
+      context.ActionArguments[sessionParameter.Name] = OpenSession();
+    }
+
+    private Session OpenSession()
+    {
+      return null
+    }
+  }
 }