C# ITransaction.Complete方法代码示例

            //验证Transaction
            internal void ValidateTransaction(ITransaction transaction)
            {
                IList<IMessage> children = transaction.Children;
                int len = children.Count;
                for (int i = 0; i < len; i++)
                {
                    IMessage message = children[i];
                    var transaction1 = message as ITransaction;
                    if (transaction1 != null)
                    {
                        ValidateTransaction(transaction1);
                    }
                }

                if (!transaction.IsCompleted())
                {
                    // missing transaction end, log a BadInstrument event so that
                    // developer can fix the code
                    IMessage notCompleteEvent = new DefaultEvent("CAT", "BadInstrument")
                                                    {Status = "TransactionNotCompleted"};
                    notCompleteEvent.Complete();
                    transaction.AddChild(notCompleteEvent);
                    transaction.Complete();
                }
            }

		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();
				}
			}
		}

		// 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 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();
			}
		}