C# ITransaction.Dispose方法代码示例

        public void Intercept(IInvocation invocation)
        {
            var sessionFactories = NHibernateSessionManager.SessionFactories;
            var method = invocation.Method;
            var isTransactionScoped = method.IsDecoratedBy(typeof(TransactionAttribute));

            if (isTransactionScoped) {
                foreach (var sessionFactory in sessionFactories)
                {
                    var session = sessionFactory.GetSession();

                    _transaction = sessionFactory.GetSession().Transaction.IsActive
                                ? _session.Transaction
                                : _session.BeginTransaction();
                }
                _transaction = _session.Transaction;

                try {
                    invocation.Proceed();

                    _transaction.Commit();
                } catch (Exception) {
                    _transaction.Rollback();

                    throw;
                } finally {
                    _transaction.Dispose();
                }
            }
        }

		// TODO: implement WaitAll-semantics with returned task
		private void SynchronizedCase(IInvocation invocation, ITransaction transaction)
		{
			Contract.Requires(transaction.State == TransactionState.Active);

			if (_Logger.IsDebugEnabled)
				_Logger.DebugFormat("synchronized case");

			using (new TxScope(transaction.Inner, _Logger.CreateChildLogger("TxScope")))
			{
				var localIdentifier = transaction.LocalIdentifier;

				try
				{
					invocation.Proceed();

					if (transaction.State == TransactionState.Active)
						transaction.Complete();
					else if (_Logger.IsWarnEnabled)
						_Logger.WarnFormat(
							"transaction was in state {0}, so it cannot be completed. the 'consumer' method, so to speak, might have rolled it back.",
							transaction.State);
				}
				catch (TransactionAbortedException)
				{
					// if we have aborted the transaction, we both warn and re-throw the exception
					if (_Logger.IsWarnEnabled)
						_Logger.WarnFormat("transaction aborted - synchronized case, tx#{0}", localIdentifier);

					throw;
				}
				catch (TransactionException ex)
				{
					if (_Logger.IsFatalEnabled)
						_Logger.Fatal("internal error in transaction system - synchronized case", ex);

					throw;
				}
				catch (AggregateException ex)
				{
					if (_Logger.IsWarnEnabled)
						_Logger.Warn("one or more dependent transactions failed, re-throwing exceptions!", ex);
					throw;
				}
				catch (Exception)
				{
					if (_Logger.IsErrorEnabled)
						_Logger.ErrorFormat("caught exception, rolling back transaction - synchronized case - tx#{0}",
						                    localIdentifier);

					// the transaction rolls back itself on exceptions
					//transaction.Rollback();
					throw;
				}
				finally
				{
					if (_Logger.IsDebugEnabled)
						_Logger.DebugFormat("dispoing transaction - synchronized case - tx#{0}", localIdentifier);

					transaction.Dispose();
				}
			}
		}

		private static void SynchronizedCase(IInvocation invocation, ITransaction transaction)
		{
			Contract.Requires(transaction.State == TransactionState.Active);
			_Logger.DebugFormat("synchronized case");

			using (new TransactionScope(transaction.Inner))
			{
				try
				{
					invocation.Proceed();

					if (transaction.State == TransactionState.Active)
						transaction.Complete();

					else
						_Logger.WarnFormat(
							"transaction was in state {0}, so it cannot be completed. the 'consumer' method, so to speak, might have rolled it back.",
							transaction.State);
				}
				catch (TransactionAbortedException)
				{
					// if we have aborted the transaction, we both warn and re-throw the exception
					_Logger.Warn("transaction aborted - synchronized case");
					throw;
				}
				catch (TransactionException ex)
				{
					if (_Logger.IsFatalEnabled)
						_Logger.Fatal("internal error in transaction system - synchronized case", ex);

					throw;
				}
				catch (Exception)
				{
					if (_Logger.IsErrorEnabled)
						_Logger.ErrorFormat("caught exception, rolling back transaction - synchronized case - tx#{0}",
						                    transaction.LocalIdentifier);

					transaction.Rollback();
					throw;
				}
				finally
				{
					if (_Logger.IsDebugEnabled)
						_Logger.DebugFormat("dispoing transaction - synchronized case - tx#{0}", transaction.LocalIdentifier);

					transaction.Dispose();
				}
			}
		}

 private ITransaction DisposeTransaction(ITransaction transaction)
 {
     if (transaction != null)
     {
         transaction.Commit();
         transaction.Dispose();
         transaction = null;
     }
     return transaction;
 }

		private void AsyncCase(IInvocation invocation, ITransaction transaction)
		{
			Contract.Requires(transaction.State == TransactionState.Active);

			var txScope = new TxScope(transaction.Inner, _Logger.CreateChildLogger("TxScope"));

			// using (new TxScope(transaction.Inner, _Logger.CreateChildLogger("TxScope")))
			// var localIdentifier = transaction.LocalIdentifier;

			invocation.Proceed();

			var ret = (Task) invocation.ReturnValue;
					
			if (!ret.IsCompleted)
			{
				ret.ContinueWith((t, aTransaction) =>
				{
					var tran = (ITransaction) aTransaction;

					if (!t.IsFaulted && !t.IsCanceled)
					{
						if (tran.State == TransactionState.Active)
						{
							try
							{
								tran.Complete();
							}
							catch (Exception) { }
						}
					}

					tran.Dispose();

				}, transaction, TaskContinuationOptions.AttachedToParent);
			}
			else
			{
				if (transaction.State == TransactionState.Active)
					transaction.Complete();
				else if (_Logger.IsWarnEnabled)
					_Logger.WarnFormat(
						"transaction was in state {0}, so it cannot be completed. the 'consumer' method, so to speak, might have rolled it back.",
						transaction.State);

				transaction.Dispose();
			}
		}