C# – subsonic – collection load versus query

csubsonic

I am setting the data source of a datagridview to a subsonic collection

        TcolorCollection tc = new TcolorCollection().Load();
        dataGridView1.DataSource = tc;

and I've noticed that the previous code is much (way to much) slower then the following

        SubSonic.Query q3 = new SubSonic.Query("tcolor");
        q3.QueryType = SubSonic.QueryType.Select;
        IDataReader reader = q3.ExecuteReader();
        DataTable dt = new DataTable();
        dt.Load(reader);
        dataGridView1.DataSource = dt;

I would like to use the collection class and it's connectivity, but I need a way for the .Load() to be faster.

fyi the table I am using has 8000+ records. Not small, but not huge either.

Best Answer

Couple of thoughts...

If you have to use a DataSet/DataTable you could just do this:

grid.DataSource=new Select().From("tcolor").ExecuteDataSet();

Both of the things you show above use the same core bits - not sure why one is slower than the other.

Related Solutions

C# – LINQ query on a DataTable

You can't query against the DataTable's Rows collection, since DataRowCollection doesn't implement IEnumerable<T>. You need to use the AsEnumerable() extension for DataTable. Like so:

var results = from myRow in myDataTable.AsEnumerable()
where myRow.Field<int>("RowNo") == 1
select myRow;

And as @Keith says, you'll need to add a reference to System.Data.DataSetExtensions

AsEnumerable() returns IEnumerable<DataRow>. If you need to convert IEnumerable<DataRow> to a DataTable, use the CopyToDataTable() extension.

Below is query with Lambda Expression,

var result = myDataTable
    .AsEnumerable()
    .Where(myRow => myRow.Field<int>("RowNo") == 1);

C# Interfaces. Implicit implementation versus Explicit implementation

Implicit is when you define your interface via a member on your class. Explicit is when you define methods within your class on the interface. I know that sounds confusing but here is what I mean: IList.CopyTo would be implicitly implemented as:

public void CopyTo(Array array, int index)
{
    throw new NotImplementedException();
}

and explicitly as:

void ICollection.CopyTo(Array array, int index)
{
    throw new NotImplementedException();
}

The difference is that implicit implementation allows you to access the interface through the class you created by casting the interface as that class and as the interface itself. Explicit implementation allows you to access the interface only by casting it as the interface itself.

MyClass myClass = new MyClass(); // Declared as concrete class
myclass.CopyTo //invalid with explicit
((IList)myClass).CopyTo //valid with explicit.

I use explicit primarily to keep the implementation clean, or when I need two implementations. Regardless, I rarely use it.

I am sure there are more reasons to use/not use explicit that others will post.

See the next post in this thread for excellent reasoning behind each.

Best Answer

Related Solutions

C# – LINQ query on a DataTable

C# Interfaces. Implicit implementation versus Explicit implementation

Related Topic