C# 4 and .NET 4

834 ❘ ChaPTer 30 cOre AdO.net
As an aside, the numeric indexer took on average 0.09 seconds for the million accesses, and the textual
one 0.63 seconds. The reason for this difference is that the textual method looks up the column number
internally from the schema and then accesses it using its ordinal. If you know this information beforehand,
you can do a better job of accessing the data.
So, should you use the numeric indexer Maybe, but there is a better way. In addition to the indexers just
presented, OleDbDataReader has a set of type-safe methods that can be used to read columns. These are
fairly self-explanatory, and all begin with Get. There are methods to read most types of data, such as
GetInt32, GetFloat, GetGuid, and so on.
The million iterations using GetInt32 took 0.06 seconds. The overhead in the numeric indexer is incurred
while getting the data type, calling the same code as GetInt32, then boxing (and in this instance unboxing)
an integer. So, if you know the schema beforehand, are willing to use cryptic numbers instead of column
names, and can be bothered to use a type-safe function for each and every column access, you stand to gain
somewhere in the region of a tenfold speed increase over using a textual column name (when selecting those
million copies of the same column).
Needless to say, there is a tradeoff between maintainability and speed. If you must use numeric indexers,
define constants within class scope for each of the columns that you will be accessing. The preceding code
can be used to select data from any OLE DB database; however, there are a number of SQL Server–specific
classes that can be used with the obvious portability tradeoff.
The following example is the same as the previous one, except that in this instance the OLE DB provider
and all references to OLE DB classes have been replaced with their SQL counterparts. The example is
located in the 04_DataReaderSql directory:
using System;
using System.Data.SqlClient;
public class DataReaderSql
{
public static int Main(string[] args)
{
string source = "server=(local);" +
"integrated security=SSPI;" +
"database=northwind";
string select = "SELECT ContactName,CompanyName FROM Customers";
SqlConnection conn = new SqlConnection(source);
conn.Open();
SqlCommand cmd = new SqlCommand(select, conn);
SqlDataReader aReader = cmd.ExecuteReader();
while(aReader.Read())
Console.WriteLine("'{0}' from {1}", aReader.GetString(0),
aReader.GetString(1));
aReader.Close();
conn.Close();
return 0;
}
}
code download DataReaderSql.cs
Notice the difference If you’re typing this, do a global replace on OleDb with Sql, change the data source
string, and recompile. It’s that easy!
The same performance tests were run on the indexers for the SQL provider, and this time the numeric
indexers were both exactly the same at 0.13 seconds for the million accesses, and the string-based indexer
ran at about 0.65 seconds.
www.it-ebooks.info