C# ITransaction类代码示例

 private void OnNewTransaction(ITransaction transaction, TransactionMode transactionMode, IsolationMode isolationMode, bool distributedTransaction)
 {
     if (!transaction.DistributedTransaction)
     {
         transaction.Enlist(new RhinoTransactionResourceAdapter(transactionMode));
     }
 }

        public SchemaManager(ITransaction transaction)
        {
            if (transaction == null)
                throw new ArgumentNullException("transaction");

            Transaction = transaction;
        }

        public void DetachFrom(ITransaction transaction)
        {
            transaction.UnregisterOnCommit(OnCommit);

            if (transaction is ICallbackHandler)
                ((ICallbackHandler)transaction).OnCallbackDetached(this);
        }

        public void AttachTo(ITransaction transaction)
        {
            transaction.RegisterOnCommit(OnCommit);

            if (transaction is ICallbackHandler)
                ((ICallbackHandler)transaction).OnCallbackAttached(this);
        }

 /// <summary>
 /// ���캯��
 /// </summary>
 public UnitOfWorkSynchronization(ITransaction transaction, UnitOfWorkDelegate unitOfWorkDelegate)
 {
     _transaction = transaction;
     _unitOfWorkDelegate = unitOfWorkDelegate;
     _asyncMessageBus = DependencyResolver.Resolve<IAsyncMessageBus>();
     _logger = DependencyResolver.Resolve<ILoggerFactory>().Create("EventSourcing.UnitOfWorkSynchronization");
 }

        public Dictionary<string, object> Insert(string tableName, Dictionary<string, object> row, ITransaction transaction = null)
        {
            if (!DataStore.ContainsKey(tableName))
                DataStore.Add(tableName, new FakeDBTable());

            var table = DataStore[tableName];

            var dictToUse = row.Copy();
            //var id = DataStore[tableName].Count + 1;
            var primaryKeys = Analyzer.GetPrimaryKeys(tableName);
            var autoKey = Analyzer.GetAutoNumberKey(tableName);

            if (autoKey != null)
            {
                if (!dictToUse.ContainsKey(autoKey))
                    dictToUse.Add(autoKey, table.NextAutoKey++);
                else
                    dictToUse[autoKey] = table.NextAutoKey++;
            }

            var invalid = primaryKeys.Where(key => dictToUse[key] == null);
            if (invalid.Any())
                throw new KeyNotSetException(tableName, invalid);

            table.Add(dictToUse);
            return dictToUse.WhereKeys(key => primaryKeys.Contains(key));
        }

        public IEnumerable<Dictionary<string, object>> RawRead(string tableName, Dictionary<string, object> id, ITransaction transaction = null)
        {
            if (!DataStore.ContainsKey(tableName))
                return new List<Dictionary<string, object>>();

            return DataStore[tableName].FindByFieldValues(id);
        }

 public UnitOfWork(IProvider dataProvider)
 {
     provider = dataProvider as Provider;
     if (provider == null)
         throw new Exception("Invalid Data Provider");
     transaction = provider.Session.BeginTransaction();
 }

 protected void SessionInitializeTransaction()
 {
     if (session == null) {
         session = NHibernateHelper.OpenSession ();
         tx = session.BeginTransaction ();
     }
 }

 //查找用户的基本套餐
 public Int32 getId(Int64 num)
 {
     trans = session.BeginTransaction();
     try
     {
         IEnumerable<Rule> rule = session.CreateQuery("from Rule as c where c.Mobilenumber='" + num + "'").List<Rule>();
         Int32 id = 0;
         foreach (Rule r in rule)
         {
             if (r.Chargeid == 1)
             {
                 id = 1;
                 break;
             }
             else if (r.Chargeid == 2)
             {
                 id = 2;
                 break;
             }
             else if (r.Chargeid == 3)
             {
                 id = 3;
                 break;
             }
             else continue;
         }
         return id;
     }
     catch (Exception)
     {
         throw new Exception();
     }
 }

        public void Dispose()
        {
            if (disposed)
                return;

            if (session == null)
                return;

            try
            {
                if (preventCommit)
                    transaction.Rollback();
                else
                    transaction.Commit();
            }
            catch
            {
                transaction.Rollback();
                throw;
            }
            finally
            {
                transaction.Dispose();
            }

            session.Dispose();
            session = null;
            transaction = null;
            disposed = true;
        }

 public void Setup()
 {
     session = WindsorPersistenceFixture.Container.Resolve<ISession>();
     repository = new SecurityRepository();
     repository.Session = session;
     tx = session.BeginTransaction();
 }

 public void BeginTransaction()
 {
     if (_transaction == null)
     {
         _transaction = Session.BeginTransaction();
     }
 }

 public void Start()
 {
     _session = _sessionSource.CreateSession();
     _session.FlushMode = FlushMode.Commit;
     _transaction = _session.BeginTransaction();
     _isInitialized = true;
 }

 public UnitOfWork(ISessionFactory sessionFactory)
 {
     _sessionFactory = sessionFactory;
     CurrentSession = _sessionFactory.OpenSession();
     //CurrentSession.EnableFilter("translationFilter").SetParameter("locale", Thread.CurrentThread.CurrentUICulture.TwoLetterISOLanguageName);
     _transaction = CurrentSession.BeginTransaction();
 }