Refactor OpenSession methods using GetSessionConfiguration() helper

Author: SergeiPavlov

Orm/Xtensive.Orm/Orm/Domain.cs

@@ -187,11 +187,8 @@ private void NotifyDisposing()
     /// }
     /// </code></sample>
     /// <seealso cref="Session"/>
-    public Session OpenSession()
-    {
-      var configuration = Configuration.Sessions.Default;
-      return OpenSession(configuration);
-    }
+    public Session OpenSession() =>
+      OpenSession(Configuration.Sessions.Default);
 
     /// <summary>
     /// Opens new <see cref="Session"/> of specified <see cref="SessionType"/>.
@@ -205,21 +202,8 @@ public Session OpenSession()
     /// // work with persistent objects here.
     /// }
     /// </code></sample>
-    public Session OpenSession(SessionType type)
-    {
-      switch (type) {
-        case SessionType.User:
-          return OpenSession(Configuration.Sessions.Default);
-        case SessionType.System:
-          return OpenSession(Configuration.Sessions.System);
-        case SessionType.KeyGenerator:
-          return OpenSession(Configuration.Sessions.KeyGenerator);
-        case SessionType.Service:
-          return OpenSession(Configuration.Sessions.Service);
-        default:
-          throw new ArgumentOutOfRangeException("type");
-      }
-    }
+    public Session OpenSession(SessionType type) =>
+      OpenSession(GetSessionConfiguration(type));
 
     /// <summary>
     /// Opens new <see cref="Session"/> with specified <see cref="SessionConfiguration"/>.
@@ -277,11 +261,8 @@ internal Session OpenSessionInternal(SessionConfiguration configuration, Storage
     /// }
     /// </code></sample>
     /// <seealso cref="Session"/>
-    public Task<Session> OpenSessionAsync(CancellationToken cancellationToken = default)
-    {
-      var configuration = Configuration.Sessions.Default;
-      return OpenSessionAsync(configuration, cancellationToken);
-    }
+    public Task<Session> OpenSessionAsync(CancellationToken cancellationToken = default) =>
+      OpenSessionAsync(Configuration.Sessions.Default, cancellationToken);
 
     /// <summary>
     /// Opens new <see cref="Session"/> of specified <see cref="SessionType"/> asynchronously.
@@ -298,18 +279,7 @@ public Task<Session> OpenSessionAsync(CancellationToken cancellationToken = defa
     public Task<Session> OpenSessionAsync(SessionType type, CancellationToken cancellationToken = default)
     {
       cancellationToken.ThrowIfCancellationRequested();
-      switch (type) {
-        case SessionType.User:
-          return OpenSessionAsync(Configuration.Sessions.Default, cancellationToken);
-        case SessionType.System:
-          return OpenSessionAsync(Configuration.Sessions.System, cancellationToken);
-        case SessionType.KeyGenerator:
-          return OpenSessionAsync(Configuration.Sessions.KeyGenerator, cancellationToken);
-        case SessionType.Service:
-          return OpenSessionAsync(Configuration.Sessions.Service, cancellationToken);
-        default:
-          throw new ArgumentOutOfRangeException("type");
-      }
+      return OpenSessionAsync(GetSessionConfiguration(type), cancellationToken);
     }
 
     /// <summary>
@@ -342,6 +312,15 @@ public Task<Session> OpenSessionAsync(SessionConfiguration configuration, Cancel
       }
     }
 
+    internal SessionConfiguration GetSessionConfiguration(SessionType type) =>
+      type switch {
+        SessionType.User => Configuration.Sessions.Default,
+        SessionType.System => Configuration.Sessions.System,
+        SessionType.KeyGenerator => Configuration.Sessions.KeyGenerator,
+        SessionType.Service => Configuration.Sessions.Service,
+        _ => throw new ArgumentOutOfRangeException(nameof(type))
+      };
+
     internal async Task<Session> OpenSessionInternalAsync(SessionConfiguration configuration, StorageNode storageNode, SessionScope sessionScope, CancellationToken cancellationToken)
     {
       configuration.Lock(true);

Orm/Xtensive.Orm/Orm/StorageNode.cs

@@ -75,44 +75,24 @@ public sealed class StorageNode : ISessionSource
     internal ConcurrentDictionary<PersistRequestBuilderTask, ICollection<PersistRequest>> PersistRequestCache { get; }
 
     /// <inheritdoc/>
-    public Session OpenSession()
-    {
-      return OpenSession(domain.Configuration.Sessions.Default);
-    }
+    public Session OpenSession() =>
+      OpenSession(domain.Configuration.Sessions.Default);
 
     /// <inheritdoc/>
-    public Session OpenSession(SessionType type)
-    {
-      return type switch {
-        SessionType.User => OpenSession(domain.Configuration.Sessions.Default),
-        SessionType.System => OpenSession(domain.Configuration.Sessions.System),
-        SessionType.KeyGenerator => OpenSession(domain.Configuration.Sessions.KeyGenerator),
-        SessionType.Service => OpenSession(domain.Configuration.Sessions.Service),
-        _ => throw new ArgumentOutOfRangeException("type"),
-      };
-    }
+    public Session OpenSession(SessionType type) =>
+      OpenSession(domain.GetSessionConfiguration(type));
 
     /// <inheritdoc/>
-    public Session OpenSession(SessionConfiguration configuration)
-    {
-      return domain.OpenSessionInternal(configuration, this, configuration.Supports(SessionOptions.AutoActivation));
-    }
+    public Session OpenSession(SessionConfiguration configuration) =>
+      domain.OpenSessionInternal(configuration, this, configuration.Supports(SessionOptions.AutoActivation));
 
     /// <inheritdoc/>
     public Task<Session> OpenSessionAsync(CancellationToken cancellationToken = default) =>
       OpenSessionAsync(domain.Configuration.Sessions.Default, cancellationToken);
 
     /// <inheritdoc/>
-    public Task<Session> OpenSessionAsync(SessionType type, CancellationToken cancellationToken = default)
-    {
-      return type switch {
-        SessionType.User => OpenSessionAsync(domain.Configuration.Sessions.Default),
-        SessionType.System => OpenSessionAsync(domain.Configuration.Sessions.System),
-        SessionType.KeyGenerator => OpenSessionAsync(domain.Configuration.Sessions.KeyGenerator),
-        SessionType.Service => OpenSessionAsync(domain.Configuration.Sessions.Service),
-        _ => throw new ArgumentOutOfRangeException("type"),
-      };
-    }
+    public Task<Session> OpenSessionAsync(SessionType type, CancellationToken cancellationToken = default) =>
+      OpenSessionAsync(domain.GetSessionConfiguration(type), cancellationToken);
 
     /// <inheritdoc/>
     public Task<Session> OpenSessionAsync(SessionConfiguration configuration, CancellationToken cancellationToken = default)