title: Under what circumstances is an SqlConnection automatically enlisted in an ambient TransactionScope Transaction?
body: <p>What does it mean for an SqlConnection to be "enlisted" in a transaction?  Does it simply mean that commands I execute on the connection will participate in the transaction?</p>
  
  <p>If so, under what circumstances is an SqlConnection <em>automatically</em> enlisted in an ambient TransactionScope Transaction?</p>
  
  <p>See questions in code comments.  My guess to each question's answer follows each question in parenthesis.</p>
  
  <h2>Scenario 1: Opening connections INSIDE a transaction scope</h2>
  
  <pre><code>using (TransactionScope scope = new TransactionScope())
  using (SqlConnection conn = ConnectToDB())
  {   
      // Q1: Is connection automatically enlisted in transaction? (Yes?)
      //
      // Q2: If I open (and run commands on) a second connection now,
      // with an identical connection string,
      // what, if any, is the relationship of this second connection to the first?
      //
      // Q3: Will this second connection's automatic enlistment
      // in the current transaction scope cause the transaction to be
      // escalated to a distributed transaction? (Yes?)
  }
  </code></pre>
  
  <h2>Scenario 2: Using connections INSIDE a transaction scope that were opened OUTSIDE of it</h2>
  
  <pre><code>//Assume no ambient transaction active now
  SqlConnection new_or_existing_connection = ConnectToDB(); //or passed in as method parameter
  using (TransactionScope scope = new TransactionScope())
  {
      // Connection was opened before transaction scope was created
      // Q4: If I start executing commands on the connection now,
      // will it automatically become enlisted in the current transaction scope? (No?)
      //
      // Q5: If not enlisted, will commands I execute on the connection now
      // participate in the ambient transaction? (No?)
      //
      // Q6: If commands on this connection are
      // not participating in the current transaction, will they be committed
      // even if rollback the current transaction scope? (Yes?)
      //
      // If my thoughts are correct, all of the above is disturbing,
      // because it would look like I'm executing commands
      // in a transaction scope, when in fact I'm not at all, 
      // until I do the following...
      //
      // Now enlisting existing connection in current transaction
      conn.EnlistTransaction( Transaction.Current );
      //
      // Q7: Does the above method explicitly enlist the pre-existing connection
      // in the current ambient transaction, so that commands I
      // execute on the connection now participate in the
      // ambient transaction? (Yes?)
      //
      // Q8: If the existing connection was already enlisted in a transaction
      // when I called the above method, what would happen?  Might an error be thrown? (Probably?)
      //
      // Q9: If the existing connection was already enlisted in a transaction
      // and I did NOT call the above method to enlist it, would any commands
      // I execute on it participate in it's existing transaction rather than
      // the current transaction scope. (Yes?)
  }
  </code></pre>