No Session.SelectStorageNode() usage + formatting

alex-kulakov · alex-kulakov · commit 727e69764837 · 2020-10-27T18:04:16.000+05:00
diff --git a/Orm/Xtensive.Orm.Tests/Storage/Multinode/DynamicTypeIdTest.cs b/Orm/Xtensive.Orm.Tests/Storage/Multinode/DynamicTypeIdTest.cs
@@ -147,7 +147,9 @@ public async Task MainAsyncTest()
       BuildDomain(AlternativeSchema, DomainUpgradeMode.Recreate, typeof(Entity2)).Dispose();
       BuildDomain(AlternativeSchema, DomainUpgradeMode.PerformSafely, typeof(Entity2), typeof(Entity1)).Dispose();
 
-      using (var domain = await BuildDomainAsync(DefaultSchema, DomainUpgradeMode.Validate, typeof(Entity1), typeof(Entity2))) {
+      var domain = await BuildDomainAsync(DefaultSchema, DomainUpgradeMode.Validate, typeof(Entity1), typeof(Entity2));
+
+      await using (domain) {
         var nodeConfiguration = new NodeConfiguration(AlternativeSchema) { UpgradeMode = DomainUpgradeMode.Validate };
         nodeConfiguration.SchemaMapping.Add(DefaultSchema, AlternativeSchema);
         _ = await domain.StorageNodeManager.AddNodeAsync(nodeConfiguration);
@@ -218,15 +220,17 @@ public async Task SelectAbstractClassDescendantsAsyncTest()
       InitializeSchemas();
 
       BuildDomain(DefaultSchema, DomainUpgradeMode.Recreate, typeof(Entity3)).Dispose();
-      using (var domain = BuildDomain(DefaultSchema, DomainUpgradeMode.PerformSafely, typeof(Entity3), typeof(Entity4)))
+      var domain = BuildDomain(DefaultSchema, DomainUpgradeMode.PerformSafely, typeof(Entity3), typeof(Entity4));
+
+      using (domain)
       using (var session = domain.OpenSession())
       using (var transaction = session.OpenTransaction()) {
-        for (int i = 0; i < 10; i++) {
-          new Entity3 {
+        for (var i = 0; i < 10; i++) {
+          _ = new Entity3 {
             Name = "1 before test " + i,
             StringValue = "1 before test " + i
           };
-          new Entity4 {
+          _ = new Entity4 {
             Name = "1 before test " + i,
             IntValue = i
           };
@@ -235,23 +239,27 @@ public async Task SelectAbstractClassDescendantsAsyncTest()
       }
 
       BuildDomain(AlternativeSchema, DomainUpgradeMode.Recreate, typeof(Entity4)).Dispose();
-      using (var domain = BuildDomain(AlternativeSchema, DomainUpgradeMode.PerformSafely, typeof(Entity4), typeof(Entity3)))
+      domain = BuildDomain(AlternativeSchema, DomainUpgradeMode.PerformSafely, typeof(Entity4), typeof(Entity3));
+
+      using (domain)
       using (var session = domain.OpenSession())
       using (var transaction = session.OpenTransaction()) {
-        for (int i = 0; i < 10; i++) {
-          new Entity3 {
+        for (var i = 0; i < 10; i++) {
+          _ = new Entity3 {
             Name = "2 before test " + i,
             StringValue = "1 before test " + i
           };
-          new Entity4 {
+          _ = new Entity4 {
             Name = "2 before test " + i,
             IntValue = i
           };
         }
         transaction.Complete();
       }
 
-      using (var domain = await BuildDomainAsync(DefaultSchema, DomainUpgradeMode.Validate, typeof(Entity3), typeof(Entity4))) {
+      domain = await BuildDomainAsync(DefaultSchema, DomainUpgradeMode.Validate, typeof(Entity3), typeof(Entity4));
+
+      await using (domain) {
         var nodeConfiguration = new NodeConfiguration(AlternativeSchema) { UpgradeMode = DomainUpgradeMode.Validate };
         nodeConfiguration.SchemaMapping.Add(DefaultSchema, AlternativeSchema);
         _ = await domain.StorageNodeManager.AddNodeAsync(nodeConfiguration);
@@ -327,16 +335,18 @@ public async Task SelectInterfaceImplementationsAsyncTest()
       InitializeSchemas();
 
       BuildDomain(DefaultSchema, DomainUpgradeMode.Recreate, typeof(SomeInterfaceImpl1)).Dispose();
-      using (var domain = BuildDomain(DefaultSchema, DomainUpgradeMode.PerformSafely, typeof(SomeInterfaceImpl1), typeof(SomeInterfaceImpl2)))
+      var domain = BuildDomain(DefaultSchema, DomainUpgradeMode.PerformSafely, typeof(SomeInterfaceImpl1), typeof(SomeInterfaceImpl2));
+
+      using (domain)
       using (var session = domain.OpenSession())
       using (var transaction = session.OpenTransaction()) {
-        for (int i = 0; i < 10; i++) {
-          new SomeInterfaceImpl1 {
+        for (var i = 0; i < 10; i++) {
+          _ = new SomeInterfaceImpl1 {
             Name = "1 before test " + i,
             StringValue = "1 before test " + i,
             GuidValue = Guid.NewGuid()
           };
-          new SomeInterfaceImpl2 {
+          _ = new SomeInterfaceImpl2 {
             Name = "1 before test " + i,
             IntValue = i,
             GuidValue = Guid.NewGuid()
@@ -346,16 +356,18 @@ public async Task SelectInterfaceImplementationsAsyncTest()
       }
 
       BuildDomain(AlternativeSchema, DomainUpgradeMode.Recreate, typeof(SomeInterfaceImpl2)).Dispose();
-      using (var domain = BuildDomain(AlternativeSchema, DomainUpgradeMode.PerformSafely, typeof(SomeInterfaceImpl1), typeof(SomeInterfaceImpl2)))
+      domain = BuildDomain(AlternativeSchema, DomainUpgradeMode.PerformSafely, typeof(SomeInterfaceImpl1), typeof(SomeInterfaceImpl2));
+
+      using (domain)
       using (var session = domain.OpenSession())
       using (var transaction = session.OpenTransaction()) {
-        for (int i = 0; i < 10; i++) {
-          new SomeInterfaceImpl1 {
+        for (var i = 0; i < 10; i++) {
+          _ = new SomeInterfaceImpl1 {
             Name = "2 before test " + i,
             StringValue = "1 before test " + i,
             GuidValue = Guid.NewGuid()
           };
-          new SomeInterfaceImpl2 {
+          _ = new SomeInterfaceImpl2 {
             Name = "2 before test " + i,
             IntValue = i,
             GuidValue = Guid.NewGuid()
@@ -364,7 +376,9 @@ public async Task SelectInterfaceImplementationsAsyncTest()
         transaction.Complete();
       }
 
-      using (var domain = await BuildDomainAsync(DefaultSchema, DomainUpgradeMode.Validate, typeof(SomeInterfaceImpl1), typeof(SomeInterfaceImpl2))) {
+      domain = await BuildDomainAsync(DefaultSchema, DomainUpgradeMode.Validate, typeof(SomeInterfaceImpl1), typeof(SomeInterfaceImpl2));
+
+      await using (domain) {
         var nodeConfiguration = new NodeConfiguration(AlternativeSchema) { UpgradeMode = DomainUpgradeMode.Validate };
         nodeConfiguration.SchemaMapping.Add(DefaultSchema, AlternativeSchema);
         _ = await domain.StorageNodeManager.AddNodeAsync(nodeConfiguration);
@@ -435,15 +449,17 @@ public async Task SelectNonAbstractDescendantAsyncTest()
       InitializeSchemas();
 
       BuildDomain(DefaultSchema, DomainUpgradeMode.Recreate, typeof(Entity1)).Dispose();
-      using (var domain = BuildDomain(DefaultSchema, DomainUpgradeMode.PerformSafely, typeof(Entity1), typeof(Entity2)))
+      var domain = BuildDomain(DefaultSchema, DomainUpgradeMode.PerformSafely, typeof(Entity1), typeof(Entity2));
+
+      using (domain)
       using (var session = domain.OpenSession())
       using (var transaction = session.OpenTransaction()) {
-        for (int i = 0; i < 10; i++) {
-          new Entity1 {
+        for (var i = 0; i < 10; i++) {
+          _ = new Entity1 {
             Name = "1 before test " + i,
             StringValue = "1 before test " + i
           };
-          new Entity2 {
+          _ = new Entity2 {
             Name = "1 before test " + i,
             IntValue = i
           };
@@ -452,23 +468,27 @@ public async Task SelectNonAbstractDescendantAsyncTest()
       }
 
       BuildDomain(AlternativeSchema, DomainUpgradeMode.Recreate, typeof(Entity2)).Dispose();
-      using (var domain = BuildDomain(AlternativeSchema, DomainUpgradeMode.PerformSafely, typeof(Entity2), typeof(Entity1)))
+      domain = BuildDomain(AlternativeSchema, DomainUpgradeMode.PerformSafely, typeof(Entity2), typeof(Entity1));
+
+      using (domain)
       using (var session = domain.OpenSession())
       using (var transaction = session.OpenTransaction()) {
-        for (int i = 0; i < 10; i++) {
-          new Entity1 {
+        for (var i = 0; i < 10; i++) {
+          _ = new Entity1 {
             Name = "2 before test " + i,
             StringValue = "1 before test " + i
           };
-          new Entity2 {
+          _ = new Entity2 {
             Name = "2 before test " + i,
             IntValue = i
           };
         }
         transaction.Complete();
       }
 
-      using (var domain = await BuildDomainAsync(DefaultSchema, DomainUpgradeMode.Validate, typeof(Entity1), typeof(Entity2))) {
+      domain = await BuildDomainAsync(DefaultSchema, DomainUpgradeMode.Validate, typeof(Entity1), typeof(Entity2));
+
+      await using (domain) {
         var nodeConfiguration = new NodeConfiguration(AlternativeSchema) { UpgradeMode = DomainUpgradeMode.Validate };
         nodeConfiguration.SchemaMapping.Add(DefaultSchema, AlternativeSchema);
         _ = await domain.StorageNodeManager.AddNodeAsync(nodeConfiguration);
@@ -518,7 +538,6 @@ public void TypeIdExtractionTest()
         _ = domain.StorageNodeManager.AddNode(nodeConfiguration);
         var selectedNode = domain.StorageNodeManager.GetNode(nodeConfiguration.NodeId);
         using (var session = selectedNode.OpenSession()) {
-          session.SelectStorageNode(AlternativeSchema);
           var types = new[] { typeof(BaseEntity), typeof(Entity1), typeof(Entity2) };
           foreach (var type in types) {
             Assert.That(session.StorageNode.TypeIdRegistry[domain.Model.Types[type]], Is.EqualTo(alternativeSchemaMap[type]));
@@ -538,30 +557,36 @@ public async Task TypeIdExtractionAsyncTest()
       var alternativeSchemaMap = new Dictionary<Type, int>();
 
       BuildDomain(DefaultSchema, DomainUpgradeMode.Recreate, typeof(Entity1)).Dispose();
-      using (var domain = BuildDomain(DefaultSchema, DomainUpgradeMode.PerformSafely, typeof(Entity1), typeof(Entity2))) {
+      var domain = BuildDomain(DefaultSchema, DomainUpgradeMode.PerformSafely, typeof(Entity1), typeof(Entity2));
+
+      using (domain) {
         defaultSchemaMap = domain.Model.Types.ToDictionary(el => el.UnderlyingType, el => el.TypeId);
       }
 
       BuildDomain(AlternativeSchema, DomainUpgradeMode.Recreate, typeof(Entity2)).Dispose();
-      using (var domain = BuildDomain(AlternativeSchema, DomainUpgradeMode.PerformSafely, typeof(Entity2), typeof(Entity1))) {
+      domain = BuildDomain(AlternativeSchema, DomainUpgradeMode.PerformSafely, typeof(Entity2), typeof(Entity1));
+
+      using (domain) {
         alternativeSchemaMap = domain.Model.Types.ToDictionary(el => el.UnderlyingType, el => el.TypeId);
       }
 
-      using (var domain = await BuildDomainAsync(DefaultSchema, DomainUpgradeMode.Validate, typeof(Entity1), typeof(Entity2))) {
+      domain = await BuildDomainAsync(DefaultSchema, DomainUpgradeMode.Validate, typeof(Entity1), typeof(Entity2));
+
+      await using (domain) {
         var nodeConfiguration = new NodeConfiguration(AlternativeSchema) { UpgradeMode = DomainUpgradeMode.Validate };
         nodeConfiguration.SchemaMapping.Add(DefaultSchema, AlternativeSchema);
-        _ = await domain.StorageNodeManager.AddNodeAsync(nodeConfiguration);
+        
 
         using (var session = domain.OpenSession()) {
-          session.SelectStorageNode(WellKnown.DefaultNodeId);
           var types = new[] { typeof(BaseEntity), typeof(Entity1), typeof(Entity2) };
           foreach (var type in types) {
             Assert.That(session.StorageNode.TypeIdRegistry[domain.Model.Types[type]], Is.EqualTo(defaultSchemaMap[type]));
           }
         }
 
-        using (var session = domain.OpenSession()) {
-          session.SelectStorageNode(AlternativeSchema);
+        _ = await domain.StorageNodeManager.AddNodeAsync(nodeConfiguration);
+        var selectedNode = domain.StorageNodeManager.GetNode(nodeConfiguration.NodeId);
+        using (var session = selectedNode.OpenSession()) {
           var types = new[] { typeof(BaseEntity), typeof(Entity1), typeof(Entity2) };
           foreach (var type in types) {
             Assert.That(session.StorageNode.TypeIdRegistry[domain.Model.Types[type]], Is.EqualTo(alternativeSchemaMap[type]));
diff --git a/Orm/Xtensive.Orm/Orm/Session.cs b/Orm/Xtensive.Orm/Orm/Session.cs
@@ -238,20 +238,20 @@ internal void EnsureNotDisposed()
     internal void AttachToScope(SessionScope sessionScope)
     {
       sessionScope.Session = this;
-      disposableSet.Add(sessionScope);
+      _ = disposableSet.Add(sessionScope);
     }
 
     internal EnumerationContext CreateEnumerationContext(ParameterContext parameterContext)
     {
       Persist(PersistReason.Query);
-      ProcessUserDefinedDelayedQueries(true);
+      _ = ProcessUserDefinedDelayedQueries(true);
       return new Providers.EnumerationContext(this, parameterContext, GetEnumerationContextOptions());
     }
 
     internal async Task<EnumerationContext> CreateEnumerationContextAsync(ParameterContext parameterContext, CancellationToken token)
     {
       await PersistAsync(PersistReason.Other, token).ConfigureAwait(false);
-      await ProcessUserDefinedDelayedQueriesAsync(token).ConfigureAwait(false);
+      _ = await ProcessUserDefinedDelayedQueriesAsync(token).ConfigureAwait(false);
       return new Providers.EnumerationContext(this, parameterContext, GetEnumerationContextOptions());
     }
 
@@ -430,9 +430,11 @@ VersionSet IVersionSetProvider.CreateVersionSet(IEnumerable<Key> keys)
       using (var tx = OpenAutoTransaction()) {
         var entities = Query.Many<Entity>(keys);
         var result = new VersionSet();
-        foreach (var entity in entities)
-          if (entity!=null)
-            result.Add(entity, false);
+        foreach (var entity in entities) {
+          if (entity != null) {
+            _ = result.Add(entity, false);
+          }
+        }
         tx.Complete();
         return result;
       }

Original file line number	Diff line number	Diff line change
`@@ -238,20 +238,20 @@ internal void EnsureNotDisposed()`
`238`	`238`	`internal void AttachToScope(SessionScope sessionScope)`
`239`	`239`	`{`
`240`	`240`	`sessionScope.Session = this;`
`241`		`- disposableSet.Add(sessionScope);`
	`241`	`+ _ = disposableSet.Add(sessionScope);`
`242`	`242`	`}`
`243`	`243`
`244`	`244`	`internal EnumerationContext CreateEnumerationContext(ParameterContext parameterContext)`
`245`	`245`	`{`
`246`	`246`	`Persist(PersistReason.Query);`
`247`		`- ProcessUserDefinedDelayedQueries(true);`
	`247`	`+ _ = ProcessUserDefinedDelayedQueries(true);`
`248`	`248`	`return new Providers.EnumerationContext(this, parameterContext, GetEnumerationContextOptions());`
`249`	`249`	`}`
`250`	`250`
`251`	`251`	`internal async Task<EnumerationContext> CreateEnumerationContextAsync(ParameterContext parameterContext, CancellationToken token)`
`252`	`252`	`{`
`253`	`253`	`await PersistAsync(PersistReason.Other, token).ConfigureAwait(false);`
`254`		`- await ProcessUserDefinedDelayedQueriesAsync(token).ConfigureAwait(false);`
	`254`	`+ _ = await ProcessUserDefinedDelayedQueriesAsync(token).ConfigureAwait(false);`
`255`	`255`	`return new Providers.EnumerationContext(this, parameterContext, GetEnumerationContextOptions());`
`256`	`256`	`}`
`257`	`257`
`@@ -430,9 +430,11 @@ VersionSet IVersionSetProvider.CreateVersionSet(IEnumerable<Key> keys)`
`430`	`430`	`using (var tx = OpenAutoTransaction()) {`
`431`	`431`	`var entities = Query.Many<Entity>(keys);`
`432`	`432`	`var result = new VersionSet();`
`433`		`- foreach (var entity in entities)`
`434`		`- if (entity!=null)`
`435`		`- result.Add(entity, false);`
	`433`	`+ foreach (var entity in entities) {`
	`434`	`+ if (entity != null) {`
	`435`	`+ _ = result.Add(entity, false);`
	`436`	`+ }`
	`437`	`+ }`
`436`	`438`	`tx.Complete();`
`437`	`439`	`return result;`
`438`	`440`	`}`