//TransactionOutcomeEvent.cs
using System;
using System.Runtime.InteropServices;
using System.Threading;

namespace DtcInterop
{

    public class TransactionOutcomeEvent : ITransactionOutcomeEvents
    {
        private ManualResetEvent _evt;
        private DtcTransactionStatus _txStatus;

        public TransactionOutcomeEvent(ref ManualResetEvent evt)
        {
            _evt = evt;
            _txStatus = DtcTransactionStatus.Unknown;
        }

        #region ITransactionOutcomeEvents Members

        // Implement the ITransactionOutcomeEvents members
        
        public void Committed(bool fRetaining, IntPtr pNewUOW, Int32 hResult)
        {
            _txStatus = DtcTransactionStatus.Commited;
            _evt.Set();
        }

        public void Aborted(IntPtr pBoidReason, bool fRetaining, IntPtr pNewUOW, Int32 hResult)
        {
            _txStatus = DtcTransactionStatus.Aborted;
            _evt.Set();
        }

        public void HeuristicDecision(UInt32 decision, IntPtr pBoidReason, Int32 hResult)
        {
            _txStatus = DtcTransactionStatus.Error;
            _evt.Set();
        }

        public void Indoubt()
        {
            _txStatus = DtcTransactionStatus.InDoubt;
            _evt.Set();
        }

        #endregion  


        public DtcTransactionStatus TransactionOutcomeStatus
        {
            get { return _txStatus; }
        }
    }


    #region ITransactionOutcomeEvents Definition

        // Here is the definition of the ITransactionOutcomeEvents interface
        // Your class must implement this interface before trying to subscribe to the TransactionOutcomeEvents events
        [
        ComImport,
        Guid("3A6AD9E2-23B9-11cf-AD60-00AA00A74CCD"),
        InterfaceType(ComInterfaceType.InterfaceIsIUnknown),
        ]
        internal interface ITransactionOutcomeEvents 
        {
        void Committed([MarshalAs(UnmanagedType.Bool)] bool fRetaining,
        IntPtr pNewUOW,
        Int32 hResult);
        void Aborted(IntPtr pBoidReason,
        [MarshalAs(UnmanagedType.Bool)] bool fRetaining,
        IntPtr pNewUOW,
        Int32 hResult);
        void HeuristicDecision(UInt32 decision,
        IntPtr pBoidReason,
        Int32 hResult);
        void Indoubt();
        }

    #endregion


    public enum DtcTransactionStatus
    {
        Commited,
        Aborted,
        InDoubt,
        Error,
        Unknown
    }

}

//Class1.cs
using System;
using System.Runtime.InteropServices;
using System.EnterpriseServices;
using System.Data.SqlClient;
using System.Data;
using System.Threading;

namespace DtcInterop
{

    public class Class1
    {
        // Member variables used to set up ITransactionOutcomeEvents notifier
        private UCOMIConnectionPointContainer _iConPointContainer;
        private UCOMIConnectionPoint _iConnectionPoint;
        private int _adviseCookie;
        private TransactionOutcomeEvent _objEvent;
        private ManualResetEvent[] _txStatusSignaled = new ManualResetEvent[1]; 
       // You cannot execute the 'finally' code until you receive the result from DTC about the transaction status

        public Class1()
        {
            _txStatusSignaled[0] = new ManualResetEvent(false);
        }


        public void Run(string CustomerId, string ContactName)
        {
            // Here you enter into ServiceConfig, register for ITransactionOutcomeEvents
            // Execute the transactional code
            ServiceConfig sc = new ServiceConfig();
            sc.Transaction = TransactionOption.Required;
            sc.IsolationLevel = TransactionIsolationLevel.ReadCommitted;
            sc.TransactionDescription = "Test Transactions"
            sc.TransactionTimeout = -1;

            ServiceDomain.Enter(sc);
            try 
            {
                RegisterForITransactionOutcomeEvents();
                ExecuteTransactionCode(CustomerId, ContactName);
                ContextUtil.SetComplete();
            }
                catch(Exception ex)
            {
                ContextUtil.SetAbort();
                Console.WriteLine("\nError while executing client!!!");
                Console.WriteLine("Message: " + ex.Message);
                Console.WriteLine("Source: " +ex.Source);
                Console.WriteLine("Callstack:\n" +ex.StackTrace);
            }
            finally
            {
                // Leave the ServiceDomain
                ServiceDomain.Leave();

                // Wait until you are notified of the transaction outcome event from DTC
                int index = WaitHandle.WaitAny(_txStatusSignaled);

                if (index == WaitHandle.WaitTimeout)
                {
                    Console.WriteLine("We did not receive Transaction outcome event within 60 seconds");
                }
                else
                {
                    // You are notified of the transaction outcome event from DTC
                    // Now take action based on the transaction outcome event

                    switch (this.TransactionOutcomeStatus)
                    {
                        case DtcTransactionStatus.Commited:
                            Console.WriteLine("ITransactionOutcomeEvent Status -> COMMITED");
                            break;
                        case DtcTransactionStatus.Aborted:
                            Console.WriteLine("ITransactionOutcomeEvent Status -> ABORTED");
                            break;
                        case DtcTransactionStatus.Error:
                            Console.WriteLine("ITransactionOutcomeEvent Status -> ERROR");
                            break;
                        case DtcTransactionStatus.InDoubt:
                            Console.WriteLine("ITransactionOutcomeEvent Status -> INDOUBT");
                            break;
                        case DtcTransactionStatus.Unknown:
                        default:
                            Console.WriteLine("Tx Outcome Status not set.");
                            break;
                    }
                }

                // You have the Transaction status. Un-register for the ITransactionOutcomeEvents notifications
                _iConnectionPoint.Unadvise(_adviseCookie); 
            }
        }


        private void RegisterForITransactionOutcomeEvents()
        { 
            System.EnterpriseServices.ITransaction iTxn;
            // UUID of the ITransactionOutcomeEvents interface
            Guid GuidOutcomeEvents = new Guid("{3A6AD9E2-23B9-11CF-AD60-00AA00A74CCD}"); 
            GetCurrentITransaction(out iTxn);
            _objEvent = new TransactionOutcomeEvent(ref _txStatusSignaled[0]);
            _iConPointContainer = (UCOMIConnectionPointContainer)iTxn;
            _iConPointContainer.FindConnectionPoint(ref GuidOutcomeEvents, out _iConnectionPoint);
            _iConnectionPoint.Advise(_objEvent, out _adviseCookie);
        }

        private void ExecuteTransactionCode(string custId, string custName)
        {
            string connString="server=servername;uid=sa;pwd=*****;database=Northwind;"
            string commandName = "UpdateCustomer"
            using (SqlConnection conn = new SqlConnection(connString))
            {
                conn.Open();
                SqlCommand command = new SqlCommand(commandName, conn);
                command.CommandType = CommandType.StoredProcedure;
                // @customerId parameter
                SqlParameter pCustID = new SqlParameter("@CustomerId", SqlDbType.NChar, 5);
                pCustID.Direction = ParameterDirection.Input;
                pCustID.Value = custId;
                command.Parameters.Add(pCustID);
                // @ContactName parameter
                SqlParameter pContactName = new SqlParameter("@ContactName", SqlDbType.NVarChar, 30);
                pContactName.Direction = ParameterDirection.Input;
                pContactName.Value = custName;
                command.Parameters.Add(pContactName);
                // Execute update stored proc
                command.ExecuteNonQuery();
            }
        }

        private void GetCurrentITransaction(out System.EnterpriseServices.ITransaction ITxn)
        {
            if (ContextUtil.IsInTransaction)
            ITxn = (System.EnterpriseServices.ITransaction) ContextUtil.Transaction;
            else
            ITxn = null;
        }

        public DtcTransactionStatus TransactionOutcomeStatus
        {
            get { return _objEvent.TransactionOutcomeStatus; }
        }
    }
}