C# CommittableTransaction.Dispose方法代码示例

		public void TransactionDispose3 ()
		{
			CommittableTransaction ct = new CommittableTransaction ();
			IntResourceManager irm = new IntResourceManager (1);

			try {
				Transaction.Current = ct;
				irm.Value = 5;
				ct.Commit ();
				ct.Dispose ();
			} finally {
				Transaction.Current = null;
			}

			irm.Check (1, 1, 0, 0, "Dispose transaction");
			Assert.AreEqual (5, irm.Value);
		}

        private void EmployWorkersForJob(RunningJob runningJob)
        {
            foreach (JobSection jobSection in runningJob.Sections)
            {
                if (null == jobSection.WorkerCard) continue; // We don't have workers for this role
                uint availableWorkers = jobSection.WorkerCard.MaxNumOfInstances - GetWorkingWorkersNumber(jobSection.RoleType);
                if (availableWorkers == 0) continue; // All available workers for that role are busy

                // Try to hire ONE worker for the role.
                // We should not hire more than one worker for the role in one iteration to give other WorkerManagers a chance to take some workload.
                RoleSlotToken roleSlotToken = null;

                var transaction = new CommittableTransaction(TransactionManager.MaximumTimeout);
                Transaction oldAmbient = Transaction.Current;
                Transaction.Current = transaction;
                try
                {
                    roleSlotToken = jobSection.GetFreeSlot();
                }
                finally
                {
                    Transaction.Current = oldAmbient;
                    if (null == roleSlotToken)
                    {
                        transaction.Rollback();
                        transaction.Dispose();
                    }
                }

                if (null == roleSlotToken)
                {
                    continue;
                }
                WorkAssignment workAssignment = new WorkAssignment(jobSection.WorkRequest, roleSlotToken,
                    runningJob.JobId, runningJob.ScheduleRunDuration, runningJob.ScheduleCreatedBy, runningJob.NotificationId, runningJob.Frequency);
                EmployWorker(jobSection.WorkerCard, workAssignment, transaction);
                jobSection.WorkerIDs.Add(workAssignment.WorkerId);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns>Retrieved work item or null if not found, didn't pass pre-check, etc.</returns>
        private WorkItem GetWorkItemFromQueue
            ()
        {
            //TODO: Pay great attention here, now workItemCandidate is an instance field!!! (SD)
            workItemCandidate = null;

            #region Get message from queue

            var transaction = new CommittableTransaction();

            try
            {

                Job job;


                using (DependentTransaction dependentTransaction =
                    transaction.DependentClone(DependentCloneOption.BlockCommitUntilComplete))
                {
                    using (var scope = new TransactionScope(dependentTransaction))
                    {
                        job = ItemProvider.GetNextItem();
                        scope.Complete();
                    }

                    dependentTransaction.Complete();
                }

                if (job != null)
                {
                    PerformanceHandler.HandleEvent("Reads From Queue/sec", 1);

                    workItemCandidate = new RequestWorkItem(job.ContextIdentifier.InternalId,
                                                            0, WorkItemState.AvailableForProcessing,
                                                            SubmissionPriority.Normal, null, false, false, "test",
                                                            new ContextIdentifier());
                    // Set transaction on the work item
                    workItemCandidate.Transaction = transaction;
                    workItemCandidate.RetrievedAt = DateTime.Now;
                    workItemCandidate.MessageBody = SerializationUtility.Serialize2ByteArray(job);
                }
                else
                {
                    workItemCandidate = null;
                }

                FailureExceptionHandler.ResetState();
            }
            catch (Exception ex)
            {
                try
                {
                    // Rollback the commitable transaction
                    transaction.Rollback(ex);
                }
                finally
                {
                    transaction.Dispose();
                }

                Log.Source.TraceData(TraceEventType.Error,
                                     ProducerMessage.ErrorDuringObtainingTheWorkItem,
                                     new ContextualLogEntry
                                         {
                                             Message =
                                                 "Exception happened when trying to get item from the message queue (" +
                                                 "queue.QueuePath" + "). " + Environment.NewLine + ex
                                             ,
                                             ContextIdentifier =
                                                 ((workItemCandidate != null)
                                                      ? workItemCandidate.ContextIdentifier
                                                      :
                                                          new ContextIdentifier())
                                         });
                // To review what is the required handling here for us (SD)
                if (ExecutionState == ProcessExecutionState.Running)
                {
                    FailureExceptionType type = FailureExceptionHandler.HandleFailure(ex);
                    if (type == FailureExceptionType.NonRecoverable)
                        Stop();
                }
                else
                {
                    if (workItemCandidate != null)
                    {
                        Log.Source.TraceData(TraceEventType.Information,
                                             ProducerMessage.RetrievedMessageReturnedToTheRetrievalQueue,
                                             new ContextualLogEntry
                                                 {
                                                     Message =
                                                         string.Format
                                                         (
                                                         "'{0}': Retrieved Recurrence(Id = {1}) Successfully Saved to the {2} queue",
                                                         Name,
                                                         workItemCandidate.Id,
                                                         ""
//.........这里部分代码省略.........

		public void TransactionDispose ()
		{
			CommittableTransaction ct = new CommittableTransaction ();
			IntResourceManager irm = new IntResourceManager (1);
			irm.Type = ResourceManagerType.Durable;

			ct.Dispose ();
			irm.Check  (0, 0, 0, 0, "Dispose transaction");
		}

		public override int Insert(DataTable dt, DataColumnCollection colinfo, params string[] ignoreFields)
		{
			/*
				insert into Managers(ManagerName)
				select 'a' union all
				select 'b' union all
				select 'c'
			 */
			int rlt = 0;
			int vNextSubmitValue = vSubmitCount;
			string sqlmain = "insert into {0} ({1}) {2}";
			string sqlsel = " union all select {0} ";
			string cols = "", sels = "", sql;
			string tname = SqlHelper.MakeSafeFieldNameSql(dt.TableName);
			int i = 0;
			LastException = null;

			foreach (DataColumn col in dt.Columns)
			{
				if (!ignoreFields.Contains<string>(col.ColumnName))
				{
					cols += "," + SqlHelper.MakeSafeFieldNameSql(col.ColumnName);
				}
			}
			cols = cols.Substring(1);
			CommittableTransaction ts = new CommittableTransaction();
			DbConnection conn = db.GetConnection();
			conn.Open();
			conn.EnlistTransaction(ts);

			while (i < dt.Rows.Count)
			{
				for (; i < dt.Rows.Count; i++)
				{
					DataRow row = dt.Rows[i];
					string vals = "";
					foreach (DataColumn col in dt.Columns)
					{
						if (!ignoreFields.Contains<string>(col.ColumnName))
						{
							string val = row[col].ToString();
							vals += "," + SqlHelper.MakeSafeFieldSql(val, colinfo, col) + " ";
						}
					}
					sels += string.Format(sqlsel, vals.Substring(1));
					if (i + 1 >= vNextSubmitValue)
					{
						vNextSubmitValue += vSubmitCount;
						break;
					}
				}

				sels = sels.Substring(11);
				sql = string.Format(sqlmain, tname, cols, sels);
				Logger.Log(sql);
				ExecuteResult er = db.Execute(sql, conn, ts);
				rlt += er.IntRlt;
				if (er.Exception != null)
				{
					rlt = 0;
					LastException = er.Exception;
					break;
				}
				sels = "";
				i++;
			}
			if (rlt != 0 && LastException == null)
			{
				ts.Commit();
			}
			if (conn.State != ConnectionState.Closed)
			{
				conn.Close();
			}
			ts.Dispose();
			return rlt;
		}

 internal static void SafeRollbackTransaction(CommittableTransaction transaction)
 {
     if (transaction != null)
     {
         try
         {
             transaction.Rollback();
             transaction.Dispose();
         }
         catch (TransactionException transactionException)
         {
             if (TD.RoutingServiceHandledExceptionIsEnabled())
             {
                 TD.RoutingServiceHandledException(null, transactionException);
             }
         }
         catch (ObjectDisposedException disposedException)
         {
             if (TD.RoutingServiceHandledExceptionIsEnabled())
             {
                 TD.RoutingServiceHandledException(null, disposedException);
             }
         }
     }
 }

		public override int Delete(DataTable dt, string fname, DataColumnCollection colinfo)
		{
			int rlt = 0;
			string sqlmain = "delete from {0} ";
			string sqlwhere = " where {0} in ({1}) ";
			string sql, where, ids = "";
			LastException = null;
			foreach (DataRow row in dt.Rows)
			{
				if (dt.Columns.Contains(fname))
				{
					ids += "," + SqlHelper.MakeSafeFieldSql(row[fname].ToString(), colinfo[fname].ToString(), true);
				}
			}
			ids = ids.Substring(1);
			where = string.Format(sqlwhere, SqlHelper.MakeSafeFieldNameSql(fname), ids);
			sql = string.Format(sqlmain, SqlHelper.MakeSafeFieldNameSql(dt.TableName)) + where;
			Logger.Log(sql);
			CommittableTransaction ts = new CommittableTransaction();
			DbConnection conn = db.GetConnection();
			conn.Open();
			conn.EnlistTransaction(ts);
			ExecuteResult er = db.Execute(sql, conn, ts);
			rlt = er.IntRlt;
			if (er.Exception != null)
			{
				LastException = er.Exception;
				rlt = 0;
			}
			else
			{
				ts.Commit();
			}
			if (conn.State != ConnectionState.Closed)
			{
				conn.Close();
			}
			ts.Dispose();
			return rlt;
		}

//.........这里部分代码省略.........
				SET ManagerName = CASE id
					WHEN 6 THEN 'value'
					WHEN 7 THEN 'value'
					WHEN 8 THEN 'value'
				END
				WHERE id IN (6,7,8)"
			 */
			int rlt = 0;
			int vNextSubmitValue = vSubmitCount;
			string sqlmain = "update {0} set {1} ";
			string sqlset = " , {0} = case {1} {2} end ";
			string sqlwhen = " when {0} then {1} ";
			string sqlwhere = " where {0} in ({1}) ";
			string sets = "", ids = "", sql, where, whens;
			string tname = SqlHelper.MakeSafeFieldNameSql(dt.TableName);
			int i = 0, n = 0;
			LastException = null;

			CommittableTransaction ts = new CommittableTransaction();
			DbConnection conn = db.GetConnection();
			conn.Open();
			conn.EnlistTransaction(ts);

			while (i < dt.Rows.Count)
			{
				foreach (DataColumn col in dt.Columns)
				{
					whens = "";
					//foreach (DataRow row in dt.Rows)
					for (i = vNextSubmitValue - vSubmitCount; i < vNextSubmitValue; i++)
					{
						DataRow row = dt.Rows[i];
						if (!col.ColumnName.Equals(fname))
						{
							whens += string.Format(sqlwhen
								, SqlHelper.MakeSafeFieldSql(row[fname].ToString(), colinfo, dt.Columns[fname])
								, SqlHelper.MakeSafeFieldSql(row[col].ToString(), colinfo, col));
						}
						else
						{
							ids += ","
								+ SqlHelper.MakeSafeFieldSql(row[col].ToString(), colinfo, col);
						}
						if (i + 1 >= vNextSubmitValue)
						{
							break;
						}
						else if (i + 1 >= dt.Rows.Count)
						{
							break;
						}
					}
					if (!col.ColumnName.Equals(fname))
					{
						if (ignoreFields.Contains<string>(col.ColumnName))
						{
							continue;
						}
						sets += string.Format(sqlset, SqlHelper.MakeSafeFieldNameSql(col.ColumnName), SqlHelper.MakeSafeFieldNameSql(fname), whens);
					}
				}
				sets = sets.Substring(2);
				ids = ids.Substring(1);
				where = string.Format(sqlwhere, fname, ids);
				sql = string.Format(sqlmain, tname, sets) + where;
				Logger.Log(sql);
				ExecuteResult er = db.Execute(sql, conn, ts);
				rlt += er.IntRlt;
				if (er.Exception != null)
				{
					rlt = 0;
					LastException = er.Exception;
					break;
				}
				//rlt += Execute(sql, conn, ts);
				//if (LastException != null)
				//{
				//    rlt = 0;
				//    break;
				//}
				sets = "";
				where = "";
				ids = "";
				vNextSubmitValue += vSubmitCount;
				if (i + 1 >= dt.Rows.Count)
				{
					break;
				}
			}
			if (rlt != 0 && LastException == null)
			{
				ts.Commit();
			}
			if (conn.State != ConnectionState.Closed)
			{
				conn.Close();
			}
			ts.Dispose();
			return rlt;
		}

		public void TransactionDispose ()
		{
			CommittableTransaction ct = new CommittableTransaction ();
			IntResourceManager irm = new IntResourceManager (1);
			irm.Volatile = false;

			ct.Dispose ();
			irm.Check  (0, 0, 0, 0, "Dispose transaction");
		}

        /// <summary>
        /// 
        /// </summary>
        /// <param name="priority"></param>
        /// <returns>Retrieved work item or null if not found, didn't pass pre-check, etc.</returns>
        private WorkItem GetWorkItemFromQueue(SubmissionPriority priority)
        {
            //TODO: Pay great attention here, now workItemCandidate is an instance field!!! (SD)
            workItemCandidate = null;
            WorkItem workItem = null;
            Tools.Commands.Implementation.IF1.req item = null;

            Trace.CorrelationManager.ActivityId = Guid.NewGuid();


            #region Get message from queue

            var transaction = new CommittableTransaction();

            try
            {
                #region Get next job from the queue

                //var 

                using (DependentTransaction dependentTransaction =
                    transaction.DependentClone(DependentCloneOption.BlockCommitUntilComplete))
                {
                    using (var scope = new TransactionScope(dependentTransaction))
                    {
                        //TODO: (SD) Provide timeout option
                        item = new Tools.Commands.Implementation.IF1.req
                        {
                            reqId = (++IdSequence).ToString(),
                            processingStatus = "P",
                            errorDesc = "ok",
                            returnValue = "ok",
                            updateMechanism = "JMS"
                        }; 
                        
                        scope.Complete();
                    }

                    dependentTransaction.Complete();

                    if (item == null)
                    {
                        // if token is equal to null then commit here, as 
                        // consumer will not get to the item anyway.
                        if (transaction.TransactionInformation.Status == TransactionStatus.Active)
                            transaction.Commit();
                    }
                }

                #endregion

                #region If job is not null create a work item for it

                if (item != null)
                {
                    workItemCandidate = new RequestWorkItem(0, 0, WorkItemState.AvailableForProcessing,
                        SubmissionPriority.Normal, Encoding.UTF8.GetBytes(SerializationUtility.Serialize2String(item)), false, false, this.Name,
                        new ContextIdentifier { InternalId = 0, ExternalReference = IdSequence.ToString(), ExternalId = IdSequence.ToString() })
                        {
                            Transaction = transaction,
                            RetrievedAt = DateTime.Now
                        };

                    //**Trace.CorrelationManager.ActivityId = .ContextUid;
                    Log.Source.TraceEvent(TraceEventType.Start, 0, "Received the item " + item);

                    // Set transaction on the work item
                }

                #endregion

                this.FailureExceptionHandler.ResetState();
            }
            catch (Exception ex)
            {

                try
                {

                    // Rollback the commitable transaction
                    transaction.Rollback(ex);
                }
                finally
                {
                    transaction.Dispose();
                }

                Log.TraceData(Log.Source,
                    TraceEventType.Error,
                    ProducerMessage.ErrorDuringObtainingTheWorkItem,
                    new ContextualLogEntry
                    {
                        Message =
                            "Exception happened when trying to get item " + Environment.NewLine + ex,
                        ContextIdentifier = ((workItemCandidate != null) ? workItemCandidate.ContextIdentifier : new ContextIdentifier())
//.........这里部分代码省略.........

        public static void ListenerThreadProc(object queueListenerConfig)
        {
            QueueListenerConfig config = (QueueListenerConfig) queueListenerConfig;
              while (!stopping)
              {
            TransactionOptions to = new TransactionOptions();
            to.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
            to.Timeout = TimeSpan.MaxValue;

            CommittableTransaction tran = new CommittableTransaction(to);

            try
            {

              using (var con = new SqlConnection(config.ConnectionString))
              {
            con.Open();
            con.EnlistTransaction(tran);
            byte[] message = ServiceBrokerUtils.GetMessage(config.QueueName, con, TimeSpan.FromSeconds(10));
            if (message == null) //no message available
            {
              tran.Commit();
              con.Close();
              continue;
            }

            try
            {
              if (config.EnlistMessageProcessor)
              {
                using (var ts = new TransactionScope(tran))
                {
                  config.MessageProcessor(message);
                  ts.Complete();
                }
              }
              else
              {
                config.MessageProcessor(message);
              }

            }
            catch (SqlException ex) //catch selected exceptions thrown by the MessageProcessor
            {
              config.FailedMessageProcessor(message, con, ex);
            }

            tran.Commit(); // the message processing succeeded or the FailedMessageProcessor ran so commit the RECEIVE
            con.Close();

              }
            }
            catch (SqlException ex)
            {
              System.Diagnostics.Trace.Write("Error processing message from " + config.QueueName + ": " + ex.Message);
              tran.Rollback();
              tran.Dispose();
              Thread.Sleep(1000);
            }
              ///catch any other non-fatal exceptions that should not stop the listener loop.
            catch (Exception ex)
            {
              Trace.WriteLine("Unexpected Exception in Thread Proc for " + config.QueueName + ".  Thread Proc is exiting: " + ex.Message);
              tran.Rollback();
              tran.Dispose();
              return;
            }

              }
        }