public EnlistVolatile ( IEnlistmentNotification enlistmentNotification, EnlistmentOptions enlistmentOptions ) : |
||
enlistmentNotification | IEnlistmentNotification | |
enlistmentOptions | EnlistmentOptions | |
Результат |
internal SQLiteEnlistment(SQLiteConnection cnn, Transaction scope) { _transaction = cnn.BeginTransaction(); _scope = scope; _scope.EnlistVolatile(this, System.Transactions.EnlistmentOptions.None); }
private TransactionException CreateVolatileEnlistment(System.Transactions.Transaction transactionToEnlist) { TransactionException exception = null; PersistenceContextEnlistment enlistment = null; int hashCode = transactionToEnlist.GetHashCode(); lock (System.ServiceModel.Activities.Dispatcher.PersistenceContext.Enlistments) { try { if (!System.ServiceModel.Activities.Dispatcher.PersistenceContext.Enlistments.TryGetValue(hashCode, out enlistment)) { enlistment = new PersistenceContextEnlistment(this.PersistenceContext, transactionToEnlist); transactionToEnlist.EnlistVolatile(enlistment, EnlistmentOptions.None); System.ServiceModel.Activities.Dispatcher.PersistenceContext.Enlistments.Add(hashCode, enlistment); return(exception); } enlistment.AddToEnlistment(this.PersistenceContext); return(exception); } catch (TransactionException exception2) { exception = exception2; this.PersistenceContext.ScheduleNextTransactionWaiter(); } } return(exception); }
public DeveelDbEnlistment(DeveelDbConnection connection, Transaction scope) { transaction = connection.BeginTransaction(); Scope = scope; Scope.EnlistVolatile(this, EnlistmentOptions.None); }
public FbEnlistmentNotification(FbConnectionInternal connection, Transaction systemTransaction) { _connection = connection; _transaction = connection.BeginTransaction(systemTransaction.IsolationLevel); _systemTransaction = systemTransaction; _systemTransaction.EnlistVolatile(this, System.Transactions.EnlistmentOptions.None); }
private bool Enlist(Db4oEnlist enlist) { System.Transactions.Transaction currentTx = System.Transactions.Transaction.Current; if (currentTx != null) { currentTx.EnlistVolatile(enlist, EnlistmentOptions.None); return(true); } return(false); }
internal SQLiteEnlistment( SQLiteConnection cnn, Transaction scope, System.Data.IsolationLevel defaultIsolationLevel, bool throwOnUnavailable, bool throwOnUnsupported ) { _transaction = cnn.BeginTransaction(GetSystemDataIsolationLevel( cnn, scope, defaultIsolationLevel, throwOnUnavailable, throwOnUnsupported)); _scope = scope; _scope.EnlistVolatile(this, System.Transactions.EnlistmentOptions.None); }
public void SetInteriorTransaction(Transaction interiorTransaction, bool needsCommit) { Fx.Assert(!this.context.IsHostTransaction, "SetInteriorTransaction called for a host transaction."); if (this.waitForTransaction != null) { throw Fx.Exception.AsError(new InvalidOperationException(SRCore.ExecuteMustBeNested)); } bool success = false; try { this.waitForTransaction = new AsyncWaitHandle(EventResetMode.ManualReset); interiorTransaction.EnlistVolatile(this, EnlistmentOptions.None); success = true; } finally { if (!success) { if (this.waitForTransaction != null) { this.waitForTransaction.Set(); } } else if (needsCommit) { this.transactionToCommit = (CommittableTransaction)interiorTransaction; } } }
void RegisterForTransactionNotification(Transaction transaction) { if (Transaction.Current != null) { ReceiveContextEnlistmentNotification notification = new ReceiveContextEnlistmentNotification(this); transaction.EnlistVolatile(notification, EnlistmentOptions.None); Interlocked.Increment(ref this.ambientTransactionCount); } }
public TxEnlistment(Transaction tx) { tx.EnlistVolatile(this, EnlistmentOptions.None); }
TransactionException CreateVolatileEnlistment(Transaction transactionToEnlist) { TransactionException result = null; PersistenceContextEnlistment enlistment = null; int key = transactionToEnlist.GetHashCode(); lock (PersistenceContext.Enlistments) { try { if (!PersistenceContext.Enlistments.TryGetValue(key, out enlistment)) { enlistment = new PersistenceContextEnlistment(this.PersistenceContext, transactionToEnlist); transactionToEnlist.EnlistVolatile(enlistment, EnlistmentOptions.None); // We don't save of the Enlistment object returned from EnlistVolatile. We don't need // it here. When our PersistenceContextEnlistment object gets notified on Prepare, // Commit, Rollback, or InDoubt, it is provided with the Enlistment object. PersistenceContext.Enlistments.Add(key, enlistment); } else { enlistment.AddToEnlistment(this.PersistenceContext); } } catch (TransactionException txException) { result = txException; // We own the lock but failed to create enlistment. Manually wake up the next waiter. // We only handle TransactionException, in case of other exception that failed to create enlistment, // It will fallback to Timeout. This is safe to avoid multiple waiters owning same lock. this.PersistenceContext.ScheduleNextTransactionWaiter(); } } return result; }
public void SetInteriorTransaction(Transaction interiorTransaction, bool needsCommit) { if (this.waitForTransaction != null) { throw Fx.Exception.AsError(new InvalidOperationException(SRCore.ExecuteMustBeNested)); } bool flag = false; try { this.waitForTransaction = new AsyncWaitHandle(EventResetMode.ManualReset); interiorTransaction.EnlistVolatile((ISinglePhaseNotification) this, EnlistmentOptions.None); flag = true; } finally { if (!flag) { if (this.waitForTransaction != null) { this.waitForTransaction.Set(); } } else if (needsCommit) { this.transactionToCommit = (CommittableTransaction) interiorTransaction; } } }
public EventResourceManager(EventEmitter eventEmitter, Transaction transaction) { this.eventEmitter = eventEmitter; transaction.EnlistVolatile(this, EnlistmentOptions.None); changes = new List<RaisedEvent>(); }
internal VoterBallot(ITransactionVoterNotifyAsync2 notification, Transaction transaction) { this.transaction = transaction; this.notification = notification; this.enlistment = transaction.EnlistVolatile(this, EnlistmentOptions.None); }