C# 4 and .NET 4

824 ❘ ChaPTer 30 cOre AdO.net
// Close it myself
conn.Close ( );
}
}
catch (SqlException e)
{
// Log the exception
}
Note that this example called Close(), which is not strictly necessary, because the using clause will ensure
that this is done anyway. However, you should ensure that any resources such as this are released as soon
as possible — you might have more code in the rest of the block, and there is no point locking a resource
unnecessarily.
In addition, if an exception is raised within the using block, the IDisposable.Dispose method will
be called on the resource guarded by the using clause, which in this example ensures that the database
connection is always closed. This produces easier-to-read code than having to ensure you close a connection
within an exception clause. You might also note that the exception is defined as a SqlException rather
than the catch-all Exception type — always try to catch as specific an exception as possible and let all
others that are not explicitly handled rise up the execution stack. You really should only catch this exception
if your specific data class can handle the error and do something with it.
In conclusion, if you are writing a class that wraps a resource, whatever that resource may be, always
implement the IDisposable interface to close the resource. That way anyone coding with your class can use
the using() statement and guarantee that the resource will be cleared up.
Transactions
Often when there is more than one update to be made to the database, these updates must be performed
within the scope of a transaction. It is common in code to find a transaction object being passed around
to many methods that update the database; however, since the release of the .NET Framework 2.0, the
TransactionScope class has been available. This class is found within the System.Transactions
assembly. This vastly simplifies writing transactional code because you can compose several transactional
methods within a transaction scope, and the transaction will flow to each of these methods as necessary.
The following sequence of code initiates a transaction on a SQL Server connection:
string source = "server=(local);" +
"integrated security=SSPI;" +
"database=Northwind";
using (TransactionScope scope = new
TransactionScope(TransactionScopeOption.Required))
{
using (SqlConnection conn = new SqlConnection(source))
{
// Do something in SQL
.
}
}
// Then mark complete
scope.Complete();
Here, the transaction is explicitly marked as complete by using the scope.Complete() method. In the
absence of this call, the transaction will be rolled back so that no changes are made to the database.
When you use a transaction scope, you can optionally choose the isolation level for commands executed
within that transaction. The level determines how changes made in one database session are viewed by
another. Not all database engines support all of the four levels presented in the following table.
www.it-ebooks.info