Here's the doc comment that caused the exception:

/// <summary>
/// Instantiates a new service host loader and starts it.
/// </summary>
/// <remarks>
/// Since this class implements IDisposable<seealso cref="IDisposable"/>, it is
/// especially useful to use this in a using clause. This will run the service
/// until the block ends.
///
/// For example:
/// <code>
/// using (ServiceHostLoader.LoadAndStartServices())
/// { /// Console.WriteLine(); /// Console.WriteLine("Press Any Key to Shut Down Services..."); /// Console.WriteLine(); /// Console.Read(); /// }
/// </code>
///
/// Because Windows Services in .Net throw an OnStart and OnStop event, this
/// technique does not work well for these. Therefor, this class also supports
/// stopping the services with a public method, StopServices(), for those
/// situations.
///
/// </remarks>
/// <returns>A Service Host loader with running services.</returns>
Build337, VS2005

The cursor was in an XML comment block.

Build340, VS2005

Here's the doc dcomment that causes this exception:

/// <summary>
/// Class to assist in managing transaction lifetimes inside scopes on a particular thread.
/// </summary>
/// <remarks>
/// <para />
/// Allows almost-automated re-use of database transactions across multiple call levels
/// while still controlling transaction lifetimes.
/// <para />
/// To use:
/// <para />
/// <list type="bullet">
/// <item>
/// Create a new transaction scope object in a using statement at the level within which you
/// want to scope transactions.
/// </item>
/// <item>
/// Access the Transaction using scope.Transaction property. This object should not
/// be committed or rolled back directly.
/// </item>
/// <item>
/// If you want to roll back, execute scope.Rollback befor the end of the transaction. call
/// to Rollback at any level of the transaction will cause the entire transaction to roll back.
/// </item>
/// <item>
/// You can test the result of the transaction using scope.TransactionState.
/// </item>
/// </list>
/// <para />
/// Example of transaction that commits:
/// <code>
/// using (DbTransactionScope scope = new DbTransactionScope())
/// { /// _entity1TableAdapter.Update(dataSet, scope.Transaction); /// _entity2TableAdapter.Update(dataSet, scope.Transaction); /// }
/// </code>
/// Example of rollback:
/// <code>
/// using (DbTransactionScope scope = new DbTransactionScope())
/// { /// _entity1TableAdapter.Update(dataSet, scope.Transaction); /// _entity2TableAdapter.Update(dataSet, scope.Transaction); /// /// scope.Rollback(); /// }
/// </code>
/// <para />
/// Inspiration from this blog post:
/// <para />
/// http://blogs.msdn.com/dataaccess/attachment/532026.ashx
/// </remarks>

Build340, VS2005

Actually, All doc comments are not showing with this build.
Build340, VS2005

Here is the comment:

/// <summary>
/// <para>
/// DbTransactionScope manages a single database transaction lifetime on a single thread.
/// It allows for a non-predetermined level of nesting and handles commiting and rolling back in the
/// presence of unhandled exceptions.
/// </para>
/// <remarks>
/// <para>
/// This class was created to avoid using the System.Transactions.TransactionScope object for transactions
/// that are known, from the outset, to utilize only one database connection. It can be substituted for
/// the TransactionScope class in this situation.
/// </para>
/// <para>
/// TransactionScope is not a good option if more than one connection is made to the same database as part or the
/// same transaction. In this situation, the TransactionScope object, will promote the transaction to a two-phase commit
/// using DCOM.
/// </para>
/// <para>
/// Furthermore, the Enterprise Library 2.0 Data Access Block has two alternatives to accessing the database:
/// </para>
/// <list type="number">
/// <item>Methods that pull a connection from the connection pool and executes the SQL or stored procedure; and</item>
/// <item>Overrides that accept a Database transaction. These overrides allows multiple SQL or stored procedures to be
/// executed on the same transaction and, by extension, the same connection.</item>
/// </list>
/// <para>
/// Using TransactionScope to surround multiple calls to the first type of method will create the exact promotion to
/// DCOM transactions that DbTransactionScope is designed to avoid.
/// </para>
/// </para>
/// In order to support transactions with Enterprise Library, the transaction must be created and passed
/// to the Data Access Block layer. Creating a series of methods in data and business layer classes to pass this
/// instance of tranasction around is cumbersome. Also it requires knowledge of whether a calling process has already
/// created a transaction that the object should use, or whether the object should start the transaction. The
/// DbTransactionScope helps solve this problem; in the context of a single thread; by storing a transaction
/// in the static state of the thread.
/// </para>
/// </para>
/// DbTransactionScope creates or inherits a transaction from an outer scope depending on
/// whether it is a "top level" ccope or a "nested" scope. This is not unlike the TransactionScope
/// object, and the protocol on DbTransactionScope is designed to work in the same manner as TransactionScope.
/// </para>
/// <para>
/// DbTransactionScope is compatible with the TransactionScope object and can be used with it if necessary.
/// This would allow SbTransactionScope to work in transactions that do require a two-phase commit. Even in that
/// case it will cause fewer connections to a single database that participates in the transaction.
/// </para>
/// <para>
/// To use:
/// </para>
/// <list type="number">
/// <item>
/// Create a new DbTransactionScope object, typically with a using statement, in any method within which you
/// want to execute database updates on a single transaction. This will cause the following behaviour at the
/// start of the using clause:
/// <list type="bullet">
/// <item>In the presence of no previous DbTransactionScope on the thread, the constructor will create a top level
/// DbTransactionScope containing a new DbTransaction. Depending on the constructor used, the
/// transaction will be created against the default database or a named database defined in
/// EnterpriseLibrary configuration.
/// </item>
/// <item>In the presence of an existing DbTransactionScope on the thread, the constructor
/// will create nested transaction scope containing the same DbTransaction as the outer scope. If the
/// constructor used does not specify a named database in EnterpriseLibrary configuration, the
/// transaction will be against the same database as the top level scope. If it specifies a named configuration,
/// it must be the same as the top level scope, or an exception will be thrown.
/// </item>
/// </list>
/// </item>
/// <item>
/// In each scope, explicitly complete the transaction scope using the Complete() method.
/// If you want to roll back, do not call Complete() before the end of the transaction scope.
/// This will cause the entire tranasction to roll back on disposal of the top level
/// transaction.
/// </item>
/// <item>
/// You can test whether the transaction is still scheduled to commit by
/// accessing the scope.IsActive() property. This is useful if you want to avoid work when
/// a transaction is already scheduled to be rolled back. Note that if a scope is already rolled back,
/// subsequent calls to the database will not be made.
/// </item>
/// </list>
/// </para>
/// <para>
/// Example of transaction that commits:
/// </para>
/// <code>
/// using (DbTransactionScope scope = new DbTransactionScope())
/// { /// _entity1TableAdapter.Update(dataSet); /// _entity2TableAdapter.Update(dataSet); /// /// scope.Complete(); /// }
/// </code>
/// <para>
/// Example of rollback (assuming "Some Condition") is not met:
/// </para>
/// <code>
/// using (DbTransactionScope scope = new DbTransactionScope())
/// { /// _entity1TableAdapter.Update(dataSet); /// _entity2TableAdapter.Update(dataSet); /// /// if ("Some Condition") /// scope.Complete(); /// }
/// </code>
/// <para>
/// Inspiration from this blog post:
/// </para>
/// <para>
/// http://blogs.msdn.com/dataaccess/attachment/532026.ashx
/// <para>
/// </para>
/// as well as the protocol on the much broader System.Transactions.TransactionScope
/// class in the .Net framework.
/// </para>
/// </remarks>
/// </summary>
Build351, VS2005

/// <summary>
/// Returns <code>true</code> if the specified key already exists as a tool item, <code>false</code> otherwise.
/// </summary>
/// <param name="key">The key.</param>
/// <returns></returns>
Build351, VS2005

/// <exception cref="InvalidOperationException">thrown if </exception>

and put the cursor after the opening < character and pressed Ctrl-Q, wondering if I'd get documentation for the <exception> documentation tag.
Build351, VS2005

Wow, this happens each time.
Build370, VS2005

Build337, VS2005

Build376, VS2005