C# Transaction.Dispose方法代码示例

 public static void WithDatabase(this JET_INSTANCE instance, string database, Func<Session, JET_DBID, Transaction, Transaction> action)
 {
     using (var session = new Session(instance))
     {
         var tx = new Transaction(session);
         try
         {
             JET_DBID dbid;
             Api.JetOpenDatabase(session, database, "", out dbid, OpenDatabaseGrbit.None);
             try
             {
                 tx = action(session, dbid, tx);
             }
             finally
             {
                 Api.JetCloseDatabase(session, dbid, CloseDatabaseGrbit.None);
             }
             tx.Commit(CommitTransactionGrbit.None);
         }
         finally
         {
             if(tx != null)
                 tx.Dispose();
         }
     }
 }

		public void Update(Session session, JET_DBID dbid)
		{
			Transaction tx;
			using (tx = new Transaction(session))
			{
				using ( var tbl = new Table(session, dbid, "indexes_stats",
					OpenTableGrbit.PermitDDL | OpenTableGrbit.DenyRead | OpenTableGrbit.DenyWrite))
				{
					var columnDictionary = Api.GetColumnDictionary(session, tbl);

					if (columnDictionary.ContainsKey("reduce_attempts"))
						Api.JetDeleteColumn(session, tbl, "reduce_attempts");
					if (columnDictionary.ContainsKey("reduce_errors"))
						Api.JetDeleteColumn(session, tbl, "reduce_errors");
					if (columnDictionary.ContainsKey("reduce_successes"))
						Api.JetDeleteColumn(session, tbl, "reduce_successes");
				}

				CreateIndexesStatsReduce(session, dbid);

				using (var stats = new Table(session, dbid, "indexes_stats",OpenTableGrbit.None))
				using (var reduce = new Table(session, dbid, "indexes_stats_reduce", OpenTableGrbit.None))
				{
					var tblKeyColumn = Api.GetColumnDictionary(session, stats)["key"];
					var reduceKeyCol = Api.GetColumnDictionary(session, reduce)["key"];

					Api.MoveBeforeFirst(session, stats);
					while (Api.TryMoveNext(session, stats))
					{
						using(var update = new Update(session, reduce, JET_prep.Insert))
						{
							var indexName = Api.RetrieveColumnAsString(session, stats, tblKeyColumn, Encoding.Unicode);
							Api.SetColumn(session, reduce, reduceKeyCol, indexName, Encoding.Unicode);
							update.Save();
						}
					}
				}

				tx.Commit(CommitTransactionGrbit.LazyFlush);
				tx.Dispose();
				tx = new Transaction(session);
			}

			using (var details = new Table(session, dbid, "details", OpenTableGrbit.None))
			{
				Api.JetMove(session, details, JET_Move.First, MoveGrbit.None);
				var columnids = Api.GetColumnDictionary(session, details);

				using (var update = new Update(session, details, JET_prep.Replace))
				{
					Api.SetColumn(session, details, columnids["schema_version"], "3.4", Encoding.Unicode);

					update.Save();
				}
			}
			tx.Commit(CommitTransactionGrbit.None);
			tx.Dispose();
		}

        public void Update(Session session, JET_DBID dbid)
        {
            Transaction tx;
            using (tx = new Transaction(session))
            {
                var count = 0;
                const int rowsInTxCount = 100;
                var tablesWithEtags = new[]
                {
                    new {Table = "indexes_stats", Column = "last_indexed_etag"},
                    new {Table = "documents", Column = "etag"},
                    new {Table = "mapped_results", Column = "etag"},
                    new {Table = "files", Column = "etag"},
                    new {Table = "documents_modified_by_transaction", Column = "etag"},
                };
                foreach (var tablesWithEtag in tablesWithEtags)
                {
                    using (var tbl = new Table(session, dbid, tablesWithEtag.Table, OpenTableGrbit.None))
                    {
                        var columnid = Api.GetColumnDictionary(session, tbl)[tablesWithEtag.Column];
                        Api.MoveBeforeFirst(session, tbl);
                        while (Api.TryMoveNext(session, tbl))
                        {
                            using (var update = new Update(session, tbl, JET_prep.Replace))
                            {
                                Api.SetColumn(session, tbl, columnid, Guid.Empty.TransformToValueForEsentSorting());
                                update.Save();
                            }
                            if (count++%rowsInTxCount == 0)
                            {
                                tx.Commit(CommitTransactionGrbit.LazyFlush);
                                tx.Dispose();
                                tx = new Transaction(session);
                            }
                        }
                        tx.Commit(CommitTransactionGrbit.LazyFlush);
                        tx.Dispose();
                        tx = new Transaction(session);
                    }
                }

                using (var details = new Table(session, dbid, "details", OpenTableGrbit.None))
                {
                    Api.JetMove(session, details, JET_Move.First, MoveGrbit.None);
                    var columnids = Api.GetColumnDictionary(session, details);

                    using (var update = new Update(session, details, JET_prep.Replace))
                    {
                        Api.SetColumn(session, details, columnids["schema_version"], "3.2", Encoding.Unicode);

                        update.Save();
                    }
                }
                tx.Commit(CommitTransactionGrbit.None);
                tx.Dispose();
            }
        }

		public DocumentStorageActions(
			JET_INSTANCE instance,
			string database,
			TableColumnsCache tableColumnsCache,
			OrderedPartCollection<AbstractDocumentCodec> documentCodecs,
			IUuidGenerator uuidGenerator,
			IDocumentCacher cacher,
			EsentTransactionContext transactionContext,
			TransactionalStorage transactionalStorage)
		{
			this.tableColumnsCache = tableColumnsCache;
			this.documentCodecs = documentCodecs;
			this.uuidGenerator = uuidGenerator;
			this.cacher = cacher;
			this.transactionalStorage = transactionalStorage;
			this.transactionContext = transactionContext;

			try
			{
				if (transactionContext == null)
				{
					session = new Session(instance);
					transaction = new Transaction(session);
					sessionAndTransactionDisposer = () =>
					{
						if(transaction != null)
							transaction.Dispose();
						if(session != null)
							session.Dispose();
					};
				}
				else
				{
					session = transactionContext.Session;
					transaction = transactionContext.Transaction;
					var disposable = transactionContext.EnterSessionContext();
					sessionAndTransactionDisposer = disposable.Dispose;
				}
				Api.JetOpenDatabase(session, database, null, out dbid, OpenDatabaseGrbit.None);
			}
			catch (Exception ex)
			{
			    logger.WarnException("Error when trying to open a new DocumentStorageActions", ex);
			    try
			    {
			        Dispose();
			    }
			    catch (Exception e)
			    {
			        logger.WarnException("Error on dispose when the ctor threw an exception, resources may have leaked", e);
			    }
				throw;
			}
		}

		public void Update(Session session, JET_DBID dbid)
		{
			Transaction tx;
			using (tx = new Transaction(session))
			{
				using (var tbl = new Table(session, dbid, "indexes_stats", OpenTableGrbit.PermitDDL | OpenTableGrbit.DenyRead|OpenTableGrbit.DenyWrite))
				{
					JET_COLUMNID columnid;
					var defaultValue = BitConverter.GetBytes(0);
					Api.JetAddColumn(session, tbl, "reduce_attempts", new JET_COLUMNDEF
					{
						coltyp = JET_coltyp.Long,
						grbit =
							ColumndefGrbit.ColumnFixed | ColumndefGrbit.ColumnEscrowUpdate | ColumndefGrbit.ColumnNotNULL
					}, defaultValue, defaultValue.Length, out columnid);

					Api.JetAddColumn(session, tbl, "reduce_errors", new JET_COLUMNDEF
					{
						coltyp = JET_coltyp.Long,
						grbit =
							ColumndefGrbit.ColumnFixed | ColumndefGrbit.ColumnEscrowUpdate | ColumndefGrbit.ColumnNotNULL
					}, defaultValue, defaultValue.Length, out columnid);

					Api.JetAddColumn(session, tbl, "reduce_successes", new JET_COLUMNDEF
					{
						coltyp = JET_coltyp.Long,
						grbit =
							ColumndefGrbit.ColumnFixed | ColumndefGrbit.ColumnNotNULL | ColumndefGrbit.ColumnEscrowUpdate
					}, defaultValue, defaultValue.Length, out columnid);
				}
				tx.Commit(CommitTransactionGrbit.LazyFlush);
				tx.Dispose();
				tx = new Transaction(session);
			}

			using (var details = new Table(session, dbid, "details", OpenTableGrbit.None))
			{
				Api.JetMove(session, details, JET_Move.First, MoveGrbit.None);
				var columnids = Api.GetColumnDictionary(session, details);

				using (var update = new Update(session, details, JET_prep.Replace))
				{
					Api.SetColumn(session, details, columnids["schema_version"], "3.3", Encoding.Unicode);

					update.Save();
				}
			}
			tx.Commit(CommitTransactionGrbit.None);
			tx.Dispose();
		}

		public void Update(Session session, JET_DBID dbid)
		{
			Transaction tx;
			using (tx = new Transaction(session))
			{
				CreateIndexingEtagsTable(dbid, session);

				using (var stats = new Table(session, dbid, "indexes_stats",OpenTableGrbit.None))
				using (var reduce = new Table(session, dbid, "indexes_etag", OpenTableGrbit.None))
				{
					var tblKeyColumn = Api.GetColumnDictionary(session, stats)["key"];
					var reduceKeyCol = Api.GetColumnDictionary(session, reduce)["key"];

					Api.MoveBeforeFirst(session, stats);
					while (Api.TryMoveNext(session, stats))
					{
						using(var update = new Update(session, reduce, JET_prep.Insert))
						{
							var indexName = Api.RetrieveColumnAsString(session, stats, tblKeyColumn, Encoding.Unicode);
							Api.SetColumn(session, reduce, reduceKeyCol, indexName, Encoding.Unicode);
							update.Save();
						}
					}
				}

				tx.Commit(CommitTransactionGrbit.LazyFlush);
				tx.Dispose();
				tx = new Transaction(session);
			}

			using (var details = new Table(session, dbid, "details", OpenTableGrbit.None))
			{
				Api.JetMove(session, details, JET_Move.First, MoveGrbit.None);
				var columnids = Api.GetColumnDictionary(session, details);

				using (var update = new Update(session, details, JET_prep.Replace))
				{
					Api.SetColumn(session, details, columnids["schema_version"], "3.6", Encoding.Unicode);

					update.Save();
				}
			}
			tx.Commit(CommitTransactionGrbit.None);
			tx.Dispose();
		}

		public void Update(Session session, JET_DBID dbid)
		{
			Transaction tx;
			using (tx = new Transaction(session))
			{
				int count = 0;
				const int rowsInTxCount = 100;
				using (var files = new Table(session, dbid, "files", OpenTableGrbit.None))
				{
					var columnid = Api.GetColumnDictionary(session, files)["etag"];
					Api.MoveBeforeFirst(session, files);
					while (Api.TryMoveNext(session, files))
					{
						using (var update = new Update(session, files, JET_prep.Replace))
						{
							Api.SetColumn(session, files, columnid, DocumentDatabase.CreateSequentialUuid().TransformToValueForEsentSorting());
							update.Save();
						}
						if (count++ % rowsInTxCount == 0)
						{
							tx.Commit(CommitTransactionGrbit.LazyFlush);
							tx.Dispose();
							tx = new Transaction(session);
						}
					}
					tx.Commit(CommitTransactionGrbit.LazyFlush);
					tx.Dispose();
					tx = new Transaction(session);
				}

				using (var documents = new Table(session, dbid, "documents", OpenTableGrbit.None))
				{
					var columnid = Api.GetColumnDictionary(session, documents)["etag"];
					Api.MoveBeforeFirst(session, documents);
					while (Api.TryMoveNext(session, documents))
					{
						using (var update = new Update(session, documents, JET_prep.Replace))
						{
							Api.SetColumn(session, documents, columnid, DocumentDatabase.CreateSequentialUuid().TransformToValueForEsentSorting());
							update.Save();
						}
						if (count++ % rowsInTxCount == 0)
						{
							tx.Commit(CommitTransactionGrbit.LazyFlush);
							tx.Dispose();
							tx = new Transaction(session);
						}
					}
					tx.Commit(CommitTransactionGrbit.LazyFlush);
					tx.Dispose();
					tx = new Transaction(session);
				}

				using (var indexesStats = new Table(session, dbid, "indexes_stats", OpenTableGrbit.None))
				{
					var columnid = Api.GetColumnDictionary(session, indexesStats)["last_indexed_etag"];
					Api.MoveBeforeFirst(session, indexesStats);
					while (Api.TryMoveNext(session, indexesStats))
					{
						using (var update = new Update(session, indexesStats, JET_prep.Replace))
						{
							Api.SetColumn(session, indexesStats, columnid, Guid.Empty.TransformToValueForEsentSorting());
							update.Save();
						}
						if (count++ % rowsInTxCount == 0)
						{
							tx.Commit(CommitTransactionGrbit.LazyFlush);
							tx.Dispose();
							tx = new Transaction(session);
						}
					}
					tx.Commit(CommitTransactionGrbit.LazyFlush);
					tx.Dispose();
					tx = new Transaction(session);
				}

				using (var documentsModifiedByTransaction = new Table(session, dbid, "documents_modified_by_transaction", OpenTableGrbit.None))
				{
					var columnid = Api.GetColumnDictionary(session, documentsModifiedByTransaction)["etag"];
					Api.MoveBeforeFirst(session, documentsModifiedByTransaction);
					while (Api.TryMoveNext(session, documentsModifiedByTransaction))
					{
						using (var update = new Update(session, documentsModifiedByTransaction, JET_prep.Replace))
						{
							Api.SetColumn(session, documentsModifiedByTransaction, columnid, DocumentDatabase.CreateSequentialUuid().TransformToValueForEsentSorting());
							update.Save();
						}
						if (count++ % rowsInTxCount == 0)
						{
							tx.Commit(CommitTransactionGrbit.LazyFlush);
							tx.Dispose();
							tx = new Transaction(session);
						}
					}
					tx.Commit(CommitTransactionGrbit.LazyFlush);
					tx.Dispose();
					tx = new Transaction(session);

				}

//.........这里部分代码省略.........

  public void TestPropertyThrowsExceptionWhenDisposed()
  {
      var transaction = new Transaction(this.sesid);
      transaction.Dispose();
      bool x = transaction.IsInTransaction;
 }

 public void TestRollbackThrowsExceptionWhenDisposed()
 {
     var transaction = new Transaction(this.sesid);
     transaction.Dispose();
     transaction.Rollback();
 }

 public void TestCommitThrowsExceptionWhenDisposed()
 {
     var transaction = new Transaction(this.sesid);
     transaction.Dispose();
     transaction.Commit(CommitTransactionGrbit.None);
 }

 public void TestBeginThrowsExceptionWhenDisposed()
 {
     var transaction = new Transaction(this.sesid);
     transaction.Dispose();
     transaction.Begin();
 }

 public long ReAddAllLogsToIndex(JET_SESID session, IndexTableSchema idxSchema)
 {
     var ret = 0L;
     Transaction tran = new Transaction(session);
     try
     {
         var tranCount = 0;
         Api.MoveBeforeFirst(session, logTable);
         while (Api.TryMoveNext(session, logTable))
         {
             var curLogId = (long)Api.RetrieveColumnAsInt64(session, logTable, colID_ID);
             idxSchema.InsertIndexRow(session, tran, curLogId);
             tranCount++;
             ret++;
             if (tranCount >= 50)
             {
                 tran.Commit(CommitTransactionGrbit.LazyFlush);
                 tran.Dispose();
                 tran = new Transaction(session);
             }
         }
         tran.Commit(CommitTransactionGrbit.LazyFlush);
     }
     finally
     {
         tran.Dispose();
     }
     return ret;
 }

		public void Update(Session session, JET_DBID dbid)
		{
			Transaction tx;
			using (tx = new Transaction(session))
			{
                using (var tbl = new Table(session, dbid, "indexes_stats_reduce",
					OpenTableGrbit.PermitDDL | OpenTableGrbit.DenyRead | OpenTableGrbit.DenyWrite))
				{
				    JET_COLUMNID columnid;
				    Api.JetAddColumn(session, tbl, "last_reduced_etag", new JET_COLUMNDEF
                    {
                        coltyp = JET_coltyp.Binary,
                        cbMax = 16,
                        grbit = ColumndefGrbit.ColumnFixed
                    }, null, 0, out columnid);


                    Api.JetAddColumn(session, tbl, "last_reduced_timestamp", new JET_COLUMNDEF
                    {
                        coltyp = JET_coltyp.DateTime,
                        grbit = ColumndefGrbit.ColumnFixed
                    }, null, 0, out columnid);
				}

				tx.Commit(CommitTransactionGrbit.LazyFlush);
				tx.Dispose();
				tx = new Transaction(session);
			}

            using (var tbl = new Table(session, dbid, "mapped_results",
                    OpenTableGrbit.PermitDDL | OpenTableGrbit.DenyRead | OpenTableGrbit.DenyWrite))
            {
                JET_COLUMNID columnid;
                Api.JetAddColumn(session, tbl, "timestamp", new JET_COLUMNDEF
                {
                    coltyp = JET_coltyp.DateTime,
                    grbit = ColumndefGrbit.ColumnFixed
                }, null, 0, out columnid);
                const string indexDef = "+view\0-etag\0\0";
                Api.JetCreateIndex(session, tbl, "by_view_and_etag", CreateIndexGrbit.IndexDisallowNull, indexDef, indexDef.Length,
                                   100);

            }

            using (var mappedResults = new Table(session, dbid, "mapped_results", OpenTableGrbit.None))
            {
                var tblKeyColumn = Api.GetColumnDictionary(session, mappedResults);

                Api.MoveBeforeFirst(session, mappedResults);
                while (Api.TryMoveNext(session, mappedResults))
                {
                    using (var update = new Update(session, mappedResults, JET_prep.Replace))
                    {
                        Api.SetColumn(session, mappedResults, tblKeyColumn["timestamp"], DateTime.Now);
                        update.Save();
                    }
                }
            }

			using (var details = new Table(session, dbid, "details", OpenTableGrbit.None))
			{
				Api.JetMove(session, details, JET_Move.First, MoveGrbit.None);
				var columnids = Api.GetColumnDictionary(session, details);

				using (var update = new Update(session, details, JET_prep.Replace))
				{
					Api.SetColumn(session, details, columnids["schema_version"], "3.5", Encoding.Unicode);

					update.Save();
				}
			}
			tx.Commit(CommitTransactionGrbit.None);
			tx.Dispose();
		}