We Keep Coding

Transaction management using TransactionScope ()

I need to create a simple dotnet application which is going to call a stored procedure inside a loop (the stored procedure accepts few parameters and add them to a table). The requirement is that either all the rows get inserted or non.
To ensure this I've used:
using (TransactionScope scope = new TransactionScope())
{
foreach (EditedRule editedRules in request.EditedRules)
{
...stored procedure call
}
}
I've never used TransactionScope before, can someone please let me know if this code will work and will all my rows be rolled back.
I would also appreciate if there is a better approach to this.

Assuming that your stored procedure does not create and commit its own transaction, this code will work, with one change: your code needs to code scope.Complete() before the end of the using block; otherwise, the transaction is going to roll back.
using (TransactionScope scope = new TransactionScope()) {
foreach (EditedRule editedRules in request.EditedRules) {
...stored procedure call
}
scope.Complete(); // <<== Add this line
}
The idea behind this construct is that the call of Complete will happen only if the block exits normally, i.e. there's no exception in processing the loop. If an exception is thrown, scope would detect it, and cause the transaction to roll back.

The only thing I would call out about your code is to make sure to do a scope.Complete() in order to commit the transaction:
using (TransactionScope scope = new TransactionScope())
{
foreach (EditedRule editedRules in request.EditedRules)
{
// stored proc
}
scope.Complete();
}
if any exceptions occur during the using block, the transaction would be rolled back.

I think this is what you're looking for:
using (var transaction = conn.BeginTransaction()) {
try
{
transaction.Commit();
}
catch
{
transaction.Rollback();
throw;
}
}

How to implement Transaction?

I am working on sql, my query is that i have some methods in which i am doing different-different tasks. for example:-
1st method - Inserting
2nd method - Updation
3rd method - deletion
4th methos - Inserting
now i want to execute all these in once. but if somehow any error occur then the whole process roll back it self.
code :
private void btnSubmit_Click(object sender, EventArgs e)
{
DialogResult dr = MessageBox.Show("Are you sure you want to submit the information? Click 'Yes' to Submit or 'No' to re-Check.", "eParty - Confirmation", MessageBoxButtons.YesNo, MessageBoxIcon.Information);
if (dr == DialogResult.Yes)
{
this.Cursor = Cursors.WaitCursor;
INSERT();
UPDATE();
DELETE();
INSERTAGAIN();
MessageBox.Show("Booked successfully.", "eParty - Done!", MessageBoxButtons.OK, MessageBoxIcon.Information);
this.Cursor = Cursors.Default;
this.Cursor = Cursors.WaitCursor;
this.Close();
}
else
{
}
}
now how to implement Transaction at 'btnSubmit_Click' method...

Try this:
using(var scope = new TransactionScope())
{
INSERT();
UPDATE();
DELETE();
INSERTAGAIN();
scope.Complete(); //if we make it here - commit the changes,
//if not - everything is rolled back
}
remember to include System.Transactions to you project

It depends on what db access technology you have.
If you use Entity Framework, SaveChanges() method already has transaction support.
In case of pure ADO.NET please see this https://stackoverflow.com/a/224702/210994

You can use ADO transactions and send your transaction as a param to all your methods
SqlConnection db = new SqlConnection("connstringhere");
SqlTransaction transaction;
db.Open();
transaction = db.BeginTransaction();
try
{
INSERT(transaction);
UPDATE(transaction);
DELETE(transaction);
INSERT(transaction);
transaction.Commit();
}
catch (SqlException sqlError)
{
transaction.Rollback();
}

Typically something like:
void DoStuff(args)
{
using (var conn = CreateOpenConnection())
using (var tran = conn.BeginTransaction())
{
try
{
// various operations here
ForExample(conn, tran);
tran.Commit();
}
catch
{
tran.Rollback();
throw;
}
}
}
void ForExample(DbConnection conn, DbTransaction tran = null)
{
using (var cmd = conn.CreateCommand())
{
cmd.Transaction = tran;
cmd.CommandText = "For example";
// cmd.Parameters.Add(...)
cmd.ExecuteNonQuery();
}
}
Although most of this can be reduced using any of the tools / libraries that are available that sit above raw ADO.NET.

You can use .Net's TransactionScope class to achieve this.
http://msdn.microsoft.com/en-us/library/system.transactions.transactionscope.aspx
You can choose Isolation level's as per need. If you are not sure, please use the Serializable level which is the most consistent and least performant. But if your sql stored procedures have isolation levels, they will gain precedence. If this is a critical design please read about transactions before proceeding.

Maybe you should create one stored procedure and based on a parameter execute your CRUD operations. For example:
BEGIN TRANSACTION
IF(#PartyID <= 0)
BEGIN
//INSERT
IF ##ERROR <> 0
BEGIN
ROLLBACK TRANSACTION
RETURN
END
END
ELSE
BEGIN
//UPDATE
IF ##ERROR <> 0
BEGIN
ROLLBACK TRANSACTION
RETURN
END
END

Please refer to this topic: Implementing an Implicit Transaction using Transaction Scope.
The TransactionScope class provides a simple way to mark a block of
code as participating in a transaction, without requiring you to
interact with the transaction itself. A transaction scope can select
and manage the ambient transaction automatically. Due to its ease of
use and efficiency, it is recommended that you use the
TransactionScope class when developing a transaction application. In
addition, you do not need to enlist resources explicitly with the
transaction. Any System.Transactions resource manager (such as SQL
Server 2005) can detect the existence of an ambient transaction
created by the scope and automatically enlist.
I would also like to recommend you to read this question and it's answers. It touches interesting topics about using transactions over multiple connections.

Does TransactionScope work with pre-existing connections?

I have a code like this:
try
{
using (TransactionScope scope = new TransactionScope())
{
some_db_function();
for (i = 0; i < 10; i++)
{
some_other_db_function();
}
scope.Complete();
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message + " all done transactions will rollback");
}
and inside the db functions something like this happens:
private void some_db_functions()
{
using (TransactionScope scope = new TransactionScope())
{
//some processing on db
scope.Complete();
}
}
It is supposed to be that if there was any problem in the database transactions, like an error inserting or updating in the functions; all the transactions that had been done so far get rolled back. But it does not work like that; and although it throws an exception and the scope.Complete() in the parent function never gets triggered, still nothing get rolled back.
Where is the problem?

If the open connection already exists it will not automatically enlist in an ambient transaction. You would have to set it explicitly.
Implicitly enlisting connections is not supported. To enlist in a
transaction scope, you can do the following:
Open a connection in a transaction scope.
Or, if the connection is already opened, call EnlistTransaction method
on the connection object.
Ref.
This will enlist an existing connection:
connection.EnlistTransaction(Transaction.Current)

IIRC, automatic enlisting into ambient transactions happens at connection creation/opening time; if you create the connection inside the scope of the transaction, all should be good. However:
they are all using the same connection, declared previously
if the connection exists outside of the transaction, it won't enlist.
Best practice is to create/open a connection only around a unit of work, not forever (and: let connection pooling do its job). If you follow that practice, it should work fine. So:
This won't work:
using(var conn = CreateAndOpenConnection()) {
// ...
using(var tran = new TransactionScope()) {
SomeOperations(conn);
tran.Complete();
}
// ...
}
where-as this should work:
using(var tran = new TransactionScope()) {
// ...
using(var conn = CreateAndOpenConnection()) {
SomeOperations(conn);
}
tran.Complete();
// ...
}

SqlCommand.Dispose() before SqlTransaction.Commit()?

would it work to dispose a command assigned to a transaction before the transaction is committed? I tested the following code myself, and it seems to have worked fine, but this is a rather small example, so I'm looking for confirmation if someone positively knows.
internal static void TestTransaction()
{
try
{
Program.dbConnection.Open();
using (SqlTransaction transaction = Program.dbConnection.BeginTransaction())
{
Boolean doRollback = false;
for (int i = 0; i < 10; i++)
{
using (SqlCommand cmd = new SqlCommand("INSERT INTO [testdb].[dbo].[transactiontest] (testvalcol) VALUES (#index)", Program.dbConnection, transaction))
{
cmd.Parameters.AddWithValue("#index", i);
try
{
cmd.ExecuteNonQuery();
}
catch (SqlException)
{
doRollback = true;
break;
}
}
}
if (doRollback)
transaction.Rollback();
else
transaction.Commit();
}
}
finally
{
Program.dbConnection.Close();
}
}

The connection, transaction and command objects are just vehicles to send commands to a database. Once a command is executed the database has received it. Whatever you do with the command object afterwards, dispose it, burn it, or shoot it to the moon, this fact does not change. (It can only be rolled back).
You can create and dispose as many commands as you like within the scope of one SqlConnection (with or without SqlTransaction). And you can start and dispose as many transactions as you like within one SqlConnection. To demonstrate this, see:
using (var conn = new SqlConnection(#"server=(local)\sql2008;database=Junk;Integrated Security=SSPI"))
{
conn.Open();
// Repeat this block as often as you like...
using (var tran = conn.BeginTransaction())
{
using (var cmd = new SqlCommand("INSERT INTO Mess VALUES ('mess1')", conn, tran))
{
cmd.ExecuteNonQuery(); // Shows in Sql profiler
}
tran.Commit(); // Commits
}
using (var cmd = new SqlCommand("INSERT INTO Mess VALUES ('mess2')", conn))
{
cmd.ExecuteNonQuery(); // Executes and commits (implicit transaction).
}
}
Of course, for healthy code you need to dispose of all objects in the correct order. Disposing a command after disposing a SqlConnection may cause the connection object to stay in memory.

Yes, it's probably safe. The using() is closing the Command, not the Connection.
But you should put that Connection in another using() block or in a try/finally construct.

Confirmed, this works very well and (at least here at our company) is even considered the correct approach.
create connection
create transaction
create command(s), use the transaction, execute
dispose command(s)
commit transaction
dispose connection

How to use transactions with a datacontext

Can I use transactions with a datacontext, so that I can rollback the state of the context after an error? And if so, how does that work?

I use them in testing all the time :)
try
{
dc.Connection.Open();
dc.Transaction = dc.Connection.BeginTransaction();
dc.SubmitChanges();
}
finally
{
dc.Transaction.Rollback();
}
UPDATE
This will ALWAYS rollback after the fact. I use this in testing.

A DataContext will pick up an ambient transaction by default, so it is just a matter of ensuring there is a Transaction in scope. The details become the main issue:
What options do you need (e.g. isolation level)
Do you want a new transaction or reuse an existing transaction (e.g. an audit/logging operation might require a new transaction so it can be committed even if the overall business operation fails and thus the outer transaction is rolled back).
This is simplified some prototype code, the real code uses helpers to create the transactions with policy driven options (one of the purposes of the prototype was to examine the impact of these options).
using (var trans = new TransactionScope(
TransactionScopeOption.Required,
new TransactionOptions {
IsolationLevel = IsolationLevel.ReadCommitted
},
EnterpriseServicesInteropOption.Automatic)) {
// Perform operations using your DC, including submitting changes
if (allOK) {
trans.Complete();
}
}
If Complete() is not called then the transaction will be rolled back. If there is a containing transaction scope then both the inner and outer transactions need to Complete for the changes on the database to be committed.

It's not as simple as the TransactionScope method but, as I understand it, this is the "correct" way to do it for LINQ-to-SQL. It doesn't require any reference to System.Transactions.
dataContext.Connection.Open();
using (dataContext.Transaction = dataContext.Connection.BeginTransaction())
{
dataContext.SubmitChanges();
if (allOK)
{
dataContext.Transaction.Commit();
}
else
{
dataContext.Transaction.RollBack();
}
}
Of course, the RollBack is only required if you intend to do further data operations within the using, otherwise changes will be automatically discarded.

Something like this, probably:
try
{
using (TransactionScope scope = new TransactionScope())
{
//Do some stuff
//Submit changes, use ConflictMode to specify what to do
context.SubmitChanges(ConflictMode.ContinueOnConflict);
scope.Complete();
}
}
catch (ChangeConflictException cce)
{
//Exception, as the scope was not completed it will rollback
}

Is something like this:
using (YourDatacontext m_DB = new YourDatacontext())
using (TransactionScope tran = new TransactionScope())
{
try
{
//make here the changes
m_DB.SubmitChanges();
tran.Complete();
}
catch (Exception ex)
{
Transaction.Current.Rollback();
}
}