public void Cloning_the_interception_context_preserves_contextual_information_but_not_mutable_state() { var objectContext = new ObjectContext(); var dbContext = DbContextMockHelper.CreateDbContext(objectContext); var interceptionContext = new EnlistTransactionInterceptionContext(); interceptionContext.SuppressExecution(); interceptionContext.Exception = new Exception("Cheez Whiz"); var transaction = new CommittableTransaction(); interceptionContext = interceptionContext .WithDbContext(dbContext) .WithObjectContext(objectContext) .WithTransaction(transaction) .AsAsync(); Assert.Equal(new[] { objectContext }, interceptionContext.ObjectContexts); Assert.Equal(new[] { dbContext }, interceptionContext.DbContexts); Assert.True(interceptionContext.IsAsync); Assert.Same(transaction, interceptionContext.Transaction); Assert.Null(interceptionContext.Exception); Assert.Null(interceptionContext.OriginalException); Assert.False(interceptionContext.IsExecutionSuppressed); }
public void Cloning_the_interception_context_preserves_contextual_information_but_not_mutable_state() { var objectContext = new ObjectContext(); var dbContext = DbContextMockHelper.CreateDbContext(objectContext); var interceptionContext = new EnlistTransactionInterceptionContext(); interceptionContext.SuppressExecution(); interceptionContext.Exception = new Exception("Cheez Whiz"); var transaction = new CommittableTransaction(); interceptionContext = interceptionContext .WithDbContext(dbContext) .WithObjectContext(objectContext) .WithTransaction(transaction) .AsAsync(); Assert.Equal(new[] { objectContext }, interceptionContext.ObjectContexts); Assert.Equal(new[] { dbContext }, interceptionContext.DbContexts); Assert.True(interceptionContext.IsAsync); Assert.Same(transaction, interceptionContext.Transaction); Assert.Null(interceptionContext.Exception); Assert.Null(interceptionContext.OriginalException); Assert.False(interceptionContext.IsExecutionSuppressed); }
/// <summary> /// Creates a new <see cref="T:System.Data.Entity.Infrastructure.Interception.EnlistTransactionInterceptionContext" /> that contains all the contextual information in this /// interception context together with the given <see cref="P:System.Data.Entity.Infrastructure.Interception.EnlistTransactionInterceptionContext.Transaction" />. /// </summary> /// <param name="transaction">The transaction to be used in the <see cref="M:System.Data.Common.DbConnection.EnlistTransaction(System.Transactions.Transaction)" /> invocation.</param> /// <returns>A new interception context associated with the given isolation level.</returns> public EnlistTransactionInterceptionContext WithTransaction( Transaction transaction) { EnlistTransactionInterceptionContext interceptionContext = this.TypedClone(); interceptionContext._transaction = transaction; return(interceptionContext); }
/// <summary> /// Sends <see cref="M:System.Data.Entity.Infrastructure.Interception.IDbConnectionInterceptor.EnlistingTransaction(System.Data.Common.DbConnection,System.Data.Entity.Infrastructure.Interception.EnlistTransactionInterceptionContext)" /> and /// <see cref="M:System.Data.Entity.Infrastructure.Interception.IDbConnectionInterceptor.EnlistedTransaction(System.Data.Common.DbConnection,System.Data.Entity.Infrastructure.Interception.EnlistTransactionInterceptionContext)" /> to any <see cref="T:System.Data.Entity.Infrastructure.Interception.IDbConnectionInterceptor" /> /// registered on <see cref="T:System.Data.Entity.Infrastructure.Interception.DbInterception" /> before/after making a /// call to <see cref="M:System.Data.Common.DbConnection.EnlistTransaction(System.Transactions.Transaction)" />. /// </summary> /// <param name="connection">The connection on which the operation will be executed.</param> /// <param name="interceptionContext">Optional information about the context of the call being made.</param> public virtual void EnlistTransaction( DbConnection connection, EnlistTransactionInterceptionContext interceptionContext) { Check.NotNull <DbConnection>(connection, nameof(connection)); Check.NotNull <EnlistTransactionInterceptionContext>(interceptionContext, nameof(interceptionContext)); this.InternalDispatcher.Dispatch <DbConnection, EnlistTransactionInterceptionContext>(connection, (Action <DbConnection, EnlistTransactionInterceptionContext>)((t, c) => t.EnlistTransaction(c.Transaction)), new EnlistTransactionInterceptionContext((DbInterceptionContext)interceptionContext), (Action <IDbConnectionInterceptor, DbConnection, EnlistTransactionInterceptionContext>)((i, t, c) => i.EnlistingTransaction(t, c)), (Action <IDbConnectionInterceptor, DbConnection, EnlistTransactionInterceptionContext>)((i, t, c) => i.EnlistedTransaction(t, c))); }
/// <summary> /// Sends <see cref="IDbConnectionInterceptor.EnlistingTransaction" /> and /// <see cref="IDbConnectionInterceptor.EnlistedTransaction" /> to any <see cref="IDbConnectionInterceptor" /> /// registered on <see cref="DbInterception" /> before/after making a /// call to <see cref="DbConnection.EnlistTransaction" />. /// </summary> /// <param name="connection">The connection on which the operation will be executed.</param> /// <param name="interceptionContext">Optional information about the context of the call being made.</param> public virtual void EnlistTransaction(DbConnection connection, EnlistTransactionInterceptionContext interceptionContext) { Check.NotNull(connection, "connection"); Check.NotNull(interceptionContext, "interceptionContext"); InternalDispatcher.Dispatch( connection, (t, c) => t.EnlistTransaction(c.Transaction), new EnlistTransactionInterceptionContext(interceptionContext), (i, t, c) => i.EnlistingTransaction(t, c), (i, t, c) => i.EnlistedTransaction(t, c)); }
/// <summary> /// Creates a new <see cref="T:System.Data.Entity.Infrastructure.Interception.EnlistTransactionInterceptionContext" /> by copying immutable state from the given /// interception context. Also see <see cref="M:System.Data.Entity.Infrastructure.Interception.EnlistTransactionInterceptionContext.Clone" /> /// </summary> /// <param name="copyFrom">The context from which to copy state.</param> public EnlistTransactionInterceptionContext(DbInterceptionContext copyFrom) : base(copyFrom) { Check.NotNull <DbInterceptionContext>(copyFrom, nameof(copyFrom)); EnlistTransactionInterceptionContext interceptionContext = copyFrom as EnlistTransactionInterceptionContext; if (interceptionContext == null) { return; } this._transaction = interceptionContext._transaction; }
/// <summary> /// Sends <see cref="IDbConnectionInterceptor.EnlistingTransaction" /> and /// <see cref="IDbConnectionInterceptor.EnlistedTransaction" /> to any <see cref="IDbConnectionInterceptor" /> /// registered on <see cref="DbInterception" /> before/after making a /// call to <see cref="DbConnection.EnlistTransaction" />. /// </summary> /// <param name="dbConnection">The connection on which the operation will be executed.</param> /// <param name="interceptionContext">Optional information about the context of the call being made.</param> public virtual void EnlistTransaction(DbConnection dbConnection, EnlistTransactionInterceptionContext interceptionContext) { Check.NotNull(dbConnection, "dbConnection"); Check.NotNull(interceptionContext, "interceptionContext"); var clonedInterceptionContext = new EnlistTransactionInterceptionContext(interceptionContext); InternalDispatcher.Dispatch( () => dbConnection.EnlistTransaction(clonedInterceptionContext.Transaction), clonedInterceptionContext, i => i.EnlistingTransaction(dbConnection, clonedInterceptionContext), i => i.EnlistedTransaction(dbConnection, clonedInterceptionContext)); }
public void Initially_has_no_state() { var interceptionContext = new EnlistTransactionInterceptionContext(); Assert.Empty(interceptionContext.DbContexts); Assert.Null(interceptionContext.Exception); Assert.False(interceptionContext.IsAsync); Assert.False(interceptionContext.IsExecutionSuppressed); Assert.Null(interceptionContext.Transaction); Assert.Empty(interceptionContext.ObjectContexts); Assert.Null(interceptionContext.OriginalException); Assert.Equal((TaskStatus)0, interceptionContext.TaskStatus); }
public void Initially_has_no_state() { var interceptionContext = new EnlistTransactionInterceptionContext(); Assert.Empty(interceptionContext.DbContexts); Assert.Null(interceptionContext.Exception); Assert.False(interceptionContext.IsAsync); Assert.False(interceptionContext.IsExecutionSuppressed); Assert.Null(interceptionContext.Transaction); Assert.Empty(interceptionContext.ObjectContexts); Assert.Null(interceptionContext.OriginalException); Assert.Equal((TaskStatus)0, interceptionContext.TaskStatus); }
public void EnlistTransaction_executes_operation_and_dispatches_to_interceptors() { var mockConnection = new Mock<DbConnection>(); var mockInterceptor = new Mock<IDbConnectionInterceptor>(); var dispatcher = new DbConnectionDispatcher(); var internalDispatcher = dispatcher.InternalDispatcher; internalDispatcher.Add(mockInterceptor.Object); var transaction = new CommittableTransaction(); var interceptionContext = new EnlistTransactionInterceptionContext().WithTransaction(transaction); dispatcher.EnlistTransaction(mockConnection.Object, interceptionContext); mockConnection.Verify(m => m.EnlistTransaction(transaction), Times.Once()); mockInterceptor.Verify(m => m.EnlistingTransaction(mockConnection.Object, It.IsAny<EnlistTransactionInterceptionContext>()), Times.Once()); mockInterceptor.Verify(m => m.EnlistedTransaction(mockConnection.Object, It.IsAny<EnlistTransactionInterceptionContext>()), Times.Once()); }
public void EnlistTransaction_executes_operation_and_dispatches_to_interceptors() { var mockConnection = new Mock <DbConnection>(); var mockInterceptor = new Mock <IDbConnectionInterceptor>(); var dispatcher = new DbConnectionDispatcher(); var internalDispatcher = dispatcher.InternalDispatcher; internalDispatcher.Add(mockInterceptor.Object); var transaction = new CommittableTransaction(); var interceptionContext = new EnlistTransactionInterceptionContext().WithTransaction(transaction); dispatcher.EnlistTransaction(mockConnection.Object, interceptionContext); mockConnection.Verify(m => m.EnlistTransaction(transaction), Times.Once()); mockInterceptor.Verify(m => m.EnlistingTransaction(mockConnection.Object, It.IsAny <EnlistTransactionInterceptionContext>()), Times.Once()); mockInterceptor.Verify(m => m.EnlistedTransaction(mockConnection.Object, It.IsAny <EnlistTransactionInterceptionContext>()), Times.Once()); }
public void EnlistedTransaction(DbConnection connection, EnlistTransactionInterceptionContext interceptionContext) { }
/// <summary> /// Enlists this <see cref="T:System.Data.Entity.Core.EntityClient.EntityConnection" /> in the specified transaction. /// </summary> /// <param name="transaction">The transaction object to enlist into.</param> /// <exception cref="T:System.InvalidOperationException"> /// The state of the <see cref="T:System.Data.Entity.Core.EntityClient.EntityConnection" /> is not /// <see /// cref="F:System.Data.ConnectionState.Open" /> /// . /// </exception> public override void EnlistTransaction(Transaction transaction) { if (_storeConnection == null) { throw Error.EntityClient_ConnectionStringNeededBeforeOperation(); } if (State != ConnectionState.Open) { throw Error.EntityClient_ConnectionNotOpen(); } try { var interceptionContext = new EnlistTransactionInterceptionContext(InterceptionContext); interceptionContext = interceptionContext.WithTransaction(transaction); DbInterception.Dispatch.Connection.EnlistTransaction(_storeConnection, interceptionContext); // null means "Unenlist transaction". It is fine if no transaction is in progress (no op). Otherwise // _storeConnection.EnlistTransaction should throw and we would not get here. Debug.Assert( transaction != null || !EnlistedInUserTransaction, "DbConnection should not allow unenlist from a transaction that has not completed."); // It is OK to enlist in null transaction or multiple times in the same transaction. // In the latter case we don't need to be called multiple times when the transaction completes // so subscribe only when enlisting for the first time. Note that _storeConnection.EnlistTransaction // will throw in invalid cases (like enlisting the connection in a transaction when another // transaction has not completed) so when we get here we are sure that either no transactions are // active or the transaction the caller tries enlisting to // is the active transaction. if (transaction != null && !EnlistedInUserTransaction) { transaction.TransactionCompleted += EnlistedTransactionCompleted; } _enlistedTransaction = transaction; } catch (Exception e) { if (e.IsCatchableExceptionType()) { throw new EntityException(Strings.EntityClient_ProviderSpecificError(@"EnlistTransaction"), e); } throw; } }
/// <summary> /// Does not write to log unless overridden. /// </summary> /// <param name="connection">The connection.</param> /// <param name="interceptionContext">Contextual information associated with the call.</param> public virtual void EnlistedTransaction(DbConnection connection, EnlistTransactionInterceptionContext interceptionContext) { }
/// <summary> /// Sends <see cref="IDbConnectionInterceptor.EnlistingTransaction" /> and /// <see cref="IDbConnectionInterceptor.EnlistedTransaction" /> to any <see cref="IDbConnectionInterceptor" /> /// registered on <see cref="DbInterception" /> before/after making a /// call to <see cref="DbConnection.EnlistTransaction" />. /// </summary> /// <param name="connection">The connection on which the operation will be executed.</param> /// <param name="interceptionContext">Optional information about the context of the call being made.</param> public virtual void EnlistTransaction(DbConnection connection, EnlistTransactionInterceptionContext interceptionContext) { Check.NotNull(connection, "connection"); Check.NotNull(interceptionContext, "interceptionContext"); InternalDispatcher.Dispatch( connection, (t, c) => t.EnlistTransaction(c.Transaction), new EnlistTransactionInterceptionContext(interceptionContext), (i, t, c) => i.EnlistingTransaction(t, c), (i, t, c) => i.EnlistedTransaction(t, c)); }
/// <summary> /// 在数据库操作事务提交动作执行前瞬间触发。 /// </summary> /// <param name="connection"></param> /// <param name="interceptionContext"></param> public virtual void EnlistingTransaction(DbConnection connection, EnlistTransactionInterceptionContext interceptionContext) { }
public abstract void EnlistingTransaction(DbConnection connection, EnlistTransactionInterceptionContext interceptionContext);
public abstract void EnlistedTransaction(DbConnection connection, EnlistTransactionInterceptionContext interceptionContext);