public void GuardarAsignaciones(IList<int> ordenesVenta, IList<Usuario> asistentes)
        {
            try
            {
                var transactionOptions = new TransactionOptions { IsolationLevel = IsolationLevel.ReadUncommitted };

                using (var transactionScope = new TransactionScope(TransactionScopeOption.Required, transactionOptions))
                {
                    foreach (var idOrdenVenta in ordenesVenta)
                    {
                        var ordenVenta = _orderVentaDA.ObtenerPorID(idOrdenVenta);

                        var asistenteConMenorCarga = asistentes.OrderBy(p => p.CantidadOV).FirstOrDefault();

                        if (asistenteConMenorCarga != null)
                        {
                            asistenteConMenorCarga.CantidadOV++;

                            ordenVenta.Estado = Constantes.EstadoOrdenVenta.Asignado;
                            ordenVenta.AsistentePlaneamiento = asistenteConMenorCarga;

                            _orderVentaDA.AsignarAsistentePlaneamiento(ordenVenta);
                        }
                    }

                    transactionScope.Complete();
                }
            }
            catch (Exception ex)
            {
                throw ThrowException(ex, MethodBase.GetCurrentMethod().Name);
            }
        }

 private static WaitCallback JobEntity(TransactionOptions options)
 {
     return state =>
         {
             try
             {
                 using (var scope = new TransactionScope(TransactionScopeOption.RequiresNew, options))
                 {
                     using (var context = new ProjectTemplate_DevEntities())
                     {
                         var element = context.Element.First(d => d.Id == "d0530ea7-639f-4d5e-91fb-1a4fed1debfe");
                         var intInternalName = Int32.Parse(element.InternalName);
                         PrintMessage("ReadValue=" + intInternalName.ToString());
                         element.InternalName = (intInternalName + 1).ToString();
                         PrintMessage("Incrementing to" + element.InternalName);
                         Thread.Sleep(2000);
                         context.SaveChanges(); // Save changes to DB
                         PrintMessage("Saving");
                         Thread.Sleep(2000);
                     }
                     scope.Complete(); // Commit transaction
                     PrintMessage("Commit");
                 }
             }
             catch (Exception e)
             {
                 PrintMessage( e.Message);
             }finally
             {
                 ((ManualResetEvent)state).Set();
             }
         };
 }

        public MsmqScopeOptions(TimeSpan? requestedTimeout = null, IsolationLevel? requestedIsolationLevel = null)
        {
            var timeout = TransactionManager.DefaultTimeout;
            var isolationLevel = IsolationLevel.ReadCommitted;
            if (requestedTimeout.HasValue)
            {
                var maxTimeout = GetMaxTimeout();

                if (requestedTimeout.Value > maxTimeout)
                {
                    throw new ConfigurationErrorsException(
                        "Timeout requested is longer than the maximum value for this machine. Override using the maxTimeout setting of the system.transactions section in machine.config");
                }

                timeout = requestedTimeout.Value;
            }

            if (requestedIsolationLevel.HasValue)
            {
                isolationLevel = requestedIsolationLevel.Value;
            }

            TransactionOptions = new TransactionOptions
            {
                IsolationLevel = isolationLevel,
                Timeout = timeout
            };
        }

        public void Abandon(int masterSysNo, int userSysNo)
        {
            TransactionOptions options = new TransactionOptions();
            options.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
            options.Timeout = TransactionManager.DefaultTimeout;

            using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, options))
            {

                //�����dz�ʼ״̬
                POInfo dbInfo = LoadPO(masterSysNo);
                if ( dbInfo == null )
                    throw new BizException("does not exist this po sysno");
                if ( dbInfo.Status != (int)AppEnum.POStatus.Origin )
                    throw new BizException("status is not origin now, abandon failed");

                //���� ���š�״̬�������
                Hashtable ht = new Hashtable(4);

                ht.Add("SysNo", masterSysNo);
                ht.Add("Status", (int)AppEnum.POStatus.Abandon);
                if ( 1!=new PODac().UpdateMaster(ht))
                    throw new BizException("expected one-row update failed, verify failed ");

                ProductIDManager.GetInstance().AbandonProductIDsByPO(masterSysNo);

                scope.Complete();
            }
        }

		public TransactionScope (TransactionScopeOption scopeOption,
			TransactionOptions options,
			DTCOption opt)
		{
			Initialize (scopeOption, null, options, opt,
				TransactionManager.DefaultTimeout);
		}

        /// <summary>
        /// ����rma��
        /// </summary>
        /// <param name="rmaInfo"></param>
        public void AddRMA(RMAInfo rmaInfo)
        {
            TransactionOptions options = new TransactionOptions();
            options.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
            options.Timeout = TransactionManager.DefaultTimeout;

            using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, options))
            {
                if(!this.IfExistOpenedRMA(rmaInfo.SOSysNo))
                {
                    Hashtable leftHash = this.GetLeftRMAQty(rmaInfo.SOSysNo);
                    foreach(RMAItemInfo item in rmaInfo.ItemHash.Values)
                    {
                        if(item.RMAQty>(int)leftHash[item.ProductSysNo])
                            throw new BizException("����д�ı�����Ʒ�����������۵���ʵ�ʹ�����������ȷ���豣�޵���Ʒ��Ϊ�˵�����");
                    }
                    rmaInfo.SysNo = SequenceDac.GetInstance().Create("RMA_Sequence");
                    rmaInfo.RMAID = this.BuildRMAID(rmaInfo.SysNo);
                    rmaInfo.SubmitInfo = this.GetRMASnapShot(rmaInfo);
                    rmaInfo.Status = (int)AppEnum.RMAStatus.Origin;
                    this.InsertMaster(rmaInfo);
                    foreach(RMAItemInfo rmaItem in rmaInfo.ItemHash.Values)
                    {
                        rmaItem.RMASysNo = rmaInfo.SysNo;
                        this.InsertItem(rmaItem);
                    }
                }
                else
                    throw new BizException("�����۵��Ѿ�����һ�ű��޵��ڴ����У�������������ύ�µı������룬����ϵORS�̳ǿͷ�");
                scope.Complete();
            }
        }

        /// Execute action
        public override object Execute()
        {
            TransactionOptions options = new TransactionOptions
                                             {
                                                 IsolationLevel = IsolationLevel,
                                                 Timeout = (Utils.ToTimeSpan(Context.TransformStr(Timeout, Transform)) ?? TimeSpan.FromSeconds(60))
                                             };

            VerboseMessage(" -- Starting transaction {0} (Isolation: {1}) --",Option,IsolationLevel);

            object ret;
            using (TransactionScope scope=new TransactionScope(Option,options))
            {
                try
                {
                    ret = base.Execute();
                    scope.Complete();
                    VerboseMessage(" -- Transaction commit --");
                }
                catch
                {
                    VerboseMessage(" -- Transaction rollback --");
                    throw;
                }
            }

            return ret;
        }

 public static TransactionScope CreateTransactionScope()
 {
     var transactionOptions = new TransactionOptions();
     transactionOptions.IsolationLevel = IsolationLevel.ReadCommitted;
     transactionOptions.Timeout = TimeSpan.MaxValue;
     return new TransactionScope(TransactionScopeOption.Required, transactionOptions);
 }

 public static TransactionScope CreateTransactionScope()
 {
     var transactionOptions = new TransactionOptions();
     transactionOptions.IsolationLevel = IsolationLevel.ReadCommitted;
     transactionOptions.Timeout = TransactionManager.MaximumTimeout;
     return new TransactionScope(TransactionScopeOption.Required, transactionOptions);
 }

 /// <summary>
 /// 获取事务隔离级别
 /// </summary>
 /// <returns></returns>
 public static TransactionOptions GetTransactionOptions()
 {
     TransactionOptions transactionOptions = new TransactionOptions();
         switch (ConfigurationManager.AppSettings["IsolationLevel"].ToString())
         {
             case "Chaos":
                 transactionOptions.IsolationLevel = IsolationLevel.Chaos;
                 break;
             case "ReadCommitted":
                 transactionOptions.IsolationLevel = IsolationLevel.ReadCommitted;
                 break;
             case "ReadUncommitted":
                 transactionOptions.IsolationLevel = IsolationLevel.ReadUncommitted;
                 break;
             case "RepeatableRead":
                 transactionOptions.IsolationLevel = IsolationLevel.RepeatableRead;
                 break;
             case "Serializable":
                 transactionOptions.IsolationLevel = IsolationLevel.Serializable;
                 break;
             case "Snapshot":
                 transactionOptions.IsolationLevel = IsolationLevel.Snapshot;
                 break;
             case "Unspecified":
                 transactionOptions.IsolationLevel = IsolationLevel.Unspecified;
                 break;
             default:
                 transactionOptions.IsolationLevel = IsolationLevel.ReadCommitted;
                 break;
         }
     return transactionOptions;
 }

        public void CommendCustomerEmailVerified(int CustomerSysNo,string CommendEmail)
        {
            TransactionOptions options = new TransactionOptions();
            options.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
            options.Timeout = TransactionManager.DefaultTimeout;

            using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, options))
            {
                CustomerCommendInfo oInfo = LoadCustomerCommend(CommendEmail);
                if(oInfo == null)
                    throw new BizException("");
                decimal increment = 5; //�Ƽ��ĺ���ͨ��Email��֤����5���˷�
                int rowsAffected = new FreeShipFeeDac().SetFreeShipFee(CustomerSysNo, increment);
                if (rowsAffected != 1)
                    throw new BizException("�ͻ��˷�������ʧ�ܣ�������Ϊ�˷����㡣");

                UpdateCustomerCommendStatus(CommendEmail, (int) AppEnum.CommendStatus.Registered); //�����Ƽ�״̬

                if (increment != 0)
                {
                    int freeShipFeeLogType = (int)AppEnum.FreeShipFeeLogType.CustomerRegister;
                    string freeShipFeeLogMemo = "�Ƽ��ͻ�ע�����˷� - " + CommendEmail;
                    CustomerFreeShipFeeLogInfo oLog = new CustomerFreeShipFeeLogInfo(CustomerSysNo, freeShipFeeLogType, increment, freeShipFeeLogMemo);
                    oLog.LogCheck = oLog.CalcLogCheck();

                    if (1 != new FreeShipFeeDac().Insert(oLog))
                        throw new BizException("�����˷����ʧ��");
                }

                scope.Complete();
            }
        }

        public void CommendCustomerEmailList(int CustomerSysNo,decimal FreeShipFee,Hashtable ht,string EmailBody)
        {
            TransactionOptions options = new TransactionOptions();
            options.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
            options.Timeout = TransactionManager.DefaultTimeout;

            using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, options))
            {
                if (!VerifyValidEmailList(ht))
                    throw new BizException("�����ظ��Ƽ�!");

                CustomerInfo cInfo = CustomerManager.GetInstance().Load(CustomerSysNo);
                string CustomerName = cInfo.CustomerName;
                string mailSubject = CustomerName + " �����Ƽ�ORS�̳���";
                foreach (string email in ht.Keys)
                {
                    UpdateCustomerCommendStatus(email, (int) AppEnum.CommendStatus.Origin);

                    string mailBody = "@FriendName<br>" + EmailBody + "<br>@CustomerName<br>" + DateTime.Now.ToString(AppConst.DateFormat);
                    mailBody = mailBody.Replace("@FriendName", ht[email].ToString());
                    mailBody = mailBody.Replace("@CustomerName", CustomerName);

                    EmailInfo oEmail = new EmailInfo(email, mailSubject, mailBody);
                    EmailManager.GetInstance().InsertEmail(oEmail);
                }

                SetFreeShipFee(CustomerSysNo, FreeShipFee, (int)AppEnum.FreeShipFeeLogType.CommendCustomer, "�Ƽ�����Email");

                scope.Complete();
            }
        }

        public int AddItem(RMARevertInfo oParam)
        {
            TransactionOptions options = new TransactionOptions();
            options.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
            options.Timeout = TransactionManager.DefaultTimeout;

            using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, options))
            {
                foreach (int registerSysNo in oParam.ItemHash.Keys)
                {
                    RMARevertItemInfo oRevertItem = new RMARevertItemInfo();
                    oRevertItem.RegisterSysNo = registerSysNo;
                    oRevertItem.RevertSysNo = oParam.SysNo;
                    //��Register�ֿ��д��RMA_Revert_Item
                    int revertStockSysNo = AppConst.IntNull;
                    DataRow regdr = RMARegisterManager.GetInstance().GetRegisterRow(registerSysNo);
                    revertStockSysNo = Util.TrimIntNull(regdr["RevertStockSysNo"]);

                    oRevertItem.StockSysNo = Util.TrimIntNull(revertStockSysNo);

                    this.InsertRevertItem(oRevertItem);
                }

                scope.Complete();
                return oParam.SysNo;
            }
        }

        /// <summary>
        /// Initializes the <see cref="IDequeueMessages" />.
        /// </summary>
        /// <param name="address">The address to listen on.</param>
        /// <param name="transactionSettings">The <see cref="TransactionSettings" /> to be used by <see cref="IDequeueMessages" />.</param>
        /// <param name="tryProcessMessage">Called when a message has been dequeued and is ready for processing.</param>
        /// <param name="endProcessMessage">Needs to be called by <see cref="IDequeueMessages" /> after the message has been processed regardless if the outcome was successful or not.</param>
        public void Init(Address address, TransactionSettings transactionSettings, Func<TransportMessage, bool> tryProcessMessage, Action<TransportMessage, Exception> endProcessMessage)
        {
            this.tryProcessMessage = tryProcessMessage;
            this.endProcessMessage = endProcessMessage;
            this.workQueue = this.NamePolicy.GetQueueName(address);
            this.clientInfo = string.Format("OracleAQDequeueStrategy for {0}", this.workQueue);

            this.transactionOptions = new TransactionOptions
            {
                IsolationLevel = transactionSettings.IsolationLevel,
                Timeout = transactionSettings.TransactionTimeout,
            };

            this.dequeueOptions = new OracleAQDequeueOptions
            {
                DequeueMode = OracleAQDequeueMode.Remove,
                ProviderSpecificType = true,
                Wait = 0,
            };

            if (this.PurgeOnStartup)
            {
                this.Purger.Purge(this.workQueue);
            }
        }

        public static List<SalesHistoryData> GetSalesHistory()
        {
            List<SalesHistoryData> result = new List<SalesHistoryData>();
            try
            {
                // The encrypted list will timeout for slightly large lists (in the hundreds), so the list is
                // being grabbed in smaller chunks.  Transaction logic is used to lock the list while the list is being
                // grabbed.
                TransactionOptions transactionOptions = new TransactionOptions();
                transactionOptions.IsolationLevel = IsolationLevel.RepeatableRead;
                transactionOptions.Timeout = new TimeSpan(0, 2, 0);
                using (TransactionScope scope = new TransactionScope(TransactionScopeOption.RequiresNew, transactionOptions))
                {
                    Console.WriteLine("Test 1: List all Sales Orders");
                    int take = 5;
                    int count = UserSession.Current.Client.GetSalesOrderListCount();
                    for (int skip = 0; skip < count; skip = skip + take)
                    {
                        List<SalesHistoryData> salesOrders = UserSession.Current.Client.GetSalesHistory(take, skip).ToList();
                        result = result.Union(salesOrders).ToList();
                    }
                    result = result.OrderByDescending(so => so.SalesOrderNumber).ThenBy(so => so.SortOrder).ToList();
                    //No scope.Complete here as no write tasks are being scoped.

                    scope.Dispose();
                }
            }
            catch (Exception) { throw; }
            return result;
        }

        public void CancelAbandon(int masterSysNo)
        {
            TransactionOptions options = new TransactionOptions();
            options.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
            options.Timeout = TransactionManager.DefaultTimeout;

            using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, options))
            {

                AdjustInfo masterInfo = Load(masterSysNo);

                //�����Ƿ���״̬
                if ( masterInfo.Status != (int)AppEnum.AdjustStatus.Abandon )
                    throw new BizException("status is not abandon now ,  cancel abandon failed");

                //���� ���š�״̬
                Hashtable ht = new Hashtable(4);
                ht.Add("SysNo", masterSysNo);
                ht.Add("Status", (int)AppEnum.AdjustStatus.Origin);
                if ( 1!=new AdjustDac().UpdateMaster(ht))
                    throw new BizException("expected one-row update failed, cancel abandon failed ");

                //���Ӷ�available������ռ��
                foreach(AdjustItemInfo item in masterInfo.itemHash.Values)
                {
                    if ( item.AdjustQty < 0 )
                    {
                        InventoryManager.GetInstance().SetAvailableQty(masterInfo.StockSysNo, item.ProductSysNo, -1*item.AdjustQty);
                    }
                }
                scope.Complete();
            }
        }

        public void TransactionCommit()
        {
            ITransactionScopeAdapter txAdapter = (ITransactionScopeAdapter) mocks.CreateMock(typeof(ITransactionScopeAdapter));

            using (mocks.Ordered())
            {
                Expect.Call(txAdapter.IsExistingTransaction).Return(false);
                TransactionOptions txOptions = new TransactionOptions();
                txOptions.IsolationLevel = IsolationLevel.ReadCommitted;
                txAdapter.CreateTransactionScope(TransactionScopeOption.Required, txOptions, EnterpriseServicesInteropOption.None);

                Expect.Call(txAdapter.RollbackOnly).Return(false);
                txAdapter.Complete();
                txAdapter.Dispose();
            }
            mocks.ReplayAll();

            TxScopeTransactionManager tm = new TxScopeTransactionManager(txAdapter);
            tm.TransactionSynchronization = TransactionSynchronizationState.Always;

            TransactionTemplate tt = new TransactionTemplate(tm);
            tt.Execute(status =>
                           {
                               Assert.IsTrue(TransactionSynchronizationManager.SynchronizationActive);
                               Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly);
                               return null;
                           });

            Assert.IsFalse(TransactionSynchronizationManager.SynchronizationActive);
            Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly);   

            mocks.VerifyAll();


        }

 public void Commit(TransactionScopeOption scopeOption, TransactionOptions transactionOptions)
 {
     using (TransactionScope scope = new TransactionScope(scopeOption, transactionOptions))
     {
         foreach (UnitOfWork.Operation operation2 in from o in this.operations
                                                     orderby o.ProcessDate
                                                     select o)
         {
             switch (operation2.Type)
             {
                 case UnitOfWork.OperationType.Insert:
                     operation2.Repository.PersistNewItem(operation2.Entity);
                     break;
                 case UnitOfWork.OperationType.Update:
                     operation2.Repository.PersistUpdatedItem(operation2.Entity);
                     break;
                 case UnitOfWork.OperationType.Delete:
                     operation2.Repository.PersistDeletedItem(operation2.Entity);
                     break;
             }
         }
         scope.Complete();
     }
     foreach (EntityBase entityBase in (from operation in this.operations
                                        select operation.Entity).OfType<EntityBase>())
     {
         entityBase.ClearChangedProperties();
     }
     this.Reset();
 }

        /// <summary>
        /// ����rma��
        /// </summary>
        /// <param name="rmaInfo"></param>
        public void AddRMA(RMARequestInfo rmaInfo)
        {
            TransactionOptions options = new TransactionOptions();
            options.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
            options.Timeout = TransactionManager.DefaultTimeout;

            using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, options))
            {
                rmaInfo.SysNo = SequenceDac.GetInstance().Create("RMA_Request_Sequence");
                rmaInfo.RequestID = this.BuildRMAID(rmaInfo.SysNo);
                rmaInfo.Status = (int)AppEnum.RMAStatus.Origin;
                this.InsertRequest(rmaInfo);
                foreach (RMARegisterInfo rmaItem in rmaInfo.ItemHash.Values)
                {
                    rmaItem.SysNo = SequenceDac.GetInstance().Create("RMA_Register_Sequence");
                    rmaItem.Status = (int)AppEnum.RMARequestStatus.Orgin;
                    rmaItem.OwnBy = (int)AppEnum.RMAOwnBy.Origin;
                    rmaItem.Location = (int)AppEnum.RMALocation.Origin;
                    RMARegisterManager.GetInstance().InsertRegister(rmaItem);
                    RMARequestItemInfo rmaiteminfo = new RMARequestItemInfo();
                    rmaiteminfo.RegisterSysNo = rmaItem.SysNo;
                    rmaiteminfo.RequestSysNo = rmaInfo.SysNo;
                    this.InsertRequestItem(rmaiteminfo);
                }

                scope.Complete();
            }
            //SendMail(rmaInfo);
        }

        public ATMOperationResult GetCardCash(string cardNumber, string cardPIN, out decimal cash)
        {
            cash = 0.0M;

            var options = new TransactionOptions
            {
                IsolationLevel = IsolationLevel.RepeatableRead,
                Timeout = new TimeSpan(0, 0, 0, 10)
            };

            using (var scope = new TransactionScope(TransactionScopeOption.RequiresNew, options))
            {
                var matches = this.atmContext.CardAccounts.Where(a => a.CardNumber == cardNumber).ToList();

                if (matches.Count == 0)
                {
                    return ATMOperationResult.CardNumberInvalid;
                }

                var account = matches[0];

                if (account.CardPIN != cardPIN)
                {
                    return ATMOperationResult.CardPINInvalid;
                }

                cash = account.CardCash;

                scope.Complete();

                return ATMOperationResult.Success;
            }
        }