nhibernate · hazzik · Sep 28, 2020 · Sep 28, 2020 · Sep 28, 2020
diff --git a/src/AsyncGenerator.yml b/src/AsyncGenerator.yml
@@ -287,6 +287,7 @@ methodRules:
   - containingType: NHibernate.Linq.DmlExtensionMethods
   - containingType: NHibernate.Linq.InsertBuilder<TSource, TTarget>
   - containingType: NHibernate.Linq.UpdateBuilder<TSource>
+  - containingType: NHibernate.Multi.IQueryBatch 
   name: PubliclyExposedType
 - filters:
   - hasAttributeName: ObsoleteAttribute

diff --git a/src/NHibernate.Test/Async/CacheTest/BatchableCacheFixture.cs b/src/NHibernate.Test/Async/CacheTest/BatchableCacheFixture.cs
@@ -1112,7 +1112,7 @@ public async Task QueryCacheTestAsync()
 
 				using (var t = s.BeginTransaction())
 				{
-					await (queries.ExecuteAsync(CancellationToken.None));
+					await (queries.ExecuteAsync());
 					await (t.CommitAsync());
 				}
 
@@ -1127,24 +1127,24 @@ public async Task QueryCacheTestAsync()
 				// Run a second time, to test the query cache
 				using (var t = s.BeginTransaction())
 				{
-					await (queries.ExecuteAsync(CancellationToken.None));
+					await (queries.ExecuteAsync());
 					await (t.CommitAsync());
 				}
 
 				Assert.That(
-					await (queries.GetResultAsync<ReadOnly>(0, CancellationToken.None)),
+					await (queries.GetResultAsync<ReadOnly>(0)),
 					Has.Count.EqualTo(1).And.One.Property(nameof(ReadOnly.Name)).EqualTo(name1), "q1");
 				Assert.That(
-					await (queries.GetResultAsync<ReadOnly>(1, CancellationToken.None)),
+					await (queries.GetResultAsync<ReadOnly>(1)),
 					Has.Count.EqualTo(1).And.One.Property(nameof(ReadOnly.Name)).EqualTo(name2), "q2");
 				Assert.That(
-					await (queries.GetResultAsync<ReadWrite>(2, CancellationToken.None)),
+					await (queries.GetResultAsync<ReadWrite>(2)),
 					Has.Count.EqualTo(1).And.One.Property(nameof(ReadWrite.Name)).EqualTo(name3), "q3");
 				Assert.That(
-					await (queries.GetResultAsync<ReadWrite>(3, CancellationToken.None)),
+					await (queries.GetResultAsync<ReadWrite>(3)),
 					Has.Count.EqualTo(1).And.One.Property(nameof(ReadWrite.Name)).EqualTo(name4), "q4");
 				Assert.That(
-					await (queries.GetResultAsync<ReadOnly>(4, CancellationToken.None)),
+					await (queries.GetResultAsync<ReadOnly>(4)),
 					Has.Count.EqualTo(1).And.One.Property(nameof(ReadOnly.Name)).EqualTo(name5), "q5");
 
 				Assert.That(cache.GetMultipleCalls, Has.Count.EqualTo(2), "cache GetMany secondExecution");
@@ -1174,24 +1174,24 @@ public async Task QueryCacheTestAsync()
 				// Run a third time, to re-test the query cache
 				using (var t = s.BeginTransaction())
 				{
-					await (queries.ExecuteAsync(CancellationToken.None));
+					await (queries.ExecuteAsync());
 					await (t.CommitAsync());
 				}
 
 				Assert.That(
-					await (queries.GetResultAsync<ReadOnly>(0, CancellationToken.None)),
+					await (queries.GetResultAsync<ReadOnly>(0)),
 					Has.Count.EqualTo(1).And.One.Property(nameof(ReadOnly.Name)).EqualTo(name1), "q1 after update");
 				Assert.That(
-					await (queries.GetResultAsync<ReadOnly>(1, CancellationToken.None)),
+					await (queries.GetResultAsync<ReadOnly>(1)),
 					Has.Count.EqualTo(1).And.One.Property(nameof(ReadOnly.Name)).EqualTo(name2), "q2 after update");
 				Assert.That(
-					await (queries.GetResultAsync<ReadWrite>(2, CancellationToken.None)),
+					await (queries.GetResultAsync<ReadWrite>(2)),
 					Has.Count.EqualTo(0), "q3 after update");
 				Assert.That(
-					await (queries.GetResultAsync<ReadWrite>(3, CancellationToken.None)),
+					await (queries.GetResultAsync<ReadWrite>(3)),
 					Has.Count.EqualTo(1).And.One.Property(nameof(ReadWrite.Name)).EqualTo(name4), "q4 after update");
 				Assert.That(
-					await (queries.GetResultAsync<ReadOnly>(4, CancellationToken.None)),
+					await (queries.GetResultAsync<ReadOnly>(4)),
 					Has.Count.EqualTo(1).And.One.Property(nameof(ReadOnly.Name)).EqualTo(name5), "q5 after update");
 
 				Assert.That(cache.GetMultipleCalls, Has.Count.EqualTo(3), "cache GetMany thirdExecution");

diff --git a/src/NHibernate.Test/Async/Criteria/Lambda/IntegrationFixture.cs b/src/NHibernate.Test/Async/Criteria/Lambda/IntegrationFixture.cs
@@ -428,8 +428,8 @@ public async Task MultiQueryAsync()
 					 .Add("page", query)
 					 .Add<int>("count", query.ToRowCountQuery());
 
-				var pageResults = await (multiQuery.GetResultAsync<Person>("page", CancellationToken.None));
-				var countResults = await (multiQuery.GetResultAsync<int>("count", CancellationToken.None));
+				var pageResults = await (multiQuery.GetResultAsync<Person>("page"));
+				var countResults = await (multiQuery.GetResultAsync<int>("count"));
 
 				Assert.That(pageResults.Count, Is.EqualTo(1));
 				Assert.That(pageResults[0].Name, Is.EqualTo("Name 3"));
@@ -451,8 +451,8 @@ public async Task MultiQueryAsync()
 					 .Add("page", query)
 					 .Add<int>("count", query.ToRowCountQuery());
 
-				var pageResults = await (multiCriteria.GetResultAsync<Person>("page", CancellationToken.None));
-				var countResults = await (multiCriteria.GetResultAsync<int>("count", CancellationToken.None));
+				var pageResults = await (multiCriteria.GetResultAsync<Person>("page"));
+				var countResults = await (multiCriteria.GetResultAsync<int>("count"));
 
 				Assert.That(pageResults.Count, Is.EqualTo(1));
 				Assert.That(pageResults[0].Name, Is.EqualTo("Name 3"));

diff --git a/src/NHibernate.Test/Async/Futures/QueryBatchFixture.cs b/src/NHibernate.Test/Async/Futures/QueryBatchFixture.cs
@@ -22,7 +22,6 @@
 namespace NHibernate.Test.Futures
 {
 	using System.Threading.Tasks;
-	using System.Threading;
 	[TestFixture]
 	public class QueryBatchFixtureAsync : TestCaseMappingByCode
 	{
@@ -81,10 +80,10 @@ public async Task CanCombineCriteriaAndHqlInBatchAsync()
 
 				using (var sqlLog = new SqlLogSpy())
 				{
-					await (batch.GetResultAsync<int>(0, CancellationToken.None));
-					await (batch.GetResultAsync<EntityComplex>("queryOver", CancellationToken.None));
-					await (batch.GetResultAsync<EntityComplex>(2, CancellationToken.None));
-					await (batch.GetResultAsync<EntitySimpleChild>("sql", CancellationToken.None));
+					await (batch.GetResultAsync<int>(0));
+					await (batch.GetResultAsync<EntityComplex>("queryOver"));
+					await (batch.GetResultAsync<EntityComplex>(2));
+					await (batch.GetResultAsync<EntitySimpleChild>("sql"));
 					if (SupportsMultipleQueries)
 						Assert.That(sqlLog.Appender.GetEvents().Length, Is.EqualTo(1));
 				}
@@ -142,7 +141,7 @@ public async Task CanFetchCollectionInBatchAsync()
 
 				batch.Add(q1);
 				batch.Add(session.Query<EntityComplex>().Fetch(c => c.ChildrenList));
-				await (batch.ExecuteAsync(CancellationToken.None));
+				await (batch.ExecuteAsync());
 
 				var parent = await (session.LoadAsync<EntityComplex>(_parentId));
 				Assert.That(NHibernateUtil.IsInitialized(parent), Is.True);
@@ -162,7 +161,7 @@ public async Task AfterLoadCallbackAsync()
 				int count = 0;
 				batch.Add(session.Query<EntityComplex>().WithOptions(o => o.SetCacheable(true)), r => results = r);
 				batch.Add(session.Query<EntityComplex>().WithOptions(o => o.SetCacheable(true)), ec => ec.Count(), r => count = r);
-				await (batch.ExecuteAsync(CancellationToken.None));
+				await (batch.ExecuteAsync());
 
 				Assert.That(results, Is.Not.Null);
 				Assert.That(count, Is.GreaterThan(0));
@@ -177,7 +176,7 @@ public async Task AfterLoadCallbackAsync()
 				batch.Add(session.Query<EntityComplex>().WithOptions(o => o.SetCacheable(true)), r => results = r);
 				batch.Add(session.Query<EntityComplex>().WithOptions(o => o.SetCacheable(true)), ec => ec.Count(), r => count = r);
 
-				await (batch.ExecuteAsync(CancellationToken.None));
+				await (batch.ExecuteAsync());
 
 				Assert.That(results, Is.Not.Null);
 				Assert.That(count, Is.GreaterThan(0));

diff --git a/src/NHibernate.Test/Async/NHSpecificTest/DataReaderWrapperTest/Fixture.cs b/src/NHibernate.Test/Async/NHSpecificTest/DataReaderWrapperTest/Fixture.cs
@@ -16,7 +16,6 @@
 namespace NHibernate.Test.NHSpecificTest.DataReaderWrapperTest
 {
 	using System.Threading.Tasks;
-	using System.Threading;
 	[TestFixture]
 	public class FixtureAsync : BugTestCase
 	{
@@ -71,7 +70,7 @@ public async Task CanUseDatareadersGetValueWithQueryBatchAsync()
 				var crit = s.CreateCriteria(typeof (TheEntity));
 				var multi = s.CreateQueryBatch();
 				multi.Add<TheEntity>(crit);
-				var res = await (multi.GetResultAsync<TheEntity>(0, CancellationToken.None));
+				var res = await (multi.GetResultAsync<TheEntity>(0));
 				Assert.That(res.Count, Is.EqualTo(1));
 			}
 		}

diff --git a/src/NHibernate.Test/Async/NHSpecificTest/NH1253/Fixture.cs b/src/NHibernate.Test/Async/NHSpecificTest/NH1253/Fixture.cs
@@ -15,7 +15,6 @@
 namespace NHibernate.Test.NHSpecificTest.NH1253
 {
 	using System.Threading.Tasks;
-	using System.Threading;
 	[TestFixture]
 	public class FixtureAsync : BugTestCase
 	{
@@ -119,7 +118,7 @@ public async Task QueryBatchSingleInListAsync()
 				await (s.CreateQueryBatch()
 				 .Add<Car>(q1)
 				 .Add<Car>(q2)
-				 .ExecuteAsync(CancellationToken.None));
+				 .ExecuteAsync());
 
 				await (tx.CommitAsync());
 			}

diff --git a/src/NHibernate.Test/Async/NHSpecificTest/NH1508/Fixture.cs b/src/NHibernate.Test/Async/NHSpecificTest/NH1508/Fixture.cs
@@ -15,7 +15,6 @@
 namespace NHibernate.Test.NHSpecificTest.NH1508
 {
 	using System.Threading.Tasks;
-	using System.Threading;
 	[TestFixture]
 	public class FixtureAsync : BugTestCase
 	{
@@ -81,7 +80,7 @@ public async Task DoesntThrowExceptionWhenHqlQueryIsGivenToQueryBatchAsync()
 				var q = session
 				        .CreateQueryBatch()
 				        .Add<Document>(sqlQuery);
-				await (q.ExecuteAsync(CancellationToken.None));
+				await (q.ExecuteAsync());
 			}
 		}
 	}

diff --git a/src/NHibernate.Test/Async/NHSpecificTest/NH1609/Fixture.cs b/src/NHibernate.Test/Async/NHSpecificTest/NH1609/Fixture.cs
@@ -86,9 +86,9 @@ public async Task TestWithQueryBatchAsync()
 					session.CreateCriteria(typeof (EntityB)).Add(Restrictions.Eq("A.Id", a1.Id)).Add(Restrictions.Eq("C.Id", c.Id)).
 					        SetFirstResult(0).SetMaxResults(1));
 
-				Assert.That(await (multi.GetResultAsync<EntityA>(0, CancellationToken.None)), Has.Count.EqualTo(1));
-				Assert.That(await (multi.GetResultAsync<EntityA>(1, CancellationToken.None)), Has.Count.EqualTo(1));
-				Assert.That(await (multi.GetResultAsync<EntityB>(2, CancellationToken.None)), Has.Count.EqualTo(1));
+				Assert.That(await (multi.GetResultAsync<EntityA>(0)), Has.Count.EqualTo(1));
+				Assert.That(await (multi.GetResultAsync<EntityA>(1)), Has.Count.EqualTo(1));
+				Assert.That(await (multi.GetResultAsync<EntityB>(2)), Has.Count.EqualTo(1));
 			}
 		}
 

diff --git a/src/NHibernate.Test/Async/NHSpecificTest/NH1836/Fixture.cs b/src/NHibernate.Test/Async/NHSpecificTest/NH1836/Fixture.cs
@@ -18,7 +18,6 @@
 namespace NHibernate.Test.NHSpecificTest.NH1836
 {
 	using System.Threading.Tasks;
-	using System.Threading;
 	[TestFixture]
 	public class FixtureAsync : BugTestCase
 	{
@@ -70,7 +69,7 @@ public async Task AliasToBeanTransformerShouldApplyCorrectlyToQueryBatchAsync()
 				                                 .SetResultTransformer(Transformers.AliasToBean(typeof(EntityDTO))));
 
 				Assert.That(multiQuery.Execute, Throws.Nothing);
-				var results = await (multiQuery.GetResultAsync<EntityDTO>(0, CancellationToken.None));
+				var results = await (multiQuery.GetResultAsync<EntityDTO>(0));
 				Assert.That(results.First(), Is.TypeOf<EntityDTO>().And.Property("EntityId").EqualTo(1));
 				await (t.CommitAsync());
 			}

diff --git a/src/NHibernate.Test/Async/NHSpecificTest/NH1869/Fixture.cs b/src/NHibernate.Test/Async/NHSpecificTest/NH1869/Fixture.cs
@@ -107,8 +107,8 @@ public async Task TestWithQueryBatchAsync()
 			using (var session = Sfi.OpenSession())
 			{
 				var result = await (GetResultWithQueryBatchAsync(session));
-				Assert.That(await (result.GetResultAsync<NodeKeyword>(0, CancellationToken.None)), Has.Count.EqualTo(1));
-				Assert.That(await (result.GetResultAsync<NodeKeyword>(1, CancellationToken.None)), Has.Count.EqualTo(1));
+				Assert.That(await (result.GetResultAsync<NodeKeyword>(0)), Has.Count.EqualTo(1));
+				Assert.That(await (result.GetResultAsync<NodeKeyword>(1)), Has.Count.EqualTo(1));
 			}
 		}
 

diff --git a/src/NHibernate.Test/Async/NHSpecificTest/NH2195/SQLiteMultiCriteriaTest.cs b/src/NHibernate.Test/Async/NHSpecificTest/NH2195/SQLiteMultiCriteriaTest.cs
@@ -20,7 +20,6 @@
 namespace NHibernate.Test.NHSpecificTest.NH2195
 {
 	using System.Threading.Tasks;
-	using System.Threading;
 	[TestFixture]
 	public class SQLiteMultiCriteriaTestAsync : BugTestCase
 	{
@@ -173,8 +172,8 @@ public async Task QueryBatchWithIntsShouldExecuteCorrectlyAsync()
 				multi.Add<DomainClass>(criteriaWithPagination);
 				multi.Add<long>(criteriaWithRowCount);
 
-				var numResults = (await (multi.GetResultAsync<long>(1, CancellationToken.None))).Single();
-				var list = await (multi.GetResultAsync<DomainClass>(0, CancellationToken.None));
+				var numResults = (await (multi.GetResultAsync<long>(1))).Single();
+				var list = await (multi.GetResultAsync<DomainClass>(0));
 
 				Assert.That(numResults, Is.EqualTo(2));
 				Assert.That(list.Count, Is.EqualTo(1));
@@ -198,8 +197,8 @@ public async Task QueryBatchWithStringsShouldExecuteCorrectlyAsync()
 				multi.Add<DomainClass>(criteriaWithPagination);
 				multi.Add<long>(criteriaWithRowCount);
 
-				var numResults = (await (multi.GetResultAsync<long>(1, CancellationToken.None))).Single();
-				var list = await (multi.GetResultAsync<DomainClass>(0, CancellationToken.None));
+				var numResults = (await (multi.GetResultAsync<long>(1))).Single();
+				var list = await (multi.GetResultAsync<DomainClass>(0));
 
 				Assert.That(numResults, Is.EqualTo(2));
 				Assert.That(list.Count, Is.EqualTo(1));

diff --git a/src/NHibernate.Test/Async/NHSpecificTest/NH2201/Fixture.cs b/src/NHibernate.Test/Async/NHSpecificTest/NH2201/Fixture.cs
@@ -16,7 +16,6 @@
 namespace NHibernate.Test.NHSpecificTest.NH2201
 {
 	using System.Threading.Tasks;
-	using System.Threading;
 	[TestFixture]
 	public class FixtureAsync : BugTestCase
 	{
@@ -78,8 +77,8 @@ public async Task CanUseQueryBatchAndFetchSelectAsync()
 					 .Add<Parent>(s.CreateCriteria<Parent>())
 					 .Add<Parent>(s.CreateCriteria<Parent>());
 
-				var result1 = await (multi.GetResultAsync<Parent>(0, CancellationToken.None));
-				var result2 = await (multi.GetResultAsync<Parent>(1, CancellationToken.None));
+				var result1 = await (multi.GetResultAsync<Parent>(0));
+				var result2 = await (multi.GetResultAsync<Parent>(1));
 
 				Assert.That(result1.Count, Is.EqualTo(2));
 				Assert.That(result2.Count, Is.EqualTo(2));

diff --git a/src/NHibernate.Test/Async/NHSpecificTest/NH2959/Fixture.cs b/src/NHibernate.Test/Async/NHSpecificTest/NH2959/Fixture.cs
@@ -15,7 +15,6 @@
 namespace NHibernate.Test.NHSpecificTest.NH2959
 {
 	using System.Threading.Tasks;
-	using System.Threading;
 	[TestFixture]
 	public class FixtureAsync : BugTestCase
 	{
@@ -89,7 +88,7 @@ public async Task CanUsePolymorphicCriteriaInQueryBatchAsync()
 			{
 				var results = await (session.CreateQueryBatch()
 				                     .Add<BaseEntity>(session.CreateCriteria(typeof(BaseEntity)))
-				                     .GetResultAsync<BaseEntity>(0, CancellationToken.None));
+				                     .GetResultAsync<BaseEntity>(0));
 
 				Assert.That(results, Has.Count.EqualTo(2));
 			}
@@ -103,7 +102,7 @@ public async Task CanUsePolymorphicQueryInQueryBatchAsync()
 			{
 				var results = await (session.CreateQueryBatch()
 				                     .Add<BaseEntity>(session.CreateQuery("from " + typeof(BaseEntity).FullName))
-				                     .GetResultAsync<BaseEntity>(0, CancellationToken.None));
+				                     .GetResultAsync<BaseEntity>(0));
 
 				Assert.That(results, Has.Count.EqualTo(2));
 			}

diff --git a/src/NHibernate.Test/Async/NHSpecificTest/SqlConverterAndMultiQuery/Fixture.cs b/src/NHibernate.Test/Async/NHSpecificTest/SqlConverterAndMultiQuery/Fixture.cs
@@ -18,7 +18,6 @@
 namespace NHibernate.Test.NHSpecificTest.SqlConverterAndMultiQuery
 {
 	using System.Threading.Tasks;
-	using System.Threading;
 	[TestFixture]
 	public class FixtureAsync : BugTestCase
 	{
@@ -76,7 +75,7 @@ public void QueryBatchShouldThrowUserExceptionAsync()
 				var multi = s.CreateQueryBatch();
 				multi.Add<int>(s.CreateQuery(hqlQuery));
 				s.Connection.Close();
-				Assert.ThrowsAsync<UnitTestException>(() => multi.ExecuteAsync(CancellationToken.None));
+				Assert.ThrowsAsync<UnitTestException>(() => multi.ExecuteAsync());
 			}
 		}
 
@@ -118,7 +117,7 @@ public void CriteriaQueryBatchShouldThrowUserExceptionAsync()
 				var multi = s.CreateQueryBatch();
 				multi.Add<ClassA>(s.CreateCriteria(typeof(ClassA)));
 				s.Connection.Close();
-				Assert.ThrowsAsync<UnitTestException>(() => multi.ExecuteAsync(CancellationToken.None));
+				Assert.ThrowsAsync<UnitTestException>(() => multi.ExecuteAsync());
 			}
 		}
 	}

diff --git a/src/NHibernate.Test/Async/Pagination/CustomDialectFixture.cs b/src/NHibernate.Test/Async/Pagination/CustomDialectFixture.cs
@@ -23,7 +23,6 @@
 namespace NHibernate.Test.Pagination
 {
 	using System.Threading.Tasks;
-	using System.Threading;
 	[TestFixture]
 	public class CustomDialectFixtureAsync : TestCase
 	{
@@ -153,7 +152,7 @@ public async Task LimitFirstQueryBatchAsync()
 						  .SetFirstResult(1)
 						  .SetMaxResults(2));
 
-				var points = await (query.GetResultAsync<DataPoint>(0, CancellationToken.None));
+				var points = await (query.GetResultAsync<DataPoint>(0));
 
 				Assert.That(points.Count, Is.EqualTo(2));
 				Assert.That(points[0].X, Is.EqualTo(7d));