public void ProcessData(int employeeId) { // There is not much processing logic here... // We are assuming that the organization has 50 employees with sequential Employee Ids // If the employeeId > 50, we are sending an Http Status code of 500 (Internal Server Error) back to the client // else, we assume that the processing is successful and send an Http Status code of 200 (Successfull) ReceiveContext receiveContext; if (!ReceiveContext.TryGet(OperationContext.Current.IncomingMessageProperties, out receiveContext)) { Console.WriteLine("ReceiveContext property was not found in the message..."); return; } if (employeeId > 50) { // Abandon receiveContext.Abandon(TimeSpan.MaxValue); } else { // Complete in Transaction block. CommittableTransaction committableTransaction = new CommittableTransaction(); Transaction.Current = committableTransaction; try { receiveContext.Complete(TimeSpan.MaxValue); committableTransaction.Commit(); } catch { committableTransaction.Rollback(); // If the transaction was not completed we call Abandon explicitly which sends an Http 500 to the client receiveContext.Abandon(TimeSpan.MaxValue); } } }
public void ExplicitTransaction6 () { ExceptionAssert.Throws<InvalidOperationException>( delegate { CommittableTransaction ct = new CommittableTransaction(); IntResourceManager irm = new IntResourceManager(1); irm.Value = 2; ct.Commit(); ct.Commit(); }); }
public void EnlistmentCounts_CommittableTransaction() { var newGuid = Guid.NewGuid(); for (int i = 0; i < 5; i++) { using (var tx = new CommittableTransaction(new TransactionOptions() { IsolationLevel = IsolationLevel.ReadCommitted })) using (new TxScope(tx, NullLogger.Instance)) // set ambient also! { System.Transactions.Transaction.Current.EnlistDurable(newGuid, new EnlistmentTracking(), EnlistmentOptions.None); System.Transactions.Transaction.Current.EnlistDurable(newGuid, new EnlistmentTracking(), EnlistmentOptions.None); tx.Commit(); } Assert.That(EnlistmentTracking.EnlistmentCounts, Is.EqualTo(0).Or.EqualTo(1).Or.EqualTo(2)); } }
public void Vol2_Dur1_Fail5 () { CommittableTransaction ct = new CommittableTransaction (); IntResourceManager [] irm = new IntResourceManager [2]; irm [0] = new IntResourceManager ( 1 ); irm [1] = new IntResourceManager ( 3 ); Transaction.Current = ct; irm [0].Type = ResourceManagerType.Durable; irm [0].FailSPC = true; irm [0].FailWithException = true; for ( int i = 0; i < 2; i++ ) irm [i].UseSingle = true; /* Durable RM irm[2] does on SPC, so * all volatile RMs get Rollback */ using ( TransactionScope scope = new TransactionScope () ) { irm [0].Value = 2; irm [1].Value = 6; scope.Complete (); } try { ct.Commit (); } catch ( TransactionAbortedException e ) { Assert.IsNotNull ( e.InnerException, "Expected e.InnerException == NotSupportedException, but got None" ); Assert.AreEqual ( typeof ( NotSupportedException ), e.InnerException.GetType (), "Expected e.InnerException == NotSupportedException, but got " + e.GetType () ); irm [0].Check ( 1, 0, 0, 0, 0, 0, 0, "irm [0]" ); irm [1].Check ( 0, 1, 0, 1, 0, 0, 0, "irm [1]" ); try { ct.Commit (); } catch (InvalidOperationException x ) { Assert.IsNull ( x.InnerException); Transaction.Current = null; return; } Assert.Fail ( "Should not be reached" ); } Assert.Fail ( "Expected TransactionAbortedException" ); }
public void RetryOnFailure() { using (var t = new CommittableTransaction()) using (new TxScope(t, NullLogger.Instance)) { t.EnlistVolatile(new ThrowingResource(true), EnlistmentOptions.EnlistDuringPrepareRequired); using (var c = GetConnection()) using (var cmd = c.CreateCommand()) { cmd.CommandText = "SELECT TOP 1 Val FROM Thing"; var scalar = (double)cmd.ExecuteScalar(); Console.WriteLine("got val {0}", scalar); } try { t.Commit(); Assert.Fail("first commit should fail"); } catch (ApplicationException) { Assert.That(t.TransactionInformation.Status, Is.EqualTo(TransactionStatus.Committed)); } } }
private void button84_Click(object sender, EventArgs e) { CommittableTransaction tx = null; try { using (tx = new CommittableTransaction()) { using (SqlConnection conn1 = new SqlConnection(Properties.Settings.Default.NorthwindConnectionString)) { using (SqlCommand myCommand = new SqlCommand()) { myCommand.Connection = conn1; conn1.Open(); conn1.EnlistTransaction(tx); //Restore database to near it's original condition so sample will work correctly. myCommand.CommandText = "DELETE FROM Region WHERE (RegionID = 100) OR (RegionID = 101)"; myCommand.ExecuteNonQuery(); //Insert the first record. myCommand.CommandText = "Insert into Region (RegionID, RegionDescription) VALUES (100, 'MidWestern')"; myCommand.ExecuteNonQuery(); //測試交易失敗用 //Insert the first record. myCommand.CommandText = "Insert into Region (RegionID, RegionDescription) VALUES (100, 'MidWestern')"; myCommand.ExecuteNonQuery(); //Insert the second record. myCommand.CommandText = "Insert into Region (RegionID, RegionDescription) VALUES (101, 'MidEastern')"; myCommand.ExecuteNonQuery(); tx.Commit(); MessageBox.Show("trans. Successfully"); } } } } catch (TransactionException ex) { MessageBox.Show(ex.Message); tx.Rollback(); } catch (Exception ex) { MessageBox.Show("trans. roll back " + ex.Message); } }
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; }
public void ExplicitTransaction2 () { Assert.IsNull (Transaction.Current, "Ambient transaction exists (before)"); CommittableTransaction ct = new CommittableTransaction (); Transaction oldTransaction = Transaction.Current; Transaction.Current = ct; IntResourceManager irm = new IntResourceManager (1); irm.Value = 2; using (TransactionScope scope = new TransactionScope ()) { Assert.AreEqual (ct, Transaction.Current, "#44"); /* Not calling scope.Complete scope.Complete ();*/ } Assert.AreEqual (TransactionStatus.Aborted, ct.TransactionInformation.Status, "#45"); Assert.AreEqual (ct, Transaction.Current, "#46"); Assert.AreEqual (1, irm.Actual, "#47"); Assert.AreEqual (1, irm.NumRollback, "#48"); irm.Check ( 0, 0, 1, 0, "irm" ); Transaction.Current = oldTransaction; try { ct.Commit (); } catch (TransactionAbortedException) { return; } Assert.Fail ("Commit on an aborted transaction should fail"); }
public void ExplicitTransaction3 () { Assert.IsNull (Transaction.Current, "Ambient transaction exists (before)"); CommittableTransaction ct = new CommittableTransaction (); Transaction oldTransaction = Transaction.Current; Transaction.Current = ct; IntResourceManager irm = new IntResourceManager (1); using (TransactionScope scope = new TransactionScope (TransactionScopeOption.RequiresNew)) { Assert.IsTrue (ct != Transaction.Current, "Scope with RequiresNew should have a new ambient transaction"); irm.Value = 3; scope.Complete (); } irm.Value = 2; Assert.AreEqual (3, irm.Actual, "#50"); Assert.AreEqual (ct, Transaction.Current, "#51"); ct.Commit (); Assert.AreEqual (2, irm.Actual, "#52"); Transaction.Current = oldTransaction; }
public void ExplicitTransactionCommit () { Assert.IsNull (Transaction.Current, "Ambient transaction exists (before)"); CommittableTransaction ct = new CommittableTransaction (); Transaction oldTransaction = Transaction.Current; Transaction.Current = ct; IntResourceManager irm = new IntResourceManager (1); irm.Value = 2; ct.Commit (); Assert.AreEqual (2, irm.Value, "#33"); Assert.AreEqual (TransactionStatus.Committed, ct.TransactionInformation.Status, "#34"); Transaction.Current = oldTransaction; }
public void ExplicitTransaction1 () { Assert.IsNull (Transaction.Current, "Ambient transaction exists (before)"); CommittableTransaction ct = new CommittableTransaction (); Transaction oldTransaction = Transaction.Current; Transaction.Current = ct; IntResourceManager irm = new IntResourceManager (1); irm.Value = 2; using (TransactionScope scope = new TransactionScope ()) { Assert.AreEqual (ct, Transaction.Current, "#38"); irm.Value = 4; scope.Complete (); } Assert.AreEqual (ct, Transaction.Current, "#39"); Assert.AreEqual (TransactionStatus.Active, Transaction.Current.TransactionInformation.Status, "#40"); Assert.AreEqual (1, irm.Actual, "#41"); /* Actual value */ ct.Commit (); Assert.AreEqual (4, irm.Actual, "#42"); /* New committed actual value */ Assert.AreEqual (TransactionStatus.Committed, Transaction.Current.TransactionInformation.Status, "#43"); Transaction.Current = oldTransaction; }
public void ExplicitTransaction16 () { CommittableTransaction ct = new CommittableTransaction (); IntResourceManager irm0 = new IntResourceManager ( 3 ); IntResourceManager irm = new IntResourceManager ( 1 ); Assert.IsNull ( Transaction.Current ); Transaction.Current = ct; irm.FailPrepare = true; irm.FailWithException = true; irm.Value = 2; irm0.Value = 6; try { ct.Commit (); } catch (TransactionAbortedException e) { Assert.IsNotNull ( e.InnerException, "Expected an InnerException of type NotSupportedException" ); Assert.AreEqual ( typeof (NotSupportedException), e.InnerException.GetType (), "Inner exception should be NotSupportedException" ); irm.Check ( 1, 0, 0, 0, "irm" ); irm0.Check ( 0, 0, 1, 0, "irm0" ); Transaction.Current = null; return; } Assert.Fail ( "Should not be reached" ); }
public void Learn(Stream words) { var wordStream = new WordStream(words); LinkedList<string> wordHistory = new LinkedList<string>(); for (int i = 0; i < 4; i++) { wordHistory.AddLast(String.Empty); } foreach (var word in wordStream) { using (var transaction = new CommittableTransaction()) { wordHistory.RemoveFirst(); wordHistory.AddLast(word); HandleWord(word); HandleTwoGram(wordHistory.AsEnumerable().Skip(2).Take(2).ToList()); var gram = HandleThreeGram(wordHistory.AsEnumerable().Skip(1).Take(3).ToList()); HandleFourGram(wordHistory.AsEnumerable().ToList(), gram); context.SaveChanges(); transaction.Commit(); } } }
public void ExplicitTransaction6a () { ExceptionAssert.Throws<InvalidOperationException>( delegate { CommittableTransaction ct = new CommittableTransaction(); IntResourceManager irm = new IntResourceManager(1); irm.Value = 2; ct.Commit(); /* Using a already committed transaction in a new * TransactionScope */ TransactionScope scope = new TransactionScope(ct); }); }
public void ExplicitTransaction13 () { CommittableTransaction ct = new CommittableTransaction (); IntResourceManager irm = new IntResourceManager ( 1 ); Assert.IsNull ( Transaction.Current ); Transaction.Current = ct; irm.Value = 2; irm.FailPrepare = true; try { ct.Commit (); } catch ( TransactionAbortedException ) { Assert.AreEqual ( TransactionStatus.Aborted, ct.TransactionInformation.Status ); try { ct.BeginCommit ( null, null ); } catch (Exception) { Transaction.Current = null; return; } Assert.Fail ( "Should not be reached(2)" ); } Assert.Fail ("Should not be reached"); }
public void ExplicitTransaction4 () { Assert.IsNull (Transaction.Current, "Ambient transaction exists (before)"); CommittableTransaction ct = new CommittableTransaction (); Transaction oldTransaction = Transaction.Current; /* Not setting ambient transaction Transaction.Current = ct; */ IntResourceManager irm = new IntResourceManager (1); using (TransactionScope scope = new TransactionScope (ct)) { Assert.AreEqual (ct, Transaction.Current, "#53"); irm.Value = 2; scope.Complete (); } Assert.AreEqual (oldTransaction, Transaction.Current, "#54"); Assert.AreEqual (TransactionStatus.Active, ct.TransactionInformation.Status, "#55"); Assert.AreEqual (1, irm.Actual, "#56"); /* Actual value */ ct.Commit (); Assert.AreEqual (2, irm.Actual, "#57"); /* New committed actual value */ Assert.AreEqual (TransactionStatus.Committed, ct.TransactionInformation.Status, "#58"); irm.Check ( 1, 1, 0, 0, "irm"); }
private static byte[] CreateFixedPropagationToken() { if (fixedPropagationToken == null) { CommittableTransaction transaction = new CommittableTransaction(); byte[] transmitterPropagationToken = TransactionInterop.GetTransmitterPropagationToken(transaction); try { transaction.Commit(); } catch (TransactionException exception) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Information); } Interlocked.CompareExchange<byte[]>(ref fixedPropagationToken, transmitterPropagationToken, null); } byte[] destinationArray = new byte[fixedPropagationToken.Length]; Array.Copy(fixedPropagationToken, destinationArray, fixedPropagationToken.Length); return destinationArray; }
public void ExplicitTransaction6 () { CommittableTransaction ct = new CommittableTransaction (); IntResourceManager irm = new IntResourceManager (1); irm.Value = 2; ct.Commit (); ct.Commit (); }
public override int Update(DataTable dt, string fname, DataColumnCollection colinfo, params string[] ignoreFields) { /* UPDATE Managers 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 ExplicitTransaction6a () { CommittableTransaction ct = new CommittableTransaction (); IntResourceManager irm = new IntResourceManager ( 1 ); irm.Value = 2; ct.Commit (); /* Using a already committed transaction in a new * TransactionScope */ TransactionScope scope = new TransactionScope ( ct ); }
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; }
public void ExplicitTransaction6b () { CommittableTransaction ct = new CommittableTransaction (); IntResourceManager irm = new IntResourceManager ( 1 ); Transaction.Current = ct; TransactionScope scope1 = new TransactionScope (); /* Enlist */ irm.Value = 2; scope1.Complete (); try { ct.Commit (); } catch (TransactionAbortedException) { irm.Check ( 0, 0, 1, 0, "irm" ); scope1.Dispose (); Transaction.Current = null; return; } Assert.Fail ( "Commit should've failed" ); }
public void ExplicitTransactionWithDependentTransaction() { using (var t = new CommittableTransaction()) using (new TxScope(t, NullLogger.Instance)) { Console.WriteLine("T1 STATUS: {0}", t.TransactionInformation.Status); using (var c = GetConnection()) using (var cmd = c.CreateCommand()) { cmd.CommandText = "SELECT TOP 1 Val FROM Thing"; var scalar = (double)cmd.ExecuteScalar(); Console.WriteLine("T1 STATUS: {0}", t.TransactionInformation.Status); Console.WriteLine("got val {0}, disposing command and connection", scalar); } using (var t2 = t.DependentClone(DependentCloneOption.RollbackIfNotComplete)) using (new TxScope(t2, NullLogger.Instance)) using (var c = GetConnection()) using (var cmd = c.CreateCommand()) { t2.TransactionCompleted += (s, ea) => Console.WriteLine("::: T2 TransactionCompleted: {0}", ea.Transaction.TransactionInformation.LocalIdentifier); cmd.CommandText = "DELETE FROM Thing"; Console.WriteLine("T2: EXECUTING NON QUERY"); cmd.ExecuteNonQuery(); Console.WriteLine("T2: Enlisting volatile"); t2.EnlistVolatile(new VolatileResource(false), EnlistmentOptions.None); Console.WriteLine("T2: COMPLETE-CALL"); t2.Complete(); Console.WriteLine("T2 STATUS: {0}", t2.TransactionInformation.Status); } Console.WriteLine("T1: COMMITTING, status: {0}", t.TransactionInformation.Status); try { t.Commit(); } catch (TransactionAbortedException e) { Console.WriteLine("TransactionAbortedException, {0}", e); t.Rollback(e); } Console.WriteLine("T1 STATUS: {0}", t.TransactionInformation.Status); Console.WriteLine("T1: DISPOSING"); } }
public void ExplicitTransaction7 () { CommittableTransaction ct = new CommittableTransaction (); IntResourceManager irm = new IntResourceManager (1); irm.Value = 2; ct.Commit (); /* Cannot accept any new work now, so TransactionException */ ct.Rollback (); }
public void ExplicitTransaction() { using (var t = new CommittableTransaction()) using (new TxScope(t, NullLogger.Instance)) { using (var c = GetConnection()) using (var cmd = c.CreateCommand()) { cmd.CommandText = "SELECT TOP 1 Val FROM Thing"; var scalar = (double)cmd.ExecuteScalar(); Console.WriteLine("got val {0}", scalar); } Console.WriteLine("COMMITTING"); t.Commit(); Console.WriteLine("DISPOSING"); } }
public void ExplicitTransaction8a () { CommittableTransaction ct = new CommittableTransaction (); IntResourceManager irm = new IntResourceManager ( 1 ); using ( TransactionScope scope = new TransactionScope ( ct ) ) { irm.Value = 2; scope.Complete (); /* FIXME: Why TransactionAbortedException ?? */ try { ct.Commit (); } catch ( TransactionAbortedException) { irm.Check ( 0, 0, 1, 0, "irm" ); return; } Assert.Fail ( "Should not be reached" ); } }
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); }
public void ExplicitTransaction10a () { CommittableTransaction ct = new CommittableTransaction (); IntResourceManager irm = new IntResourceManager ( 1 ); Transaction.Current = ct; irm.Value = 2; Transaction.Current = null; TransactionScope scope = new TransactionScope ( ct ); Assert.AreEqual ( ct, Transaction.Current, "ambient transaction" ); Transaction.Current = null; //scope2.Complete (); //scope2.Dispose (); try { ct.Commit (); } catch ( TransactionAbortedException) { irm.Check ( 0, 0, 1, 0, "irm" ); Transaction.Current = null; return; } Transaction.Current = null; Assert.Fail (); }
public void IfOneWorks_AndOneFails_FirstShouldRollback() { var newGuid = Guid.NewGuid(); for (int i = 0; i < 5; i++) { using (var tx = new CommittableTransaction(new TransactionOptions() { IsolationLevel = IsolationLevel.ReadCommitted })) using (new TxScope(tx, NullLogger.Instance)) // set ambient also! { var first = new AnotherEnlistment(false); System.Transactions.Transaction.Current.EnlistDurable(newGuid, first, EnlistmentOptions.None); var second = new AnotherEnlistment(true); System.Transactions.Transaction.Current.EnlistDurable(newGuid, second, EnlistmentOptions.None); try { tx.Commit(); Assert.Fail("we have a failing resource"); } catch (TransactionAbortedException) { Assert.That(second.RolledBack, Is.False); first.HasRolledBack.WaitOne(); Assert.That(first.RolledBack, Is.True); } } } }
private void ExecutePolling() { string dataAvailableStatement = Connection.ConnectionFactory.Adapter.DataAvailableStatement; string getDataStatement = Connection.ConnectionFactory.Adapter.GetDataStatement; string endOperationStatement = Connection.ConnectionFactory.Adapter.EndOperationStatement; bool dataAvailable = true; if (!string.IsNullOrWhiteSpace(dataAvailableStatement)) { using (var connection = Connection.CreateDbConnection()) { connection.Open(); var dataAvailableCommand = connection.CreateCommand(); dataAvailableCommand.CommandText = dataAvailableStatement; int? count = dataAvailableCommand.ExecuteScalar() as int?; dataAvailable = count.HasValue && (count > 0); } } if (dataAvailable) { bool goOn = Connection.ConnectionFactory.Adapter.PollWhileDataFound; do { if (queue.IsAddingCompleted) return; var connection = Connection.CreateDbConnection(); connection.Open(); var transaction = new CommittableTransaction(new TransactionOptions { IsolationLevel = Connection.ConnectionFactory.Adapter.IsolationLevel }); connection.EnlistTransaction(transaction); var getDataCommand = connection.CreateCommand(); getDataCommand.CommandText = getDataStatement; using (var reader = getDataCommand.ExecuteReader()) { if (reader.HasRows) { queue.Add(new MessageItem { Message = DbHelpers.CreateMessage(reader, Connection.ConnectionFactory.Adapter.UseAmbientTransaction ? transaction : null, action), Connection = connection, Transaction = transaction, EndOperationStatement = endOperationStatement }); } else { transaction.Commit(); connection.Close(); goOn = false; } } } while (goOn); } }