public QueryCompilationContextDependencies(
[NotNull] IModel model,
[NotNull] IQueryTranslationPreprocessorFactory queryTranslationPreprocessorFactory,
[NotNull] IQueryableMethodTranslatingExpressionVisitorFactory queryableMethodTranslatingExpressionVisitorFactory,
[NotNull] IQueryTranslationPostprocessorFactory queryTranslationPostprocessorFactory,
[NotNull] IShapedQueryCompilingExpressionVisitorFactory shapedQueryCompilingExpressionVisitorFactory,
[NotNull] IExecutionStrategyFactory executionStrategyFactory,
[NotNull] ICurrentDbContext currentContext,
[NotNull] IDbContextOptions contextOptions,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Query> logger)
{
Check.NotNull(model, nameof(model));
Check.NotNull(queryTranslationPreprocessorFactory, nameof(queryTranslationPreprocessorFactory));
Check.NotNull(queryableMethodTranslatingExpressionVisitorFactory, nameof(queryableMethodTranslatingExpressionVisitorFactory));
Check.NotNull(queryTranslationPostprocessorFactory, nameof(queryTranslationPostprocessorFactory));
Check.NotNull(shapedQueryCompilingExpressionVisitorFactory, nameof(shapedQueryCompilingExpressionVisitorFactory));
Check.NotNull(executionStrategyFactory, nameof(executionStrategyFactory));
Check.NotNull(currentContext, nameof(currentContext));
Check.NotNull(contextOptions, nameof(contextOptions));
Check.NotNull(logger, nameof(logger));
_currentContext = currentContext;
Model = model;
QueryTranslationPreprocessorFactory = queryTranslationPreprocessorFactory;
QueryableMethodTranslatingExpressionVisitorFactory = queryableMethodTranslatingExpressionVisitorFactory;
QueryTranslationPostprocessorFactory = queryTranslationPostprocessorFactory;
ShapedQueryCompilingExpressionVisitorFactory = shapedQueryCompilingExpressionVisitorFactory;
_executionStrategyFactory = executionStrategyFactory;
IsRetryingExecutionStrategy = executionStrategyFactory.Create().RetriesOnFailure;
ContextOptions = contextOptions;
Logger = logger;
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public BatchExecutor([NotNull] ICurrentDbContext currentContext, [NotNull] IExecutionStrategyFactory executionStrategyFactory)
{
CurrentContext = currentContext;
#pragma warning disable 618
ExecutionStrategyFactory = executionStrategyFactory;
#pragma warning restore 618
}
public StateManagerDependencies(
[NotNull] IInternalEntityEntryFactory internalEntityEntryFactory,
[NotNull] IInternalEntityEntrySubscriber internalEntityEntrySubscriber,
[NotNull] IInternalEntityEntryNotifier internalEntityEntryNotifier,
[NotNull] IValueGenerationManager valueGenerationManager,
[NotNull] IModel model,
[NotNull] IDatabase database,
[NotNull] IConcurrencyDetector concurrencyDetector,
[NotNull] ICurrentDbContext currentContext,
[NotNull] IEntityFinderSource entityFinderSource,
[NotNull] IDbSetSource setSource,
[NotNull] IEntityMaterializerSource entityMaterializerSource,
[NotNull] IExecutionStrategyFactory executionStrategyFactory,
[NotNull] ILoggingOptions loggingOptions,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Update> updateLogger,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.ChangeTracking> changeTrackingLogger)
{
InternalEntityEntryFactory = internalEntityEntryFactory;
InternalEntityEntrySubscriber = internalEntityEntrySubscriber;
InternalEntityEntryNotifier = internalEntityEntryNotifier;
ValueGenerationManager = valueGenerationManager;
Model = model;
Database = database;
ConcurrencyDetector = concurrencyDetector;
CurrentContext = currentContext;
EntityFinderSource = entityFinderSource;
SetSource = setSource;
EntityMaterializerSource = entityMaterializerSource;
ExecutionStrategyFactory = executionStrategyFactory;
LoggingOptions = loggingOptions;
UpdateLogger = updateLogger;
ChangeTrackingLogger = changeTrackingLogger;
}
public RelationalDatabaseCreatorDependencies(
[NotNull] IModel model,
[NotNull] IRelationalConnection connection,
[NotNull] IMigrationsModelDiffer modelDiffer,
[NotNull] IMigrationsSqlGenerator migrationsSqlGenerator,
[NotNull] IMigrationCommandExecutor migrationCommandExecutor,
[NotNull] ISqlGenerationHelper sqlGenerationHelper,
[NotNull] IExecutionStrategyFactory executionStrategyFactory,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Database.Command> commandLogger)
{
Check.NotNull(model, nameof(model));
Check.NotNull(connection, nameof(connection));
Check.NotNull(modelDiffer, nameof(modelDiffer));
Check.NotNull(migrationsSqlGenerator, nameof(migrationsSqlGenerator));
Check.NotNull(migrationCommandExecutor, nameof(migrationCommandExecutor));
Check.NotNull(sqlGenerationHelper, nameof(sqlGenerationHelper));
Check.NotNull(executionStrategyFactory, nameof(executionStrategyFactory));
Check.NotNull(commandLogger, nameof(commandLogger));
Model = model;
Connection = connection;
ModelDiffer = modelDiffer;
MigrationsSqlGenerator = migrationsSqlGenerator;
MigrationCommandExecutor = migrationCommandExecutor;
SqlGenerationHelper = sqlGenerationHelper;
ExecutionStrategyFactory = executionStrategyFactory;
CommandLogger = commandLogger;
}
/// <summary>
/// Clones this dependency parameter object with one service replaced.
/// </summary>
/// <param name="executionStrategyFactory"> A replacement for the current dependency of this type. </param>
/// <returns> A new parameter object with the given service replaced. </returns>
public RelationalDatabaseCreatorDependencies With([NotNull] IExecutionStrategyFactory executionStrategyFactory)
=> new RelationalDatabaseCreatorDependencies(
Model,
Connection,
ModelDiffer,
MigrationsSqlGenerator,
MigrationCommandExecutor,
executionStrategyFactory);
public MySqlQueryContextFactory(
[NotNull] QueryContextDependencies dependencies,
[NotNull] IRelationalConnection connection,
[NotNull] IExecutionStrategyFactory executionStrategyFactory)
: base(dependencies, connection, executionStrategyFactory)
{
_connection = connection;
}
public MySqlQueryContext(
[NotNull] QueryContextDependencies dependencies,
[NotNull] Func <IQueryBuffer> queryBufferFactory,
[NotNull] IRelationalConnection connection,
[NotNull] IExecutionStrategyFactory executionStrategyFactory)
: base(dependencies, queryBufferFactory, connection, executionStrategyFactory)
{
}
public MySqlQueryContextFactory(
[NotNull] ICurrentDbContext currentContext,
[NotNull] IConcurrencyDetector concurrencyDetector,
[NotNull] IRelationalConnection connection,
[NotNull] IExecutionStrategyFactory executionStrategyFactory)
: base(currentContext, concurrencyDetector, connection, executionStrategyFactory)
{
_connection = connection;
}
/// <summary>
/// 构造一个 <see cref="BatchExecutorRewrite"/>。
/// </summary>
/// <param name="currentContext">给定的 <see cref="ICurrentDbContext"/>。</param>
/// <param name="executionStrategyFactory">给定的 <see cref="IExecutionStrategyFactory"/>。</param>
public BatchExecutorRewrite(ICurrentDbContext currentContext,
IExecutionStrategyFactory executionStrategyFactory)
{
CurrentContext = currentContext.NotNull(nameof(currentContext));
#pragma warning disable 618
ExecutionStrategyFactory = executionStrategyFactory.NotNull(nameof(executionStrategyFactory));
#pragma warning restore 618
}
public MySqlQueryContext(
[NotNull] Func <IQueryBuffer> queryBufferFactory,
[NotNull] IRelationalConnection connection,
[NotNull] LazyRef <IStateManager> stateManager,
[NotNull] IConcurrencyDetector concurrencyDetector,
[NotNull] IExecutionStrategyFactory executionStrategyFactory)
: base(queryBufferFactory, connection, stateManager, concurrencyDetector, executionStrategyFactory)
{
}
public RelationalQueryContextDependencies(
[NotNull] IRelationalConnection relationalConnection,
[NotNull] IExecutionStrategyFactory executionStrategyFactory)
{
Check.NotNull(relationalConnection, nameof(relationalConnection));
Check.NotNull(executionStrategyFactory, nameof(executionStrategyFactory));
RelationalConnection = relationalConnection;
ExecutionStrategyFactory = executionStrategyFactory;
}
public TestDatabaseCreator(
NpgsqlRelationalConnection connection,
IMigrationsModelDiffer modelDiffer,
IMigrationsSqlGenerator sqlGenerator,
IMigrationCommandExecutor migrationCommandExecutor,
IModel model,
IRawSqlCommandBuilder rawSqlCommandBuilder,
IExecutionStrategyFactory executionStrategyFactory)
: base(connection, modelDiffer, sqlGenerator, migrationCommandExecutor, model, rawSqlCommandBuilder, executionStrategyFactory)
{
}
/// <summary>
/// Clones this dependency parameter object with one service replaced.
/// </summary>
/// <param name="executionStrategyFactory"> A replacement for the current dependency of this type. </param>
/// <returns> A new parameter object with the given service replaced. </returns>
public QueryCompilationContextDependencies With([NotNull] IExecutionStrategyFactory executionStrategyFactory)
=> new QueryCompilationContextDependencies(
Model,
QueryTranslationPreprocessorFactory,
QueryableMethodTranslatingExpressionVisitorFactory,
QueryTranslationPostprocessorFactory,
ShapedQueryCompilingExpressionVisitorFactory,
executionStrategyFactory,
_currentContext,
ContextOptions,
Logger);
public RelationalQueryContextDependencies(
[NotNull] IRelationalConnection relationalConnection,
[NotNull] IExecutionStrategyFactory executionStrategyFactory)
{
Check.NotNull(relationalConnection, nameof(relationalConnection));
Check.NotNull(executionStrategyFactory, nameof(executionStrategyFactory));
RelationalConnection = relationalConnection;
#pragma warning disable 618
ExecutionStrategyFactory = executionStrategyFactory;
#pragma warning restore 618
}
/// <summary>
/// <para>
/// Creates a new <see cref="RelationalQueryContext"/> instance.
/// </para>
/// <para>
/// This type is typically used by database providers (and other extensions). It is generally
/// not used in application code.
/// </para>
/// </summary>
/// <param name="dependencies"> The dependencies to use. </param>
/// <param name="connection"> The relational connection. </param>
/// <param name="executionStrategyFactory"> A factory for creating the execution strategy to use. </param>
public RelationalQueryContext(
[NotNull] QueryContextDependencies dependencies,
[NotNull] IRelationalConnection connection,
[NotNull] IExecutionStrategyFactory executionStrategyFactory)
: base(dependencies)
{
Check.NotNull(connection, nameof(connection));
Check.NotNull(executionStrategyFactory, nameof(executionStrategyFactory));
Connection = connection;
ExecutionStrategyFactory = executionStrategyFactory;
}
public CosmosClientWrapper(
[NotNull] IDbContextOptions dbContextOptions,
[NotNull] IExecutionStrategyFactory executionStrategyFactory,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Database.Command> commandLogger)
{
var options = dbContextOptions.FindExtension <CosmosDbOptionsExtension>();
_databaseId = options.DatabaseName;
_endPoint = options.ServiceEndPoint;
_authKey = options.AuthKeyOrResourceToken;
_executionStrategyFactory = executionStrategyFactory;
_commandLogger = commandLogger;
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public CosmosClientWrapper(
[NotNull] SingletonCosmosClientWrapper singletonWrapper,
[NotNull] IDbContextOptions dbContextOptions,
[NotNull] IExecutionStrategyFactory executionStrategyFactory,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Database.Command> commandLogger)
{
var options = dbContextOptions.FindExtension <CosmosOptionsExtension>();
_singletonWrapper = singletonWrapper;
_databaseId = options.DatabaseName;
_executionStrategyFactory = executionStrategyFactory;
_commandLogger = commandLogger;
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public CosmosClientWrapper(
ISingletonCosmosClientWrapper singletonWrapper,
IDbContextOptions dbContextOptions,
IExecutionStrategyFactory executionStrategyFactory,
IDiagnosticsLogger <DbLoggerCategory.Database.Command> commandLogger)
{
var options = dbContextOptions.FindExtension <CosmosOptionsExtension>();
_singletonWrapper = singletonWrapper;
_databaseId = options !.DatabaseName;
_executionStrategyFactory = executionStrategyFactory;
_commandLogger = commandLogger;
_enableContentResponseOnWrite = options.EnableContentResponseOnWrite;
}
public CompiledQueryCacheKeyGeneratorDependencies(
[NotNull] IModel model,
[NotNull] ICurrentDbContext currentContext,
[NotNull] IExecutionStrategyFactory executionStrategyFactory)
{
Check.NotNull(model, nameof(model));
Check.NotNull(currentContext, nameof(currentContext));
Check.NotNull(executionStrategyFactory, nameof(executionStrategyFactory));
Model = model;
CurrentContext = currentContext;
_executionStrategyFactory = executionStrategyFactory;
IsRetryingExecutionStrategy = executionStrategyFactory.Create().RetriesOnFailure;
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public SqliteDatabaseCreator(
[NotNull] SqliteRelationalConnection connection,
[NotNull] IMigrationsModelDiffer modelDiffer,
[NotNull] IMigrationsSqlGenerator migrationsSqlGenerator,
[NotNull] IMigrationCommandExecutor migrationCommandExecutor,
[NotNull] IModel model,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder,
[NotNull] IExecutionStrategyFactory executionStrategyFactory)
: base(model, connection, modelDiffer, migrationsSqlGenerator, migrationCommandExecutor, executionStrategyFactory)
{
Check.NotNull(rawSqlCommandBuilder, nameof(rawSqlCommandBuilder));
_connection = connection;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public DatabaseFacadeDependencies(
[NotNull] IDbContextTransactionManager transactionManager,
[NotNull] IDatabaseCreator databaseCreator,
[NotNull] IExecutionStrategyFactory executionStrategyFactory,
[NotNull] IEnumerable <IDatabaseProvider> databaseProviders,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Database.Command> commandLogger,
[NotNull] IConcurrencyDetector concurrencyDetector)
{
TransactionManager = transactionManager;
DatabaseCreator = databaseCreator;
ExecutionStrategyFactory = executionStrategyFactory;
DatabaseProviders = databaseProviders;
CommandLogger = commandLogger;
ConcurrencyDetector = concurrencyDetector;
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public RelationalQueryContext(
[NotNull] Func <IQueryBuffer> queryBufferFactory,
[NotNull] IRelationalConnection connection,
[NotNull] LazyRef <IStateManager> stateManager,
[NotNull] IConcurrencyDetector concurrencyDetector,
[NotNull] IExecutionStrategyFactory executionStrategyFactory)
: base(
Check.NotNull(queryBufferFactory, nameof(queryBufferFactory)),
Check.NotNull(stateManager, nameof(stateManager)),
Check.NotNull(concurrencyDetector, nameof(concurrencyDetector)))
{
Check.NotNull(connection, nameof(connection));
Connection = connection;
ExecutionStrategyFactory = executionStrategyFactory;
}
/// <summary>
/// Clones this dependency parameter object with one service replaced.
/// </summary>
/// <param name="executionStrategyFactory"> A replacement for the current dependency of this type. </param>
/// <returns> A new parameter object with the given service replaced. </returns>
public StateManagerDependencies With([NotNull] IExecutionStrategyFactory executionStrategyFactory)
=> new StateManagerDependencies(
InternalEntityEntryFactory,
InternalEntityEntrySubscriber,
InternalEntityEntryNotifier,
ValueGenerationManager,
Model,
Database,
ConcurrencyDetector,
CurrentContext,
EntityFinderSource,
SetSource,
EntityMaterializerSource,
executionStrategyFactory,
LoggingOptions,
UpdateLogger,
ChangeTrackingLogger);
public QueryContextDependencies(
[NotNull] ICurrentDbContext currentContext,
[NotNull] IExecutionStrategyFactory executionStrategyFactory,
[NotNull] IConcurrencyDetector concurrencyDetector,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Database.Command> commandLogger,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Query> queryLogger)
{
Check.NotNull(currentContext, nameof(currentContext));
Check.NotNull(executionStrategyFactory, nameof(executionStrategyFactory));
Check.NotNull(concurrencyDetector, nameof(concurrencyDetector));
Check.NotNull(commandLogger, nameof(commandLogger));
Check.NotNull(queryLogger, nameof(queryLogger));
CurrentContext = currentContext;
ExecutionStrategyFactory = executionStrategyFactory;
ConcurrencyDetector = concurrencyDetector;
CommandLogger = commandLogger;
QueryLogger = queryLogger;
}
public MySQLDatabaseCreator(
[NotNull] MySQLServerConnection cxn,
[NotNull] IMigrationsModelDiffer differ,
[NotNull] IMigrationsSqlGenerator generator,
[NotNull] IMigrationCommandExecutor migrationCommandExecutor,
[NotNull] IModel model,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder,
[NotNull] IExecutionStrategyFactory executionStrategyFactory)
: base(model, cxn, differ, generator, migrationCommandExecutor, executionStrategyFactory)
{
ThrowIf.Argument.IsNull(cxn, "connection");
ThrowIf.Argument.IsNull(differ, "modelDiffer");
ThrowIf.Argument.IsNull(generator, "generator");
ThrowIf.Argument.IsNull(rawSqlCommandBuilder, "commandBuilder");
_connection = cxn;
_sqlGenerator = generator;
_rawSqlCommandBuilder = rawSqlCommandBuilder;
_migrationCommandExecutor = migrationCommandExecutor;
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public RelationalDatabaseFacadeDependencies(
[NotNull] IDbContextTransactionManager transactionManager,
[NotNull] IDatabaseCreator databaseCreator,
[NotNull] IExecutionStrategyFactory executionStrategyFactory,
[NotNull] IEnumerable <IDatabaseProvider> databaseProviders,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Database.Command> commandLogger,
[NotNull] IConcurrencyDetector concurrencyDetector,
[NotNull] IRelationalConnection relationalConnection,
[NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder)
: base(
transactionManager,
databaseCreator,
executionStrategyFactory,
databaseProviders,
commandLogger,
concurrencyDetector)
{
RelationalConnection = relationalConnection;
RawSqlCommandBuilder = rawSqlCommandBuilder;
}
public CosmosClient(
[NotNull] IDbContextOptions dbContextOptions,
[NotNull] IExecutionStrategyFactory executionStrategyFactory,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Database.Command> commandLogger)
{
var options = dbContextOptions.FindExtension <CosmosDbOptionsExtension>();
_databaseId = options.DatabaseName;
_baseUri = options.ServiceEndPoint;
_masterKey = options.AuthKeyOrResourceToken;
_executionStrategyFactory = executionStrategyFactory;
_commandLogger = commandLogger;
_client = new HttpClient
{
// TODO: configure in options
Timeout = new TimeSpan(0, 0, 60)
};
WebRequest.DefaultWebProxy = new WebProxy();
}
/// <summary>
/// <para>
/// Creates the service dependencies parameter object for a <see cref="RelationalDatabaseCreator" />.
/// </para>
/// <para>
/// Do not call this constructor directly from either provider or application code as it may change
/// as new dependencies are added. Instead, use this type in your constructor so that an instance
/// will be created and injected automatically by the dependency injection container. To create
/// an instance with some dependent services replaced, first resolve the object from the dependency
/// injection container, then replace selected services using the 'With...' methods. Do not call
/// the constructor at any point in this process.
/// </para>
/// <para>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </para>
/// </summary>
/// <param name="model"> The <see cref="IModel" /> for the context this creator is being used with. </param>
/// <param name="connection"> The <see cref="IRelationalConnection" /> to be used. </param>
/// <param name="modelDiffer"> The <see cref="IMigrationsModelDiffer" /> to be used. </param>
/// <param name="migrationsSqlGenerator"> The <see cref="IMigrationsSqlGenerator" /> to be used. </param>
/// <param name="migrationCommandExecutor"> The <see cref="IMigrationCommandExecutor" /> to be used. </param>
/// <param name="executionStrategyFactory">The <see cref="IExecutionStrategyFactory" /> to be used. </param>
public RelationalDatabaseCreatorDependencies(
[NotNull] IModel model,
[NotNull] IRelationalConnection connection,
[NotNull] IMigrationsModelDiffer modelDiffer,
[NotNull] IMigrationsSqlGenerator migrationsSqlGenerator,
[NotNull] IMigrationCommandExecutor migrationCommandExecutor,
[NotNull] IExecutionStrategyFactory executionStrategyFactory)
{
Check.NotNull(model, nameof(model));
Check.NotNull(connection, nameof(connection));
Check.NotNull(modelDiffer, nameof(modelDiffer));
Check.NotNull(migrationsSqlGenerator, nameof(migrationsSqlGenerator));
Check.NotNull(migrationCommandExecutor, nameof(migrationCommandExecutor));
Check.NotNull(executionStrategyFactory, nameof(executionStrategyFactory));
Model = model;
Connection = connection;
ModelDiffer = modelDiffer;
MigrationsSqlGenerator = migrationsSqlGenerator;
MigrationCommandExecutor = migrationCommandExecutor;
ExecutionStrategyFactory = executionStrategyFactory;
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public CassandraBatchExecutor(ICurrentDbContext currentContext, IExecutionStrategyFactory executionStrategyFactory)
{
CurrentContext = currentContext;
ExecutionStrategyFactory = executionStrategyFactory;
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public BatchExecutor([NotNull] ICurrentDbContext currentContext, [NotNull] IExecutionStrategyFactory executionStrategyFactory)
{
CurrentContext = currentContext;
ExecutionStrategyFactory = executionStrategyFactory;
}
