private async Task <ObjectResult <T> > GetResultsAsync(
MergeOption?forMergeOption,
IDbExecutionStrategy executionStrategy,
CancellationToken cancellationToken)
{
MergeOption mergeOption = forMergeOption.HasValue ? forMergeOption.Value : this.QueryState.EffectiveMergeOption;
if (mergeOption != MergeOption.NoTracking)
{
this.QueryState.ObjectContext.AsyncMonitor.Enter();
}
ObjectResult <T> objectResult;
try
{
// ISSUE: reference to a compiler-generated field
// ISSUE: reference to a compiler-generated field
// ISSUE: reference to a compiler-generated field
// ISSUE: reference to a compiler-generated field
// ISSUE: reference to a compiler-generated field
objectResult = await executionStrategy.ExecuteAsync <ObjectResult <T> >((Func <Task <ObjectResult <T> > >)(() => this.\u003C\u003E4__this.QueryState.ObjectContext.ExecuteInTransactionAsync <ObjectResult <T> >((Func <Task <ObjectResult <T> > >)(() => this.\u003C\u003E4__this.QueryState.GetExecutionPlan(forMergeOption).ExecuteAsync <T>(this.\u003C\u003E4__this.QueryState.ObjectContext, this.\u003C\u003E4__this.QueryState.Parameters, cancellationToken)), executionStrategy, false, !this.\u003C\u003E4__this.QueryState.EffectiveStreamingBehavior, cancellationToken)), cancellationToken).WithCurrentCulture <ObjectResult <T> >();
}
finally
{
if (mergeOption != MergeOption.NoTracking)
{
this.QueryState.ObjectContext.AsyncMonitor.Exit();
}
}
return(objectResult);
}
private async Task <ObjectResult <T> > GetResultsAsync(
MergeOption?forMergeOption, IDbExecutionStrategy executionStrategy, CancellationToken cancellationToken)
{
var mergeOption = forMergeOption.HasValue
? forMergeOption.Value
: QueryState.EffectiveMergeOption;
if (mergeOption != MergeOption.NoTracking)
{
QueryState.ObjectContext.AsyncMonitor.Enter();
}
try
{
return(await executionStrategy.ExecuteAsync(
() => QueryState.ObjectContext.ExecuteInTransactionAsync(
() => QueryState.GetExecutionPlan(forMergeOption)
.ExecuteAsync <T>(QueryState.ObjectContext, QueryState.Parameters, cancellationToken),
executionStrategy,
/*startLocalTransaction:*/ false, /*releaseConnectionOnSuccess:*/ !QueryState.EffectiveStreamingBehavior,
cancellationToken),
cancellationToken).WithCurrentCulture());
}
finally
{
if (mergeOption != MergeOption.NoTracking)
{
QueryState.ObjectContext.AsyncMonitor.Exit();
}
}
}
public SqlDbConfiguration()
{
if (AppConfigConfiguration.Instance == null)
{
return;
}
foreach (StrategyConfigurationElement strategy in AppConfigConfiguration.Instance.SqlExecutionStrategies)
{
var strategyType = Type.GetType(strategy.StrategyType);
if (strategyType != null)
{
var maxDelay = strategy.MaxDelay.Value;
IDbExecutionStrategy strategyObj = (IDbExecutionStrategy)Activator.CreateInstance(strategyType);
if (string.IsNullOrWhiteSpace(strategy.ServerName))
{
SetExecutionStrategy(strategy.ProviderName,
delegate
{
return(SuspendExecutionStrategy
? (IDbExecutionStrategy) new DefaultExecutionStrategy()
: strategyObj);
});
}
else
{
SetExecutionStrategy(strategy.ProviderName,
() => SuspendExecutionStrategy
?(IDbExecutionStrategy) new DefaultExecutionStrategy()
:strategyObj, strategy.ServerName);
}
}
}
}
public override IInternalQuery <TEntity> WithExecutionStrategy(IDbExecutionStrategy executionStrategy)
{
Initialize();
// WithExecutionStrategy called directly on the DbSet (as opposed to a DbQuery) is special-cased so that
// it doesn't result in a LINQ query being created where one is not needed. This adds a perf boost
// for simple queries such as context.Products.WithExecutionStrategy().
return(new InternalQuery <TEntity>(InternalContext, CreateObjectQuery(asNoTracking: false, streaming: false, executionStrategy: executionStrategy)));
}
internal virtual DbQuery <TResult> WithExecutionStrategy(
IDbExecutionStrategy executionStrategy)
{
if (this._internalQuery != null)
{
return(new DbQuery <TResult>(this._internalQuery.WithExecutionStrategy(executionStrategy)));
}
return(this);
}
protected virtual async Task ExecuteOnExecutionStrategyAsync(Func <Task> operation, CancellationToken?cancellationToken)
{
IDbExecutionStrategy strategy = ContextDbConfiguration.ExecutionStrategy;
SuspendExecutionStrategy();
await strategy.ExecuteAsync(operation, cancellationToken ?? new CancellationToken());
ResumeExecutionStrategy();
}
public override bool AnyModelTableExistsInDatabase(
ObjectContext context,
DbConnection connection,
IEnumerable <EntitySet> modelTables,
string edmMetadataContextTableName)
{
StringBuilder stringBuilder = new StringBuilder();
foreach (EntitySet modelTable in modelTables)
{
stringBuilder.Append("'");
stringBuilder.Append((string)modelTable.MetadataProperties["Schema"].Value);
stringBuilder.Append(".");
stringBuilder.Append(this.GetTableName(modelTable));
stringBuilder.Append("',");
}
stringBuilder.Remove(stringBuilder.Length - 1, 1);
using (DbCommand command = connection.CreateCommand())
{
command.CommandText = "\r\nSELECT Count(*)\r\nFROM INFORMATION_SCHEMA.TABLES AS t\r\nWHERE t.TABLE_SCHEMA + '.' + t.TABLE_NAME IN (" + (object)stringBuilder + ")\r\n OR t.TABLE_NAME = '" + edmMetadataContextTableName + "'";
bool flag = true;
if (DbInterception.Dispatch.Connection.GetState(connection, context.InterceptionContext) == ConnectionState.Open)
{
flag = false;
EntityTransaction currentTransaction = ((EntityConnection)context.Connection).CurrentTransaction;
if (currentTransaction != null)
{
command.Transaction = currentTransaction.StoreTransaction;
}
}
IDbExecutionStrategy executionStrategy = DbProviderServices.GetExecutionStrategy(connection);
try
{
return(executionStrategy.Execute <bool>((Func <bool>)(() =>
{
if (DbInterception.Dispatch.Connection.GetState(connection, context.InterceptionContext) == ConnectionState.Broken)
{
DbInterception.Dispatch.Connection.Close(connection, context.InterceptionContext);
}
if (DbInterception.Dispatch.Connection.GetState(connection, context.InterceptionContext) == ConnectionState.Closed)
{
DbInterception.Dispatch.Connection.Open(connection, context.InterceptionContext);
}
return (int)DbInterception.Dispatch.Command.Scalar(command, new DbCommandInterceptionContext(context.InterceptionContext)) > 0;
})));
}
finally
{
if (flag && DbInterception.Dispatch.Connection.GetState(connection, context.InterceptionContext) != ConnectionState.Closed)
{
DbInterception.Dispatch.Connection.Close(connection, context.InterceptionContext);
}
}
}
}
private ObjectResult <T> GetResults(MergeOption?forMergeOption)
{
this.QueryState.ObjectContext.AsyncMonitor.EnsureNotEntered();
IDbExecutionStrategy executionStrategy = this.ExecutionStrategy ?? DbProviderServices.GetExecutionStrategy(this.QueryState.ObjectContext.Connection, this.QueryState.ObjectContext.MetadataWorkspace);
if (executionStrategy.RetriesOnFailure && this.QueryState.EffectiveStreamingBehavior)
{
throw new InvalidOperationException(Strings.ExecutionStrategy_StreamingNotSupported((object)executionStrategy.GetType().Name));
}
return(executionStrategy.Execute <ObjectResult <T> >((Func <ObjectResult <T> >)(() => this.QueryState.ObjectContext.ExecuteInTransaction <ObjectResult <T> >((Func <ObjectResult <T> >)(() => this.QueryState.GetExecutionPlan(forMergeOption).Execute <T>(this.QueryState.ObjectContext, this.QueryState.Parameters)), executionStrategy, false, !this.QueryState.EffectiveStreamingBehavior))));
}
public static IQueryable CreateQueryWithExecutionStrategy(
ObjectQuery query,
IDbExecutionStrategy executionStrategy)
{
IQueryable queryable = (IQueryable)query;
ObjectQuery query1 = (ObjectQuery)queryable.Provider.CreateQuery(queryable.Expression);
query1.ExecutionStrategy = executionStrategy;
query1.MergeOption = query.MergeOption;
query1.Streaming = query.Streaming;
return((IQueryable)query1);
}
public static IQueryable CreateQueryWithExecutionStrategy(ObjectQuery query, IDbExecutionStrategy executionStrategy)
{
DebugCheck.NotNull(query);
var asIQueryable = (IQueryable)query;
var newQuery = (ObjectQuery)asIQueryable.Provider.CreateQuery(asIQueryable.Expression);
newQuery.ExecutionStrategy = executionStrategy;
newQuery.MergeOption = query.MergeOption;
newQuery.Streaming = query.Streaming;
return(newQuery);
}
protected virtual async Task <TResult> ExecuteOnExecutionStrategyAsync <TResult>(Func <Task <TResult> > operation, CancellationToken?cancellationToken)
{
IDbExecutionStrategy strategy = ContextDbConfiguration.ExecutionStrategy;
SuspendExecutionStrategy();
var result = await strategy.ExecuteAsync(operation, cancellationToken ?? new CancellationToken());
ResumeExecutionStrategy();
return(result);
}
public KeyVaultConnectionFactory()
{
// we would use some decoupling here
var connectionStringFactory = new KeyVaultConnectionStringFactory()
{
ConnectionStringNameSuffix = ConnectionStringNameSuffix
};
_connectionStringFactory = new CachedConnectionStringFactory(connectionStringFactory);
_retrySqlStrategy = new RetrySqlInvalidPasswordStrategy(FailedConnectionAttempt);
_baseConnectionFactory = new SqlConnectionFactory();
}
private Task <ObjectResult <T> > GetResultsAsync(
MergeOption?forMergeOption,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
this.QueryState.ObjectContext.AsyncMonitor.EnsureNotEntered();
IDbExecutionStrategy executionStrategy = this.ExecutionStrategy ?? DbProviderServices.GetExecutionStrategy(this.QueryState.ObjectContext.Connection, this.QueryState.ObjectContext.MetadataWorkspace);
if (executionStrategy.RetriesOnFailure && this.QueryState.EffectiveStreamingBehavior)
{
throw new InvalidOperationException(Strings.ExecutionStrategy_StreamingNotSupported((object)executionStrategy.GetType().Name));
}
return(this.GetResultsAsync(forMergeOption, executionStrategy, cancellationToken));
}
public void Initialize(ILogging logger = null)
{
var providerInvariantName = Constants.PROVIDER_INVARIANTNAME_SQLITE; // (e.g. "System.Data.SQLite.EF6")
IDbExecutionStrategy dbExecutionStrategy = null;
dbExecutionStrategy = EfCfDbConfiguration.IsExecutionStrategySuspended ? (IDbExecutionStrategy) new DefaultExecutionStrategy() : new SqliteEfCfExecutionStrategy(logger);
// If 'execution strategy' is suspended, use the 'DefaultExecutionStrategy'.
// 'DefaultExecutionStrategy' allows user-initiated transactions as there is no automated 'retry' logic (such as the 'ShouldRetryOn()' overridden method in 'EfCfExecutionStrategy').
// 'EfCfExecutionStrategy' inherits 'DbExecutionStrategy' and overrides the 'ShouldRetryOn()' method to allow automated 'retry' logic via EntityFramework.
this.SetExecutionStrategy(providerInvariantName,
() => EfCfDbConfiguration.IsExecutionStrategySuspended ? (IDbExecutionStrategy) new DefaultExecutionStrategy() : new SqliteEfCfExecutionStrategy(logger));
this.DbExecutionStrategy = dbExecutionStrategy;
}
public void Initialize(ILogging logger = null)
{
//var providerInvariantName = Constants.PROVIDER_INVARIANTNAME_MYSQL; // (e.g. "MySql.Data.MySqlClient")
IDbExecutionStrategy dbExecutionStrategy = null;
dbExecutionStrategy = EfCfDbConfiguration.IsExecutionStrategySuspended ? (IDbExecutionStrategy) new MySqlExecutionStrategy() : new MySqlEfCfExecutionStrategy(logger);
// works
//this.SetExecutionStrategy(MySqlProviderInvariantName.ProviderName,
// () => EfCfDbConfiguration.IsExecutionStrategySuspended ? (IDbExecutionStrategy)new DefaultExecutionStrategy() : new MySqlExecutionStrategy());
// also works. Is it correct? Does I need to make a class that inherits from MySqlExecutionStrategy() to actually have 'retry' logic? How to test if MySqlEfCfExecutionStrategy will get called and work?
this.SetExecutionStrategy(MySqlProviderInvariantName.ProviderName,
() => EfCfDbConfiguration.IsExecutionStrategySuspended ? (IDbExecutionStrategy) new DefaultExecutionStrategy() : new MySqlEfCfExecutionStrategy(logger));
this.DbExecutionStrategy = dbExecutionStrategy;
}
private System.Data.Entity.Core.Objects.ObjectQuery <TEntity> CreateObjectQuery(
bool asNoTracking,
bool?streaming = null,
IDbExecutionStrategy executionStrategy = null)
{
System.Data.Entity.Core.Objects.ObjectQuery <TEntity> objectQuery = this.InternalContext.ObjectContext.CreateQuery <TEntity>(this._quotedEntitySetName);
if (this._baseType != typeof(TEntity))
{
objectQuery = objectQuery.OfType <TEntity>();
}
if (asNoTracking)
{
objectQuery.MergeOption = MergeOption.NoTracking;
}
if (streaming.HasValue)
{
objectQuery.Streaming = streaming.Value;
}
objectQuery.ExecutionStrategy = executionStrategy;
return(objectQuery);
}
// <summary>
// Creates an underlying <see cref="System.Data.Entity.Core.Objects.ObjectQuery{T}" /> for this set.
// </summary>
// <param name="asNoTracking">
// if set to <c>true</c> then the query is set to be no-tracking.
// </param>
// <returns> The query. </returns>
private ObjectQuery<TEntity> CreateObjectQuery(bool asNoTracking, bool? streaming = null, IDbExecutionStrategy executionStrategy = null)
{
var objectQuery = InternalContext.ObjectContext.CreateQuery<TEntity>(_quotedEntitySetName);
if (_baseType != typeof(TEntity))
{
objectQuery = objectQuery.OfType<TEntity>();
}
if (asNoTracking)
{
objectQuery.MergeOption = MergeOption.NoTracking;
}
if (streaming.HasValue) { objectQuery.Streaming = streaming.Value; }
objectQuery.ExecutionStrategy = executionStrategy;
return objectQuery;
}
internal virtual DbQuery <TResult> WithExecutionStrategy(IDbExecutionStrategy executionStrategy)
{
return(_internalQuery == null ? this : new DbQuery <TResult>(_internalQuery.WithExecutionStrategy(executionStrategy)));
}
public override IInternalQuery <TEntity> WithExecutionStrategy(
IDbExecutionStrategy executionStrategy)
{
this.Initialize();
return((IInternalQuery <TEntity>) new InternalQuery <TEntity>(this.InternalContext, (System.Data.Entity.Core.Objects.ObjectQuery) this.CreateObjectQuery(false, new bool?(false), executionStrategy)));
}
public TestSqlAzureExecutionStrategy()
{
azureExecutionStrategy = new ExtendedSqlAzureExecutionStrategy();
}
internal override DbQuery WithExecutionStrategy(IDbExecutionStrategy executionStrategy)
{
return(new InternalDbQuery <TEntity>(_internalSet.WithExecutionStrategy(executionStrategy)));
}
public virtual IInternalQuery <TElement> WithExecutionStrategy(
IDbExecutionStrategy executionStrategy)
{
return((IInternalQuery <TElement>) new InternalQuery <TElement>(this._internalContext, (System.Data.Entity.Core.Objects.ObjectQuery)DbHelpers.CreateQueryWithExecutionStrategy((System.Data.Entity.Core.Objects.ObjectQuery) this._objectQuery, executionStrategy)));
}
internal virtual DbQuery WithExecutionStrategy(IDbExecutionStrategy executionStrategy)
{
return(this);
}
internal override DbQuery WithExecutionStrategy(IDbExecutionStrategy executionStrategy)
{
return(new InternalDbQuery <TElement>(_internalQuery.WithExecutionStrategy(executionStrategy)));
}
public static void SetExecutionStrategy(IDbExecutionStrategy executionStrategy)
{
ExecutionStrategy = executionStrategy;
}
public virtual IInternalQuery <TElement> WithExecutionStrategy(IDbExecutionStrategy executionStrategy)
{
return(new InternalQuery <TElement>(
_internalContext, (ObjectQuery)DbHelpers.CreateQueryWithExecutionStrategy(_objectQuery, executionStrategy)));
}
public SuspendableSqlAzureExecutionStrategy()
{
_azureExecutionStrategy = new ExtendedSqlAzureExecutionStrategy();
}