With partial page updates it becomes more feasible to create pages with no viewstate, however this requires a bit trickier coding. I have a DropDownList control that I need to rebind every time I am refreshing the UpdatePanel that contains it. The first thought is to put the binding process in the event handler of the item that caused the partial postback. However, since this occurs in the pipeline after the DropDown's selected value is applied, the selected value is lost. Thus the binding of the DropDown has to happen in the Page_Init stage. But at this stage I don't have the event yet unless you examine the raw posted data (ugly). It would be nice if the ScriptManager could be interogated on post back to tell us which UpdatePanel caused the partial post. Then in the Page_Init I can say "If the UpdatePanel doing the posting contains my DropDown then do the binding". I have not seen any way to get a reference of the UpdatePanel that contains the control that triggered the partial post back. If it exists I would like to know.

Thanks

Instead of interogating the ScriptManager we can interogate each UpdatePanel's IsInPartialRendering property to know if an update panel is part of the asynchronous postback. Maybe you can figure a way around this property instead.

 

Bogdan 

Is there a way to find out which control triggered the partial postback within the updatepanel?

BTW, I always get a False value on the IsInPartialRendering property of all my UpdatePanels so this property seems useless.

You can use:

ScriptManager

.GetCurrent(Page).AsyncPostBackSourceElementID

to see what caused the async postback.

Hi,

I think this code would help you.

 

Thanks for the code, Cyril...

There is one more case.  UpdatePanel can be refreshed using a submit button or another control inside it.  In that case you would need to use code like this:

            Control control=this.Page.FindControl(scriptManager.AsyncPostBackSourceElementID);

            while (control != null)
            {
                if (control is UpdatePanel)
                      return (UpdatePanel)control;

                 control = control.Parent;
            }

            return null;

Regards,

Eric

 

Gents, 

Actually, it gets worse. Both code blocks above make the assumption that the triggering AsyncPostBackSourceElementID is a child of the UpdatePanel in question. This is by no means a safe assumption.

External triggers could set it off. The only way I can see to ensure that you've unequivocally determined which UpdatePanel is being processed is to iterate the UpdatePanels (for which there is no simple method), iterate their triggers (which have to be cast either to PostBackTrigger or AsyncPostBackTrigger to get the ControlID), and compare said ControlIDs with the AsyncPostBackSourceElementID. If you try to generalize it across all the UpdatePanels on a page, it gets pretty Rube Goldberg. I'm using the following code to tell if a specific panel is being updated:

	private bool IsUpdating(ScriptManager sm, UpdatePanel up) {
		string elemID = sm.AsyncPostBackSourceElementID;
		foreach (UpdatePanelTrigger t in up.Triggers) {
			PostBackTrigger pt = t as PostBackTrigger;
			if (pt != null)
				if (pt.ControlID == elemID)
					return true;
			AsyncPostBackTrigger apt = t as AsyncPostBackTrigger;
			if (apt != null)
				if (apt.ControlID == elemID)
					return true;
		}
		return false;
	}

 

Why the UpdatePanel doesn't provide an event to indicate that it's getting partially updated is quite beyond me. This seems like a glaring hole in the implementation. If there was a compelling reason to leave this out, I'd be very curious to hear it.

Cheers!

Eric

My apologies, Cyril.

I didn't get a really good look at your code before posting. You do seem to have the problem covered pretty well. One thing neither of us handles quite right is the case where a single control might trigger the update of multiple panels.

Still, does anyone else find it just a bit crazy that we have to go to this monumental effort just to determine which panels are being updated? There should be a better way.

Cheers!

Eric

Hi Eric,

The better way would be if UpdatePanel.IsInPartialRendering would actually return the correct value.  Unfortunately it doesn't work correctly and always seems to return false.

Right now Cyril's and my code only returns the first UpdatePanel, but it should be pretty easy to modify our code to return a list of all panels being refreshed.

Regards,

Eric P
 

 

Hi,

you're right, my code works only for refreshed panel fired with a trigger. This code would work in many case :

But I think in some complex case it would not works. For example if we use UserControl, nested UpdatePanel and things like that ... I will have a look at this tommorow.

 

ewlloyd > I don't try your code but it will not work, if (apt.ControlID == elemID) apt.ControlID is only the ID of the client and elemID is the UniqueID ... so if you use UserControl or MasterPage it will not work because the ControlID is different to UniqueID :-)

Cyril, 

Yeah, you're right. Good catch. I'll tweak on it some more as the need arises.

Thanks!

Eric

Hi All,

I faced the same problem this week. In the documentation I read about the RequiresUpdate property wich is a protected property on the UpdatePanel. Since it's a protected property I could'nt access it directly. That's why I created my own contol wich extends the update panel. I created an extra property "IsUpating", wich will indicate if an updatepanel is triggered for updating. The property will return true if a AscyncPostbackTrigger was raised or the Update method was called Directly. The downside of this solution is that the property is available not earlier then the OnLoadComplete Event.

Here´s the code for the extended component

1    using System;
2    using System.Collections.Generic;
3    using System.Text;
4    using System.Web;
5    using System.Web.UI;
6    
7    namespace UpdatePanelControlExtender
8    {
9        /// <summary>
10       /// Extends the Normal UpdatePanel so we can determine if the 
11       /// UpdatePanel is in PartialRendering stage.
12       /// </summary>
13       public class ExtendedUpdatePanel : UpdatePanel
14       {
15   
16           /// <summary>
17           /// Indicates that the UpdatePanel is updating
18           /// </summary>
19           public bool IsUpdating
20           {
21               get
22               {
23                   return this.RequiresUpdate;
24               }
25           }
26       }
27   
28   }
29   

Below you find the Sample ASPX and the Code behind I used for testing. Basicly you have three buttons:

1. UpdateButton. The click event is added to the AsyncPostbackTriggerCollection, so ExtendedUpdatePanel2 will be updated

2.  UpdateInCodeBehind. The Click event handler calls the UodateMethod of ExtendedUpdatePanel2, so ExtendedUpdatePanel2  will be updated

3.  NoUpdateButton. This button will cause an update ExtendedUpdatePanel2

 I have used an extra ExtendedUpdatepanel (ExtendedUpdatePanel1) to show is ExtendedUpdatePanel2 was updated.

 Default.aspx file
1    <%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>
2    
3    <%@ Register Assembly="UpdatePanelControlExtender" Namespace="UpdatePanelControlExtender"
4        TagPrefix="cc1" %>
5    
6    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
7    <html xmlns="http://www.w3.org/1999/xhtml">
8    <head runat="server">
9        <title>Untitled Page</title>
10   </head>
11   <body>
12       <form id="form1" runat="server">
13           <asp:ScriptManager ID="ScriptManager1" runat="server" />
14           <div>
15               <cc1:extendedupdatepanel id="ExtendedUpdatePanel1" runat="server" UpdateMode="Conditional"><ContentTemplate>
16   <asp:Label id="IsUpdatingLabel" runat="server" Text=""></asp:Label>
17   </ContentTemplate>
18                   <Triggers>
19                       <asp:AsyncPostBackTrigger ControlID="NoUpdateBut