From a7e13d06d552452916cbde97a1c6c8c64061f5c2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20Delaporte?= <12201973+fredericdelaporte@users.noreply.github.com> Date: Tue, 11 Dec 2018 15:56:12 +0100 Subject: [PATCH 1/2] Upgrade AsyncGenerator to 0.13.1 --- Tools/packages.config | 2 +- .../Async/Linq/QueryTimeoutTests.cs | 22 +- .../Async/NHSpecificTest/GH1547/Fixture.cs | 9 +- .../Async/NHSpecificTest/NH3848/Fixture.cs | 19 +- .../Async/SessionBuilder/Fixture.cs | 45 ---- .../DistributedSystemTransactionFixture.cs | 13 +- .../TransactionNotificationFixture.cs | 22 +- src/NHibernate.sln.DotSettings | 6 + .../Async/Action/CollectionAction.cs | 11 +- .../Action/EntityIdentityInsertAction.cs | 19 +- .../AbstractPersistentCollection.cs | 33 ++- src/NHibernate/Async/Engine/ActionQueue.cs | 13 +- .../Async/Engine/BatchFetchQueue.cs | 208 ++++++++++-------- .../Async/Event/Default/AbstractVisitor.cs | 9 +- .../DefaultFlushEntityEventListener.cs | 31 +-- .../Event/Default/DefaultLoadEventListener.cs | 45 ++-- src/NHibernate/Async/Impl/SessionImpl.cs | 13 +- .../Async/Impl/StatelessSessionImpl.cs | 34 +-- src/NHibernate/Async/Multi/QueryBatch.cs | 18 +- .../Collection/AbstractCollectionPersister.cs | 11 +- src/NHibernate/Async/Type/AnyType.cs | 11 +- src/NHibernate/Async/Type/ClassMetaType.cs | 9 +- 22 files changed, 247 insertions(+), 356 deletions(-) diff --git a/Tools/packages.config b/Tools/packages.config index 438a75071ab..02ff3ebc965 100644 --- a/Tools/packages.config +++ b/Tools/packages.config @@ -7,7 +7,7 @@ - + diff --git a/src/NHibernate.Test/Async/Linq/QueryTimeoutTests.cs b/src/NHibernate.Test/Async/Linq/QueryTimeoutTests.cs index 5d72e1ae54d..2f3cdba95a4 100644 --- a/src/NHibernate.Test/Async/Linq/QueryTimeoutTests.cs +++ b/src/NHibernate.Test/Async/Linq/QueryTimeoutTests.cs @@ -114,15 +114,8 @@ public TimeoutCatchingNonBatchingBatcher(ConnectionManager connectionManager, II public override Task ExecuteReaderAsync(DbCommand cmd, CancellationToken cancellationToken) { - try - { - LastCommandTimeout = cmd.CommandTimeout; - return base.ExecuteReaderAsync(cmd, cancellationToken); - } - catch (System.Exception ex) - { - return Task.FromException(ex); - } + LastCommandTimeout = cmd.CommandTimeout; + return base.ExecuteReaderAsync(cmd, cancellationToken); } public override DbDataReader ExecuteReader(DbCommand cmd) @@ -150,15 +143,8 @@ public partial class TimeoutCatchingNonBatchingBatcher : NonBatchingBatcher public override Task ExecuteReaderAsync(DbCommand cmd, CancellationToken cancellationToken) { - try - { - LastCommandTimeout = cmd.CommandTimeout; - return base.ExecuteReaderAsync(cmd, cancellationToken); - } - catch (System.Exception ex) - { - return Task.FromException(ex); - } + LastCommandTimeout = cmd.CommandTimeout; + return base.ExecuteReaderAsync(cmd, cancellationToken); } } } diff --git a/src/NHibernate.Test/Async/NHSpecificTest/GH1547/Fixture.cs b/src/NHibernate.Test/Async/NHSpecificTest/GH1547/Fixture.cs index 5077e7979e1..f55778a975f 100644 --- a/src/NHibernate.Test/Async/NHSpecificTest/GH1547/Fixture.cs +++ b/src/NHibernate.Test/Async/NHSpecificTest/GH1547/Fixture.cs @@ -158,14 +158,7 @@ private partial class SubstituteDbCommand : DbCommand protected override Task ExecuteDbDataReaderAsync(CommandBehavior behavior, CancellationToken cancellationToken) { - try - { - return Task.FromResult(_substituteReader); - } - catch (Exception ex) - { - return Task.FromException(ex); - } + return Task.FromResult(_substituteReader); } public override Task ExecuteNonQueryAsync(CancellationToken cancellationToken) diff --git a/src/NHibernate.Test/Async/NHSpecificTest/NH3848/Fixture.cs b/src/NHibernate.Test/Async/NHSpecificTest/NH3848/Fixture.cs index be5a8125f28..26ecc4db471 100644 --- a/src/NHibernate.Test/Async/NHSpecificTest/NH3848/Fixture.cs +++ b/src/NHibernate.Test/Async/NHSpecificTest/NH3848/Fixture.cs @@ -573,20 +573,13 @@ protected void ClearSecondLevelCacheFor(System.Type entity) protected Task ClearCollectionCacheAsync(Expression> pathToCollection, CancellationToken cancellationToken = default(CancellationToken)) { - try - { - var rootEntityTypeFullPath = typeof(T).FullName; - var memberExpression = pathToCollection.Body as MemberExpression; - if (memberExpression == null) - return Task.FromException(new ArgumentException("pathToCollection should be member expression")); + var rootEntityTypeFullPath = typeof(T).FullName; + var memberExpression = pathToCollection.Body as MemberExpression; + if (memberExpression == null) + return Task.FromException(new ArgumentException("pathToCollection should be member expression")); - var role = $"{rootEntityTypeFullPath}.{memberExpression.Member.Name}"; - return Sfi.EvictCollectionAsync(role, cancellationToken); - } - catch (Exception ex) - { - return Task.FromException(ex); - } + var role = $"{rootEntityTypeFullPath}.{memberExpression.Member.Name}"; + return Sfi.EvictCollectionAsync(role, cancellationToken); } protected void ClearCollectionCache(Expression> pathToCollection) diff --git a/src/NHibernate.Test/Async/SessionBuilder/Fixture.cs b/src/NHibernate.Test/Async/SessionBuilder/Fixture.cs index bebdb8fe084..0cd255eae26 100644 --- a/src/NHibernate.Test/Async/SessionBuilder/Fixture.cs +++ b/src/NHibernate.Test/Async/SessionBuilder/Fixture.cs @@ -189,51 +189,6 @@ private void CanSetFlushMode(T sb) where T : ISessionBuilder FlushMode.Always, FlushMode.Auto, FlushMode.Commit, FlushMode.Manual); } - [Test] - public async Task CanSetInterceptorAsync() - { - var sb = Sfi.WithOptions(); - await (CanSetInterceptorAsync(sb)); - using (var s = sb.OpenSession()) - { - await (CanSetInterceptorAsync(s.SessionWithOptions())); - } - } - - private Task CanSetInterceptorAsync(T sb) where T : ISessionBuilder - { - try - { - var sbType = sb.GetType().Name; - // Do not use .Instance here, we want another instance. - var interceptor = new EmptyInterceptor(); - var options = DebugSessionFactory.GetCreationOptions(sb); - - Assert.AreEqual(Sfi.Interceptor, options.SessionInterceptor, $"{sbType}: Initial value"); - var fsb = sb.Interceptor(interceptor); - Assert.AreEqual(interceptor, options.SessionInterceptor, $"{sbType}: After call with an interceptor"); - Assert.AreEqual(sb, fsb, $"{sbType}: Unexpected fluent return after call with an interceptor"); - - if (sb is ISharedSessionBuilder ssb) - { - var fssb = ssb.Interceptor(); - Assert.AreEqual(EmptyInterceptor.Instance, options.SessionInterceptor, $"{sbType}: After call with shared interceptor"); - Assert.AreEqual(sb, fssb, $"{sbType}: Unexpected fluent return on shared"); - } - - Assert.Throws(() => sb.Interceptor(null), $"{sbType}: After call with null"); - - fsb = sb.NoInterceptor(); - Assert.AreEqual(EmptyInterceptor.Instance, options.SessionInterceptor, $"{sbType}: After no call"); - Assert.AreEqual(sb, fsb, $"{sbType}: Unexpected fluent return after no call"); - return Task.CompletedTask; - } - catch (Exception ex) - { - return Task.FromException(ex); - } - } - private void CanSet(T sb, Func setter, Func getter, Func shared, V initialValue, params V[] values) where T : ISessionBuilder { diff --git a/src/NHibernate.Test/Async/SystemTransactions/DistributedSystemTransactionFixture.cs b/src/NHibernate.Test/Async/SystemTransactions/DistributedSystemTransactionFixture.cs index d8cafe793a3..adf6c455d3c 100644 --- a/src/NHibernate.Test/Async/SystemTransactions/DistributedSystemTransactionFixture.cs +++ b/src/NHibernate.Test/Async/SystemTransactions/DistributedSystemTransactionFixture.cs @@ -690,16 +690,9 @@ public async Task EnforceConnectionUsageRulesOnTransactionCompletionAsync() private Task DodgeTransactionCompletionDelayIfRequiredAsync(CancellationToken cancellationToken = default(CancellationToken)) { - try - { - if (Sfi.ConnectionProvider.Driver.HasDelayedDistributedTransactionCompletion) - return Task.Delay(500, cancellationToken); - return Task.CompletedTask; - } - catch (Exception ex) - { - return Task.FromException(ex); - } + if (Sfi.ConnectionProvider.Driver.HasDelayedDistributedTransactionCompletion) + return Task.Delay(500, cancellationToken); + return Task.CompletedTask; } private void DodgeTransactionCompletionDelayIfRequired() diff --git a/src/NHibernate.Test/Async/TransactionTest/TransactionNotificationFixture.cs b/src/NHibernate.Test/Async/TransactionTest/TransactionNotificationFixture.cs index 0f262c29ddd..9403ebaac10 100644 --- a/src/NHibernate.Test/Async/TransactionTest/TransactionNotificationFixture.cs +++ b/src/NHibernate.Test/Async/TransactionTest/TransactionNotificationFixture.cs @@ -132,28 +132,14 @@ public partial class Synchronization : ITransactionCompletionSynchronization public Task ExecuteBeforeTransactionCompletionAsync(CancellationToken cancellationToken) { - try - { - BeforeExecutions += 1; - return Task.CompletedTask; - } - catch (Exception ex) - { - return Task.FromException(ex); - } + BeforeExecutions += 1; + return Task.CompletedTask; } public Task ExecuteAfterTransactionCompletionAsync(bool success, CancellationToken cancellationToken) { - try - { - AfterExecutions += 1; - return Task.CompletedTask; - } - catch (Exception ex) - { - return Task.FromException(ex); - } + AfterExecutions += 1; + return Task.CompletedTask; } } diff --git a/src/NHibernate.sln.DotSettings b/src/NHibernate.sln.DotSettings index a38b0a203a1..e159fd0bbbc 100644 --- a/src/NHibernate.sln.DotSettings +++ b/src/NHibernate.sln.DotSettings @@ -7,7 +7,9 @@ True True True + NEVER False + NEVER False True True @@ -20,9 +22,13 @@ <Policy Inspect="True" Prefix="_" Suffix="" Style="aaBb" /> <Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /> True + True + True True + True True True + True True True NUnit Assert.NotNull diff --git a/src/NHibernate/Async/Action/CollectionAction.cs b/src/NHibernate/Async/Action/CollectionAction.cs index 62582ddb9c1..8b84803547c 100644 --- a/src/NHibernate/Async/Action/CollectionAction.cs +++ b/src/NHibernate/Async/Action/CollectionAction.cs @@ -55,15 +55,8 @@ public virtual Task ExecuteAfterTransactionCompletionAsync(bool success, Cancell { return Task.FromCanceled(cancellationToken); } - try - { - var ck = new CacheKey(key, persister.KeyType, persister.Role, Session.Factory); - return persister.Cache.ReleaseAsync(ck, softLock, cancellationToken); - } - catch (Exception ex) - { - return Task.FromException(ex); - } + var ck = new CacheKey(key, persister.KeyType, persister.Role, Session.Factory); + return persister.Cache.ReleaseAsync(ck, softLock, cancellationToken); } #endregion diff --git a/src/NHibernate/Async/Action/EntityIdentityInsertAction.cs b/src/NHibernate/Async/Action/EntityIdentityInsertAction.cs index 633fafe1a80..f84c27cc9dd 100644 --- a/src/NHibernate/Async/Action/EntityIdentityInsertAction.cs +++ b/src/NHibernate/Async/Action/EntityIdentityInsertAction.cs @@ -121,24 +121,17 @@ protected override Task AfterTransactionCompletionProcessImplAsync(bool success, { return Task.FromCanceled(cancellationToken); } - try - { - //TODO Make 100% certain that this is called before any subsequent ScheduledUpdate.afterTransactionCompletion()!! - //TODO from H3.2: reenable if we also fix the above todo - /*EntityPersister persister = getEntityPersister(); + //TODO Make 100% certain that this is called before any subsequent ScheduledUpdate.afterTransactionCompletion()!! + //TODO from H3.2: reenable if we also fix the above todo + /*EntityPersister persister = getEntityPersister(); if ( success && persister.hasCache() && !persister.isCacheInvalidationRequired() ) { persister.getCache().afterInsert( getGeneratedId(), cacheEntry ); }*/ - if (success) - { - return PostCommitInsertAsync(cancellationToken); - } - return Task.CompletedTask; - } - catch (Exception ex) + if (success) { - return Task.FromException(ex); + return PostCommitInsertAsync(cancellationToken); } + return Task.CompletedTask; } } } diff --git a/src/NHibernate/Async/Collection/AbstractPersistentCollection.cs b/src/NHibernate/Async/Collection/AbstractPersistentCollection.cs index cbff191d3fa..00b1c3cccb3 100644 --- a/src/NHibernate/Async/Collection/AbstractPersistentCollection.cs +++ b/src/NHibernate/Async/Collection/AbstractPersistentCollection.cs @@ -73,30 +73,23 @@ public virtual Task ForceInitializationAsync(CancellationToken cancellationToken { return Task.FromCanceled(cancellationToken); } - try + if (!initialized) { - if (!initialized) + if (initializing) { - if (initializing) - { - return Task.FromException(new AssertionFailure("force initialize loading collection")); - } - if (session == null) - { - return Task.FromException(new HibernateException("collection is not associated with any session")); - } - if (!session.IsConnected) - { - return Task.FromException(new HibernateException("disconnected session")); - } - return session.InitializeCollectionAsync(this, false, cancellationToken); + return Task.FromException(new AssertionFailure("force initialize loading collection")); } - return Task.CompletedTask; - } - catch (Exception ex) - { - return Task.FromException(ex); + if (session == null) + { + return Task.FromException(new HibernateException("collection is not associated with any session")); + } + if (!session.IsConnected) + { + return Task.FromException(new HibernateException("disconnected session")); + } + return session.InitializeCollectionAsync(this, false, cancellationToken); } + return Task.CompletedTask; } public Task GetQueuedOrphansAsync(string entityName, CancellationToken cancellationToken) diff --git a/src/NHibernate/Async/Engine/ActionQueue.cs b/src/NHibernate/Async/Engine/ActionQueue.cs index 204ba7cd8d6..80fe7b063a5 100644 --- a/src/NHibernate/Async/Engine/ActionQueue.cs +++ b/src/NHibernate/Async/Engine/ActionQueue.cs @@ -46,18 +46,11 @@ private Task PreInvalidateCachesAsync(CancellationToken cancellationToken) { return Task.FromCanceled(cancellationToken); } - try - { - if (session.Factory.Settings.IsQueryCacheEnabled) - { - return session.Factory.UpdateTimestampsCache.PreInvalidateAsync(executedSpaces, cancellationToken); - } - return Task.CompletedTask; - } - catch (Exception ex) + if (session.Factory.Settings.IsQueryCacheEnabled) { - return Task.FromException(ex); + return session.Factory.UpdateTimestampsCache.PreInvalidateAsync(executedSpaces, cancellationToken); } + return Task.CompletedTask; } public async Task ExecuteAsync(IExecutable executable, CancellationToken cancellationToken) diff --git a/src/NHibernate/Async/Engine/BatchFetchQueue.cs b/src/NHibernate/Async/Engine/BatchFetchQueue.cs index 83cbbd1a928..4a20cad9677 100644 --- a/src/NHibernate/Async/Engine/BatchFetchQueue.cs +++ b/src/NHibernate/Async/Engine/BatchFetchQueue.cs @@ -134,82 +134,89 @@ async Task CheckCacheAndProcessResultAsync() Task ProcessKeyAsync(KeyValuePair me, bool ignoreCache = false) { - var ce = me.Key; - var collection = me.Value; - if (ce.LoadedKey == null) + try { - // the LoadedKey of the CollectionEntry might be null as it might have been reset to null - // (see for example Collections.ProcessDereferencedCollection() - // and CollectionEntry.AfterAction()) - // though we clear the queue on flush, it seems like a good idea to guard - // against potentially null LoadedKey:s - return Task.FromResult(false); - } + var ce = me.Key; + var collection = me.Value; + if (ce.LoadedKey == null) + { + // the LoadedKey of the CollectionEntry might be null as it might have been reset to null + // (see for example Collections.ProcessDereferencedCollection() + // and CollectionEntry.AfterAction()) + // though we clear the queue on flush, it seems like a good idea to guard + // against potentially null LoadedKey:s + return Task.FromResult(false); + } - if (collection.WasInitialized) - { - log.Warn("Encountered initialized collection in BatchFetchQueue, this should not happen."); - return Task.FromResult(false); - } + if (collection.WasInitialized) + { + log.Warn("Encountered initialized collection in BatchFetchQueue, this should not happen."); + return Task.FromResult(false); + } - if (checkForEnd && (index == map.Count || index >= keyIndex.Value + batchSize)) - { - return Task.FromResult(true); - } - if (collectionPersister.KeyType.IsEqual(key, ce.LoadedKey, collectionPersister.Factory)) - { - if (collectionEntries != null) + if (checkForEnd && (index == map.Count || index >= keyIndex.Value + batchSize)) { - collectionEntries[0] = ce; + return Task.FromResult(true); } - keyIndex = index; - } - else if (!checkCache || batchableCache == null) - { - if (index < map.Count && (!keyIndex.HasValue || index < keyIndex.Value)) + if (collectionPersister.KeyType.IsEqual(key, ce.LoadedKey, collectionPersister.Factory)) { - collectionKeys.Add(new KeyValuePair, int>(me, index)); - return Task.FromResult(false); + if (collectionEntries != null) + { + collectionEntries[0] = ce; + } + keyIndex = index; } + else if (!checkCache || batchableCache == null) + { + if (index < map.Count && (!keyIndex.HasValue || index < keyIndex.Value)) + { + collectionKeys.Add(new KeyValuePair, int>(me, index)); + return Task.FromResult(false); + } - // No need to check "!checkCache || !IsCached(ce.LoadedKey, collectionPersister)": - // "batchableCache == null" already means there is no cache, so IsCached can only yield false. - // (This method is now removed.) - if (collectionEntries != null) + // No need to check "!checkCache || !IsCached(ce.LoadedKey, collectionPersister)": + // "batchableCache == null" already means there is no cache, so IsCached can only yield false. + // (This method is now removed.) + if (collectionEntries != null) + { + collectionEntries[i] = ce; + } + keys[i++] = ce.LoadedKey; + } + else if (ignoreCache) { - collectionEntries[i] = ce; + if (collectionEntries != null) + { + collectionEntries[i] = ce; + } + keys[i++] = ce.LoadedKey; } - keys[i++] = ce.LoadedKey; - } - else if (ignoreCache) - { - if (collectionEntries != null) + else { - collectionEntries[i] = ce; + collectionKeys.Add(new KeyValuePair, int>(me, index)); + // Check the cache only when we have collected as many keys as are needed to fill the batch, + // that are after the demanded key. + if (!keyIndex.HasValue || index < keyIndex.Value + batchSize) + { + return Task.FromResult(false); + } + return CheckCacheAndProcessResultAsync(); } - keys[i++] = ce.LoadedKey; - } - else - { - collectionKeys.Add(new KeyValuePair, int>(me, index)); - // Check the cache only when we have collected as many keys as are needed to fill the batch, - // that are after the demanded key. - if (!keyIndex.HasValue || index < keyIndex.Value + batchSize) + if (i == batchSize) { - return Task.FromResult(false); + i = 1; // End of array, start filling again from start + if (index == map.Count || keyIndex.HasValue) + { + checkForEnd = true; + return Task.FromResult(index == map.Count || index >= keyIndex.Value + batchSize); + } } - return CheckCacheAndProcessResultAsync(); + return Task.FromResult(false); } - if (i == batchSize) + catch (Exception ex) { - i = 1; // End of array, start filling again from start - if (index == map.Count || keyIndex.HasValue) - { - checkForEnd = true; - return Task.FromResult(index == map.Count || index >= keyIndex.Value + batchSize); - } + return Task.FromException(ex); } - return Task.FromResult(false); } } @@ -326,53 +333,60 @@ async Task CheckCacheAndProcessResultAsync() Task ProcessKeyAsync(EntityKey key, bool ignoreCache = false) { - //TODO: this needn't exclude subclasses... - if (checkForEnd && (index == set.Count || index >= idIndex.Value + batchSize)) - { - return Task.FromResult(true); - } - if (persister.IdentifierType.IsEqual(id, key.Identifier)) - { - idIndex = index; - } - else if (!checkCache || batchableCache == null) + try { - if (index < set.Count && (!idIndex.HasValue || index < idIndex.Value)) + //TODO: this needn't exclude subclasses... + if (checkForEnd && (index == set.Count || index >= idIndex.Value + batchSize)) { - entityKeys.Add(new KeyValuePair(key, index)); - return Task.FromResult(false); + return Task.FromResult(true); + } + if (persister.IdentifierType.IsEqual(id, key.Identifier)) + { + idIndex = index; } + else if (!checkCache || batchableCache == null) + { + if (index < set.Count && (!idIndex.HasValue || index < idIndex.Value)) + { + entityKeys.Add(new KeyValuePair(key, index)); + return Task.FromResult(false); + } - // No need to check "!checkCache || !IsCached(key, persister)": "batchableCache == null" - // already means there is no cache, so IsCached can only yield false. (This method is now - // removed.) - ids[i++] = key.Identifier; - } - else if (ignoreCache) - { - ids[i++] = key.Identifier; - } - else - { - entityKeys.Add(new KeyValuePair(key, index)); - // Check the cache only when we have collected as many keys as are needed to fill the batch, - // that are after the demanded key. - if (!idIndex.HasValue || index < idIndex.Value + batchSize) + // No need to check "!checkCache || !IsCached(key, persister)": "batchableCache == null" + // already means there is no cache, so IsCached can only yield false. (This method is now + // removed.) + ids[i++] = key.Identifier; + } + else if (ignoreCache) { - return Task.FromResult(false); + ids[i++] = key.Identifier; } - return CheckCacheAndProcessResultAsync(); - } - if (i == batchSize) - { - i = 1; // End of array, start filling again from start - if (index == set.Count || idIndex.HasValue) + else + { + entityKeys.Add(new KeyValuePair(key, index)); + // Check the cache only when we have collected as many keys as are needed to fill the batch, + // that are after the demanded key. + if (!idIndex.HasValue || index < idIndex.Value + batchSize) + { + return Task.FromResult(false); + } + return CheckCacheAndProcessResultAsync(); + } + if (i == batchSize) { - checkForEnd = true; - return Task.FromResult(index == set.Count || index >= idIndex.Value + batchSize); + i = 1; // End of array, start filling again from start + if (index == set.Count || idIndex.HasValue) + { + checkForEnd = true; + return Task.FromResult(index == set.Count || index >= idIndex.Value + batchSize); + } } + return Task.FromResult(false); + } + catch (Exception ex) + { + return Task.FromException(ex); } - return Task.FromResult(false); } } diff --git a/src/NHibernate/Async/Event/Default/AbstractVisitor.cs b/src/NHibernate/Async/Event/Default/AbstractVisitor.cs index 1729e45d40e..ac40e1dc682 100644 --- a/src/NHibernate/Async/Event/Default/AbstractVisitor.cs +++ b/src/NHibernate/Async/Event/Default/AbstractVisitor.cs @@ -38,7 +38,14 @@ internal virtual Task ProcessValueAsync(int i, object[] values, IType[] types, C { return Task.FromCanceled(cancellationToken); } - return ProcessValueAsync(values[i], types[i], cancellationToken); + try + { + return ProcessValueAsync(values[i], types[i], cancellationToken); + } + catch (System.Exception ex) + { + return Task.FromException(ex); + } } /// diff --git a/src/NHibernate/Async/Event/Default/DefaultFlushEntityEventListener.cs b/src/NHibernate/Async/Event/Default/DefaultFlushEntityEventListener.cs index 9bf172e0043..1341bccd9d2 100644 --- a/src/NHibernate/Async/Event/Default/DefaultFlushEntityEventListener.cs +++ b/src/NHibernate/Async/Event/Default/DefaultFlushEntityEventListener.cs @@ -342,33 +342,26 @@ protected Task IsUpdateNecessaryAsync(FlushEntityEvent @event, Cancellatio { return Task.FromCanceled(cancellationToken); } - try + IEntityPersister persister = @event.EntityEntry.Persister; + Status status = @event.EntityEntry.Status; + + if (!@event.DirtyCheckPossible) + { + return Task.FromResult(true); + } + else { - IEntityPersister persister = @event.EntityEntry.Persister; - Status status = @event.EntityEntry.Status; - if (!@event.DirtyCheckPossible) + int[] dirtyProperties = @event.DirtyProperties; + if (dirtyProperties != null && dirtyProperties.Length != 0) { - return Task.FromResult(true); + return Task.FromResult(true); //TODO: suck into event class } else { - - int[] dirtyProperties = @event.DirtyProperties; - if (dirtyProperties != null && dirtyProperties.Length != 0) - { - return Task.FromResult(true); //TODO: suck into event class - } - else - { - return HasDirtyCollectionsAsync(@event, persister, status, cancellationToken); - } + return HasDirtyCollectionsAsync(@event, persister, status, cancellationToken); } } - catch (Exception ex) - { - return Task.FromException(ex); - } } private async Task HasDirtyCollectionsAsync(FlushEntityEvent @event, IEntityPersister persister, Status status, CancellationToken cancellationToken) diff --git a/src/NHibernate/Async/Event/Default/DefaultLoadEventListener.cs b/src/NHibernate/Async/Event/Default/DefaultLoadEventListener.cs index 45f0295e6e4..46cdf81a439 100644 --- a/src/NHibernate/Async/Event/Default/DefaultLoadEventListener.cs +++ b/src/NHibernate/Async/Event/Default/DefaultLoadEventListener.cs @@ -449,33 +449,40 @@ protected virtual async Task LoadFromSecondLevelCacheAsync(LoadEvent @ev Task AssembleAsync(CacheKey ck, object ce, LoadEvent evt, bool alterStatistics) { - if (factory.Statistics.IsStatisticsEnabled && alterStatistics) + try { - if (ce == null) + if (factory.Statistics.IsStatisticsEnabled && alterStatistics) { - factory.StatisticsImplementor.SecondLevelCacheMiss(persister.Cache.RegionName); - log.Debug("Entity cache miss: {0}", ck); + if (ce == null) + { + factory.StatisticsImplementor.SecondLevelCacheMiss(persister.Cache.RegionName); + log.Debug("Entity cache miss: {0}", ck); + } + else + { + factory.StatisticsImplementor.SecondLevelCacheHit(persister.Cache.RegionName); + log.Debug("Entity cache hit: {0}", ck); + } } - else + + if (ce != null) { - factory.StatisticsImplementor.SecondLevelCacheHit(persister.Cache.RegionName); - log.Debug("Entity cache hit: {0}", ck); + CacheEntry entry = (CacheEntry) persister.CacheEntryStructure.Destructure(ce, factory); + + // Entity was found in second-level cache... + // NH: Different behavior (take a look to options.ExactPersister (NH-295)) + if (!options.ExactPersister || persister.EntityMetamodel.SubclassEntityNames.Contains(entry.Subclass)) + { + return AssembleCacheEntryAsync(entry, evt.EntityId, persister, evt, cancellationToken); + } } - } - if (ce != null) + return Task.FromResult(null); + } + catch (Exception ex) { - CacheEntry entry = (CacheEntry) persister.CacheEntryStructure.Destructure(ce, factory); - - // Entity was found in second-level cache... - // NH: Different behavior (take a look to options.ExactPersister (NH-295)) - if (!options.ExactPersister || persister.EntityMetamodel.SubclassEntityNames.Contains(entry.Subclass)) - { - return AssembleCacheEntryAsync(entry, evt.EntityId, persister, evt, cancellationToken); - } + return Task.FromException(ex); } - - return Task.FromResult(null); } } diff --git a/src/NHibernate/Async/Impl/SessionImpl.cs b/src/NHibernate/Async/Impl/SessionImpl.cs index 15f38e26943..5905e6801a9 100644 --- a/src/NHibernate/Async/Impl/SessionImpl.cs +++ b/src/NHibernate/Async/Impl/SessionImpl.cs @@ -1266,16 +1266,9 @@ public override Task FlushBeforeTransactionCompletionAsync(CancellationToken can { return Task.FromCanceled(cancellationToken); } - try - { - if (FlushMode != FlushMode.Manual) - return FlushAsync(cancellationToken); - return Task.CompletedTask; - } - catch (Exception ex) - { - return Task.FromException(ex); - } + if (FlushMode != FlushMode.Manual) + return FlushAsync(cancellationToken); + return Task.CompletedTask; } private async Task FireDeleteAsync(DeleteEvent @event, CancellationToken cancellationToken) diff --git a/src/NHibernate/Async/Impl/StatelessSessionImpl.cs b/src/NHibernate/Async/Impl/StatelessSessionImpl.cs index b713f0b5cf7..f1ba521b612 100644 --- a/src/NHibernate/Async/Impl/StatelessSessionImpl.cs +++ b/src/NHibernate/Async/Impl/StatelessSessionImpl.cs @@ -205,20 +205,13 @@ public override Task BeforeTransactionCompletionAsync(ITransaction tx, Cancellat { return Task.FromCanceled(cancellationToken); } - try - { - var context = TransactionContext; - if (tx == null && context == null) - return Task.FromException(new InvalidOperationException("Cannot complete a transaction without neither an explicit transaction nor an ambient one.")); - // Always allow flushing from explicit transactions, otherwise check if flushing from scope is enabled. - if (tx != null || context.CanFlushOnSystemTransactionCompleted) - return FlushBeforeTransactionCompletionAsync(cancellationToken); - return Task.CompletedTask; - } - catch (Exception ex) - { - return Task.FromException(ex); - } + var context = TransactionContext; + if (tx == null && context == null) + return Task.FromException(new InvalidOperationException("Cannot complete a transaction without neither an explicit transaction nor an ambient one.")); + // Always allow flushing from explicit transactions, otherwise check if flushing from scope is enabled. + if (tx != null || context.CanFlushOnSystemTransactionCompleted) + return FlushBeforeTransactionCompletionAsync(cancellationToken); + return Task.CompletedTask; } public override Task FlushBeforeTransactionCompletionAsync(CancellationToken cancellationToken) @@ -227,16 +220,9 @@ public override Task FlushBeforeTransactionCompletionAsync(CancellationToken can { return Task.FromCanceled(cancellationToken); } - try - { - if (FlushMode != FlushMode.Manual) - return FlushAsync(cancellationToken); - return Task.CompletedTask; - } - catch (Exception ex) - { - return Task.FromException(ex); - } + if (FlushMode != FlushMode.Manual) + return FlushAsync(cancellationToken); + return Task.CompletedTask; } public override Task AfterTransactionCompletionAsync(bool successful, ITransaction tx, CancellationToken cancellationToken) diff --git a/src/NHibernate/Async/Multi/QueryBatch.cs b/src/NHibernate/Async/Multi/QueryBatch.cs index e1faf9c5b47..0e8f03daadb 100644 --- a/src/NHibernate/Async/Multi/QueryBatch.cs +++ b/src/NHibernate/Async/Multi/QueryBatch.cs @@ -76,7 +76,14 @@ public Task> GetResultAsync(int queryIndex, Cancellation { return Task.FromCanceled>(cancellationToken); } - return GetResultsAsync(_queries[queryIndex], cancellationToken); + try + { + return GetResultsAsync(_queries[queryIndex], cancellationToken); + } + catch (Exception ex) + { + return Task.FromException>(ex); + } } /// @@ -86,7 +93,14 @@ public Task> GetResultAsync(string querykey, Cancellatio { return Task.FromCanceled>(cancellationToken); } - return GetResultsAsync(_queriesByKey[querykey], cancellationToken); + try + { + return GetResultsAsync(_queriesByKey[querykey], cancellationToken); + } + catch (Exception ex) + { + return Task.FromException>(ex); + } } private async Task> GetResultsAsync(IQueryBatchItem query, CancellationToken cancellationToken) diff --git a/src/NHibernate/Async/Persister/Collection/AbstractCollectionPersister.cs b/src/NHibernate/Async/Persister/Collection/AbstractCollectionPersister.cs index 892d506139e..eb15d667603 100644 --- a/src/NHibernate/Async/Persister/Collection/AbstractCollectionPersister.cs +++ b/src/NHibernate/Async/Persister/Collection/AbstractCollectionPersister.cs @@ -585,15 +585,8 @@ protected Task PerformInsertAsync(object ownerId, IPersistentCollection { return Task.FromCanceled(cancellationToken); } - try - { - IBinder binder = new GeneratedIdentifierBinder(ownerId, collection, entry, index, session, this); - return identityDelegate.PerformInsertAsync(SqlInsertRowString, session, binder, cancellationToken); - } - catch (Exception ex) - { - return Task.FromException(ex); - } + IBinder binder = new GeneratedIdentifierBinder(ownerId, collection, entry, index, session, this); + return identityDelegate.PerformInsertAsync(SqlInsertRowString, session, binder, cancellationToken); } protected partial class GeneratedIdentifierBinder : IBinder diff --git a/src/NHibernate/Async/Type/AnyType.cs b/src/NHibernate/Async/Type/AnyType.cs index bc44efe796b..996e25fa6bf 100644 --- a/src/NHibernate/Async/Type/AnyType.cs +++ b/src/NHibernate/Async/Type/AnyType.cs @@ -119,15 +119,8 @@ public override Task AssembleAsync(object cached, ISessionImplementor se { return Task.FromCanceled(cancellationToken); } - try - { - ObjectTypeCacheEntry e = cached as ObjectTypeCacheEntry; - return (e == null) ? Task.FromResult(null ): session.InternalLoadAsync(e.EntityName, e.Id, false, false, cancellationToken); - } - catch (Exception ex) - { - return Task.FromException(ex); - } + ObjectTypeCacheEntry e = cached as ObjectTypeCacheEntry; + return (e == null) ? Task.FromResult(null ): session.InternalLoadAsync(e.EntityName, e.Id, false, false, cancellationToken); } public override async Task DisassembleAsync(object value, ISessionImplementor session, object owner, CancellationToken cancellationToken) diff --git a/src/NHibernate/Async/Type/ClassMetaType.cs b/src/NHibernate/Async/Type/ClassMetaType.cs index bccfda22aea..71dab9deb5b 100644 --- a/src/NHibernate/Async/Type/ClassMetaType.cs +++ b/src/NHibernate/Async/Type/ClassMetaType.cs @@ -26,7 +26,14 @@ public override Task NullSafeGetAsync(DbDataReader rs, string[] names, I { return Task.FromCanceled(cancellationToken); } - return NullSafeGetAsync(rs, names[0], session, owner, cancellationToken); + try + { + return NullSafeGetAsync(rs, names[0], session, owner, cancellationToken); + } + catch (Exception ex) + { + return Task.FromException(ex); + } } public override Task NullSafeGetAsync(DbDataReader rs,string name,ISessionImplementor session,object owner, CancellationToken cancellationToken) From 2c3c3b7af7fe0d743be6463d7f0a7af06fb1f7b7 Mon Sep 17 00:00:00 2001 From: Alexander Zaytsev Date: Thu, 24 Jan 2019 09:39:31 +1300 Subject: [PATCH 2/2] Migrate settings once more --- src/NHibernate.sln.DotSettings | 1 + 1 file changed, 1 insertion(+) diff --git a/src/NHibernate.sln.DotSettings b/src/NHibernate.sln.DotSettings index e159fd0bbbc..d78384192e9 100644 --- a/src/NHibernate.sln.DotSettings +++ b/src/NHibernate.sln.DotSettings @@ -24,6 +24,7 @@ True True True + True True True True