Question

I have now a problem with a very old system of ours. (!It is more then 7 years old and I have no budget and resources to make bigger change in the structure, so the decision to improve the old logic as many as we can.!)

We have an own written gridcontrol. Basically it is like a normal ASP.NET grid, you can add, change, delete elements.

The problem is that the grid has a BindGrid() method, where for further usage, the rows of the datasource table copied into a DataRow[]. I need to keep the DataRow[], but I would like to implement the best way to copy the source from the the table into the array.

The current solution:

DataRow[] rows = DataSource.Select("1=1", SortOrderString);

As I experienced so far, if I need to get a specified sort, that could be the best way (I’m also interested if it has a quicker way or not.)

BUT there are some simplified pages, where the SortOrder is not needed.

So I could make two method one for the sort order and one for without.
The real problem is the second one:

 DataRow[] rows = DataSource.Select("1=1");

Because it is very slow. I made some test and it is kind of 15 times slower then the CopyTo() solution:

DataRow[] rows = new DataRow[DataSource.Rows.Count];
DataSource.Rows.CopyTo(rows,0);

I would like to use the faster way, BUT when I made the tests some old function simply crashed. It seems, there is an other difference, what I only noticed now:
The Select() gets the rows like the RowChanges are accepted.

So if I deleted a row, and I do not use the AcceptRowChanges() (I can’t do that unfortunately), then with Select("1=1") the row is in the DataSource but not in the DataRow[].

With a simple .CopyTo() the row is there, and that is a bad news for me.

My questions are:

1) Is the Select(“1=1”) the best way to get the rows by the RowChanges? (I doubt a bit, because it is like 6 year old part)

2) And if 1) is not, is it possible to achieve a faster way with the same result than the .Select(“1=1”) ?

UPDATE:

Here is a very basic test app, what I used for speedtesting:

DataTable dt = new DataTable("Test");

dt.Columns.Add("Id", typeof (int));
dt.Columns.Add("Name", typeof(string));

for (int i = 0; i < 10000; i++)
{
    DataRow row = dt.NewRow();
    row["ID"] = i;
    row["Name"] = "Name" + i;
    dt.Rows.Add(row);
}

dt.AcceptChanges();
DateTime start = DateTime.Now;

DataRow[] rows = dt.Select();

/*DataRow[] rows = new DataRow[dt.Rows.Count];
dt.Rows.CopyTo(rows,0);*/

Console.WriteLine(DateTime.Now - start);

Answer 1

You can call Select without an argument: DataRow[] allRows = DataSource.Select(); That would be for sure more efficient than "1=1" since that applies a pointless RowFilter.

Another way is using Linq-To-DataSet to order and filter the DataTable. That isn’t more efficient but more readable and maintainable.

I have yet no example or measurement, but it is obvious that a RowFilter with "1=1" is more expensive than none. Select is implemented in this way:

public Select(DataTable table, string filterExpression, string sort, DataViewRowState recordStates)
{
    this.table = table;
    this.IndexFields = table.ParseSortString(sort);
    this.indexDesc = Select.ConvertIndexFieldtoIndexDesc(this.IndexFields);
    // following would be omitted if you would use DataSource.Select() without "1=1"
    if (filterExpression != null && filterExpression.Length > 0)
    {
        this.rowFilter = new DataExpression(this.table, filterExpression);
        this.expression = this.rowFilter.ExpressionNode;
    }
    this.recordStates = recordStates;
}

If you want to be able to select also the rows that are currently not accepted, you can use the overload of Select:

DataRow[] allRows = DataSource.Select("", "", DataViewRowState.CurrentRows | DataViewRowState.Deleted);

This will select all rows inclusive the rows that are deleted even if AcceptChanges was not called yet.