using System;
using System.Transactions;

try
            {
                //Create the transaction scope
                using (TransactionScope scope = new TransactionScope())
                {
                    //Register for the transaction completed event for the current transaction
                    Transaction.Current.TransactionCompleted += new TransactionCompletedEventHandler(Current_TransactionCompleted);

                    //Call complete on the TransactionScope or not based on input
                    ConsoleKeyInfo c;
                    while (true)
                    {
                        Console.Write("Complete the transaction scope? [Y|N] ");
                        c = Console.ReadKey();
                        Console.WriteLine();

                        if ((c.KeyChar == 'Y') || (c.KeyChar == 'y'))
                        {
                            scope.Complete();
                            break;
                        }
                        else if ((c.KeyChar == 'N') || (c.KeyChar == 'n'))
                        {
                            break;
                        }
                    }

                }

            }
            catch (System.Transactions.TransactionException ex)
            {
                Console.WriteLine(ex);
            }
            catch
            {
                Console.WriteLine("Cannot complete transaction");
                throw;
            }


static void Current_TransactionCompleted(object sender, TransactionEventArgs e)
        {
            Console.WriteLine("A transaction has completed:");
            Console.WriteLine("ID:             {0}", e.Transaction.TransactionInformation.LocalIdentifier);
            Console.WriteLine("Distributed ID: {0}", e.Transaction.TransactionInformation.DistributedIdentifier);
            Console.WriteLine("Status:         {0}", e.Transaction.TransactionInformation.Status);
            Console.WriteLine("IsolationLevel: {0}", e.Transaction.IsolationLevel);
        }

using System;
using System.Transactions;

namespace myTransaction
{
    // A simple usage of transactions with the using statement
    class VolatileEnlist
    {
        static void Main(string[] args)
        {
            try
            {
                using (TransactionScope scope = new TransactionScope())
                {
                    //Create an enlistment object
                    myEnlistmentClass myElistment = new myEnlistmentClass();

                    //Enlist on the current transaction with the enlistment object
                    Transaction.Current.EnlistVolatile(myElistment, EnlistmentOptions.None);

                    //Perform transactional work here.

                    //Call complete on the TransactionScope or not based on inputt
                    ConsoleKeyInfo c;
                    while(true)
                    {
                        Console.Write("Complete the transaction scope? [Y|N] ");
                        c = Console.ReadKey();
                        Console.WriteLine();
                
                        if ((c.KeyChar == 'Y') || (c.KeyChar == 'y'))
                        {
                            scope.Complete();
                            break;
                        }
                        else if ((c.KeyChar == 'N') || (c.KeyChar == 'n'))
                        {
                            break;
                        }
                    }
                }
            }
            catch (System.Transactions.TransactionException ex)
            {
                Console.WriteLine(ex);
            }
            catch
            {
                Console.WriteLine("Cannot complete transaction");
                throw;
            }
        }

        class myEnlistmentClass : IEnlistmentNotification
        {
            public void Prepare(PreparingEnlistment preparingEnlistment)
            {
                Console.WriteLine("Prepare notification received");

                //Do work to be included in the transaction

                //If work finished correctly, reply prepared
                preparingEnlistment.Prepared();
            }

            public void Commit(Enlistment enlistment)
            {
                Console.WriteLine("Commit notification received");

                //Do any work needed when receiving commit notification

                //Declare done on the enlistment
                enlistment.Done();
            }

            public void Rollback(Enlistment enlistment)
            {
                Console.WriteLine("Rollback notification received");

                //Do any work needed when receiving a rollback notification

                //Declare done on the enlistment
                enlistment.Done();
            }

            public void InDoubt(Enlistment enlistment)
            {
                Console.WriteLine("In doubt notification received");

                //Do any work needed in case of in doubt notification
                
                //Declare done on the enlistment
                enlistment.Done();
            }
        }
    }
}

using System;
using Oracle.DataAccess.Client;
using System.Data;
using System.Data.Common;
using System.Transactions;
 
class psfEnlistTransaction
{
  static void Main()
  {
    int retVal = 0;
    string providerName = "Oracle.DataAccess.Client";
    string constr = 
           @"User Id=scott;Password=tiger;Data Source=oracle;enlist=dynamic";
 
    // Get the provider factory.
    DbProviderFactory factory = DbProviderFactories.GetFactory(providerName);
 
    try
    {
      // Create a committable transaction object.
      CommittableTransaction cmtTx = new CommittableTransaction();
 
      // Open a connection to the DB.
      DbConnection conn1 = factory.CreateConnection();
      conn1.ConnectionString = constr;
      conn1.Open();
 
      // enlist the connection with the commitable transaction.
      conn1.EnlistTransaction(cmtTx);
 
      // Create a command to execute the sql statement.
      DbCommand cmd1 = factory.CreateCommand();
      cmd1.Connection = conn1;
      cmd1.CommandText = @"insert into emp (empno, ename, job) values 
                                                     (1234, 'emp1', 'dev1')";
 
      // Execute the SQL statement to insert one row in DB.
      retVal = cmd1.ExecuteNonQuery();
      Console.WriteLine("Rows to be affected by cmd1: {0}", retVal);
 
      // commit/rollback the transaction.
      cmtTx.Commit();   // commits the txn.
      //cmtTx.Rollback(); // rolls back the txn.
 
      // close and dispose the connection
      conn1.Close();
      conn1.Dispose();
      cmd1.Dispose();
    }
    catch (Exception ex)
    {
      Console.WriteLine(ex.Message);
      Console.WriteLine(ex.StackTrace);
    }
  }
}

using System;
using System.Transactions;
using System.Threading;


 try
            {
                using (TransactionScope scope = new TransactionScope())
                {
                    // Perform transactional work here.

                    //Queue work item
                    ThreadPool.QueueUserWorkItem(new WaitCallback(WorkerThread), Transaction.Current.DependentClone(DependentCloneOption.BlockCommitUntilComplete));

                    //Print the transaction information
                    Console.WriteLine("Transaction information:");
                    Console.WriteLine("ID:             {0}", Transaction.Current.TransactionInformation.LocalIdentifier);
                    Console.WriteLine("status:         {0}", Transaction.Current.TransactionInformation.Status);
                    Console.WriteLine("isolationlevel: {0}", Transaction.Current.IsolationLevel);

                    //Call complete on the TransactionScope or not based on input
                    ConsoleKeyInfo c;
                    while (true)
                    {
                        Console.Write("Complete the transaction scope? [Y|N] ");
                        c = Console.ReadKey();
                        Console.WriteLine();

                        if ((c.KeyChar == 'Y') || (c.KeyChar == 'y'))
                        {
                            //Call complete on the scope
                            scope.Complete();
                            break;
                        }
                        else if ((c.KeyChar == 'N') || (c.KeyChar == 'n'))
                        {
                            break;
                        }
                    }

                }
            }
            catch (System.Transactions.TransactionException ex)
            {
                Console.WriteLine(ex);
            }
            catch
            {
                Console.WriteLine("Cannot complete transaction");
                throw;
            }




private static void WorkerThread(object transaction)
        {
            //Create the DependentTransaction from the object passed to the WorkerThread
            DependentTransaction dTx = (DependentTransaction)transaction;

            //Sleep for 1 second to force the worker thread to delay
            Thread.Sleep(1000);

            //Pass the DependentTransaction to the scope so work done in the scope will be part of the transaction passed to the worker thread
            using (TransactionScope ts = new TransactionScope(dTx))
            {
                //Perform transactional work here.

                //Call complete on the transaction scope
                ts.Complete();
            }

            //Call complete on the dependent transaction
            dTx.Complete();
        }