diff --git a/Directory.Build.props b/Directory.Build.props index 5b17ca697b..c799903b81 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -128,4 +128,8 @@ + + + $(DefineConstants);DO_CONFIGURE_AWAIT_FALSE + diff --git a/Orm/Xtensive.Orm.SqlServer/Sql.Drivers.SqlServer/Connection.cs b/Orm/Xtensive.Orm.SqlServer/Sql.Drivers.SqlServer/Connection.cs index c05853c942..0389cbd45c 100644 --- a/Orm/Xtensive.Orm.SqlServer/Sql.Drivers.SqlServer/Connection.cs +++ b/Orm/Xtensive.Orm.SqlServer/Sql.Drivers.SqlServer/Connection.cs @@ -10,6 +10,7 @@ using Microsoft.Data.SqlClient; using System.Threading; using System.Threading.Tasks; +using Xtensive.Core; using SqlServerConnection = Microsoft.Data.SqlClient.SqlConnection; namespace Xtensive.Sql.Drivers.SqlServer @@ -143,11 +144,11 @@ public override async Task RollbackAsync(CancellationToken token = default) try { if (!IsTransactionZombied()) { - await ActiveTransaction.RollbackAsync(token).ConfigureAwait(false); + await ActiveTransaction.RollbackAsync(token).ConfigureAwaitFalse(); } } finally { - await ActiveTransaction.DisposeAsync().ConfigureAwait(false); + await ActiveTransaction.DisposeAsync().ConfigureAwaitFalse(); ClearActiveTransaction(); } } @@ -265,12 +266,12 @@ private async Task OpenWithCheckFastAsync(string checkQueryString, CancellationT while (!connectionChecked) { cancellationToken.ThrowIfCancellationRequested(); - await underlyingConnection.OpenAsync(cancellationToken).ConfigureAwait(false); + await underlyingConnection.OpenAsync(cancellationToken).ConfigureAwaitFalse(); try { var command = underlyingConnection.CreateCommand(); - await using (command.ConfigureAwait(false)) { + await using (command.ConfigureAwaitFalse()) { command.CommandText = checkQueryString; - _ = await command.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false); + _ = await command.ExecuteNonQueryAsync(cancellationToken).ConfigureAwaitFalse(); } connectionChecked = true; } @@ -308,27 +309,27 @@ private async Task OpenWithCheckAndNotificationAsync(string checkQueryString, await SqlHelper.NotifyConnectionOpeningAsync(accessors, UnderlyingConnection, (!connectionChecked && !restoreTriggered), cancellationToken) - .ConfigureAwait(false); + .ConfigureAwaitFalse(); - await underlyingConnection.OpenAsync(cancellationToken).ConfigureAwait(false); + await underlyingConnection.OpenAsync(cancellationToken).ConfigureAwaitFalse(); try { await SqlHelper.NotifyConnectionInitializingAsync(accessors, UnderlyingConnection, checkQueryString, (!connectionChecked && !restoreTriggered), cancellationToken) - .ConfigureAwait(false); + .ConfigureAwaitFalse(); var command = underlyingConnection.CreateCommand(); - await using (command.ConfigureAwait(false)) { + await using (command.ConfigureAwaitFalse()) { command.CommandText = checkQueryString; - _ = await command.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false); + _ = await command.ExecuteNonQueryAsync(cancellationToken).ConfigureAwaitFalse(); } connectionChecked = true; await SqlHelper.NotifyConnectionOpenedAsync(accessors, UnderlyingConnection, (!connectionChecked && !restoreTriggered), cancellationToken) - .ConfigureAwait(false); + .ConfigureAwaitFalse(); } catch (Exception exception) { await SqlHelper.NotifyConnectionOpeningFailedAsync(accessors, UnderlyingConnection, exception, (!connectionChecked && !restoreTriggered), cancellationToken) - .ConfigureAwait(false); + .ConfigureAwaitFalse(); if (InternalHelpers.ShouldRetryOn(exception)) { if (restoreTriggered) { diff --git a/Orm/Xtensive.Orm.SqlServer/Sql.Drivers.SqlServer/DriverFactory.cs b/Orm/Xtensive.Orm.SqlServer/Sql.Drivers.SqlServer/DriverFactory.cs index 8cf26837c0..07195c7115 100644 --- a/Orm/Xtensive.Orm.SqlServer/Sql.Drivers.SqlServer/DriverFactory.cs +++ b/Orm/Xtensive.Orm.SqlServer/Sql.Drivers.SqlServer/DriverFactory.cs @@ -10,6 +10,7 @@ using Microsoft.Data.SqlClient; using System.Threading; using System.Threading.Tasks; +using Xtensive.Core; using Xtensive.Orm; using Xtensive.Sql.Info; using Xtensive.SqlServer.Resources; @@ -65,18 +66,18 @@ private static async Task CreateMessageParserAsync( { bool isEnglish; var command = connection.CreateCommand(); - await using (command.ConfigureAwait(false)) { + await using (command.ConfigureAwaitFalse()) { command.CommandText = LangIdQuery; - isEnglish = (await command.ExecuteScalarAsync(token).ConfigureAwait(false)).ToString()=="0"; + isEnglish = (await command.ExecuteScalarAsync(token).ConfigureAwaitFalse()).ToString()=="0"; } var templates = new Dictionary(); command = connection.CreateCommand(); - await using (command.ConfigureAwait(false)) { + await using (command.ConfigureAwaitFalse()) { command.CommandText = MessagesQuery; - var reader = await command.ExecuteReaderAsync(token).ConfigureAwait(false); - await using (reader.ConfigureAwait(false)) { - while (await reader.ReadAsync(token).ConfigureAwait(false)) { + var reader = await command.ExecuteReaderAsync(token).ConfigureAwaitFalse(); + await using (reader.ConfigureAwaitFalse()) { + while (await reader.ReadAsync(token).ConfigureAwaitFalse()) { ReadMessageTemplate(reader, templates); } } @@ -97,9 +98,9 @@ private static bool IsAzure(SqlServerConnection connection) private static async Task IsAzureAsync(SqlServerConnection connection, CancellationToken token) { var command = connection.CreateCommand(); - await using (command.ConfigureAwait(false)) { + await using (command.ConfigureAwaitFalse()) { command.CommandText = VersionQuery; - return ((string) await command.ExecuteScalarAsync(token).ConfigureAwait(false)) + return ((string) await command.ExecuteScalarAsync(token).ConfigureAwaitFalse()) .IndexOf("Azure", StringComparison.Ordinal) >= 0; } } @@ -170,23 +171,23 @@ protected override async Task CreateDriverAsync( var isPooingOn = !IsPoolingOff(connectionString); configuration.EnsureConnectionIsAlive &= isPooingOn; - var connection = await CreateAndOpenConnectionAsync(connectionString, configuration, token).ConfigureAwait(false); - await using (connection.ConfigureAwait(false)) { + var connection = await CreateAndOpenConnectionAsync(connectionString, configuration, token).ConfigureAwaitFalse(); + await using (connection.ConfigureAwaitFalse()) { var isEnsureAlive = configuration.EnsureConnectionIsAlive; var forcedServerVersion = configuration.ForcedServerVersion; var isForcedVersion = !string.IsNullOrEmpty(forcedServerVersion); var isForcedAzure = isForcedVersion && forcedServerVersion.Equals("azure", StringComparison.OrdinalIgnoreCase); var isAzure = isForcedAzure - || (!isForcedVersion && await IsAzureAsync(connection, token).ConfigureAwait(false)); + || (!isForcedVersion && await IsAzureAsync(connection, token).ConfigureAwaitFalse()); var parser = isAzure ? new ErrorMessageParser() - : await CreateMessageParserAsync(connection, token).ConfigureAwait(false); + : await CreateMessageParserAsync(connection, token).ConfigureAwaitFalse(); var versionString = isForcedVersion ? isForcedAzure ? "10.0.0.0" : forcedServerVersion : connection.ServerVersion ?? string.Empty; var version = new Version(versionString); - var defaultSchema = await GetDefaultSchemaAsync(connection, token: token).ConfigureAwait(false); + var defaultSchema = await GetDefaultSchemaAsync(connection, token: token).ConfigureAwaitFalse(); return CreateDriverInstance(connectionString, isAzure, version, defaultSchema, parser, isEnsureAlive); } @@ -261,9 +262,9 @@ private static async Task CreateAndOpenConnectionAsync( if (!configuration.EnsureConnectionIsAlive) { if (configuration.DbConnectionAccessors.Count == 0) - await OpenConnectionFast(connection, initScript, true, token).ConfigureAwait(false); + await OpenConnectionFast(connection, initScript, true, token).ConfigureAwaitFalse(); else - await OpenConnectionWithNotification(connection, configuration, true, token).ConfigureAwait(false); + await OpenConnectionWithNotification(connection, configuration, true, token).ConfigureAwaitFalse(); return connection; } @@ -271,10 +272,10 @@ private static async Task CreateAndOpenConnectionAsync( ? CheckConnectionQuery : initScript; if (configuration.DbConnectionAccessors.Count == 0) - return await EnsureConnectionIsAliveFast(connection, testQuery, true, token).ConfigureAwait(false); + return await EnsureConnectionIsAliveFast(connection, testQuery, true, token).ConfigureAwaitFalse(); else return await EnsureConnectionIsAliveWithNotification(connection, testQuery, configuration.DbConnectionAccessors, true, token) - .ConfigureAwait(false); + .ConfigureAwaitFalse(); } private static async ValueTask OpenConnectionFast(SqlServerConnection connection, @@ -285,8 +286,8 @@ private static async ValueTask OpenConnectionFast(SqlServerConnection connection SqlHelper.ExecuteInitializationSql(connection, sqlScript); } else { - await connection.OpenAsync(token).ConfigureAwait(false); - await SqlHelper.ExecuteInitializationSqlAsync(connection, sqlScript, token).ConfigureAwait(false); + await connection.OpenAsync(token).ConfigureAwaitFalse(); + await SqlHelper.ExecuteInitializationSqlAsync(connection, sqlScript, token).ConfigureAwaitFalse(); } } @@ -362,20 +363,20 @@ private static async ValueTask EnsureConnectionIsAliveFast( } else { try { - await connection.OpenAsync(token).ConfigureAwait(false); + await connection.OpenAsync(token).ConfigureAwaitFalse(); var command = connection.CreateCommand(); - await using (command.ConfigureAwait(false)) { + await using (command.ConfigureAwaitFalse()) { command.CommandText = query; - _ = await command.ExecuteNonQueryAsync(token).ConfigureAwait(false); + _ = await command.ExecuteNonQueryAsync(token).ConfigureAwaitFalse(); } return connection; } catch (Exception exception) { try { - await connection.CloseAsync().ConfigureAwait(false); - await connection.DisposeAsync().ConfigureAwait(false); + await connection.CloseAsync().ConfigureAwaitFalse(); + await connection.DisposeAsync().ConfigureAwaitFalse(); } catch { // ignored @@ -383,7 +384,7 @@ private static async ValueTask EnsureConnectionIsAliveFast( if (InternalHelpers.ShouldRetryOn(exception)) { var (isReconnected, newConnection) = - await TryReconnectFast(connection.ConnectionString, query, isAsync, token).ConfigureAwait(false); + await TryReconnectFast(connection.ConnectionString, query, isAsync, token).ConfigureAwaitFalse(); if (isReconnected) { return newConnection; } @@ -434,32 +435,32 @@ private static async ValueTask EnsureConnectionIsAliveWithN } } else { - await SqlHelper.NotifyConnectionOpeningAsync(connectionAccessos, connection, false, token).ConfigureAwait(false); + await SqlHelper.NotifyConnectionOpeningAsync(connectionAccessos, connection, false, token).ConfigureAwaitFalse(); try { - await connection.OpenAsync(token).ConfigureAwait(false); + await connection.OpenAsync(token).ConfigureAwaitFalse(); - await SqlHelper.NotifyConnectionInitializingAsync(connectionAccessos, connection, query, false, token).ConfigureAwait(false); + await SqlHelper.NotifyConnectionInitializingAsync(connectionAccessos, connection, query, false, token).ConfigureAwaitFalse(); var command = connection.CreateCommand(); - await using (command.ConfigureAwait(false)) { + await using (command.ConfigureAwaitFalse()) { command.CommandText = query; - _ = await command.ExecuteNonQueryAsync(token).ConfigureAwait(false); + _ = await command.ExecuteNonQueryAsync(token).ConfigureAwaitFalse(); } - await SqlHelper.NotifyConnectionOpenedAsync(connectionAccessos, connection, false, token).ConfigureAwait(false); + await SqlHelper.NotifyConnectionOpenedAsync(connectionAccessos, connection, false, token).ConfigureAwaitFalse(); return connection; } catch (Exception exception) { var retryToConnect = InternalHelpers.ShouldRetryOn(exception); if (!retryToConnect) { - await SqlHelper.NotifyConnectionOpeningFailedAsync(connectionAccessos, connection, exception, false, token).ConfigureAwait(false); + await SqlHelper.NotifyConnectionOpeningFailedAsync(connectionAccessos, connection, exception, false, token).ConfigureAwaitFalse(); } var connectionString = connection.ConnectionString; try { - await connection.CloseAsync().ConfigureAwait(false); - await connection.DisposeAsync().ConfigureAwait(false); + await connection.CloseAsync().ConfigureAwaitFalse(); + await connection.DisposeAsync().ConfigureAwaitFalse(); } catch { // ignored @@ -467,7 +468,7 @@ private static async ValueTask EnsureConnectionIsAliveWithN if (retryToConnect) { var (isReconnected, newConnection) = - await TryReconnectWithNotification(connectionString, query, connectionAccessos, isAsync, token).ConfigureAwait(false); + await TryReconnectWithNotification(connectionString, query, connectionAccessos, isAsync, token).ConfigureAwaitFalse(); if (isReconnected) { return newConnection; } @@ -499,12 +500,12 @@ private static async ValueTask EnsureConnectionIsAliveWithN } else { try { - await connection.OpenAsync(token).ConfigureAwait(false); + await connection.OpenAsync(token).ConfigureAwaitFalse(); var command = connection.CreateCommand(); - await using (command.ConfigureAwait(false)) { + await using (command.ConfigureAwaitFalse()) { command.CommandText = query; - _ = await command.ExecuteNonQueryAsync(token).ConfigureAwait(false); + _ = await command.ExecuteNonQueryAsync(token).ConfigureAwaitFalse(); } return (true, connection); @@ -543,24 +544,24 @@ private static async ValueTask EnsureConnectionIsAliveWithN } } else { - await SqlHelper.NotifyConnectionOpeningAsync(connectionAccessors, connection, true, token).ConfigureAwait(false); + await SqlHelper.NotifyConnectionOpeningAsync(connectionAccessors, connection, true, token).ConfigureAwaitFalse(); try { - await connection.OpenAsync(token).ConfigureAwait(false); + await connection.OpenAsync(token).ConfigureAwaitFalse(); - await SqlHelper.NotifyConnectionInitializingAsync(connectionAccessors, connection, query, true, token).ConfigureAwait(false); + await SqlHelper.NotifyConnectionInitializingAsync(connectionAccessors, connection, query, true, token).ConfigureAwaitFalse(); var command = connection.CreateCommand(); - await using (command.ConfigureAwait(false)) { + await using (command.ConfigureAwaitFalse()) { command.CommandText = query; - _ = await command.ExecuteNonQueryAsync(token).ConfigureAwait(false); + _ = await command.ExecuteNonQueryAsync(token).ConfigureAwaitFalse(); } - await SqlHelper.NotifyConnectionOpenedAsync(connectionAccessors, connection, true, token).ConfigureAwait(false); + await SqlHelper.NotifyConnectionOpenedAsync(connectionAccessors, connection, true, token).ConfigureAwaitFalse(); return (true, connection); } catch (Exception exception) { - await SqlHelper.NotifyConnectionOpeningFailedAsync(connectionAccessors, connection, exception, true, token).ConfigureAwait(false); + await SqlHelper.NotifyConnectionOpeningFailedAsync(connectionAccessors, connection, exception, true, token).ConfigureAwaitFalse(); await connection.DisposeAsync(); return (false, null); } diff --git a/Orm/Xtensive.Orm.SqlServer/Sql.Drivers.SqlServer/v09/Extractor.cs b/Orm/Xtensive.Orm.SqlServer/Sql.Drivers.SqlServer/v09/Extractor.cs index 23d1c940e8..cd9ce5f010 100644 --- a/Orm/Xtensive.Orm.SqlServer/Sql.Drivers.SqlServer/v09/Extractor.cs +++ b/Orm/Xtensive.Orm.SqlServer/Sql.Drivers.SqlServer/v09/Extractor.cs @@ -92,7 +92,7 @@ public override async Task ExtractSchemesAsync( string catalogName, string[] schemaNames, CancellationToken token = default) { var context = CreateContext(catalogName, schemaNames); - await ExtractCatalogContentsAsync(context, token).ConfigureAwait(false); + await ExtractCatalogContentsAsync(context, token).ConfigureAwaitFalse(); return context.Catalog; } @@ -110,14 +110,14 @@ protected virtual void ExtractCatalogContents(ExtractionContext context) protected virtual async Task ExtractCatalogContentsAsync(ExtractionContext context, CancellationToken token) { - await ExtractSchemasAsync(context, token).ConfigureAwait(false); + await ExtractSchemasAsync(context, token).ConfigureAwaitFalse(); RegisterReplacements(context); - await ExtractTypesAsync(context, token).ConfigureAwait(false); - await ExtractTablesAndViewsAsync(context, token).ConfigureAwait(false); - await ExtractColumnsAsync(context, token).ConfigureAwait(false); - await ExtractIndexesAsync(context, token).ConfigureAwait(false); - await ExtractForeignKeysAsync(context, token).ConfigureAwait(false); - await ExtractFulltextIndexesAsync(context, token).ConfigureAwait(false); + await ExtractTypesAsync(context, token).ConfigureAwaitFalse(); + await ExtractTablesAndViewsAsync(context, token).ConfigureAwaitFalse(); + await ExtractColumnsAsync(context, token).ConfigureAwaitFalse(); + await ExtractIndexesAsync(context, token).ConfigureAwaitFalse(); + await ExtractForeignKeysAsync(context, token).ConfigureAwaitFalse(); + await ExtractFulltextIndexesAsync(context, token).ConfigureAwaitFalse(); } protected virtual void RegisterReplacements(ExtractionContext context) @@ -154,10 +154,10 @@ private async Task ExtractSchemasAsync(ExtractionContext context, CancellationTo var query = BuildExtractSchemasQuery(context); var cmd = Connection.CreateCommand(query); - await using (cmd.ConfigureAwait(false)) { - var reader = await cmd.ExecuteReaderAsync(token).ConfigureAwait(false); - await using (reader.ConfigureAwait(false)) { - while (await reader.ReadAsync(token).ConfigureAwait(false)) { + await using (cmd.ConfigureAwaitFalse()) { + var reader = await cmd.ExecuteReaderAsync(token).ConfigureAwaitFalse(); + await using (reader.ConfigureAwaitFalse()) { + while (await reader.ReadAsync(token).ConfigureAwaitFalse()) { ReadSchemaData(reader, context); } } @@ -207,10 +207,10 @@ private async Task ExtractTypesAsync(ExtractionContext context, CancellationToke var query = BuildExtractTypesQuery(context); var command = Connection.CreateCommand(query); - await using (command.ConfigureAwait(false)) { - var reader = await command.ExecuteReaderAsync(token).ConfigureAwait(false); - await using (reader.ConfigureAwait(false)) { - while (await reader.ReadAsync(token).ConfigureAwait(false)) { + await using (command.ConfigureAwaitFalse()) { + var reader = await command.ExecuteReaderAsync(token).ConfigureAwaitFalse(); + await using (reader.ConfigureAwaitFalse()) { + while (await reader.ReadAsync(token).ConfigureAwaitFalse()) { ReadTypeData(reader, context); } } @@ -277,10 +277,10 @@ private async Task ExtractTablesAndViewsAsync(ExtractionContext context, Cancell var query = BuildExtractTablesAndViewsQuery(context); var cmd = Connection.CreateCommand(query); - await using (cmd.ConfigureAwait(false)) { - var reader = await cmd.ExecuteReaderAsync(token).ConfigureAwait(false); - await using (reader.ConfigureAwait(false)) { - while (await reader.ReadAsync(token).ConfigureAwait(false)) { + await using (cmd.ConfigureAwaitFalse()) { + var reader = await cmd.ExecuteReaderAsync(token).ConfigureAwaitFalse(); + await using (reader.ConfigureAwaitFalse()) { + while (await reader.ReadAsync(token).ConfigureAwaitFalse()) { ReadTableOrViewData(reader, context); } } @@ -362,10 +362,10 @@ private async Task ExtractColumnsAsync(ExtractionContext context, CancellationTo var currentTableId = 0; var cmd = Connection.CreateCommand(query); ColumnResolver columnResolver = null; - await using (cmd.ConfigureAwait(false)) { - var reader = await cmd.ExecuteReaderAsync(token).ConfigureAwait(false); - await using (reader.ConfigureAwait(false)) { - while (await reader.ReadAsync(token).ConfigureAwait(false)) { + await using (cmd.ConfigureAwaitFalse()) { + var reader = await cmd.ExecuteReaderAsync(token).ConfigureAwaitFalse(); + await using (reader.ConfigureAwaitFalse()) { + while (await reader.ReadAsync(token).ConfigureAwaitFalse()) { ReadColumnData(context, reader, ref currentTableId, ref columnResolver); } } @@ -374,10 +374,10 @@ private async Task ExtractColumnsAsync(ExtractionContext context, CancellationTo query = BuildExtractIdentityColumnsQuery(context); cmd = Connection.CreateCommand(query); - await using (cmd.ConfigureAwait(false)) { - var reader = await cmd.ExecuteReaderAsync(token).ConfigureAwait(false); - await using (reader.ConfigureAwait(false)) { - while (await reader.ReadAsync(token).ConfigureAwait(false)) { + await using (cmd.ConfigureAwaitFalse()) { + var reader = await cmd.ExecuteReaderAsync(token).ConfigureAwaitFalse(); + await using (reader.ConfigureAwaitFalse()) { + while (await reader.ReadAsync(token).ConfigureAwaitFalse()) { ReadIdentityColumnData(reader, context); } } @@ -613,10 +613,10 @@ private async Task ExtractIndexesAsync(ExtractionContext context, CancellationTo PrimaryKey primaryKey = null; UniqueConstraint uniqueConstraint = null; var cmd = Connection.CreateCommand(query); - await using (cmd.ConfigureAwait(false)) { - var reader = await cmd.ExecuteReaderAsync(token).ConfigureAwait(false); - await using (reader.ConfigureAwait(false)) { - while (await reader.ReadAsync(token).ConfigureAwait(false)) { + await using (cmd.ConfigureAwaitFalse()) { + var reader = await cmd.ExecuteReaderAsync(token).ConfigureAwaitFalse(); + await using (reader.ConfigureAwaitFalse()) { + while (await reader.ReadAsync(token).ConfigureAwaitFalse()) { ReadIndexColumnData(reader, context, ref tableId, spatialIndexType, ref primaryKey, ref uniqueConstraint, ref index, ref table); } @@ -724,10 +724,10 @@ private async Task ExtractForeignKeysAsync(ExtractionContext context, Cancellati ColumnResolver referencedTable = null; ForeignKey foreignKey = null; var cmd = Connection.CreateCommand(query); - await using (cmd.ConfigureAwait(false)) { - var reader = await cmd.ExecuteReaderAsync(token).ConfigureAwait(false); - await using (reader.ConfigureAwait(false)) { - while (await reader.ReadAsync(token).ConfigureAwait(false)) { + await using (cmd.ConfigureAwaitFalse()) { + var reader = await cmd.ExecuteReaderAsync(token).ConfigureAwaitFalse(); + await using (reader.ConfigureAwaitFalse()) { + while (await reader.ReadAsync(token).ConfigureAwaitFalse()) { ReadForeignKeyColumnData(reader, context, ref tableId, ref foreignKey, ref referencingTable, ref referencedTable); } } @@ -800,10 +800,10 @@ protected virtual async Task ExtractFulltextIndexesAsync(ExtractionContext conte ColumnResolver table = null; FullTextIndex index = null; var cmd = Connection.CreateCommand(query); - await using (cmd.ConfigureAwait(false)) { - var reader = await cmd.ExecuteReaderAsync(token).ConfigureAwait(false); - await using (reader.ConfigureAwait(false)) { - while (await reader.ReadAsync(token).ConfigureAwait(false)) { + await using (cmd.ConfigureAwaitFalse()) { + var reader = await cmd.ExecuteReaderAsync(token).ConfigureAwaitFalse(); + await using (reader.ConfigureAwaitFalse()) { + while (await reader.ReadAsync(token).ConfigureAwaitFalse()) { ReadFullTextIndexColumnData(reader, context, ref currentTableId, ref table, ref index); } } diff --git a/Orm/Xtensive.Orm.SqlServer/Sql.Drivers.SqlServer/v11/Extractor.cs b/Orm/Xtensive.Orm.SqlServer/Sql.Drivers.SqlServer/v11/Extractor.cs index 950ccb9fec..f3ab8116bd 100644 --- a/Orm/Xtensive.Orm.SqlServer/Sql.Drivers.SqlServer/v11/Extractor.cs +++ b/Orm/Xtensive.Orm.SqlServer/Sql.Drivers.SqlServer/v11/Extractor.cs @@ -9,6 +9,7 @@ using System.Data.Common; using System.Threading; using System.Threading.Tasks; +using Xtensive.Core; namespace Xtensive.Sql.Drivers.SqlServer.v11 { @@ -24,8 +25,8 @@ protected override void ExtractCatalogContents(ExtractionContext context) protected override async Task ExtractCatalogContentsAsync(ExtractionContext context, CancellationToken token) { - await base.ExtractCatalogContentsAsync(context, token).ConfigureAwait(false); - await ExtractSequencesAsync(context, token).ConfigureAwait(false); + await base.ExtractCatalogContentsAsync(context, token).ConfigureAwaitFalse(); + await ExtractSequencesAsync(context, token).ConfigureAwaitFalse(); } private void ExtractSequences(ExtractionContext context) @@ -44,10 +45,10 @@ private async Task ExtractSequencesAsync(ExtractionContext context, Cancellation var query = BuildExtractSequencesQuery(context); var cmd = Connection.CreateCommand(query); - await using (cmd.ConfigureAwait(false)) { - var reader = await cmd.ExecuteReaderAsync(token).ConfigureAwait(false); - await using (reader.ConfigureAwait(false)) { - while (await reader.ReadAsync(token).ConfigureAwait(false)) { + await using (cmd.ConfigureAwaitFalse()) { + var reader = await cmd.ExecuteReaderAsync(token).ConfigureAwaitFalse(); + await using (reader.ConfigureAwaitFalse()) { + while (await reader.ReadAsync(token).ConfigureAwaitFalse()) { ReadSequenceData(reader, context); } } diff --git a/Orm/Xtensive.Orm/Core/AsyncFutureResult.cs b/Orm/Xtensive.Orm/Core/AsyncFutureResult.cs index c48216f334..7cf112720b 100644 --- a/Orm/Xtensive.Orm/Core/AsyncFutureResult.cs +++ b/Orm/Xtensive.Orm/Core/AsyncFutureResult.cs @@ -40,7 +40,7 @@ public override async ValueTask GetAsync() var localTask = task ?? worker(); task = null; worker = null; - return await localTask.ConfigureAwait(false); + return await localTask.ConfigureAwaitFalse(); } public override void Dispose() @@ -64,7 +64,7 @@ public override async ValueTask DisposeAsync() } try { - await GetAsync().ConfigureAwait(false); + await GetAsync().ConfigureAwaitFalse(); } catch (Exception exception) { logger?.Warning(nameof(Strings.LogAsyncOperationError), exception: exception); diff --git a/Orm/Xtensive.Orm/Core/DisposableSet.cs b/Orm/Xtensive.Orm/Core/DisposableSet.cs index 0b2e88ee0a..b4faa49440 100644 --- a/Orm/Xtensive.Orm/Core/DisposableSet.cs +++ b/Orm/Xtensive.Orm/Core/DisposableSet.cs @@ -132,7 +132,7 @@ async ValueTask IAsyncDisposable.DisposeAsync() for (var i = list.Count - 1; i >= 0; i--) { var disposable = list[i]; if (disposable is IAsyncDisposable asyncDisposable) { - await aggregator.ExecuteAsync(d => d.DisposeAsync(), asyncDisposable).ConfigureAwait(false); + await aggregator.ExecuteAsync(d => d.DisposeAsync(), asyncDisposable).ConfigureAwaitFalse(); } else { aggregator.Execute(d => d.Dispose(), disposable); diff --git a/Orm/Xtensive.Orm/Core/ExceptionAggregator.cs b/Orm/Xtensive.Orm/Core/ExceptionAggregator.cs index 5a7dd6b345..4ab106b569 100644 --- a/Orm/Xtensive.Orm/Core/ExceptionAggregator.cs +++ b/Orm/Xtensive.Orm/Core/ExceptionAggregator.cs @@ -152,7 +152,7 @@ public async ValueTask ExecuteAsync(Func action, T argument) } try { - await action(argument).ConfigureAwait(false); + await action(argument).ConfigureAwaitFalse(); } catch (Exception e) { HandleException(e); diff --git a/Orm/Xtensive.Orm/Core/Extensions/DisposableExtensions.cs b/Orm/Xtensive.Orm/Core/Extensions/DisposableExtensions.cs index 22f6c1c145..d508bd976d 100644 --- a/Orm/Xtensive.Orm/Core/Extensions/DisposableExtensions.cs +++ b/Orm/Xtensive.Orm/Core/Extensions/DisposableExtensions.cs @@ -72,7 +72,7 @@ public static async ValueTask DisposeSafelyAsync(this IAsyncDisposable disposabl { try { if (disposable!=null) { - await disposable.DisposeAsync().ConfigureAwait(false); + await disposable.DisposeAsync().ConfigureAwaitFalse(); } } catch { diff --git a/Orm/Xtensive.Orm/Core/Extensions/TaskExtensions.cs b/Orm/Xtensive.Orm/Core/Extensions/TaskExtensions.cs new file mode 100644 index 0000000000..2b3259f20c --- /dev/null +++ b/Orm/Xtensive.Orm/Core/Extensions/TaskExtensions.cs @@ -0,0 +1,28 @@ +using System; +using System.Collections.Generic; +using System.Runtime.CompilerServices; +using System.Threading.Tasks; + +namespace Xtensive.Core +{ + public static class TaskExtensions + { +#if DO_CONFIGURE_AWAIT_FALSE + [MethodImpl(MethodImplOptions.AggressiveInlining)] public static ConfiguredTaskAwaitable ConfigureAwaitFalse(this Task task) => task.ConfigureAwait(false); + [MethodImpl(MethodImplOptions.AggressiveInlining)] public static ConfiguredTaskAwaitable ConfigureAwaitFalse(this Task task) => task.ConfigureAwait(false); + [MethodImpl(MethodImplOptions.AggressiveInlining)] public static ConfiguredValueTaskAwaitable ConfigureAwaitFalse(this ValueTask task) => task.ConfigureAwait(false); + [MethodImpl(MethodImplOptions.AggressiveInlining)] public static ConfiguredValueTaskAwaitable ConfigureAwaitFalse(this ValueTask task) => task.ConfigureAwait(false); + [MethodImpl(MethodImplOptions.AggressiveInlining)] public static ConfiguredAsyncDisposable ConfigureAwaitFalse(this IAsyncDisposable source) => source.ConfigureAwait(false); + [MethodImpl(MethodImplOptions.AggressiveInlining)] public static ConfiguredCancelableAsyncEnumerable ConfigureAwaitFalse(this IAsyncEnumerable source) => source.ConfigureAwait(false); + [MethodImpl(MethodImplOptions.AggressiveInlining)] public static ConfiguredCancelableAsyncEnumerable ConfigureAwaitFalse(this ConfiguredCancelableAsyncEnumerable source) => source.ConfigureAwait(false); +#else + [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Task ConfigureAwaitFalse(this Task task) => task; + [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Task ConfigureAwaitFalse(this Task task) => task; + [MethodImpl(MethodImplOptions.AggressiveInlining)] public static ValueTask ConfigureAwaitFalse(this ValueTask task) => task; + [MethodImpl(MethodImplOptions.AggressiveInlining)] public static ValueTask ConfigureAwaitFalse(this ValueTask task) => task; + [MethodImpl(MethodImplOptions.AggressiveInlining)] public static IAsyncDisposable ConfigureAwaitFalse(this IAsyncDisposable source) => source; + [MethodImpl(MethodImplOptions.AggressiveInlining)] public static IAsyncEnumerable ConfigureAwaitFalse(this IAsyncEnumerable source) => source; + [MethodImpl(MethodImplOptions.AggressiveInlining)] public static ConfiguredCancelableAsyncEnumerable ConfigureAwaitFalse(this ConfiguredCancelableAsyncEnumerable source) => source; +#endif + } +} diff --git a/Orm/Xtensive.Orm/Orm/DelayedQuery.cs b/Orm/Xtensive.Orm/Orm/DelayedQuery.cs index b77e2db2c4..aec1e3589d 100644 --- a/Orm/Xtensive.Orm/Orm/DelayedQuery.cs +++ b/Orm/Xtensive.Orm/Orm/DelayedQuery.cs @@ -73,7 +73,7 @@ protected async ValueTask> MaterializeAsync(CancellationToken } if (Task.Result==null) { - await Session.ExecuteUserDefinedDelayedQueriesAsync(false, token).ConfigureAwait(false); + await Session.ExecuteUserDefinedDelayedQueriesAsync(false, token).ConfigureAwaitFalse(); } return materializer.Invoke(RecordSetReader.Create(Task.Result), Session, parameterContext); diff --git a/Orm/Xtensive.Orm/Orm/DelayedScalarQuery{T}.cs b/Orm/Xtensive.Orm/Orm/DelayedScalarQuery{T}.cs index e4e4fe7b5a..65cf115d06 100644 --- a/Orm/Xtensive.Orm/Orm/DelayedScalarQuery{T}.cs +++ b/Orm/Xtensive.Orm/Orm/DelayedScalarQuery{T}.cs @@ -37,7 +37,7 @@ public sealed class DelayedScalarQuery : DelayedQuery /// Cancellation token. /// Value representing scalar query execution result. public async ValueTask ExecuteAsync(CancellationToken token = default) => - (await MaterializeAsync(token).ConfigureAwait(false)).ToScalar(resultAccessMethod); + (await MaterializeAsync(token).ConfigureAwaitFalse()).ToScalar(resultAccessMethod); // Constructors diff --git a/Orm/Xtensive.Orm/Orm/Domain.cs b/Orm/Xtensive.Orm/Orm/Domain.cs index 3da42b0a9e..017e2b4a79 100644 --- a/Orm/Xtensive.Orm/Orm/Domain.cs +++ b/Orm/Xtensive.Orm/Orm/Domain.cs @@ -363,10 +363,10 @@ internal async Task OpenSessionInternalAsync(SessionConfiguration confi exceptionDispatchInfo = ExceptionDispatchInfo.Capture(ex); } }, TaskContinuationOptions.NotOnCanceled | TaskContinuationOptions.ExecuteSynchronously) - .ConfigureAwait(false); + .ConfigureAwaitFalse(); } catch (OperationCanceledException) { - await session.DisposeSafelyAsync().ConfigureAwait(false); + await session.DisposeSafelyAsync().ConfigureAwaitFalse(); throw; } finally { @@ -466,8 +466,8 @@ public async ValueTask InnerDispose(bool isAsync) var driver = Handlers.StorageDriver; if (isAsync) { - await driver.CloseConnectionAsync(null, singleConnectionLocal).ConfigureAwait(false); - await driver.DisposeConnectionAsync(null, singleConnectionLocal).ConfigureAwait(false); + await driver.CloseConnectionAsync(null, singleConnectionLocal).ConfigureAwaitFalse(); + await driver.DisposeConnectionAsync(null, singleConnectionLocal).ConfigureAwaitFalse(); } else { driver.CloseConnection(null, singleConnectionLocal); diff --git a/Orm/Xtensive.Orm/Orm/Internals/Prefetch/Fetcher.cs b/Orm/Xtensive.Orm/Orm/Internals/Prefetch/Fetcher.cs index 9cbfff4730..468951b797 100644 --- a/Orm/Xtensive.Orm/Orm/Internals/Prefetch/Fetcher.cs +++ b/Orm/Xtensive.Orm/Orm/Internals/Prefetch/Fetcher.cs @@ -35,7 +35,7 @@ public async ValueTask ExecuteTasks(IReadOnlyCollection con RegisterAllEntitySetTasks(containers); var isExecuted = isAsync - ? await manager.Owner.Session.ExecuteInternalDelayedQueriesAsync(skipPersist, token).ConfigureAwait(false) + ? await manager.Owner.Session.ExecuteInternalDelayedQueriesAsync(skipPersist, token).ConfigureAwaitFalse() : manager.Owner.Session.ExecuteInternalDelayedQueries(skipPersist); batchExecuted += isExecuted ? 1 : 0; @@ -59,7 +59,7 @@ public async ValueTask ExecuteTasks(IReadOnlyCollection con RegisterAllEntityGroupTasks(); isExecuted = isAsync - ? await manager.Owner.Session.ExecuteInternalDelayedQueriesAsync(skipPersist, token).ConfigureAwait(false) + ? await manager.Owner.Session.ExecuteInternalDelayedQueriesAsync(skipPersist, token).ConfigureAwaitFalse() : manager.Owner.Session.ExecuteInternalDelayedQueries(skipPersist); batchExecuted += isExecuted ? 1 : 0; diff --git a/Orm/Xtensive.Orm/Orm/Internals/Prefetch/PrefetchKeyIterator.cs b/Orm/Xtensive.Orm/Orm/Internals/Prefetch/PrefetchKeyIterator.cs index 0b5b0029a6..5b5e42bfeb 100644 --- a/Orm/Xtensive.Orm/Orm/Internals/Prefetch/PrefetchKeyIterator.cs +++ b/Orm/Xtensive.Orm/Orm/Internals/Prefetch/PrefetchKeyIterator.cs @@ -7,6 +7,7 @@ using System.Collections; using System.Collections.Generic; using System.Threading; +using Xtensive.Core; namespace Xtensive.Orm.Internals.Prefetch { @@ -92,7 +93,7 @@ public async IAsyncEnumerator GetAsyncEnumerator(CancellationToken token = de resultQueue.Enqueue(key); var defaultDescriptors = PrefetchHelper.GetCachedDescriptorsForFieldsLoadedByDefault(session.Domain, type); container.JoinIfPossible( - await session.Handler.PrefetchAsync(key, type, defaultDescriptors, token).ConfigureAwait(false)); + await session.Handler.PrefetchAsync(key, type, defaultDescriptors, token).ConfigureAwaitFalse()); } if (exists && taskCount == session.Handler.PrefetchTaskExecutionCount) { @@ -101,7 +102,7 @@ public async IAsyncEnumerator GetAsyncEnumerator(CancellationToken token = de if (!exists) { container.JoinIfPossible( - await session.Handler.ExecutePrefetchTasksAsync(token).ConfigureAwait(false)); + await session.Handler.ExecutePrefetchTasksAsync(token).ConfigureAwaitFalse()); } if (unknownTypeQueue.Count > 0) { @@ -110,10 +111,10 @@ public async IAsyncEnumerator GetAsyncEnumerator(CancellationToken token = de var unknownDescriptors = PrefetchHelper.GetCachedDescriptorsForFieldsLoadedByDefault(session.Domain, unknownType); await session.Handler.PrefetchAsync( - unknownKey, unknownType, unknownDescriptors, token).ConfigureAwait(false); + unknownKey, unknownType, unknownDescriptors, token).ConfigureAwaitFalse(); } - await session.Handler.ExecutePrefetchTasksAsync(token).ConfigureAwait(false); + await session.Handler.ExecutePrefetchTasksAsync(token).ConfigureAwaitFalse(); } while (resultQueue.TryDequeue(out var item)) { diff --git a/Orm/Xtensive.Orm/Orm/Internals/Prefetch/PrefetchManager.cs b/Orm/Xtensive.Orm/Orm/Internals/Prefetch/PrefetchManager.cs index d8ac2ebf44..a9f72c0163 100644 --- a/Orm/Xtensive.Orm/Orm/Internals/Prefetch/PrefetchManager.cs +++ b/Orm/Xtensive.Orm/Orm/Internals/Prefetch/PrefetchManager.cs @@ -104,7 +104,7 @@ public async Task PrefetchAsync(Key key, TypeInfo type IReadOnlyList descriptors, CancellationToken token = default) { var prefetchTask = Prefetch(key, type, descriptors, true, token); - return await prefetchTask.ConfigureAwait(false); + return await prefetchTask.ConfigureAwaitFalse(); } private async ValueTask Prefetch( @@ -148,7 +148,7 @@ private async ValueTask Prefetch( StrongReferenceContainer container = null; if (graphContainers.Count >= MaxContainerCount) { - container = await ExecuteTasks(false, isAsync, token).ConfigureAwait(false); + container = await ExecuteTasks(false, isAsync, token).ConfigureAwaitFalse(); } if (referenceContainer != null) { @@ -167,7 +167,7 @@ public StrongReferenceContainer ExecuteTasks(bool skipPersist = false) => ExecuteTasks(skipPersist, false, default).GetAwaiter().GetResult(); public async Task ExecuteTasksAsync(bool skipPersist, CancellationToken token = default) => - await ExecuteTasks(skipPersist, true, token).ConfigureAwait(false); + await ExecuteTasks(skipPersist, true, token).ConfigureAwaitFalse(); private async ValueTask ExecuteTasks(bool skipPersist, bool isAsync, CancellationToken token) { @@ -177,7 +177,7 @@ private async ValueTask ExecuteTasks(bool skipPersist, } try { var batchExecuted = - await fetcher.ExecuteTasks(graphContainers.Values, skipPersist, isAsync, token).ConfigureAwait(false); + await fetcher.ExecuteTasks(graphContainers.Values, skipPersist, isAsync, token).ConfigureAwaitFalse(); TaskExecutionCount += batchExecuted; foreach (var graphContainer in graphContainers.Values) { graphContainer.NotifyAboutExtractionOfKeysWithUnknownType(); diff --git a/Orm/Xtensive.Orm/Orm/Internals/Prefetch/PrefetchQueryAsyncEnumerable.cs b/Orm/Xtensive.Orm/Orm/Internals/Prefetch/PrefetchQueryAsyncEnumerable.cs index cd553decef..43362ab0e1 100644 --- a/Orm/Xtensive.Orm/Orm/Internals/Prefetch/PrefetchQueryAsyncEnumerable.cs +++ b/Orm/Xtensive.Orm/Orm/Internals/Prefetch/PrefetchQueryAsyncEnumerable.cs @@ -42,7 +42,7 @@ async IAsyncEnumerable ProcessItem(TItem item1) if (item1 != null) { foreach (var extractorNode in aggregatedNodes) { var fetchedItems = - await RegisterPrefetchAsync(extractorNode.ExtractKeys(item1), extractorNode, enumerationIdentifier, token).ConfigureAwait(false); + await RegisterPrefetchAsync(extractorNode.ExtractKeys(item1), extractorNode, enumerationIdentifier, token).ConfigureAwaitFalse(); _ = strongReferenceContainer.JoinIfPossible(fetchedItems); } } @@ -52,8 +52,8 @@ async IAsyncEnumerable ProcessItem(TItem item1) } while (strongReferenceContainer.JoinIfPossible( - await sessionHandler.ExecutePrefetchTasksAsync(token).ConfigureAwait(false))) { - _ = strongReferenceContainer.JoinIfPossible(await ProcessFetchedElementsAsync(enumerationIdentifier, token).ConfigureAwait(false)); + await sessionHandler.ExecutePrefetchTasksAsync(token).ConfigureAwaitFalse())) { + _ = strongReferenceContainer.JoinIfPossible(await ProcessFetchedElementsAsync(enumerationIdentifier, token).ConfigureAwaitFalse()); } while (resultQueue.TryDequeue(out var resultItem)) { @@ -64,27 +64,27 @@ await sessionHandler.ExecutePrefetchTasksAsync(token).ConfigureAwait(false))) { } if (source is IAsyncEnumerable asyncItemSource) { - await foreach (var item in asyncItemSource.WithCancellation(token).ConfigureAwait(false)) { - await foreach (var p in ProcessItem(item).WithCancellation(token).ConfigureAwait(false)) { + await foreach (var item in asyncItemSource.WithCancellation(token).ConfigureAwaitFalse()) { + await foreach (var p in ProcessItem(item).WithCancellation(token).ConfigureAwaitFalse()) { yield return p; } } } else { var items = source is IQueryable queryableSource - ? await queryableSource.ExecuteAsync(token).ConfigureAwait(false) + ? await queryableSource.ExecuteAsync(token).ConfigureAwaitFalse() : source; foreach (var item in items) { - await foreach (var p in ProcessItem(item).WithCancellation(token).ConfigureAwait(false)) { + await foreach (var p in ProcessItem(item).WithCancellation(token).ConfigureAwaitFalse()) { yield return p; } } } while (strongReferenceContainer.JoinIfPossible( - await sessionHandler.ExecutePrefetchTasksAsync(token).ConfigureAwait(false))) { - _ = strongReferenceContainer.JoinIfPossible(await ProcessFetchedElementsAsync(enumerationIdentifier, token).ConfigureAwait(false)); + await sessionHandler.ExecutePrefetchTasksAsync(token).ConfigureAwaitFalse())) { + _ = strongReferenceContainer.JoinIfPossible(await ProcessFetchedElementsAsync(enumerationIdentifier, token).ConfigureAwaitFalse()); } while (resultQueue.TryDequeue(out var resultItem)) { @@ -119,7 +119,7 @@ private async Task RegisterPrefetchAsync(IReadOnlyColl } _ = container.JoinIfPossible( - await sessionHandler.PrefetchAsync(key, type, fieldDescriptors, token).ConfigureAwait(false)); + await sessionHandler.PrefetchAsync(key, type, fieldDescriptors, token).ConfigureAwaitFalse()); } var nestedContainers = fieldContainer.NestedNodes.OfType(); @@ -137,7 +137,7 @@ private async Task ProcessFetchedElementsAsync(Guid en var unknownType = session.EntityStateCache[unknownKey, false].Type; var unknownDescriptors = PrefetchHelper.GetCachedDescriptorsForFieldsLoadedByDefault(session.Domain, unknownType); - _ = await sessionHandler.PrefetchAsync(unknownKey, unknownType, unknownDescriptors, token).ConfigureAwait(false); + _ = await sessionHandler.PrefetchAsync(unknownKey, unknownType, unknownDescriptors, token).ConfigureAwaitFalse(); } while (prefetchQueue.TryDequeue(out var pair)) { @@ -147,7 +147,7 @@ private async Task ProcessFetchedElementsAsync(Guid en foreach (var parentKey in parentKeys) { var entityState = session.EntityStateCache[parentKey, false]; if (entityState == null) { - _ = container.JoinIfPossible(await sessionHandler.ExecutePrefetchTasksAsync(true, token).ConfigureAwait(false)); + _ = container.JoinIfPossible(await sessionHandler.ExecutePrefetchTasksAsync(true, token).ConfigureAwaitFalse()); entityState = session.EntityStateCache[parentKey, false]; if (entityState == null) { throw new InvalidOperationException(string.Format(Strings.ExCannotResolveEntityWithKeyX, parentKey)); @@ -157,7 +157,7 @@ private async Task ProcessFetchedElementsAsync(Guid en keys.AddRange(nestedNodes.ExtractKeys(entityState.Entity)); } - _ = container.JoinIfPossible(await RegisterPrefetchAsync(keys, nestedNodes, enumerationId, token).ConfigureAwait(false)); + _ = container.JoinIfPossible(await RegisterPrefetchAsync(keys, nestedNodes, enumerationId, token).ConfigureAwaitFalse()); } return container; diff --git a/Orm/Xtensive.Orm/Orm/Linq/Materialization/MaterializingReader.cs b/Orm/Xtensive.Orm/Orm/Linq/Materialization/MaterializingReader.cs index f1e600fe4b..764a0f73e9 100644 --- a/Orm/Xtensive.Orm/Orm/Linq/Materialization/MaterializingReader.cs +++ b/Orm/Xtensive.Orm/Orm/Linq/Materialization/MaterializingReader.cs @@ -65,7 +65,7 @@ public bool MoveNext() public async ValueTask MoveNextAsync() { - while (await recordSetReader.MoveNextAsync().ConfigureAwait(false)) { + while (await recordSetReader.MoveNextAsync().ConfigureAwaitFalse()) { if (itemMaterializer.CanMaterialize(recordSetReader.Current)) { return true; } diff --git a/Orm/Xtensive.Orm/Orm/Linq/QueryProvider.cs b/Orm/Xtensive.Orm/Orm/Linq/QueryProvider.cs index 0370e30a6c..c629db68c6 100644 --- a/Orm/Xtensive.Orm/Orm/Linq/QueryProvider.cs +++ b/Orm/Xtensive.Orm/Orm/Linq/QueryProvider.cs @@ -142,7 +142,7 @@ private async Task ExecuteAsync(Expression expression, var query = Translate(expression); TResult result; try { - result = await runQuery(query, Session, new ParameterContext(), token).ConfigureAwait(false); + result = await runQuery(query, Session, new ParameterContext(), token).ConfigureAwaitFalse(); } catch (Exception exception) { Session.Events.NotifyQueryExecuted(expression, exception); diff --git a/Orm/Xtensive.Orm/Orm/Linq/Queryable.cs b/Orm/Xtensive.Orm/Orm/Linq/Queryable.cs index 42affc9d54..596f60e14d 100644 --- a/Orm/Xtensive.Orm/Orm/Linq/Queryable.cs +++ b/Orm/Xtensive.Orm/Orm/Linq/Queryable.cs @@ -46,8 +46,8 @@ public IEnumerator GetEnumerator() /// public async IAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { - var result = await provider.ExecuteSequenceAsync(expression, cancellationToken).ConfigureAwait(false); - var asyncSource = result.AsAsyncEnumerable().WithCancellation(cancellationToken).ConfigureAwait(false); + var result = await provider.ExecuteSequenceAsync(expression, cancellationToken).ConfigureAwaitFalse(); + var asyncSource = result.AsAsyncEnumerable().WithCancellation(cancellationToken).ConfigureAwaitFalse(); await foreach (var element in asyncSource) { yield return element; } diff --git a/Orm/Xtensive.Orm/Orm/Linq/TranslatedQuery.cs b/Orm/Xtensive.Orm/Orm/Linq/TranslatedQuery.cs index ff2b72524c..cb9a2cd59e 100644 --- a/Orm/Xtensive.Orm/Orm/Linq/TranslatedQuery.cs +++ b/Orm/Xtensive.Orm/Orm/Linq/TranslatedQuery.cs @@ -85,7 +85,7 @@ public QueryResult ExecuteSequence(Session session, ParameterContext param public async Task ExecuteScalarAsync( Session session, ParameterContext parameterContext, CancellationToken token) { - var sequenceResult = await ExecuteSequenceAsync(session, parameterContext, token).ConfigureAwait(false); + var sequenceResult = await ExecuteSequenceAsync(session, parameterContext, token).ConfigureAwaitFalse(); return sequenceResult.ToScalar(ResultAccessMethod); } @@ -103,7 +103,7 @@ public async Task> ExecuteSequenceAsync( { var newParameterContext = new ParameterContext(parameterContext, TupleParameterBindings); var recordSetReader = - await DataSource.GetRecordSetReaderAsync(session, newParameterContext, token).ConfigureAwait(false); + await DataSource.GetRecordSetReaderAsync(session, newParameterContext, token).ConfigureAwaitFalse(); return Materializer.Invoke(recordSetReader, session, newParameterContext); } diff --git a/Orm/Xtensive.Orm/Orm/PrefetchQuery.cs b/Orm/Xtensive.Orm/Orm/PrefetchQuery.cs index c3c25ec4df..82231e9747 100644 --- a/Orm/Xtensive.Orm/Orm/PrefetchQuery.cs +++ b/Orm/Xtensive.Orm/Orm/PrefetchQuery.cs @@ -8,6 +8,7 @@ using System.Linq.Expressions; using System.Threading; using System.Threading.Tasks; +using Xtensive.Core; using Xtensive.Collections; using Xtensive.Orm.Internals.Prefetch; @@ -82,7 +83,7 @@ public async Task> ExecuteAsync(CancellationToken token = { var list = new List(); var asyncEnumerable = new PrefetchQueryAsyncEnumerable(session, source, nodes); - await foreach (var element in asyncEnumerable.WithCancellation(token).ConfigureAwait(false)) { + await foreach (var element in asyncEnumerable.WithCancellation(token).ConfigureAwaitFalse()) { list.Add(element); } diff --git a/Orm/Xtensive.Orm/Orm/Providers/CommandProcessing/BatchingCommandProcessor.cs b/Orm/Xtensive.Orm/Orm/Providers/CommandProcessing/BatchingCommandProcessor.cs index f2bad23093..c6f30c173e 100644 --- a/Orm/Xtensive.Orm/Orm/Providers/CommandProcessing/BatchingCommandProcessor.cs +++ b/Orm/Xtensive.Orm/Orm/Providers/CommandProcessing/BatchingCommandProcessor.cs @@ -81,7 +81,7 @@ public override async Task ExecuteTasksAsync(CommandProcessorContext context, Ca var processingTasks = context.ProcessingTasks; while (processingTasks.Count >= batchSize) { - _ = await ExecuteBatchAsync(batchSize, null, context, token).ConfigureAwait(false); + _ = await ExecuteBatchAsync(batchSize, null, context, token).ConfigureAwaitFalse(); } if (!context.AllowPartialExecution) { @@ -123,12 +123,12 @@ public override async Task ExecuteTasksWithReaderAsync(QueryRequest PutTasksForExecution(context); while (context.ProcessingTasks.Count >= batchSize) { - _ = await ExecuteBatchAsync(batchSize, null, context, token).ConfigureAwait(false); + _ = await ExecuteBatchAsync(batchSize, null, context, token).ConfigureAwaitFalse(); } for (; ; ) { var currentBatchSize = (context.ProcessingTasks.Count > batchSize) ? batchSize : context.ProcessingTasks.Count; - var result = await ExecuteBatchAsync(currentBatchSize, request, context, token).ConfigureAwait(false); + var result = await ExecuteBatchAsync(currentBatchSize, request, context, token).ConfigureAwaitFalse(); if (result != null && context.ProcessingTasks.Count == 0) { return result.CreateReader(request.GetAccessor()); } @@ -246,11 +246,11 @@ private async Task ExecuteBatchAsync(int numberOfTasks, QueryRequest la var hasQueryTasks = context.ActiveTasks.Count > 0; if (!hasQueryTasks && !shouldReturnReader) { - _ = await command.ExecuteNonQueryAsync(token).ConfigureAwait(false); + _ = await command.ExecuteNonQueryAsync(token).ConfigureAwaitFalse(); return null; } - await command.ExecuteReaderAsync(token).ConfigureAwait(false); + await command.ExecuteReaderAsync(token).ConfigureAwaitFalse(); if (hasQueryTasks) { var currentQueryTask = 0; while (currentQueryTask < context.ActiveTasks.Count) { @@ -269,7 +269,7 @@ private async Task ExecuteBatchAsync(int numberOfTasks, QueryRequest la } finally { if (!shouldReturnReader) { - await context.ActiveCommand.DisposeSafelyAsync().ConfigureAwait(false); + await context.ActiveCommand.DisposeSafelyAsync().ConfigureAwaitFalse(); } ReleaseCommand(context); diff --git a/Orm/Xtensive.Orm/Orm/Providers/CommandProcessing/Command.cs b/Orm/Xtensive.Orm/Orm/Providers/CommandProcessing/Command.cs index bfdeb15625..e7b41a687a 100644 --- a/Orm/Xtensive.Orm/Orm/Providers/CommandProcessing/Command.cs +++ b/Orm/Xtensive.Orm/Orm/Providers/CommandProcessing/Command.cs @@ -71,13 +71,13 @@ public void ExecuteReader() public async Task ExecuteNonQueryAsync(CancellationToken token) { _ = Prepare(); - return await origin.Driver.ExecuteNonQueryAsync(origin.Session, underlyingCommand, token).ConfigureAwait(false); + return await origin.Driver.ExecuteNonQueryAsync(origin.Session, underlyingCommand, token).ConfigureAwaitFalse(); } public async Task ExecuteReaderAsync(CancellationToken token) { _ = Prepare(); - reader = await origin.Driver.ExecuteReaderAsync(origin.Session, underlyingCommand, token).ConfigureAwait(false); + reader = await origin.Driver.ExecuteReaderAsync(origin.Session, underlyingCommand, token).ConfigureAwaitFalse(); } public bool NextResult() @@ -93,7 +93,7 @@ public bool NextResult() public async Task NextResultAsync(CancellationToken token = default) { try { - return await reader.NextResultAsync(token).ConfigureAwait(false); + return await reader.NextResultAsync(token).ConfigureAwaitFalse(); } catch(Exception exception) { throw TranslateException(exception); @@ -113,7 +113,7 @@ public bool NextRow() public async ValueTask NextRowAsync(CancellationToken token = default) { try { - return await reader.ReadAsync(token).ConfigureAwait(false); + return await reader.ReadAsync(token).ConfigureAwaitFalse(); } catch (Exception exception) { throw TranslateException(exception); @@ -157,9 +157,9 @@ public async ValueTask DisposeAsync() { if (!isDisposed) { isDisposed = true; - await reader.DisposeSafelyAsync().ConfigureAwait(false); - await resources.DisposeSafelyAsync().ConfigureAwait(false); - await underlyingCommand.DisposeSafelyAsync().ConfigureAwait(false); + await reader.DisposeSafelyAsync().ConfigureAwaitFalse(); + await resources.DisposeSafelyAsync().ConfigureAwaitFalse(); + await underlyingCommand.DisposeSafelyAsync().ConfigureAwaitFalse(); } } diff --git a/Orm/Xtensive.Orm/Orm/Providers/CommandProcessing/CommandProcessorContext.cs b/Orm/Xtensive.Orm/Orm/Providers/CommandProcessing/CommandProcessorContext.cs index 13537473cc..102e6919a1 100644 --- a/Orm/Xtensive.Orm/Orm/Providers/CommandProcessing/CommandProcessorContext.cs +++ b/Orm/Xtensive.Orm/Orm/Providers/CommandProcessing/CommandProcessorContext.cs @@ -68,7 +68,7 @@ private async ValueTask DisposeImpl(bool isAsync) if (ActiveCommand != null) { if (isAsync) { - await ActiveCommand.DisposeAsync().ConfigureAwait(false); + await ActiveCommand.DisposeAsync().ConfigureAwaitFalse(); } else { ActiveCommand.Dispose(); diff --git a/Orm/Xtensive.Orm/Orm/Providers/CommandProcessing/DataReader.cs b/Orm/Xtensive.Orm/Orm/Providers/CommandProcessing/DataReader.cs index 410e31b2e6..1189868e02 100644 --- a/Orm/Xtensive.Orm/Orm/Providers/CommandProcessing/DataReader.cs +++ b/Orm/Xtensive.Orm/Orm/Providers/CommandProcessing/DataReader.cs @@ -7,6 +7,7 @@ using System.Collections.Generic; using System.Threading; using System.Threading.Tasks; +using Xtensive.Core; using Tuple = Xtensive.Tuples.Tuple; namespace Xtensive.Orm.Providers @@ -59,12 +60,12 @@ public async ValueTask MoveNextAsync() return ((IEnumerator) source).MoveNext(); } - if (await command.NextRowAsync(token).ConfigureAwait(false)) { + if (await command.NextRowAsync(token).ConfigureAwaitFalse()) { return true; } // We don't need the command anymore because all records are processed to the moment. - await command.DisposeAsync().ConfigureAwait(false); + await command.DisposeAsync().ConfigureAwaitFalse(); return false; } @@ -92,10 +93,10 @@ public void Dispose() public async ValueTask DisposeAsync() { if (source is Command command) { - await command.DisposeAsync().ConfigureAwait(false); + await command.DisposeAsync().ConfigureAwaitFalse(); } else { - await ((IAsyncEnumerator) source).DisposeAsync().ConfigureAwait(false); + await ((IAsyncEnumerator) source).DisposeAsync().ConfigureAwaitFalse(); } } diff --git a/Orm/Xtensive.Orm/Orm/Providers/CommandProcessing/SimpleCommandProcessor.cs b/Orm/Xtensive.Orm/Orm/Providers/CommandProcessing/SimpleCommandProcessor.cs index 64feb48571..4f1371e6e2 100644 --- a/Orm/Xtensive.Orm/Orm/Providers/CommandProcessing/SimpleCommandProcessor.cs +++ b/Orm/Xtensive.Orm/Orm/Providers/CommandProcessing/SimpleCommandProcessor.cs @@ -93,10 +93,10 @@ public override async Task ExecuteTasksAsync(CommandProcessorContext context, Ca task.ProcessWith(this, context); var loadTask = context.ActiveTasks.FirstOrDefault(); if (loadTask!=null) { - await context.ActiveCommand.ExecuteReaderAsync(token).ConfigureAwait(false); + await context.ActiveCommand.ExecuteReaderAsync(token).ConfigureAwaitFalse(); var reader = context.ActiveCommand.CreateReader(loadTask.Request.GetAccessor(), token); - await using (reader.ConfigureAwait(false)) { - while (await reader.MoveNextAsync().ConfigureAwait(false)) { + await using (reader.ConfigureAwaitFalse()) { + while (await reader.MoveNextAsync().ConfigureAwaitFalse()) { loadTask.Output.Add(reader.Current); } } @@ -104,7 +104,7 @@ public override async Task ExecuteTasksAsync(CommandProcessorContext context, Ca } } finally { - await context.ActiveCommand.DisposeSafelyAsync().ConfigureAwait(false); + await context.ActiveCommand.DisposeSafelyAsync().ConfigureAwaitFalse(); ReleaseCommand(context); } } @@ -132,7 +132,7 @@ public override async Task ExecuteTasksWithReaderAsync(QueryRequest token.ThrowIfCancellationRequested(); - await ExecuteTasksAsync(context, token).ConfigureAwait(false); + await ExecuteTasksAsync(context, token).ConfigureAwaitFalse(); context.AllowPartialExecution = oldValue; var lastRequestCommand = Factory.CreateCommand(); @@ -140,7 +140,7 @@ public override async Task ExecuteTasksWithReaderAsync(QueryRequest ValidateCommandPartParameters(commandPart); lastRequestCommand.AddPart(commandPart); token.ThrowIfCancellationRequested(); - await lastRequestCommand.ExecuteReaderAsync(token).ConfigureAwait(false); + await lastRequestCommand.ExecuteReaderAsync(token).ConfigureAwaitFalse(); return lastRequestCommand.CreateReader(lastRequest.GetAccessor()); } diff --git a/Orm/Xtensive.Orm/Orm/Providers/CommandWithDataReader.cs b/Orm/Xtensive.Orm/Orm/Providers/CommandWithDataReader.cs index 67f40513ca..7a2bad36cf 100644 --- a/Orm/Xtensive.Orm/Orm/Providers/CommandWithDataReader.cs +++ b/Orm/Xtensive.Orm/Orm/Providers/CommandWithDataReader.cs @@ -26,8 +26,8 @@ public void Dispose() public async ValueTask DisposeAsync() { // Dispose the reader first, at least firebird provider requires it - await Reader.DisposeAsync().ConfigureAwait(false); - await Command.DisposeAsync().ConfigureAwait(false); + await Reader.DisposeAsync().ConfigureAwaitFalse(); + await Command.DisposeAsync().ConfigureAwaitFalse(); } // Constructors diff --git a/Orm/Xtensive.Orm/Orm/Providers/SqlExecutor.cs b/Orm/Xtensive.Orm/Orm/Providers/SqlExecutor.cs index e81f6f1cf4..9a445800d3 100644 --- a/Orm/Xtensive.Orm/Orm/Providers/SqlExecutor.cs +++ b/Orm/Xtensive.Orm/Orm/Providers/SqlExecutor.cs @@ -40,9 +40,9 @@ public Task ExecuteReaderAsync( public async Task ExecuteReaderAsync( ISqlCompileUnit statement, CommandBehavior commandBehavior, CancellationToken token = default) { - await EnsureConnectionIsOpenAsync(token).ConfigureAwait(false); + await EnsureConnectionIsOpenAsync(token).ConfigureAwaitFalse(); return await ExecuteReaderAsync( - connection.CreateCommand(Compile(statement)), commandBehavior, token).ConfigureAwait(false); + connection.CreateCommand(Compile(statement)), commandBehavior, token).ConfigureAwaitFalse(); } public int ExecuteNonQuery(ISqlCompileUnit statement) @@ -54,10 +54,10 @@ public int ExecuteNonQuery(ISqlCompileUnit statement) public async Task ExecuteNonQueryAsync(ISqlCompileUnit statement, CancellationToken token = default) { - await EnsureConnectionIsOpenAsync(token).ConfigureAwait(false); + await EnsureConnectionIsOpenAsync(token).ConfigureAwaitFalse(); var command = connection.CreateCommand(Compile(statement)); - await using (command.ConfigureAwait(false)) { - return await driver.ExecuteNonQueryAsync(session, command, token).ConfigureAwait(false); + await using (command.ConfigureAwaitFalse()) { + return await driver.ExecuteNonQueryAsync(session, command, token).ConfigureAwaitFalse(); } } @@ -70,10 +70,10 @@ public object ExecuteScalar(ISqlCompileUnit statement) public async Task ExecuteScalarAsync(ISqlCompileUnit statement, CancellationToken token = default) { - await EnsureConnectionIsOpenAsync(token).ConfigureAwait(false); + await EnsureConnectionIsOpenAsync(token).ConfigureAwaitFalse(); var command = connection.CreateCommand(Compile(statement)); - await using (command.ConfigureAwait(false)) { - return await driver.ExecuteScalarAsync(session, command, token).ConfigureAwait(false); + await using (command.ConfigureAwaitFalse()) { + return await driver.ExecuteScalarAsync(session, command, token).ConfigureAwaitFalse(); } } @@ -90,9 +90,9 @@ public Task ExecuteReaderAsync(string commandText, Cancel public async Task ExecuteReaderAsync( string commandText, CommandBehavior commandBehavior, CancellationToken token = default) { - await EnsureConnectionIsOpenAsync(token).ConfigureAwait(false); + await EnsureConnectionIsOpenAsync(token).ConfigureAwaitFalse(); return await ExecuteReaderAsync( - connection.CreateCommand(commandText), commandBehavior, token).ConfigureAwait(false); + connection.CreateCommand(commandText), commandBehavior, token).ConfigureAwaitFalse(); } public int ExecuteNonQuery(string commandText) @@ -104,10 +104,10 @@ public int ExecuteNonQuery(string commandText) public async Task ExecuteNonQueryAsync(string commandText, CancellationToken token = default) { - await EnsureConnectionIsOpenAsync(token).ConfigureAwait(false); + await EnsureConnectionIsOpenAsync(token).ConfigureAwaitFalse(); var command = connection.CreateCommand(commandText); - await using (command.ConfigureAwait(false)) { - return await driver.ExecuteNonQueryAsync(session, command, token).ConfigureAwait(false); + await using (command.ConfigureAwaitFalse()) { + return await driver.ExecuteNonQueryAsync(session, command, token).ConfigureAwaitFalse(); } } @@ -120,10 +120,10 @@ public object ExecuteScalar(string commandText) public async Task ExecuteScalarAsync(string commandText, CancellationToken token = default) { - await EnsureConnectionIsOpenAsync(token).ConfigureAwait(false); + await EnsureConnectionIsOpenAsync(token).ConfigureAwaitFalse(); var command = connection.CreateCommand(commandText); - await using (command.ConfigureAwait(false)) { - return await driver.ExecuteScalarAsync(session, command, token).ConfigureAwait(false); + await using (command.ConfigureAwaitFalse()) { + return await driver.ExecuteScalarAsync(session, command, token).ConfigureAwaitFalse(); } } @@ -141,13 +141,13 @@ public void ExecuteMany(IEnumerable statements) public async Task ExecuteManyAsync(IEnumerable statements, CancellationToken token = default) { - await EnsureConnectionIsOpenAsync(token).ConfigureAwait(false); + await EnsureConnectionIsOpenAsync(token).ConfigureAwaitFalse(); if (driver.ProviderInfo.Supports(ProviderFeatures.Batches)) { - await ExecuteManyBatchedAsync(statements, token).ConfigureAwait(false); + await ExecuteManyBatchedAsync(statements, token).ConfigureAwaitFalse(); } else { - await ExecuteManyByOneAsync(statements, token).ConfigureAwait(false); + await ExecuteManyByOneAsync(statements, token).ConfigureAwaitFalse(); } } @@ -160,8 +160,8 @@ public SqlExtractionResult Extract(IEnumerable tasks) public async Task ExtractAsync( IEnumerable tasks, CancellationToken token = default) { - await EnsureConnectionIsOpenAsync(token).ConfigureAwait(false); - return await driver.ExtractAsync(connection, tasks, token).ConfigureAwait(false); + await EnsureConnectionIsOpenAsync(token).ConfigureAwaitFalse(); + return await driver.ExtractAsync(connection, tasks, token).ConfigureAwaitFalse(); } #region Private / internal methods @@ -186,8 +186,8 @@ private async Task ExecuteManyByOneAsync(IEnumerable statements, Cancell } var command = connection.CreateCommand(statement); - await using (command.ConfigureAwait(false)) { - await driver.ExecuteNonQueryAsync(session, command, token).ConfigureAwait(false); + await using (command.ConfigureAwaitFalse()) { + await driver.ExecuteNonQueryAsync(session, command, token).ConfigureAwaitFalse(); } } } @@ -216,8 +216,8 @@ private async Task ExecuteManyBatchedAsync(IEnumerable statements, Cance } var command = connection.CreateCommand(batch); - await using (command.ConfigureAwait(false)) { - await driver.ExecuteNonQueryAsync(session, command, token).ConfigureAwait(false); + await using (command.ConfigureAwaitFalse()) { + await driver.ExecuteNonQueryAsync(session, command, token).ConfigureAwaitFalse(); } } } @@ -274,10 +274,10 @@ private async Task ExecuteReaderAsync(DbCommand command, { DbDataReader reader; try { - reader = await driver.ExecuteReaderAsync(session, command, commandBehavior, token).ConfigureAwait(false); + reader = await driver.ExecuteReaderAsync(session, command, commandBehavior, token).ConfigureAwaitFalse(); } catch { - await command.DisposeAsync().ConfigureAwait(false); + await command.DisposeAsync().ConfigureAwaitFalse(); throw; } return new CommandWithDataReader(command, reader); diff --git a/Orm/Xtensive.Orm/Orm/Providers/SqlIncludeProvider.cs b/Orm/Xtensive.Orm/Orm/Providers/SqlIncludeProvider.cs index 2cd816488a..e81d5db6fc 100644 --- a/Orm/Xtensive.Orm/Orm/Providers/SqlIncludeProvider.cs +++ b/Orm/Xtensive.Orm/Orm/Providers/SqlIncludeProvider.cs @@ -76,13 +76,13 @@ protected internal override void OnBeforeEnumerate(Rse.Providers.EnumerationCont protected internal override async Task OnBeforeEnumerateAsync(Rse.Providers.EnumerationContext context, CancellationToken token) { - await base.OnBeforeEnumerateAsync(context, token).ConfigureAwait(false); + await base.OnBeforeEnumerateAsync(context, token).ConfigureAwaitFalse(); var parameterContext = ((EnumerationContext) context).ParameterContext; switch (Origin.Algorithm) { case IncludeAlgorithm.Auto: var filterData = filterDataSource.Invoke(parameterContext).ToList(); if (filterData.Count > DomainHandler.Domain.Configuration.MaxNumberOfConditions) - await LockAndStoreAsync(context, filterData, token).ConfigureAwait(false); + await LockAndStoreAsync(context, filterData, token).ConfigureAwaitFalse(); else parameterContext.SetValue(CreateFilterParameter(tableDescriptor), filterData); break; @@ -90,7 +90,7 @@ protected internal override async Task OnBeforeEnumerateAsync(Rse.Providers.Enum // nothing break; case IncludeAlgorithm.TemporaryTable: - await LockAndStoreAsync(context, filterDataSource.Invoke(parameterContext), token).ConfigureAwait(false); + await LockAndStoreAsync(context, filterDataSource.Invoke(parameterContext), token).ConfigureAwaitFalse(); break; default: throw new ArgumentOutOfRangeException("Origin.Algorithm"); diff --git a/Orm/Xtensive.Orm/Orm/Providers/SqlProvider.cs b/Orm/Xtensive.Orm/Orm/Providers/SqlProvider.cs index 227990d31b..2424421ee1 100644 --- a/Orm/Xtensive.Orm/Orm/Providers/SqlProvider.cs +++ b/Orm/Xtensive.Orm/Orm/Providers/SqlProvider.cs @@ -58,7 +58,7 @@ protected internal async override Task OnEnumerateAsync(Rse.Provider { var storageContext = (EnumerationContext)context; var executor = storageContext.Session.Services.Demand(); - return await executor.ExecuteTupleReaderAsync(Request, storageContext.ParameterContext, token).ConfigureAwait(false); + return await executor.ExecuteTupleReaderAsync(Request, storageContext.ParameterContext, token).ConfigureAwaitFalse(); } #region ToString related methods diff --git a/Orm/Xtensive.Orm/Orm/Providers/SqlSessionHandler.Fetching.cs b/Orm/Xtensive.Orm/Orm/Providers/SqlSessionHandler.Fetching.cs index d5069a9264..8db6a1a628 100644 --- a/Orm/Xtensive.Orm/Orm/Providers/SqlSessionHandler.Fetching.cs +++ b/Orm/Xtensive.Orm/Orm/Providers/SqlSessionHandler.Fetching.cs @@ -7,6 +7,7 @@ using System.Collections.Generic; using System.Threading; using System.Threading.Tasks; +using Xtensive.Core; using Xtensive.Orm.Internals.Prefetch; using Xtensive.Orm.Model; using TypeInfo = Xtensive.Orm.Model.TypeInfo; diff --git a/Orm/Xtensive.Orm/Orm/Providers/SqlSessionHandler.IProviderExecutor.cs b/Orm/Xtensive.Orm/Orm/Providers/SqlSessionHandler.IProviderExecutor.cs index a2a2a85d62..62744c786f 100644 --- a/Orm/Xtensive.Orm/Orm/Providers/SqlSessionHandler.IProviderExecutor.cs +++ b/Orm/Xtensive.Orm/Orm/Providers/SqlSessionHandler.IProviderExecutor.cs @@ -31,10 +31,10 @@ DataReader IProviderExecutor.ExecuteTupleReader(QueryRequest request, async Task IProviderExecutor.ExecuteTupleReaderAsync(QueryRequest request, ParameterContext parameterContext, CancellationToken token) { - await PrepareAsync(token).ConfigureAwait(false); + await PrepareAsync(token).ConfigureAwaitFalse(); var context = new CommandProcessorContext(parameterContext); - await using (context.ConfigureAwait(false)) { - return await commandProcessor.ExecuteTasksWithReaderAsync(request, context, token).ConfigureAwait(false); + await using (context.ConfigureAwaitFalse()) { + return await commandProcessor.ExecuteTasksWithReaderAsync(request, context, token).ConfigureAwaitFalse(); } } @@ -51,7 +51,7 @@ void IProviderExecutor.Store(IPersistDescriptor descriptor, IEnumerable t async Task IProviderExecutor.StoreAsync(IPersistDescriptor descriptor, IEnumerable tuples, ParameterContext parameterContext, CancellationToken token) { - await PrepareAsync(token).ConfigureAwait(false); + await PrepareAsync(token).ConfigureAwaitFalse(); StoreInternal(descriptor, tuples); @@ -79,7 +79,7 @@ private async ValueTask ExecuteInternal(ParameterContext parameterContext, bool { using (var context = new CommandProcessorContext(parameterContext)) { if (isAsync) { - await commandProcessor.ExecuteTasksAsync(context, token).ConfigureAwait(false); + await commandProcessor.ExecuteTasksAsync(context, token).ConfigureAwaitFalse(); } else { commandProcessor.ExecuteTasks(context); diff --git a/Orm/Xtensive.Orm/Orm/Providers/SqlSessionHandler.cs b/Orm/Xtensive.Orm/Orm/Providers/SqlSessionHandler.cs index 99cfd40aad..43c46370b0 100644 --- a/Orm/Xtensive.Orm/Orm/Providers/SqlSessionHandler.cs +++ b/Orm/Xtensive.Orm/Orm/Providers/SqlSessionHandler.cs @@ -10,6 +10,7 @@ using System.Threading; using System.Threading.Tasks; using Xtensive.IoC; +using Xtensive.Core; using Xtensive.Orm.Configuration; using Xtensive.Orm.Internals; using Xtensive.Orm.Internals.Prefetch; @@ -98,11 +99,11 @@ public override async ValueTask CommitTransactionAsync(Transaction transaction) { pendingTransaction = null; if (connection.ActiveTransaction != null && !transactionIsExternal) { - await driver.CommitTransactionAsync(Session, connection).ConfigureAwait(false); + await driver.CommitTransactionAsync(Session, connection).ConfigureAwaitFalse(); } if (!connectionIsExternal) { - await driver.CloseConnectionAsync(Session, connection).ConfigureAwait(false); + await driver.CloseConnectionAsync(Session, connection).ConfigureAwaitFalse(); } } @@ -124,11 +125,11 @@ public override async ValueTask RollbackTransactionAsync(Transaction transaction { pendingTransaction = null; if (connection.ActiveTransaction != null && !transactionIsExternal) { - await driver.RollbackTransactionAsync(Session, connection).ConfigureAwait(false); + await driver.RollbackTransactionAsync(Session, connection).ConfigureAwaitFalse(); } if (!connectionIsExternal) { - await driver.CloseConnectionAsync(Session, connection).ConfigureAwait(false); + await driver.CloseConnectionAsync(Session, connection).ConfigureAwaitFalse(); } } @@ -142,8 +143,8 @@ public override void CreateSavepoint(Transaction transaction) /// public override async ValueTask CreateSavepointAsync(Transaction transaction, CancellationToken token = default) { - await PrepareAsync(token).ConfigureAwait(false); - await driver.MakeSavepointAsync(Session, connection, transaction.SavepointName, token).ConfigureAwait(false); + await PrepareAsync(token).ConfigureAwaitFalse(); + await driver.MakeSavepointAsync(Session, connection, transaction.SavepointName, token).ConfigureAwaitFalse(); } /// @@ -156,8 +157,8 @@ public override void RollbackToSavepoint(Transaction transaction) /// public override async ValueTask RollbackToSavepointAsync(Transaction transaction, CancellationToken token = default) { - await PrepareAsync(token).ConfigureAwait(false); - await driver.RollbackToSavepointAsync(Session, connection, transaction.SavepointName, token).ConfigureAwait(false); + await PrepareAsync(token).ConfigureAwaitFalse(); + await driver.RollbackToSavepointAsync(Session, connection, transaction.SavepointName, token).ConfigureAwaitFalse(); } /// @@ -170,8 +171,8 @@ public override void ReleaseSavepoint(Transaction transaction) /// public override async ValueTask ReleaseSavepointAsync(Transaction transaction, CancellationToken token = default) { - await PrepareAsync(token).ConfigureAwait(false); - await driver.ReleaseSavepointAsync(Session, connection, transaction.SavepointName, token).ConfigureAwait(false); + await PrepareAsync(token).ConfigureAwaitFalse(); + await driver.ReleaseSavepointAsync(Session, connection, transaction.SavepointName, token).ConfigureAwaitFalse(); } /// @@ -222,17 +223,17 @@ private void Prepare() private async Task PrepareAsync(CancellationToken cancellationToken) { Session.EnsureNotDisposed(); - await driver.EnsureConnectionIsOpenAsync(Session, connection, cancellationToken).ConfigureAwait(false); + await driver.EnsureConnectionIsOpenAsync(Session, connection, cancellationToken).ConfigureAwaitFalse(); try { foreach (var initializationSqlScript in initializationSqlScripts) { var command = connection.CreateCommand(initializationSqlScript); - await using var commandAwaiter = command.ConfigureAwait(false); - await driver.ExecuteNonQueryAsync(Session, command, cancellationToken).ConfigureAwait(false); + await using var commandAwaiter = command.ConfigureAwaitFalse(); + await driver.ExecuteNonQueryAsync(Session, command, cancellationToken).ConfigureAwaitFalse(); } } catch (OperationCanceledException) { - await connection.CloseAsync().ConfigureAwait(false); + await connection.CloseAsync().ConfigureAwaitFalse(); throw; } @@ -245,7 +246,7 @@ private async Task PrepareAsync(CancellationToken cancellationToken) if (connection.ActiveTransaction == null) { // Handle external transactions var isolationLevel = IsolationLevelConverter.Convert(transaction.IsolationLevel); - await driver.BeginTransactionAsync(Session, connection, isolationLevel, cancellationToken).ConfigureAwait(false); + await driver.BeginTransactionAsync(Session, connection, isolationLevel, cancellationToken).ConfigureAwaitFalse(); } } @@ -286,7 +287,7 @@ public override void ExecuteQueryTasks(IEnumerable queryTasks, bool a /// public override async Task ExecuteQueryTasksAsync(IEnumerable queryTasks, bool allowPartialExecution, CancellationToken token) { - await PrepareAsync(token).ConfigureAwait(false); + await PrepareAsync(token).ConfigureAwaitFalse(); var nonBatchedTasks = new List(); foreach (var task in queryTasks) { @@ -301,15 +302,15 @@ public override async Task ExecuteQueryTasksAsync(IEnumerable queryTa CommandProcessorContext context; if (nonBatchedTasks.Count==0) { context = Session.CommandProcessorContextProvider.ProvideContext(allowPartialExecution); - await using var contextAwaiter = context.ConfigureAwait(false); - await commandProcessor.ExecuteTasksAsync(context, token).ConfigureAwait(false); + await using var contextAwaiter = context.ConfigureAwaitFalse(); + await commandProcessor.ExecuteTasksAsync(context, token).ConfigureAwaitFalse(); return; } context = Session.CommandProcessorContextProvider.ProvideContext(); - await using (context.ConfigureAwait(false)) { - await commandProcessor.ExecuteTasksAsync(context, token).ConfigureAwait(false); + await using (context.ConfigureAwaitFalse()) { + await commandProcessor.ExecuteTasksAsync(context, token).ConfigureAwaitFalse(); } foreach (var task in nonBatchedTasks) { @@ -339,12 +340,12 @@ public override void Persist(EntityChangeRegistry registry, bool allowPartialExe public override async Task PersistAsync(EntityChangeRegistry registry, bool allowPartialExecution, CancellationToken token) { - await PrepareAsync(token).ConfigureAwait(false); + await PrepareAsync(token).ConfigureAwaitFalse(); domainHandler.Persister.Persist(registry, commandProcessor); var context = Session.CommandProcessorContextProvider.ProvideContext(allowPartialExecution); - await using var contextAwaiter = context.ConfigureAwait(false); - await commandProcessor.ExecuteTasksAsync(context, token).ConfigureAwait(false); + await using var contextAwaiter = context.ConfigureAwaitFalse(); + await commandProcessor.ExecuteTasksAsync(context, token).ConfigureAwaitFalse(); } /// @@ -370,8 +371,8 @@ public override async ValueTask DisposeAsync() isDisposed = true; if (!connectionIsExternal) { - await driver.CloseConnectionAsync(Session, connection).ConfigureAwait(false); - await driver.DisposeConnectionAsync(Session, connection).ConfigureAwait(false); + await driver.CloseConnectionAsync(Session, connection).ConfigureAwaitFalse(); + await driver.DisposeConnectionAsync(Session, connection).ConfigureAwaitFalse(); } } diff --git a/Orm/Xtensive.Orm/Orm/Providers/SqlStoreProvider.cs b/Orm/Xtensive.Orm/Orm/Providers/SqlStoreProvider.cs index a71278390b..5b0e8f3e16 100644 --- a/Orm/Xtensive.Orm/Orm/Providers/SqlStoreProvider.cs +++ b/Orm/Xtensive.Orm/Orm/Providers/SqlStoreProvider.cs @@ -6,6 +6,7 @@ using System.Threading; using System.Threading.Tasks; +using Xtensive.Core; using Xtensive.Orm.Rse.Providers; namespace Xtensive.Orm.Providers @@ -35,8 +36,8 @@ protected internal override void OnBeforeEnumerate(Rse.Providers.EnumerationCont /// protected internal override async Task OnBeforeEnumerateAsync(Rse.Providers.EnumerationContext context, CancellationToken token) { - await base.OnBeforeEnumerateAsync(context, token).ConfigureAwait(false); - await LockAndStoreAsync(context, Source.ToEnumerable(context), token).ConfigureAwait(false); + await base.OnBeforeEnumerateAsync(context, token).ConfigureAwaitFalse(); + await LockAndStoreAsync(context, Source.ToEnumerable(context), token).ConfigureAwaitFalse(); } protected internal override void OnAfterEnumerate(Rse.Providers.EnumerationContext context) diff --git a/Orm/Xtensive.Orm/Orm/Providers/SqlTemporaryDataProvider.cs b/Orm/Xtensive.Orm/Orm/Providers/SqlTemporaryDataProvider.cs index c3415d52c5..755188d6f7 100644 --- a/Orm/Xtensive.Orm/Orm/Providers/SqlTemporaryDataProvider.cs +++ b/Orm/Xtensive.Orm/Orm/Providers/SqlTemporaryDataProvider.cs @@ -43,7 +43,7 @@ protected async ValueTask LockAndStoreAsync(Rse.Providers.EnumerationContext con return; storageContext.SetValue(this, TemporaryTableLockName, tableLock); var executor = storageContext.Session.Services.Demand(); - await executor.StoreAsync(tableDescriptor, data, storageContext.ParameterContext, token).ConfigureAwait(false); + await executor.StoreAsync(tableDescriptor, data, storageContext.ParameterContext, token).ConfigureAwaitFalse(); } protected bool ClearAndUnlock(Rse.Providers.EnumerationContext context) diff --git a/Orm/Xtensive.Orm/Orm/Providers/StorageDriver.Operations.cs b/Orm/Xtensive.Orm/Orm/Providers/StorageDriver.Operations.cs index d3eaf5b036..5260b85f7f 100644 --- a/Orm/Xtensive.Orm/Orm/Providers/StorageDriver.Operations.cs +++ b/Orm/Xtensive.Orm/Orm/Providers/StorageDriver.Operations.cs @@ -9,6 +9,7 @@ using System.Data.Common; using System.Threading; using System.Threading.Tasks; +using Xtensive.Core; using Xtensive.Orm.Configuration; using Xtensive.Sql; @@ -105,10 +106,10 @@ public async Task OpenConnectionAsync(Session session, SqlConnection connection, try { if (!string.IsNullOrEmpty(script)) { - await connection.OpenAndInitializeAsync(script, cancellationToken).ConfigureAwait(false); + await connection.OpenAndInitializeAsync(script, cancellationToken).ConfigureAwaitFalse(); } else { - await connection.OpenAsync(cancellationToken).ConfigureAwait(false); + await connection.OpenAsync(cancellationToken).ConfigureAwaitFalse(); } } catch (OperationCanceledException) { @@ -130,7 +131,7 @@ public async Task EnsureConnectionIsOpenAsync( Session session, SqlConnection connection, CancellationToken cancellationToken) { if (connection.State != ConnectionState.Open) { - await OpenConnectionAsync(session, connection, cancellationToken).ConfigureAwait(false); + await OpenConnectionAsync(session, connection, cancellationToken).ConfigureAwaitFalse(); } } @@ -163,7 +164,7 @@ public async Task CloseConnectionAsync(Session session, SqlConnection connection } try { - await connection.CloseAsync().ConfigureAwait(false); + await connection.CloseAsync().ConfigureAwaitFalse(); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); @@ -191,7 +192,7 @@ public async Task DisposeConnectionAsync(Session session, SqlConnection connecti } try { - await connection.DisposeAsync().ConfigureAwait(false); + await connection.DisposeAsync().ConfigureAwaitFalse(); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); @@ -226,7 +227,7 @@ public async ValueTask BeginTransactionAsync( isolationLevel ??= IsolationLevelConverter.Convert(GetConfiguration(session).DefaultIsolationLevel); try { - await connection.BeginTransactionAsync(isolationLevel.Value, token).ConfigureAwait(false); + await connection.BeginTransactionAsync(isolationLevel.Value, token).ConfigureAwaitFalse(); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); @@ -255,7 +256,7 @@ public async ValueTask CommitTransactionAsync( } try { - await connection.CommitAsync(token).ConfigureAwait(false); + await connection.CommitAsync(token).ConfigureAwaitFalse(); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); @@ -284,7 +285,7 @@ public async ValueTask RollbackTransactionAsync( } try { - await connection.RollbackAsync(token).ConfigureAwait(false); + await connection.RollbackAsync(token).ConfigureAwaitFalse(); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); @@ -321,7 +322,7 @@ public async ValueTask MakeSavepointAsync( } try { - await connection.MakeSavepointAsync(name, token).ConfigureAwait(false); + await connection.MakeSavepointAsync(name, token).ConfigureAwaitFalse(); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); @@ -358,7 +359,7 @@ public async ValueTask RollbackToSavepointAsync( } try { - await connection.RollbackToSavepointAsync(name, token).ConfigureAwait(false); + await connection.RollbackToSavepointAsync(name, token).ConfigureAwaitFalse(); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); @@ -387,7 +388,7 @@ public async ValueTask ReleaseSavepointAsync( } try { - await connection.ReleaseSavepointAsync(name, token).ConfigureAwait(false); + await connection.ReleaseSavepointAsync(name, token).ConfigureAwaitFalse(); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); @@ -466,7 +467,7 @@ private async Task ExecuteCommandAsync(Session session, TResult result; try { - result = await action(command, commandBehavior, cancellationToken).ConfigureAwait(false); + result = await action(command, commandBehavior, cancellationToken).ConfigureAwaitFalse(); } catch (OperationCanceledException) { throw; diff --git a/Orm/Xtensive.Orm/Orm/Providers/StorageDriver.cs b/Orm/Xtensive.Orm/Orm/Providers/StorageDriver.cs index 2678979104..f7c963aee8 100644 --- a/Orm/Xtensive.Orm/Orm/Providers/StorageDriver.cs +++ b/Orm/Xtensive.Orm/Orm/Providers/StorageDriver.cs @@ -74,7 +74,7 @@ public SqlExtractionResult Extract(SqlConnection connection, IEnumerable ExtractAsync( SqlConnection connection, IEnumerable tasks, CancellationToken token) { - var result = await underlyingDriver.ExtractAsync(connection, tasks, token).ConfigureAwait(false); + var result = await underlyingDriver.ExtractAsync(connection, tasks, token).ConfigureAwaitFalse(); FixExtractionResult(result); return result; } @@ -239,7 +239,7 @@ public static async Task CreateAsync( }; var driver = await driverFactory.GetDriverAsync(configuration.ConnectionInfo, driverConfiguration, token) - .ConfigureAwait(false); + .ConfigureAwaitFalse(); var providerInfo = ProviderInfoBuilder.Build(configuration.ConnectionInfo.Provider, driver); return new StorageDriver(driver, providerInfo, configuration, GetNullModel, factories); diff --git a/Orm/Xtensive.Orm/Orm/QueryResult.cs b/Orm/Xtensive.Orm/Orm/QueryResult.cs index 7a83cc87ea..b483dc922a 100644 --- a/Orm/Xtensive.Orm/Orm/QueryResult.cs +++ b/Orm/Xtensive.Orm/Orm/QueryResult.cs @@ -6,6 +6,7 @@ using System.Collections; using System.Collections.Generic; using JetBrains.Annotations; +using Xtensive.Core; using Xtensive.Orm.Linq.Materialization; namespace Xtensive.Orm @@ -55,7 +56,7 @@ public async IAsyncEnumerable AsAsyncEnumerable() { EnsureResultsAlive(); var enumerator = reader.AsAsyncEnumerator(); - while (await enumerator.MoveNextAsync().ConfigureAwait(false)) { + while (await enumerator.MoveNextAsync().ConfigureAwaitFalse()) { yield return enumerator.Current; } } diff --git a/Orm/Xtensive.Orm/Orm/QueryableExtensions.Async.cs b/Orm/Xtensive.Orm/Orm/QueryableExtensions.Async.cs index 8338ef715d..4a2a673337 100644 --- a/Orm/Xtensive.Orm/Orm/QueryableExtensions.Async.cs +++ b/Orm/Xtensive.Orm/Orm/QueryableExtensions.Async.cs @@ -1460,7 +1460,7 @@ public static async Task> ToListAsync(this IQueryable(); - var asyncSource = source.AsAsyncEnumerable().WithCancellation(cancellationToken).ConfigureAwait(false); + var asyncSource = source.AsAsyncEnumerable().WithCancellation(cancellationToken).ConfigureAwaitFalse(); await foreach (var element in asyncSource) { list.Add(element); } @@ -1482,7 +1482,7 @@ public static async Task> ToListAsync(this IQueryable public static async Task ToArrayAsync(this IQueryable source, CancellationToken cancellationToken = default) => - (await source.ToListAsync(cancellationToken).ConfigureAwait(false)).ToArray(); + (await source.ToListAsync(cancellationToken).ConfigureAwaitFalse()).ToArray(); /// /// Creates a from an @@ -1510,7 +1510,7 @@ public static async Task> ToDictionaryAsync>>(body, itemParam)); var dictionary = new Dictionary(); - var asyncSource = query.AsAsyncEnumerable().WithCancellation(cancellationToken).ConfigureAwait(false); + var asyncSource = query.AsAsyncEnumerable().WithCancellation(cancellationToken).ConfigureAwaitFalse(); await foreach (var tuple in asyncSource) { dictionary.Add(tuple.Item1, tuple.Item2); } @@ -1548,7 +1548,7 @@ public static async Task> ToDictionaryAsync>>(body, itemParam)); var dictionary = new Dictionary(); - var asyncSource = query.AsAsyncEnumerable().WithCancellation(cancellationToken).ConfigureAwait(false); + var asyncSource = query.AsAsyncEnumerable().WithCancellation(cancellationToken).ConfigureAwaitFalse(); await foreach (var tuple in asyncSource) { dictionary.Add(tuple.Item1, tuple.Item2); } @@ -1572,7 +1572,7 @@ public static async Task> ToHashSetAsync(this IQueryab CancellationToken cancellationToken = default) { var hashSet = new HashSet(); - var asyncSource = source.AsAsyncEnumerable().WithCancellation(cancellationToken).ConfigureAwait(false); + var asyncSource = source.AsAsyncEnumerable().WithCancellation(cancellationToken).ConfigureAwaitFalse(); await foreach (var element in asyncSource) { hashSet.Add(element); } @@ -1604,7 +1604,7 @@ public static async Task> ToLookupAsync(th ExpressionReplacer.ReplaceAll(keySelector.Body, keySelector.Parameters, itemParam), itemParam[0]); var query = source.Select(FastExpression.Lambda>>(body, itemParam)); - var queryResult = await query.ExecuteAsync(cancellationToken).ConfigureAwait(false); + var queryResult = await query.ExecuteAsync(cancellationToken).ConfigureAwaitFalse(); return queryResult.ToLookup(tuple => tuple.Item1, tuple => tuple.Item2); } @@ -1637,7 +1637,7 @@ public static async Task> ToLookupAsync>>(body, itemParam)); - var queryResult = await query.ExecuteAsync(cancellationToken).ConfigureAwait(false); + var queryResult = await query.ExecuteAsync(cancellationToken).ConfigureAwaitFalse(); return queryResult.ToLookup(tuple => tuple.Item1, tuple => tuple.Item2); } diff --git a/Orm/Xtensive.Orm/Orm/QueryableExtensions.cs b/Orm/Xtensive.Orm/Orm/QueryableExtensions.cs index 250ff83725..0bf1a44e6d 100644 --- a/Orm/Xtensive.Orm/Orm/QueryableExtensions.cs +++ b/Orm/Xtensive.Orm/Orm/QueryableExtensions.cs @@ -316,7 +316,7 @@ public static Task> ExecuteAsync(this IQueryable source) => public static async Task> ExecuteAsync(this IQueryable source, CancellationToken cancellationToken) { return source.Provider is QueryProvider queryProvider - ? await queryProvider.ExecuteSequenceAsync(source.Expression, cancellationToken).ConfigureAwait(false) + ? await queryProvider.ExecuteSequenceAsync(source.Expression, cancellationToken).ConfigureAwaitFalse() : new QueryResult(source.AsEnumerable()); } diff --git a/Orm/Xtensive.Orm/Orm/Rse/Providers/Executable/ExecutableRawProvider.cs b/Orm/Xtensive.Orm/Orm/Rse/Providers/Executable/ExecutableRawProvider.cs index a449e2cde3..a014d739ca 100644 --- a/Orm/Xtensive.Orm/Orm/Rse/Providers/Executable/ExecutableRawProvider.cs +++ b/Orm/Xtensive.Orm/Orm/Rse/Providers/Executable/ExecutableRawProvider.cs @@ -8,6 +8,7 @@ using System.Collections.Generic; using System.Threading; using System.Threading.Tasks; +using Xtensive.Core; using Xtensive.Orm.Providers; using Tuple = Xtensive.Tuples.Tuple; @@ -32,7 +33,7 @@ protected internal override void OnBeforeEnumerate(EnumerationContext context) /// protected internal override async Task OnBeforeEnumerateAsync(EnumerationContext context, CancellationToken token) { - await base.OnBeforeEnumerateAsync(context, token).ConfigureAwait(false); + await base.OnBeforeEnumerateAsync(context, token).ConfigureAwaitFalse(); var parameterContext = ((Xtensive.Orm.Providers.EnumerationContext) context).ParameterContext; SetValue(context, CachedSourceName, Origin.CompiledSource.Invoke(parameterContext)); } diff --git a/Orm/Xtensive.Orm/Orm/Rse/Providers/ExecutableProvider.cs b/Orm/Xtensive.Orm/Orm/Rse/Providers/ExecutableProvider.cs index 3fdfd41e48..e273168a19 100644 --- a/Orm/Xtensive.Orm/Orm/Rse/Providers/ExecutableProvider.cs +++ b/Orm/Xtensive.Orm/Orm/Rse/Providers/ExecutableProvider.cs @@ -53,7 +53,7 @@ protected internal virtual async Task OnBeforeEnumerateAsync(EnumerationContext token.ThrowIfCancellationRequested(); foreach (var source in Sources) { if (source is ExecutableProvider ep) { - await ep.OnBeforeEnumerateAsync(context, token).ConfigureAwait(false); + await ep.OnBeforeEnumerateAsync(context, token).ConfigureAwaitFalse(); } } } @@ -162,8 +162,8 @@ public async Task GetRecordSetReaderAsync( { ArgumentValidator.EnsureArgumentNotNull(session, nameof(session)); var enumerationContext = - await session.CreateEnumerationContextAsync(parameterContext, token).ConfigureAwait(false); - return await RecordSetReader.CreateAsync(enumerationContext, this, token).ConfigureAwait(false); + await session.CreateEnumerationContextAsync(parameterContext, token).ConfigureAwaitFalse(); + return await RecordSetReader.CreateAsync(enumerationContext, this, token).ConfigureAwaitFalse(); } // Constructors diff --git a/Orm/Xtensive.Orm/Orm/Rse/RecordSetReader.cs b/Orm/Xtensive.Orm/Orm/Rse/RecordSetReader.cs index dc33df8e50..5d9e7f0d37 100644 --- a/Orm/Xtensive.Orm/Orm/Rse/RecordSetReader.cs +++ b/Orm/Xtensive.Orm/Orm/Rse/RecordSetReader.cs @@ -7,6 +7,7 @@ using System.Collections.Generic; using System.Threading; using System.Threading.Tasks; +using Xtensive.Core; using Xtensive.Orm.Providers; using Xtensive.Orm.Rse.Providers; using EnumerationContext = Xtensive.Orm.Rse.Providers.EnumerationContext; @@ -106,7 +107,7 @@ public async ValueTask MoveNextAsync() goto case State.InProgress; case State.InProgress: try { - if (await dataReader.MoveNextAsync().ConfigureAwait(false)) { + if (await dataReader.MoveNextAsync().ConfigureAwaitFalse()) { return true; } } @@ -141,14 +142,14 @@ private async ValueTask Prepare(bool executeAsync) try { dataReader = executeAsync - ? await provider.OnEnumerateAsync(context, token).ConfigureAwait(false) + ? await provider.OnEnumerateAsync(context, token).ConfigureAwaitFalse() : provider.OnEnumerate(context); if (isGreedy && !dataReader.IsInMemory) { var tuples = new List(); if (executeAsync) { - await using (dataReader.ConfigureAwait(false)) { - while (await dataReader.MoveNextAsync().ConfigureAwait(false)) { + await using (dataReader.ConfigureAwaitFalse()) { + while (await dataReader.MoveNextAsync().ConfigureAwaitFalse()) { tuples.Add(dataReader.Current); } } @@ -194,7 +195,7 @@ public void Dispose() public async ValueTask DisposeAsync() { if (state != State.New) { - await dataReader.DisposeAsync().ConfigureAwait(false); + await dataReader.DisposeAsync().ConfigureAwaitFalse(); } enumerationScope?.Dispose(); } @@ -242,7 +243,7 @@ public static async ValueTask CreateAsync( EnumerationContext context, ExecutableProvider provider, CancellationToken token) { var recordSet = new RecordSetReader(context, provider, token); - await recordSet.Prepare(true).ConfigureAwait(false); + await recordSet.Prepare(true).ConfigureAwaitFalse(); return recordSet; } diff --git a/Orm/Xtensive.Orm/Orm/Session.Cache.cs b/Orm/Xtensive.Orm/Orm/Session.Cache.cs index 4e51c60669..a7ccabf0f5 100644 --- a/Orm/Xtensive.Orm/Orm/Session.Cache.cs +++ b/Orm/Xtensive.Orm/Orm/Session.Cache.cs @@ -71,7 +71,7 @@ private async ValueTask RemapEntityKeys(KeyMapping keyMapping, bool isAsync, Can return; using (Activate()) { if (!LazyKeyGenerationIsEnabled) { - await Persist(PersistReason.RemapEntityKeys, isAsync, token).ConfigureAwait(false); + await Persist(PersistReason.RemapEntityKeys, isAsync, token).ConfigureAwaitFalse(); Invalidate(); } if (IsDebugEventLoggingEnabled) { diff --git a/Orm/Xtensive.Orm/Orm/Session.Persist.cs b/Orm/Xtensive.Orm/Orm/Session.Persist.cs index 1e9fb3c2d5..bf41f53af4 100644 --- a/Orm/Xtensive.Orm/Orm/Session.Persist.cs +++ b/Orm/Xtensive.Orm/Orm/Session.Persist.cs @@ -81,10 +81,10 @@ public void SaveChanges() public async Task SaveChangesAsync(CancellationToken token = default) { if (Configuration.Supports(SessionOptions.NonTransactionalEntityStates)) { - await SaveLocalChangesAsync(token).ConfigureAwait(false); + await SaveLocalChangesAsync(token).ConfigureAwaitFalse(); } else { - await PersistAsync(PersistReason.Manual, token).ConfigureAwait(false); + await PersistAsync(PersistReason.Manual, token).ConfigureAwaitFalse(); } } @@ -109,7 +109,7 @@ public void CancelChanges() internal void Persist(PersistReason reason) => Persist(reason, false).GetAwaiter().GetResult(); internal async Task PersistAsync(PersistReason reason, CancellationToken token = default) => - await Persist(reason, true, token).ConfigureAwait(false); + await Persist(reason, true, token).ConfigureAwaitFalse(); private async ValueTask Persist(PersistReason reason, bool isAsync, CancellationToken token = default) { @@ -155,14 +155,14 @@ private async ValueTask Persist(PersistReason reason, bool isAsync, Cancellation } if (LazyKeyGenerationIsEnabled) { - await RemapEntityKeys(remapper.Remap(itemsToPersist), isAsync, token).ConfigureAwait(false); + await RemapEntityKeys(remapper.Remap(itemsToPersist), isAsync, token).ConfigureAwaitFalse(); } ApplyEntitySetsChanges(); var persistIsSuccessful = false; try { if (isAsync) { - await Handler.PersistAsync(itemsToPersist, reason == PersistReason.Query, token).ConfigureAwait(false); + await Handler.PersistAsync(itemsToPersist, reason == PersistReason.Query, token).ConfigureAwaitFalse(); } else { Handler.Persist(itemsToPersist, reason == PersistReason.Query); @@ -215,7 +215,7 @@ private async ValueTask Persist(PersistReason reason, bool isAsync, Cancellation finally { IsPersisting = false; if (isAsync) { - await ts.DisposeAsync().ConfigureAwait(false); + await ts.DisposeAsync().ConfigureAwaitFalse(); } else { ts.Dispose(); @@ -301,9 +301,9 @@ private async Task SaveLocalChangesAsync(CancellationToken token = default) { Validate(); var transaction = OpenTransaction(TransactionOpenMode.New); - await using (transaction.ConfigureAwait(false)) { + await using (transaction.ConfigureAwaitFalse()) { try { - await PersistAsync(PersistReason.Manual, token).ConfigureAwait(false); + await PersistAsync(PersistReason.Manual, token).ConfigureAwaitFalse(); } finally { transaction.Complete(); diff --git a/Orm/Xtensive.Orm/Orm/Session.QueryTasks.cs b/Orm/Xtensive.Orm/Orm/Session.QueryTasks.cs index ab51dbb902..626bebb516 100644 --- a/Orm/Xtensive.Orm/Orm/Session.QueryTasks.cs +++ b/Orm/Xtensive.Orm/Orm/Session.QueryTasks.cs @@ -8,6 +8,7 @@ using System.Linq; using System.Threading; using System.Threading.Tasks; +using Xtensive.Core; using Xtensive.Orm.Internals; @@ -41,10 +42,10 @@ internal bool ExecuteInternalDelayedQueries(bool skipPersist) internal async Task ExecuteInternalDelayedQueriesAsync(bool skipPersist, CancellationToken token = default) { if (!skipPersist) { - await PersistAsync(PersistReason.Other, token).ConfigureAwait(false); + await PersistAsync(PersistReason.Other, token).ConfigureAwaitFalse(); } - return await ProcessInternalDelayedQueriesAsync(false, token).ConfigureAwait(false); + return await ProcessInternalDelayedQueriesAsync(false, token).ConfigureAwaitFalse(); } internal bool ExecuteUserDefinedDelayedQueries(bool skipPersist) @@ -60,11 +61,11 @@ internal async Task ExecuteUserDefinedDelayedQueriesAsync(bool skipPersist { token.ThrowIfCancellationRequested(); if (!skipPersist) { - await PersistAsync(PersistReason.Other, token).ConfigureAwait(false); + await PersistAsync(PersistReason.Other, token).ConfigureAwaitFalse(); } token.ThrowIfCancellationRequested(); - return await ProcessUserDefinedDelayedQueriesAsync(false, token).ConfigureAwait(false); + return await ProcessUserDefinedDelayedQueriesAsync(false, token).ConfigureAwaitFalse(); } private bool ProcessInternalDelayedQueries(bool allowPartialExecution) @@ -90,7 +91,7 @@ private async Task ProcessInternalDelayedQueriesAsync(bool allowPartialExe try { await Handler.ExecuteQueryTasksAsync( - internalQueryTasks.Where(t=>t.LifetimeToken.IsActive), allowPartialExecution, token).ConfigureAwait(false); + internalQueryTasks.Where(t=>t.LifetimeToken.IsActive), allowPartialExecution, token).ConfigureAwaitFalse(); return true; } finally { @@ -122,7 +123,7 @@ private async Task ProcessUserDefinedDelayedQueriesAsync(bool allowPartial var aliveTasks = new List(userDefinedQueryTasks.Count); aliveTasks.AddRange(userDefinedQueryTasks.Where(t => t.LifetimeToken.IsActive)); userDefinedQueryTasks.Clear(); - await Handler.ExecuteQueryTasksAsync(aliveTasks, allowPartialExecution, token).ConfigureAwait(false); + await Handler.ExecuteQueryTasksAsync(aliveTasks, allowPartialExecution, token).ConfigureAwaitFalse(); return true; } } diff --git a/Orm/Xtensive.Orm/Orm/Session.Transactions.cs b/Orm/Xtensive.Orm/Orm/Session.Transactions.cs index a68c035d04..aee2b47323 100644 --- a/Orm/Xtensive.Orm/Orm/Session.Transactions.cs +++ b/Orm/Xtensive.Orm/Orm/Session.Transactions.cs @@ -9,6 +9,7 @@ using System.Threading; using System.Threading.Tasks; using System.Transactions; +using Xtensive.Core; using Xtensive.Orm.Configuration; using Xtensive.Orm.Internals; using Xtensive.Orm.Providers; @@ -169,7 +170,7 @@ private async ValueTask InnerOpenTransaction( return isAsync - ? await CreateOutermostTransactionAsync(isolationLevel, isAutomatic, token).ConfigureAwait(false) + ? await CreateOutermostTransactionAsync(isolationLevel, isAutomatic, token).ConfigureAwaitFalse() : CreateOutermostTransaction(isolationLevel, isAutomatic); case TransactionOpenMode.New: if (isolationLevel == IsolationLevel.Unspecified) { @@ -179,8 +180,8 @@ private async ValueTask InnerOpenTransaction( return isAsync ? transaction != null - ? await CreateNestedTransactionAsync(isolationLevel, isAutomatic, token).ConfigureAwait(false) - : await CreateOutermostTransactionAsync(isolationLevel, isAutomatic, token).ConfigureAwait(false) + ? await CreateNestedTransactionAsync(isolationLevel, isAutomatic, token).ConfigureAwaitFalse() + : await CreateOutermostTransactionAsync(isolationLevel, isAutomatic, token).ConfigureAwaitFalse() : transaction != null ? CreateNestedTransaction(isolationLevel, isAutomatic) : CreateOutermostTransaction(isolationLevel, isAutomatic); @@ -233,8 +234,8 @@ internal void BeginTransaction(Transaction transaction) internal async Task BeginTransactionAsync(Transaction transaction, CancellationToken token) { if (transaction.IsNested) { - await PersistAsync(PersistReason.NestedTransaction, token).ConfigureAwait(false); - await Handler.CreateSavepointAsync(transaction, token).ConfigureAwait(false); + await PersistAsync(PersistReason.NestedTransaction, token).ConfigureAwaitFalse(); + await Handler.CreateSavepointAsync(transaction, token).ConfigureAwaitFalse(); } else { Handler.BeginTransaction(transaction); @@ -251,7 +252,7 @@ internal async ValueTask CommitTransaction(Transaction transaction, bool isAsync Events.NotifyTransactionPrecommitting(transaction); if (isAsync) { - await PersistAsync(PersistReason.Commit).ConfigureAwait(false); + await PersistAsync(PersistReason.Commit).ConfigureAwaitFalse(); } else { Persist(PersistReason.Commit); @@ -265,7 +266,7 @@ internal async ValueTask CommitTransaction(Transaction transaction, bool isAsync Handler.CompletingTransaction(transaction); if (transaction.IsNested) { if (isAsync) { - await Handler.ReleaseSavepointAsync(transaction).ConfigureAwait(false); + await Handler.ReleaseSavepointAsync(transaction).ConfigureAwaitFalse(); } else { Handler.ReleaseSavepoint(transaction); @@ -273,7 +274,7 @@ internal async ValueTask CommitTransaction(Transaction transaction, bool isAsync } else { if (isAsync) { - await Handler.CommitTransactionAsync(transaction).ConfigureAwait(false); + await Handler.CommitTransactionAsync(transaction).ConfigureAwaitFalse(); } else { Handler.CommitTransaction(transaction); @@ -298,11 +299,11 @@ internal async ValueTask RollbackTransaction(Transaction transaction, bool isAsy finally { try { if (Configuration.Supports(SessionOptions.SuppressRollbackExceptions)) { - await RollbackWithSuppression(transaction, isAsync).ConfigureAwait(false); + await RollbackWithSuppression(transaction, isAsync).ConfigureAwaitFalse(); } else { if (isAsync) { - await RollbackAsync(transaction).ConfigureAwait(false); + await RollbackAsync(transaction).ConfigureAwaitFalse(); } else { Rollback(transaction); @@ -326,7 +327,7 @@ private async ValueTask RollbackWithSuppression(Transaction transaction, bool is { try { if (isAsync) { - await RollbackAsync(transaction).ConfigureAwait(false); + await RollbackAsync(transaction).ConfigureAwaitFalse(); } else { Rollback(transaction); @@ -350,10 +351,10 @@ private void Rollback(Transaction transaction) private async ValueTask RollbackAsync(Transaction transaction) { if (transaction.IsNested) { - await Handler.RollbackToSavepointAsync(transaction).ConfigureAwait(false); + await Handler.RollbackToSavepointAsync(transaction).ConfigureAwaitFalse(); } else { - await Handler.RollbackTransactionAsync(transaction).ConfigureAwait(false); + await Handler.RollbackTransactionAsync(transaction).ConfigureAwaitFalse(); } } @@ -463,7 +464,7 @@ private async ValueTask OpenTransactionScope( Transaction = transaction; if (isAsync) { - await transaction.BeginAsync(token).ConfigureAwait(false); + await transaction.BeginAsync(token).ConfigureAwaitFalse(); } else { transaction.Begin(); diff --git a/Orm/Xtensive.Orm/Orm/Session.cs b/Orm/Xtensive.Orm/Orm/Session.cs index df4f332675..1a27b00865 100644 --- a/Orm/Xtensive.Orm/Orm/Session.cs +++ b/Orm/Xtensive.Orm/Orm/Session.cs @@ -264,8 +264,8 @@ internal EnumerationContext CreateEnumerationContext(ParameterContext parameterC internal async Task CreateEnumerationContextAsync(ParameterContext parameterContext, CancellationToken token) { - await PersistAsync(PersistReason.Query, token).ConfigureAwait(false); - _ = await ProcessUserDefinedDelayedQueriesAsync(true, token).ConfigureAwait(false); + await PersistAsync(PersistReason.Query, token).ConfigureAwaitFalse(); + _ = await ProcessUserDefinedDelayedQueriesAsync(true, token).ConfigureAwaitFalse(); return new Providers.EnumerationContext(this, parameterContext, GetEnumerationContextOptions()); } @@ -638,7 +638,7 @@ private async ValueTask DisposeImpl(bool isAsync) Services.DisposeSafely(); if (isAsync) { - await Handler.DisposeSafelyAsync().ConfigureAwait(false); + await Handler.DisposeSafelyAsync().ConfigureAwaitFalse(); } else { Handler.DisposeSafely(); diff --git a/Orm/Xtensive.Orm/Orm/StorageNodeManager.cs b/Orm/Xtensive.Orm/Orm/StorageNodeManager.cs index 8890797b5c..6f98651c70 100644 --- a/Orm/Xtensive.Orm/Orm/StorageNodeManager.cs +++ b/Orm/Xtensive.Orm/Orm/StorageNodeManager.cs @@ -43,7 +43,7 @@ public bool AddNode([NotNull] NodeConfiguration configuration) public async Task AddNodeAsync([NotNull] NodeConfiguration configuration, CancellationToken token = default) { var node = await UpgradingDomainBuilder.BuildNodeAsync(handlers.Domain, configuration, token) - .ConfigureAwait(false); + .ConfigureAwaitFalse(); return handlers.StorageNodeRegistry.Add(node); } diff --git a/Orm/Xtensive.Orm/Orm/Transaction.cs b/Orm/Xtensive.Orm/Orm/Transaction.cs index 60490b54f7..5969ac0616 100644 --- a/Orm/Xtensive.Orm/Orm/Transaction.cs +++ b/Orm/Xtensive.Orm/Orm/Transaction.cs @@ -183,7 +183,7 @@ internal void Begin() internal async ValueTask BeginAsync(CancellationToken token) { - await Session.BeginTransactionAsync(this, token).ConfigureAwait(false); + await Session.BeginTransactionAsync(this, token).ConfigureAwaitFalse(); if (Outer != null) { Outer.inner = this; } @@ -200,10 +200,10 @@ internal async ValueTask Commit(bool isAsync) throw new InvalidOperationException(Strings.ExCanNotCompleteOuterTransactionInnerTransactionIsActive); } - await Session.CommitTransaction(this, isAsync).ConfigureAwait(false); + await Session.CommitTransaction(this, isAsync).ConfigureAwaitFalse(); } catch { - await Rollback(isAsync).ConfigureAwait(false); + await Rollback(isAsync).ConfigureAwaitFalse(); throw; } @@ -228,11 +228,11 @@ internal async ValueTask Rollback(bool isAsync) try { try { if (inner != null) { - await inner.Rollback(isAsync).ConfigureAwait(false); + await inner.Rollback(isAsync).ConfigureAwaitFalse(); } } finally { - await Session.RollbackTransaction(this, isAsync).ConfigureAwait(false); + await Session.RollbackTransaction(this, isAsync).ConfigureAwaitFalse(); } } finally { diff --git a/Orm/Xtensive.Orm/Orm/TransactionScope.cs b/Orm/Xtensive.Orm/Orm/TransactionScope.cs index 732f10f054..f01ac18e62 100644 --- a/Orm/Xtensive.Orm/Orm/TransactionScope.cs +++ b/Orm/Xtensive.Orm/Orm/TransactionScope.cs @@ -67,10 +67,10 @@ private async ValueTask DisposeImpl(bool isAsync) } if (IsCompleted) { - await Transaction.Commit(isAsync).ConfigureAwait(false); + await Transaction.Commit(isAsync).ConfigureAwaitFalse(); } else { - await Transaction.Rollback(isAsync).ConfigureAwait(false); + await Transaction.Rollback(isAsync).ConfigureAwaitFalse(); } } finally { diff --git a/Orm/Xtensive.Orm/Orm/Upgrade/Internals/Metadata/MetadataExtractor.cs b/Orm/Xtensive.Orm/Orm/Upgrade/Internals/Metadata/MetadataExtractor.cs index 90dc5eed28..21db64d3a0 100644 --- a/Orm/Xtensive.Orm/Orm/Upgrade/Internals/Metadata/MetadataExtractor.cs +++ b/Orm/Xtensive.Orm/Orm/Upgrade/Internals/Metadata/MetadataExtractor.cs @@ -32,7 +32,7 @@ public void ExtractTypes(MetadataSet output, SqlExtractionTask task) public async Task ExtractTypesAsync(MetadataSet output, SqlExtractionTask task, CancellationToken token = default) { var types = new List(); - await ExtractTypesAsync(types, task, token).ConfigureAwait(false); + await ExtractTypesAsync(types, task, token).ConfigureAwaitFalse(); output.Types.AddRange(types); } @@ -45,7 +45,7 @@ public async Task ExtractAssembliesAsync(MetadataSet output, SqlExtractionTask t CancellationToken token = default) { var assemblies = new List(); - await ExtractAssembliesAsync(assemblies, task, token).ConfigureAwait(false); + await ExtractAssembliesAsync(assemblies, task, token).ConfigureAwaitFalse(); output.Assemblies.AddRange(assemblies); } @@ -58,7 +58,7 @@ public async Task ExtractExtensionsAsync(MetadataSet output, SqlExtractionTask t CancellationToken token = default) { var extensions = new List(); - await ExtractExtensionsAsync(extensions, task, token).ConfigureAwait(false); + await ExtractExtensionsAsync(extensions, task, token).ConfigureAwaitFalse(); output.Extensions.AddRange(extensions); } @@ -134,10 +134,10 @@ private IEnumerable ExecuteQuery(ISqlCompileUnit query, Func(ICollection output, ISqlCompileUnit query, Func parser, CancellationToken token) { - var command = await executor.ExecuteReaderAsync(query, CommandBehavior.SequentialAccess, token).ConfigureAwait(false); - await using (command.ConfigureAwait(false)) { + var command = await executor.ExecuteReaderAsync(query, CommandBehavior.SequentialAccess, token).ConfigureAwaitFalse(); + await using (command.ConfigureAwaitFalse()) { var reader = command.Reader; - while (await reader.ReadAsync(token).ConfigureAwait(false)) { + while (await reader.ReadAsync(token).ConfigureAwaitFalse()) { output.Add(parser.Invoke(reader)); } } diff --git a/Orm/Xtensive.Orm/Orm/Upgrade/Internals/SchemaExtractor.cs b/Orm/Xtensive.Orm/Orm/Upgrade/Internals/SchemaExtractor.cs index ed3185b358..228f3c55c3 100644 --- a/Orm/Xtensive.Orm/Orm/Upgrade/Internals/SchemaExtractor.cs +++ b/Orm/Xtensive.Orm/Orm/Upgrade/Internals/SchemaExtractor.cs @@ -38,7 +38,7 @@ public async Task GetSchemaAsync(CancellationToken token) if (context.ExtractedModelCache!=null) return context.ExtractedModelCache; - var schemaExtractionResult = await GetSqlSchemaAsync(token).ConfigureAwait(false); + var schemaExtractionResult = await GetSqlSchemaAsync(token).ConfigureAwaitFalse(); var converter = new SqlModelConverter(services, schemaExtractionResult, GetPartialIndexes()); var result = converter.Run(); context.ExtractedModelCache = result; @@ -63,7 +63,7 @@ public async Task GetSqlSchemaAsync(CancellationToken to } var sqlExtractionTasks = services.MappingResolver.GetSchemaTasks(); - var sqlExtractionResult = await executor.ExtractAsync(sqlExtractionTasks, token).ConfigureAwait(false); + var sqlExtractionResult = await executor.ExtractAsync(sqlExtractionTasks, token).ConfigureAwaitFalse(); var schema = new SchemaExtractionResult(sqlExtractionResult); var handledSchema = new IgnoreRulesHandler(schema, services.Configuration, services.MappingResolver).Handle(); context.ExtractedSqlModelCache = handledSchema; diff --git a/Orm/Xtensive.Orm/Orm/Upgrade/Internals/SchemaUpgrader.cs b/Orm/Xtensive.Orm/Orm/Upgrade/Internals/SchemaUpgrader.cs index 62a74ba4df..eccddd8343 100644 --- a/Orm/Xtensive.Orm/Orm/Upgrade/Internals/SchemaUpgrader.cs +++ b/Orm/Xtensive.Orm/Orm/Upgrade/Internals/SchemaUpgrader.cs @@ -49,11 +49,11 @@ public async Task UpgradeSchemaAsync(SchemaExtractionResult extractedSchema, var result = TranslateActions(extractedSchema, sourceModel, targetModel, upgradeActions); foreach (var handler in context.OrderedUpgradeHandlers) { - await handler.OnBeforeExecuteActionsAsync(result, token).ConfigureAwait(false); + await handler.OnBeforeExecuteActionsAsync(result, token).ConfigureAwaitFalse(); } await result.ProcessWithAsync(asyncStatementProcessor, ExecuteNonTransactionallyAsync, token) - .ConfigureAwait(false); + .ConfigureAwaitFalse(); } private UpgradeActionSequence TranslateActions(SchemaExtractionResult extractedSchema, StorageModel sourceModel, @@ -91,9 +91,9 @@ private void ExecuteNonTransactionally(IEnumerable batch) private async Task ExecuteNonTransactionallyAsync(IEnumerable batch, CancellationToken token) { - await driver.CommitTransactionAsync(null, connection, token).ConfigureAwait(false); - await executor.ExecuteManyAsync(batch, token).ConfigureAwait(false); - await driver.BeginTransactionAsync(null, connection, null, token).ConfigureAwait(false); + await driver.CommitTransactionAsync(null, connection, token).ConfigureAwaitFalse(); + await executor.ExecuteManyAsync(batch, token).ConfigureAwaitFalse(); + await driver.BeginTransactionAsync(null, connection, null, token).ConfigureAwaitFalse(); } private void ExecuteTransactionally(IEnumerable batch) => executor.ExecuteMany(batch); diff --git a/Orm/Xtensive.Orm/Orm/Upgrade/Internals/SqlAsyncWorker.cs b/Orm/Xtensive.Orm/Orm/Upgrade/Internals/SqlAsyncWorker.cs index e8e22933b0..db717cddc8 100644 --- a/Orm/Xtensive.Orm/Orm/Upgrade/Internals/SqlAsyncWorker.cs +++ b/Orm/Xtensive.Orm/Orm/Upgrade/Internals/SqlAsyncWorker.cs @@ -26,15 +26,15 @@ private static async Task RunAsync( var result = new SqlWorkerResult(); var executor = new SqlExecutor(services.StorageDriver, services.Connection); if ((task & SqlWorkerTask.DropSchema) > 0) { - await DropSchemaAsync(services, executor, token).ConfigureAwait(false); + await DropSchemaAsync(services, executor, token).ConfigureAwaitFalse(); } if ((task & SqlWorkerTask.ExtractSchema) > 0) { - result.Schema = await ExtractSchemaAsync(services, executor, token).ConfigureAwait(false); + result.Schema = await ExtractSchemaAsync(services, executor, token).ConfigureAwaitFalse(); } if ((task & (SqlWorkerTask.ExtractMetadataTypes | SqlWorkerTask.ExtractMetadataAssemblies | SqlWorkerTask.ExtractMetadataExtension)) > 0) { - await ExtractMetadataAsync(services, executor, result, task, token).ConfigureAwait(false); + await ExtractMetadataAsync(services, executor, result, task, token).ConfigureAwaitFalse(); } return result; @@ -51,15 +51,15 @@ private static async Task ExtractMetadataAsync( .Where(metadataTask => !ShouldSkipMetadataExtraction(mapping, result, metadataTask))) { try { if (task.HasFlag(SqlWorkerTask.ExtractMetadataAssemblies)) { - await metadataExtractor.ExtractAssembliesAsync(set, metadataTask, token).ConfigureAwait(false); + await metadataExtractor.ExtractAssembliesAsync(set, metadataTask, token).ConfigureAwaitFalse(); } if (task.HasFlag(SqlWorkerTask.ExtractMetadataTypes)) { - await metadataExtractor.ExtractTypesAsync(set, metadataTask, token).ConfigureAwait(false); + await metadataExtractor.ExtractTypesAsync(set, metadataTask, token).ConfigureAwaitFalse(); } if (task.HasFlag(SqlWorkerTask.ExtractMetadataExtension)) { - await metadataExtractor.ExtractExtensionsAsync(set, metadataTask, token).ConfigureAwait(false); + await metadataExtractor.ExtractExtensionsAsync(set, metadataTask, token).ConfigureAwaitFalse(); } } catch (Exception exception) { @@ -102,7 +102,7 @@ private static async Task ExtractSchemaAsync( UpgradeServiceAccessor services, ISqlExecutor executor, CancellationToken token) { var extractionTasks = services.MappingResolver.GetSchemaTasks(); - var extractionResult = await executor.ExtractAsync(extractionTasks, token).ConfigureAwait(false); + var extractionResult = await executor.ExtractAsync(extractionTasks, token).ConfigureAwaitFalse(); var schema = new SchemaExtractionResult(extractionResult); return new IgnoreRulesHandler(schema, services.Configuration, services.MappingResolver).Handle(); } @@ -111,14 +111,14 @@ private static async Task DropSchemaAsync( UpgradeServiceAccessor services, ISqlExecutor executor, CancellationToken token) { var driver = services.StorageDriver; - var extractionResult = await ExtractSchemaAsync(services, executor, token).ConfigureAwait(false); + var extractionResult = await ExtractSchemaAsync(services, executor, token).ConfigureAwaitFalse(); var schemas = extractionResult.Catalogs.SelectMany(c => c.Schemas).ToList(); var tables = schemas.SelectMany(s => s.Tables).ToList(); var sequences = schemas.SelectMany(s => s.Sequences); - await DropForeignKeysAsync(driver, tables, executor, token).ConfigureAwait(false); - await DropTablesAsync(driver, tables, executor, token).ConfigureAwait(false); - await DropSequencesAsync(driver, sequences, executor,token).ConfigureAwait(false); + await DropForeignKeysAsync(driver, tables, executor, token).ConfigureAwaitFalse(); + await DropTablesAsync(driver, tables, executor, token).ConfigureAwaitFalse(); + await DropSequencesAsync(driver, sequences, executor,token).ConfigureAwaitFalse(); } private static Task DropSequencesAsync( diff --git a/Orm/Xtensive.Orm/Orm/Upgrade/UpgradeActionSequence.cs b/Orm/Xtensive.Orm/Orm/Upgrade/UpgradeActionSequence.cs index f9a5967487..8966843c14 100644 --- a/Orm/Xtensive.Orm/Orm/Upgrade/UpgradeActionSequence.cs +++ b/Orm/Xtensive.Orm/Orm/Upgrade/UpgradeActionSequence.cs @@ -127,15 +127,15 @@ public async Task ProcessWithAsync( ArgumentValidator.EnsureArgumentNotNull(nonTransactionalProcessor, nameof(nonTransactionalProcessor)); if (NonTransactionalPrologCommands.Count > 0) { - await nonTransactionalProcessor.Invoke(NonTransactionalPrologCommands, token).ConfigureAwait(false); + await nonTransactionalProcessor.Invoke(NonTransactionalPrologCommands, token).ConfigureAwaitFalse(); } foreach (var batch in EnumerateTransactionalCommandBatches()) { - await regularProcessor.Invoke(batch, token).ConfigureAwait(false); + await regularProcessor.Invoke(batch, token).ConfigureAwaitFalse(); } if (NonTransactionalEpilogCommands.Count > 0) { - await nonTransactionalProcessor.Invoke(NonTransactionalEpilogCommands, token).ConfigureAwait(false); + await nonTransactionalProcessor.Invoke(NonTransactionalEpilogCommands, token).ConfigureAwaitFalse(); } } diff --git a/Orm/Xtensive.Orm/Orm/Upgrade/UpgradeHandler.cs b/Orm/Xtensive.Orm/Orm/Upgrade/UpgradeHandler.cs index 6f3c0a89ba..e21f064735 100644 --- a/Orm/Xtensive.Orm/Orm/Upgrade/UpgradeHandler.cs +++ b/Orm/Xtensive.Orm/Orm/Upgrade/UpgradeHandler.cs @@ -197,7 +197,7 @@ public virtual async ValueTask OnStageAsync(CancellationToken token = default) var context = UpgradeContext; switch (context.Stage) { case UpgradeStage.Upgrading: - await OnUpgradeAsync(token).ConfigureAwait(false); + await OnUpgradeAsync(token).ConfigureAwaitFalse(); break; case UpgradeStage.Final: break; diff --git a/Orm/Xtensive.Orm/Orm/Upgrade/UpgradingDomainBuilder.cs b/Orm/Xtensive.Orm/Orm/Upgrade/UpgradingDomainBuilder.cs index 3abe3670f5..58ff5d3361 100644 --- a/Orm/Xtensive.Orm/Orm/Upgrade/UpgradingDomainBuilder.cs +++ b/Orm/Xtensive.Orm/Orm/Upgrade/UpgradingDomainBuilder.cs @@ -78,7 +78,7 @@ public static async Task BuildAsync(DomainConfiguration configuration, C using (context.Activate()) using (context.Services) { - return await new UpgradingDomainBuilder(context).RunAsync(token).ConfigureAwait(false); + return await new UpgradingDomainBuilder(context).RunAsync(token).ConfigureAwaitFalse(); } } @@ -116,7 +116,7 @@ public static async Task BuildNodeAsync( using (context.Activate()) using (context.Services) { - await new UpgradingDomainBuilder(context).RunAsync(token).ConfigureAwait(false); + await new UpgradingDomainBuilder(context).RunAsync(token).ConfigureAwaitFalse(); return context.StorageNode; } } @@ -137,15 +137,15 @@ private Domain Run() private async Task RunAsync(CancellationToken token = default) { - await BuildServices(true, token).ConfigureAwait(false); - await OnPrepareAsync(token).ConfigureAwait(false); + await BuildServices(true, token).ConfigureAwaitFalse(); + await OnPrepareAsync(token).ConfigureAwaitFalse(); var domain = upgradeMode.IsMultistage() - ? await BuildMultistageDomainAsync(token).ConfigureAwait(false) - : await BuildSingleStageDomainAsync(token).ConfigureAwait(false); + ? await BuildMultistageDomainAsync(token).ConfigureAwaitFalse() + : await BuildSingleStageDomainAsync(token).ConfigureAwaitFalse(); - await OnCompleteAsync(domain, token).ConfigureAwait(false); - await CompleteUpgradeTransactionAsync(token).ConfigureAwait(false); + await OnCompleteAsync(domain, token).ConfigureAwaitFalse(); + await CompleteUpgradeTransactionAsync(token).ConfigureAwaitFalse(); context.Services.ClearTemporaryResources(); return domain; @@ -209,19 +209,19 @@ private async Task BuildMultistageDomainAsync(CancellationToken token) { Domain finalDomain; var sqlAsyncWorker = StartSqlAsyncWorker(token); - await using (sqlAsyncWorker.ConfigureAwait(false)) { + await using (sqlAsyncWorker.ConfigureAwaitFalse()) { var domainBuilder = CreateDomainBuilder(UpgradeStage.Final); var finalDomainResult = CreateResult(domainBuilder); - await using (finalDomainResult.ConfigureAwait(false)) { + await using (finalDomainResult.ConfigureAwaitFalse()) { OnConfigureUpgradeDomain(); using (var upgradeDomain = CreateDomainBuilder(UpgradeStage.Upgrading).Invoke()) { - await CompleteSqlWorkerAsync().ConfigureAwait(false); - await PerformUpgradeAsync(upgradeDomain, UpgradeStage.Upgrading, token).ConfigureAwait(false); + await CompleteSqlWorkerAsync().ConfigureAwaitFalse(); + await PerformUpgradeAsync(upgradeDomain, UpgradeStage.Upgrading, token).ConfigureAwaitFalse(); } - finalDomain = await finalDomainResult.GetAsync().ConfigureAwait(false); + finalDomain = await finalDomainResult.GetAsync().ConfigureAwaitFalse(); } } - await PerformUpgradeAsync(finalDomain, UpgradeStage.Final, token).ConfigureAwait(false); + await PerformUpgradeAsync(finalDomain, UpgradeStage.Final, token).ConfigureAwaitFalse(); return finalDomain; } @@ -238,10 +238,10 @@ private Domain BuildSingleStageDomain() private async Task BuildSingleStageDomainAsync(CancellationToken token) { var sqlAsyncWorker = StartSqlAsyncWorker(token); - await using (sqlAsyncWorker.ConfigureAwait(false)) { + await using (sqlAsyncWorker.ConfigureAwaitFalse()) { var domain = CreateDomainBuilder(UpgradeStage.Final).Invoke(); - await CompleteSqlWorkerAsync().ConfigureAwait(false); - await PerformUpgradeAsync(domain, UpgradeStage.Final, token).ConfigureAwait(false); + await CompleteSqlWorkerAsync().ConfigureAwaitFalse(); + await PerformUpgradeAsync(domain, UpgradeStage.Final, token).ConfigureAwaitFalse(); return domain; } } @@ -259,7 +259,7 @@ private async ValueTask BuildServices(bool isAsync, CancellationToken token = de var driverFactory = (SqlDriverFactory) Activator.CreateInstance(descriptor.DriverFactory); var handlerFactory = (HandlerFactory) Activator.CreateInstance(descriptor.HandlerFactory); var driver = isAsync - ? await StorageDriver.CreateAsync(driverFactory, configuration, token).ConfigureAwait(false) + ? await StorageDriver.CreateAsync(driverFactory, configuration, token).ConfigureAwaitFalse() : StorageDriver.Create(driverFactory, configuration); services.HandlerFactory = handlerFactory; services.StorageDriver = driver; @@ -272,9 +272,9 @@ private async ValueTask BuildServices(bool isAsync, CancellationToken token = de services.NameBuilder = handlers.NameBuilder; } - await CreateConnection(services, isAsync, token).ConfigureAwait(false); + await CreateConnection(services, isAsync, token).ConfigureAwaitFalse(); context.DefaultSchemaInfo = defaultSchemaInfo = isAsync - ? await services.StorageDriver.GetDefaultSchemaAsync(services.Connection, token).ConfigureAwait(false) + ? await services.StorageDriver.GetDefaultSchemaAsync(services.Connection, token).ConfigureAwaitFalse() : services.StorageDriver.GetDefaultSchema(services.Connection); services.MappingResolver = MappingResolver.Create(configuration, context.NodeConfiguration, defaultSchemaInfo); BuildExternalServices(services, configuration); @@ -293,8 +293,8 @@ private async ValueTask CreateConnection( try { if (isAsync) { - await driver.OpenConnectionAsync(null, connection, token).ConfigureAwait(false); - await driver.BeginTransactionAsync(null, connection, null, token).ConfigureAwait(false); + await driver.OpenConnectionAsync(null, connection, token).ConfigureAwaitFalse(); + await driver.BeginTransactionAsync(null, connection, null, token).ConfigureAwaitFalse(); } else { driver.OpenConnection(null, connection); @@ -303,7 +303,7 @@ private async ValueTask CreateConnection( } catch { if (isAsync) { - await connection.DisposeAsync().ConfigureAwait(false); + await connection.DisposeAsync().ConfigureAwaitFalse(); } else { connection.Dispose(); @@ -436,19 +436,19 @@ private async Task PerformUpgradeAsync(Domain domain, UpgradeStage stage, Cancel { context.Stage = stage; - await OnBeforeStageAsync(token).ConfigureAwait(false); + await OnBeforeStageAsync(token).ConfigureAwaitFalse(); - var session = await domain.OpenSessionAsync(SessionType.System, token).ConfigureAwait(false); - await using (session.ConfigureAwait(false)) { + var session = await domain.OpenSessionAsync(SessionType.System, token).ConfigureAwaitFalse(); + await using (session.ConfigureAwaitFalse()) { using (session.Activate()) { var transaction = session.OpenTransaction(); - await using (transaction.ConfigureAwait(false)) { + await using (transaction.ConfigureAwaitFalse()) { var upgrader = new SchemaUpgrader(context, session); var extractor = new SchemaExtractor(context, session); - await SynchronizeSchemaAsync(domain, upgrader, extractor, GetUpgradeMode(stage), token).ConfigureAwait(false); - var storageNode = BuildStorageNode(domain, await extractor.GetSqlSchemaAsync(token).ConfigureAwait(false)); + await SynchronizeSchemaAsync(domain, upgrader, extractor, GetUpgradeMode(stage), token).ConfigureAwaitFalse(); + var storageNode = BuildStorageNode(domain, await extractor.GetSqlSchemaAsync(token).ConfigureAwaitFalse()); session.SetStorageNode(storageNode); - await OnStageAsync(session, token).ConfigureAwait(false); + await OnStageAsync(session, token).ConfigureAwaitFalse(); transaction.Complete(); } } @@ -657,11 +657,11 @@ private async Task SynchronizeSchemaAsync( } var builder = ExtractedModelBuilderFactory.GetBuilder(context); context.ExtractedSqlModelCache = builder.Run(); - await OnSchemaReadyAsync(token).ConfigureAwait(false); + await OnSchemaReadyAsync(token).ConfigureAwaitFalse(); return; // Skipping comparison completely } - var extractedSchema = await extractor.GetSchemaAsync(token).ConfigureAwait(false); + var extractedSchema = await extractor.GetSchemaAsync(token).ConfigureAwaitFalse(); // Hints var triplet = BuildTargetModelAndHints(extractedSchema); @@ -676,7 +676,7 @@ private async Task SynchronizeSchemaAsync( UpgradeLog.Info(nameof(Strings.LogTargetSchema)); targetSchema.Dump(); } - await OnSchemaReadyAsync(token).ConfigureAwait(false); + await OnSchemaReadyAsync(token).ConfigureAwaitFalse(); var briefExceptionFormat = domain.Configuration.SchemaSyncExceptionFormat==SchemaSyncExceptionFormat.Brief; var result = SchemaComparer.Compare(extractedSchema, targetSchema, @@ -709,9 +709,9 @@ private async Task SynchronizeSchemaAsync( goto case SchemaUpgradeMode.Perform; case SchemaUpgradeMode.Recreate: case SchemaUpgradeMode.Perform: - var extractedSqlSchema = await extractor.GetSqlSchemaAsync(token).ConfigureAwait(false); + var extractedSqlSchema = await extractor.GetSqlSchemaAsync(token).ConfigureAwaitFalse(); await upgrader.UpgradeSchemaAsync( - extractedSqlSchema, extractedSchema, targetSchema, result.UpgradeActions, token).ConfigureAwait(false); + extractedSqlSchema, extractedSchema, targetSchema, result.UpgradeActions, token).ConfigureAwaitFalse(); if (result.UpgradeActions.Any()) extractor.ClearCache(); break; @@ -755,7 +755,7 @@ private void OnSchemaReady() private async ValueTask OnSchemaReadyAsync(CancellationToken token) { foreach (var handler in context.OrderedUpgradeHandlers) { - await handler.OnSchemaReadyAsync(token).ConfigureAwait(false); + await handler.OnSchemaReadyAsync(token).ConfigureAwaitFalse(); } } @@ -769,7 +769,7 @@ private void OnPrepare() private async ValueTask OnPrepareAsync(CancellationToken token) { foreach (var handler in context.OrderedUpgradeHandlers) { - await handler.OnPrepareAsync(token).ConfigureAwait(false); + await handler.OnPrepareAsync(token).ConfigureAwaitFalse(); } } @@ -811,7 +811,7 @@ private async Task CompleteSqlWorkerAsync() return; } - var result = await workerResult.GetAsync().ConfigureAwait(false); + var result = await workerResult.GetAsync().ConfigureAwaitFalse(); context.Metadata = result.Metadata; if (result.Schema!=null) { context.ExtractedSqlModelCache = result.Schema; @@ -828,7 +828,7 @@ private void OnBeforeStage() private async ValueTask OnBeforeStageAsync(CancellationToken token) { foreach (var handler in context.OrderedUpgradeHandlers) { - await handler.OnBeforeStageAsync(token).ConfigureAwait(false); + await handler.OnBeforeStageAsync(token).ConfigureAwaitFalse(); } } @@ -850,7 +850,7 @@ private async ValueTask OnStageAsync(Session session, CancellationToken token) context.Session = session; try { foreach (var handler in context.OrderedUpgradeHandlers) { - await handler.OnStageAsync(token).ConfigureAwait(false); + await handler.OnStageAsync(token).ConfigureAwaitFalse(); } } finally { @@ -872,7 +872,7 @@ private void OnComplete(Domain domain) private async ValueTask OnCompleteAsync(Domain domain, CancellationToken token) { foreach (var handler in context.OrderedUpgradeHandlers) { - await handler.OnCompleteAsync(domain, token).ConfigureAwait(false); + await handler.OnCompleteAsync(domain, token).ConfigureAwaitFalse(); } foreach (var module in context.Modules) { diff --git a/Orm/Xtensive.Orm/Sql/Model/Extractor.cs b/Orm/Xtensive.Orm/Sql/Model/Extractor.cs index ecf1b961ad..ac196ca155 100644 --- a/Orm/Xtensive.Orm/Sql/Model/Extractor.cs +++ b/Orm/Xtensive.Orm/Sql/Model/Extractor.cs @@ -5,6 +5,7 @@ using System.Data.Common; using System.Threading; using System.Threading.Tasks; +using Xtensive.Core; namespace Xtensive.Sql.Model { @@ -130,8 +131,8 @@ protected virtual async Task ExecuteReaderAsync( ISqlCompileUnit statement, CancellationToken token = default) { var command = Connection.CreateCommand(statement); - await using (command.ConfigureAwait(false)) { - return await command.ExecuteReaderAsync(token).ConfigureAwait(false); + await using (command.ConfigureAwaitFalse()) { + return await command.ExecuteReaderAsync(token).ConfigureAwaitFalse(); } } @@ -157,8 +158,8 @@ protected virtual DbDataReader ExecuteReader(string commandText) protected virtual async Task ExecuteReaderAsync(string commandText, CancellationToken token = default) { var command = Connection.CreateCommand(commandText); - await using (command.ConfigureAwait(false)) { - return await command.ExecuteReaderAsync(token).ConfigureAwait(false); + await using (command.ConfigureAwaitFalse()) { + return await command.ExecuteReaderAsync(token).ConfigureAwaitFalse(); } } diff --git a/Orm/Xtensive.Orm/Sql/SqlConnection.cs b/Orm/Xtensive.Orm/Sql/SqlConnection.cs index b1f0c9b3b8..3c4b881600 100644 --- a/Orm/Xtensive.Orm/Sql/SqlConnection.cs +++ b/Orm/Xtensive.Orm/Sql/SqlConnection.cs @@ -237,7 +237,7 @@ public virtual async Task OpenAsync(CancellationToken cancellationToken) EnsureIsNotDisposed(); var connectionAccessorEx = Extensions.Get(); if (connectionAccessorEx == null) { - await UnderlyingConnection.OpenAsync(cancellationToken).ConfigureAwait(false); + await UnderlyingConnection.OpenAsync(cancellationToken).ConfigureAwaitFalse(); } else { var accessors = connectionAccessorEx.Accessors; @@ -267,27 +267,27 @@ public virtual async Task OpenAndInitializeAsync(string initializationScript, Ca EnsureIsNotDisposed(); var connectionAccessorEx = Extensions.Get(); if (connectionAccessorEx == null) { - await UnderlyingConnection.OpenAsync(token).ConfigureAwait(false); + await UnderlyingConnection.OpenAsync(token).ConfigureAwaitFalse(); if (string.IsNullOrEmpty(initializationScript)) { return; } try { var command = UnderlyingConnection.CreateCommand(); - await using (command.ConfigureAwait(false)) { + await using (command.ConfigureAwaitFalse()) { command.CommandText = initializationScript; - _ = await command.ExecuteNonQueryAsync(token).ConfigureAwait(false); + _ = await command.ExecuteNonQueryAsync(token).ConfigureAwaitFalse(); } } catch (OperationCanceledException) { - await UnderlyingConnection.CloseAsync().ConfigureAwait(false); + await UnderlyingConnection.CloseAsync().ConfigureAwaitFalse(); throw; } } else { var accessors = connectionAccessorEx.Accessors; await SqlHelper.NotifyConnectionOpeningAsync(accessors, UnderlyingConnection, false, token); - await UnderlyingConnection.OpenAsync(token).ConfigureAwait(false); + await UnderlyingConnection.OpenAsync(token).ConfigureAwaitFalse(); if (string.IsNullOrEmpty(initializationScript)) { await SqlHelper.NotifyConnectionOpenedAsync(accessors, UnderlyingConnection, false, token); return; @@ -296,15 +296,15 @@ public virtual async Task OpenAndInitializeAsync(string initializationScript, Ca try { await SqlHelper.NotifyConnectionInitializingAsync(accessors, UnderlyingConnection, initializationScript, false, token); var command = UnderlyingConnection.CreateCommand(); - await using (command.ConfigureAwait(false)) { + await using (command.ConfigureAwaitFalse()) { command.CommandText = initializationScript; - _ = await command.ExecuteNonQueryAsync(token).ConfigureAwait(false); + _ = await command.ExecuteNonQueryAsync(token).ConfigureAwaitFalse(); } await SqlHelper.NotifyConnectionOpenedAsync(accessors, UnderlyingConnection, false, token); } catch (OperationCanceledException ex) { await SqlHelper.NotifyConnectionOpeningFailedAsync(accessors, UnderlyingConnection, ex, false, token); - await UnderlyingConnection.CloseAsync().ConfigureAwait(false); + await UnderlyingConnection.CloseAsync().ConfigureAwaitFalse(); throw; } catch (Exception ex) { @@ -397,10 +397,10 @@ public virtual async Task CommitAsync(CancellationToken token = default) EnsureIsNotDisposed(); EnsureTransactionIsActive(); try { - await ActiveTransaction.CommitAsync(token).ConfigureAwait(false); + await ActiveTransaction.CommitAsync(token).ConfigureAwaitFalse(); } finally { - await ActiveTransaction.DisposeAsync().ConfigureAwait(false); + await ActiveTransaction.DisposeAsync().ConfigureAwaitFalse(); ClearActiveTransaction(); } } @@ -432,10 +432,10 @@ public virtual async Task RollbackAsync(CancellationToken token = default) EnsureIsNotDisposed(); EnsureTransactionIsActive(); try { - await ActiveTransaction.RollbackAsync(token).ConfigureAwait(false); + await ActiveTransaction.RollbackAsync(token).ConfigureAwaitFalse(); } finally { - await ActiveTransaction.DisposeAsync().ConfigureAwait(false); + await ActiveTransaction.DisposeAsync().ConfigureAwaitFalse(); ClearActiveTransaction(); } } @@ -538,12 +538,12 @@ public async ValueTask DisposeAsync() isDisposed = true; try { if (ActiveTransaction != null) { - await ActiveTransaction.DisposeAsync().ConfigureAwait(false); + await ActiveTransaction.DisposeAsync().ConfigureAwaitFalse(); ClearActiveTransaction(); } } finally { - await UnderlyingConnection.DisposeAsync().ConfigureAwait(false); + await UnderlyingConnection.DisposeAsync().ConfigureAwaitFalse(); ClearUnderlyingConnection(); } } diff --git a/Orm/Xtensive.Orm/Sql/SqlDriver.cs b/Orm/Xtensive.Orm/Sql/SqlDriver.cs index 4417ba622b..6f443c50b2 100644 --- a/Orm/Xtensive.Orm/Sql/SqlDriver.cs +++ b/Orm/Xtensive.Orm/Sql/SqlDriver.cs @@ -179,17 +179,17 @@ public async Task ExtractAsync(SqlConnection connection, IE var result = new SqlExtractionResult(); foreach (var (catalogName, sqlExtractionTasks) in taskGroups) { - var extractor = await BuildExtractorAsync(connection, token).ConfigureAwait(false); + var extractor = await BuildExtractorAsync(connection, token).ConfigureAwaitFalse(); if (sqlExtractionTasks.All(t => !t.AllSchemas)) { // extracting all the schemes we need var schemasToExtract = sqlExtractionTasks.Select(t => t.Schema).ToArray(); - var catalog = await extractor.ExtractSchemesAsync(catalogName, schemasToExtract, token).ConfigureAwait(false); + var catalog = await extractor.ExtractSchemesAsync(catalogName, schemasToExtract, token).ConfigureAwaitFalse(); CleanSchemas(catalog, schemasToExtract); result.Catalogs.Add(catalog); } else { // Extracting whole catalog - var catalog = await extractor.ExtractCatalogAsync(catalogName, token).ConfigureAwait(false); + var catalog = await extractor.ExtractCatalogAsync(catalogName, token).ConfigureAwaitFalse(); result.Catalogs.Add(catalog); } } @@ -223,9 +223,9 @@ public Catalog ExtractCatalog(SqlConnection connection) /// public async Task ExtractCatalogAsync(SqlConnection connection, CancellationToken token = default) { - var defaultSchema = await GetDefaultSchemaAsync(connection, token).ConfigureAwait(false); + var defaultSchema = await GetDefaultSchemaAsync(connection, token).ConfigureAwaitFalse(); var task = new SqlExtractionTask(defaultSchema.Database); - return (await ExtractAsync(connection, new[] {task}, token).ConfigureAwait(false)).Catalogs.Single(); + return (await ExtractAsync(connection, new[] {task}, token).ConfigureAwaitFalse()).Catalogs.Single(); } /// @@ -253,9 +253,9 @@ public Schema ExtractDefaultSchema(SqlConnection connection) /// public async Task ExtractDefaultSchemaAsync(SqlConnection connection, CancellationToken token = default) { - var defaultSchema = await GetDefaultSchemaAsync(connection, token).ConfigureAwait(false); + var defaultSchema = await GetDefaultSchemaAsync(connection, token).ConfigureAwaitFalse(); return await ExtractSchemaAsync(connection, defaultSchema.Database, defaultSchema.Schema, token) - .ConfigureAwait(false); + .ConfigureAwaitFalse(); } /// @@ -286,8 +286,8 @@ public Schema ExtractSchema(SqlConnection connection, string schemaName) public async Task ExtractSchemaAsync( SqlConnection connection, string schemaName, CancellationToken token = default) { - var defaultSchema = await GetDefaultSchemaAsync(connection, token).ConfigureAwait(false); - return await ExtractSchemaAsync(connection, defaultSchema.Database, schemaName, token).ConfigureAwait(false); + var defaultSchema = await GetDefaultSchemaAsync(connection, token).ConfigureAwaitFalse(); + return await ExtractSchemaAsync(connection, defaultSchema.Database, schemaName, token).ConfigureAwaitFalse(); } /// @@ -466,7 +466,7 @@ private Extractor BuildExtractor(SqlConnection connection) private async Task BuildExtractorAsync(SqlConnection connection, CancellationToken token = default) { var extractor = CreateExtractor(); - await extractor.InitializeAsync(connection, token).ConfigureAwait(false); + await extractor.InitializeAsync(connection, token).ConfigureAwaitFalse(); return extractor; } @@ -490,7 +490,7 @@ private async Task ExtractSchemaAsync(SqlConnection connection, string d CancellationToken token = default) { var task = new SqlExtractionTask(databaseName, schemaName); - return (await ExtractAsync(connection, new[] {task}, token).ConfigureAwait(false)) + return (await ExtractAsync(connection, new[] {task}, token).ConfigureAwaitFalse()) .Catalogs[databaseName].Schemas.FirstOrDefault(el => el.Name == schemaName); } diff --git a/Orm/Xtensive.Orm/Sql/SqlDriverFactory.cs b/Orm/Xtensive.Orm/Sql/SqlDriverFactory.cs index 14fd6c46fc..4dfffd761a 100644 --- a/Orm/Xtensive.Orm/Sql/SqlDriverFactory.cs +++ b/Orm/Xtensive.Orm/Sql/SqlDriverFactory.cs @@ -96,7 +96,7 @@ public async Task GetDriverAsync( var connectionString = GetConnectionString(connectionInfo); configuration = configuration.Clone(); - var driver = await CreateDriverAsync(connectionString, configuration, token).ConfigureAwait(false); + var driver = await CreateDriverAsync(connectionString, configuration, token).ConfigureAwaitFalse(); driver.Initialize(this, connectionInfo); return driver; } diff --git a/Orm/Xtensive.Orm/Sql/SqlHelper.cs b/Orm/Xtensive.Orm/Sql/SqlHelper.cs index c9e4a8151c..72d2b0aa5b 100644 --- a/Orm/Xtensive.Orm/Sql/SqlHelper.cs +++ b/Orm/Xtensive.Orm/Sql/SqlHelper.cs @@ -396,12 +396,12 @@ public static async Task ReadDatabaseAndSchemaAsync(string qu ArgumentValidator.EnsureArgumentNotNullOrEmpty(queryText, nameof(queryText)); var command = connection.CreateCommand(); - await using (command.ConfigureAwait(false)) { + await using (command.ConfigureAwaitFalse()) { command.CommandText = queryText; command.Transaction = transaction; - var reader = await command.ExecuteReaderAsync(token).ConfigureAwait(false); - await using (reader.ConfigureAwait(false)) { - if (!await reader.ReadAsync(token).ConfigureAwait(false)) { + var reader = await command.ExecuteReaderAsync(token).ConfigureAwaitFalse(); + await using (reader.ConfigureAwaitFalse()) { + if (!await reader.ReadAsync(token).ConfigureAwaitFalse()) { throw new InvalidOperationException(Strings.ExCanNotReadDatabaseAndSchemaNames); } @@ -457,9 +457,9 @@ public static async Task ExecuteInitializationSqlAsync( } var command = connection.CreateCommand(); - await using (command.ConfigureAwait(false)) { + await using (command.ConfigureAwaitFalse()) { command.CommandText = configuration.ConnectionInitializationSql; - await command.ExecuteNonQueryAsync(token).ConfigureAwait(false); + await command.ExecuteNonQueryAsync(token).ConfigureAwaitFalse(); } } @@ -479,9 +479,9 @@ public static async Task ExecuteInitializationSqlAsync( } var command = connection.CreateCommand(); - await using (command.ConfigureAwait(false)) { + await using (command.ConfigureAwaitFalse()) { command.CommandText = initializationSql; - _ = await command.ExecuteNonQueryAsync(token).ConfigureAwait(false); + _ = await command.ExecuteNonQueryAsync(token).ConfigureAwaitFalse(); } } @@ -582,7 +582,7 @@ public static async Task NotifyConnectionOpeningAsync( foreach (var accessor in connectionAccessors) { await accessor.ConnectionOpeningAsync( new ConnectionEventData(connection, reconnect), token) - .ConfigureAwait(false); + .ConfigureAwaitFalse(); } } @@ -621,7 +621,7 @@ public static async Task NotifyConnectionInitializingAsync( foreach (var accessor in connectionAccessors) { await accessor.ConnectionInitializationAsync( new ConnectionInitEventData(initializationScript, connection, reconnect), token) - .ConfigureAwait(false); + .ConfigureAwaitFalse(); } } @@ -657,7 +657,7 @@ public static async Task NotifyConnectionOpenedAsync( foreach (var accessor in connectionAccessors) { await accessor.ConnectionOpenedAsync( new ConnectionEventData(connection, reconnect), token) - .ConfigureAwait(false); + .ConfigureAwaitFalse(); } } @@ -696,7 +696,7 @@ public static async Task NotifyConnectionOpeningFailedAsync( foreach (var accessor in connectionAccessors) { await accessor.ConnectionOpeningFailedAsync( new ConnectionErrorEventData(exception, connection, reconnect), token) - .ConfigureAwait(false); + .ConfigureAwaitFalse(); } }