Do you know any drawback to add controls to a page on PreRender event?
please don't answer 'depends on your case' I'm talking in general:-)
The PreRender event happens after control events, so the control could not use any events.
If you for example add a Button in Page_PreRender, it's too late to hook up a Click event handler for it. At postack the button would not be recreated until after the click event had already been handled (and ignored).
Yes, see this link for the ASP.NET lifecycle:
http://msdn.microsoft.com/en-us/library/ms178472.aspx
I would recommend adding controls on the Init event as the new control would otherwise be cleared on any postbacks. This is as per https://web.archive.org/web/20210330142645/http://www.4guysfromrolla.com/articles/092904-1.aspx.
'Raised after all controls have been initialized and any skin settings have been applied. Use this event to read or initialize control properties.'
Related
I am trying to take advantage of the page lifecycle in Asp.NET so that I don't bind to my datasources more than I actually need to.
This has led to the following problem. I have an ObjectDataSource, GridView, and a button on my page. The button adds a record to the database, which should be picked up by the data source and presented on the Grid. The problem is that the item is not showing up on the gridview until I refresh the page.
I can solve the problem by calling GridView.DataBind() in my button's event handler, but this goes against what I understand about the .NET Page Lifecycle.
Based on this article, the lifecycle should be as follows:
In addition the article states that the Databinding event is "Raised after the control's PreRender event, which occurs after the page's PreRender event."
So, my button click event should fire first, during the Event Handling phase. It should add the record the database.
Next PreRender should be called on the controls.
Finally DataBind should be called on the controls, and the Grid should update to capture the new record.
Yet this doesn't seem to happen. What am I not understanding?
I think the issue is that your viewstate is not enabled on your GridView. This is what I experienced, but then I also had to call DataBind() on the GridView from the page PreRender event if the request was a postback to get the data updated in the GridView on postback.
Edit:
It would help to understand the issue and context better if you could post the source code of your page (aspx + codebehind). How and where do you connect your GridView to your datasource? Statically in markup or dynamically? Do you make any calls to page.DataBind()? ... These things may influence the behaviour of the GridView.
I have two radio button on my asp.net page, with AutoPostBack = True
When I click on either of those, they each set a flag SaveData=False
However, when I click on them, the page_load event occurs first, so the page_load event saves the data, then the radiobutton_OnCheckedChanged event is triggered.
How can I trigger the OnCheckedChanged before the page_load event?
You can't.
You need to read up on the page lifecycle.
You can't trigger the OnCheckedChanged before radiobutton_OnCheckedChanged because that's the normal page life cycle.
You can check in Page_Load if Page.IsPostBack is true or not, and then don't save (or save) the data.
Troy - you will have to take care of this on the client side (javascript / jquery).
Your AutoPostBack = True causes the form to do a postback which calls page load.
Its all about how the page lifecycle and server side events work.
You can't the page always needs to load before events can be fired. This has to do with control creation, view state management, control state, etc.
What you want to do in your Page_Load is something like:
if(!this.IsPostBack)
{
// Do the stuff you want on the initial page load
}
Anything that you do not want to happen when the radio buttons are clicked, put it inside the if {} block. IsPostBack indicates that the page is processing a post-back event, which is what happens when you click one of your radio buttons.
You can't change the order/sequence of event handler execution. However you may move the code inside the page_load to another event handler.
When an asp.net button is fired, will the button's event get fired before the page_load and init and pre_init events?
http://msdn.microsoft.com/en-us/library/ms178472.aspx
Page_Load goes before event handlers.
Just stick some breakpoints in the different functions and see which one fires first. I think the answer is no.
Make a page with page init, load (also variations of ispostback), prerender, unload and control events and do a trace to see when they all fire off - easier to remember too when you do it as opposed to reading it.
Page_Load, init and pre_init will happen before the button can receive any user input, so it will definitely happen before the button can fire off any events as a result of user input.
In my web application I load user controls in the page_loadComplete event. This works fine, however when a button is clicked in a user control, the click event is never fired. Does this has something to do with the page lifecycle? That button click (UI) events occur before the LoadComplete event?
You need to make sure the click event of the button is once again subscribed to, before event handlers fire. LoadComplete happens after control events. For a reference, the ASP.NET Page Life Cycle Overview gives a pretty nice summary.
Snippet:
...
Load
Control events
LoadComplete
PreRender
...
You also need to make sure that the controls that you dynamically load all end up in the same place, so viewstate and controlstate can be reapplied to the same hierarchy as before postback.
Basically, you need to load all dynamic controls on each postback.
Here's someone with the same problem, and solutions to some of them: ASP.NET dynamic controls
Actually what is happening to your situation is, when you click on the button, before event raising, LoadCoplete event fire first in the page lifecycle and same control is again created and here is your event is lost.
Event Handling in ASP.NET page happens after Validation and before Rendering phase. And Validation phase happens after Load.
LoadComplete happens after Control events and before RreRender event.
Is there any kind of event out there that would allow for a preload post back event.
The reason I ask is I have a control that adds sibling controls to it on postback events, however, by the time it has loaded the post back its too late to add the new control to the control collection. Therefore, the controls are never updated correctly.
Thanks!
Try the Init event.
Override CreateChildControls (make sure to call base!). In your postback event handler, make sure you are storing somewhere the list of controls that should be created dynamically, so when CreateChildControls gets invoked very early in the lifecycle on the next go-round, it will recreate the controls built on the last postback.
Here is a quick hack. You can always, query the __EventTarget and or the value of the submit button in init and can load dynamically the control.
But doing so, may not be appropriate as your control hierarchy would change and could cause problems.
As above, dynamic controls have to be added during the page Init event, so that they can be properly handled within the page's Viewstate. You might want to turn the Viewstate off for the page as well, since it can fire errors at you if the controls change.
As has already been stated the proper place to add dynamic controls is in the Init event.
Here's an article with more information.
Dynamic Web Controls, Postbacks, and View State
To get a better understanding of the ASP .NET page life cycle see:
ASP.NET Page Life Cycle Overview
This page explains the event order (and what happens in each one) in a postback, it helped me more than once.
I've just found this link, that can also be of use to you