Sometimes, you call DataGrid.DataBind() after doing a

DataGrid.DataSource = DataSet (or reader)

and sometimes you don't. When is it that you have to call DataBind on
the datagrid and when is it not necessary? Why is there the difference?

You should call Databind on a DataGrid after any modifications to the grid's
data source (record added, deleted, updated, etc.)

As for sometimes calling databind after setting the data source and
sometimes not...Who said you should not be databinding after setting the
data source?

What you don't do is call DataBind in the Postback section of Page_Load.
The reason being is that the page is being reloaded for a reason. It could
have been that the user switch the page of data they want to see, the user
may have initiated a sort, the user may have deleted a row or updated a row.
All of these actions will force a postback. Page_Load will run early on in
the Postback process, so you'll want to set your datasource for your grid up
there, but don't databind here, because after Page_Load, the event that
caused the postback is going to fire (say the SortCommand event, for
example). If you bind in the Page_Load and then the SortCommand event
fires, you'd have to call DataBind again in the SortCommand event (because
you just changed what the grid is showing). So, on Postback's, you re-set
the grid's datasource in Page_Load, but put the Databind in the grid's event
handlers.

"Water Cooler v2" <wtr_clr (AT) yahoo (DOT) com> wrote

There are 3 elements to making this work:

1. The actual data repository (a database?)
2. The in-memory representation of the original data (a dataset)
3. The user interface for the data (the DataGrid).

The original data needs to be replicated into the in-memory container (the
DataSet). This is accomplished by calling the .Fill() method of your
DataAdapter.

Now, the DataGrid needs to be "connected" to the in-memory data (the
DataSet). You must set the DataGrid's datasource property so it knows where
to get the data from, but just setting the datasource doesn't actually go
and get any data. So, you need to call the DataGrid's DataBind method to
tell the grid to go and look at the data (specified in the DataSource
property) and bind to it.

If the data in the DataSet ever gets changed in any way, or if you want to
show the existing data in a different way (a different page of data or a
different sorted view of the data), you are going to need to have the
DataGrid "refresh" its representation of that underlying data. Calling
DataBind does just that.



"Brian Tkatch" <Maxwell_Smart (AT) ThePentagon (DOT) com> wrote

This is correct and does not conflict with what I said in the first place.
You've only expounded upon the structure of the DataSet, but for most
purposes of conversation, it is correct to say that the DataSet is the
in-memory representation, since the DataTable is in the DataSet.

You'll need to pass that suggestion along to MS, but that doesn't change the
fact that calling .Fill() is how you populate the DataSet.

You only need to connect a DataGrid to a DataView if you want to see the
data differently than it is in the DataSet. You didn't mention that you
were in need or using DataViews, so I didn't go into setting the DataGrid's
data source to a DataView, but I have indicated that the DataGrid needs to
have its data source set to the in-memory representation of the data. If
that means DataView for you, then your data source is the DataView, rather
then the DataSet.

I'm not sure what you mean here. Are you using VS 2003 or 2005? Are you
talking about the WinForms DataGrid or the WebForms DataGrid?

Well, not always. A DataGrid is a window into the in-memory representation
of the original data. It could be a DataView or it could be a DataTable
directly or it could be a DataSet that holds a DataTable.

Not actually. A DataView holds no data whatsoever. It is simply a filtered
view of the in-memory representation of the data.

Again, I'll ask what version of .NET are you referring to? My responses are
based on the 1.1 Framework, VS.NET 2003 and the WebForms DataGrid. In these
versions, you MUST call .DataBind to get any data.

You are referring to the WinForms DataGrid aren't you? The WebForms
DataGrid does not have such a method.

In a WinForms app, you would only need DataBind on the initial DataGrid
population.

Good luck.

But after modifying the datagrid (which modifies the in-memory
representation of the original data) wouldn't you want that in-memory
representation to update the original data (thereby putting the two back in
sync)?

Actually, DataBind is must and we can give it after datasource in Page_Load, but burden on server increases which degrades the performance.

what mr.Scott adviced to do will be useful to improve the performance

Either way, the grid's data source and the original data will need to be
in-sync.

Either both have the new/edited data or both remain unchanged.

Updating the grid should update the original data and if that succeeds, the
grid's data source should be updated.


"Brian Tkatch" <Maxwell_Smart (AT) ThePentagon (DOT) com> wrote