Lebenszyklusereignisse des AJAX-Clients
Aktualisiert: November 2007
Eine AJAX-fähige ASP.NET-Seite löst die gleichen serverseitigen Lebenszyklusereignisse wie eine ASP.NET 2.0-Webseite und darüber hinaus auch clientseitige Lebenszyklusereignisse aus. Die Clientereignisse ermöglichen die Anpassung der Benutzeroberfläche sowohl für Postbacks als auch für asynchrone Postbacks (Teilaktualisierungen von Seiten). Die Clientereignisse sind auch hilfreich bei der Verwaltung benutzerdefinierter Skriptkomponenten während der Lebensdauer der Seite im Browser.
Die Clientereignisse werden von Klassen in Microsoft AJAX Library ausgelöst. Diese Klassen werden automatisch instanziiert, wenn eine Seite ASP.NET AJAX-Serversteuerelemente enthält. Die Clientklassen stellen APIs bereit, mit denen Sie Ereignisse binden und Handler für diese Ereignisse bereitstellen können. Da Microsoft AJAX Library browserunabhängig ist, funktioniert der Code, den Sie für die Handler schreiben, in allen unterstützten Browsern auf die gleiche Weise.
Das wichtigste Ereignis für ursprüngliche Anforderungen (GET-Anforderungen) und synchrone Postbacks ist das load-Ereignis der Application-Instanz. Wenn ein Skript in einem load-Ereignishandler ausgeführt wird, wurden alle Skripts und Komponenten geladen und stehen zur Verfügung. Wenn das Teilrendering von Seiten mit UpdatePanel-Steuerelementen aktiviert ist, handelt es sich bei den wichtigsten Ereignissen des Clients um die Ereignisse der PageRequestManager-Klasse. Mithilfe dieser Ereignisse können Sie viele Standardszenarien behandeln. Hierzu gehört die Möglichkeit, Postbacks abzubrechen, einem Postback Vorrang gegenüber einem anderen einzuräumen und UpdatePanel-Steuerelemente zu animieren, wenn deren Inhalt aktualisiert wird.
Clientereignisse sind hilfreich beim Erstellen von Seiten oder Schreiben von Komponenten. Als Seitenentwickler können Sie ein benutzerdefiniertes Skript bereitstellen, das beim Laden und Entladen der Seite im Browser aufgerufen wird.
Weitere Informationen zu serverseitigen Lebenszyklusereignissen finden Sie unter Übersicht über den Lebenszyklus von ASP.NET-Seiten.
Clientklassen
Die beiden wichtigsten Microsoft AJAX Library-Klassen, die während des Clientlebenszyklus einer ASP.NET AJAX-Webseite Ereignisse auslösen, sind die Application-Klasse und die PageRequestManager-Klasse.
Die Application-Klasse wird im Browser instanziiert, wenn die Seite ein ScriptManager-Steuerelement enthält. Die Application-Klasse ähnelt dem Page-Serversteuerelement, das sich von der Control-Klasse ableitet, stellt jedoch zusätzliche Funktionen zum Auslösen von Serverereignissen bereit. Ebenso wird die Application-Klasse von der Sys.Component-Klasse abgeleitet, löst jedoch Client-Lebenszyklusereignisse aus, die behandelt werden können.
Wenn eine Seite ein ScriptManager-Steuerelement sowie mindestens ein UpdatePanel-Steuerelement enthält, können Teilaktualisierungen der Seite ausgeführt werden (falls das Teilrendering von Seiten im Browser aktiviert ist und unterstützt wird). In diesem Fall ist im Browser automatisch eine Instanz der PageRequestManager-Klasse verfügbar. Die PageRequestManager-Klasse löst Clientereignisse aus, die für asynchrone Postbacks spezifisch sind. Ausführliche Informationen über das Teilrendering von Seiten finden Sie unter Übersicht über das Teilrendering von Seiten.
Hinzufügen von Handlern für Clientereignisse
Verwenden Sie zum Hinzufügen oder Entfernen von Handlern für Ereignisse, die von der Application-Klasse und der PageRequestManager-Klasse ausgelöst werden, die add_Ereignisname-Methode und die remove_Ereignisname-Methode dieser Klassen. Im folgenden Beispiel wird gezeigt, wie ein Handler mit dem Namen MyLoad dem init-Ereignis des Application-Objekts hinzugefügt wird.
Sys.Application.add_init(MyInit);
function MyInit(sender) {
}
Sys.Appplication.remove_init(MyInit);
Sys.Application.add_init(MyInit);
function MyInit(sender) {
}
Sys.Appplication.remove_init(MyInit);
.gif "Hinweis") Hinweis: |
|---|
In diesem Beispiel wird nur die Syntax der add_Ereignisname-Methode und der remove_Ereignisname-Methode veranschaulicht. Ausführliche Informationen zu den Verwendungsmöglichkeiten bestimmter Ereignisse finden Sie weiter unten in diesem Thema. |
Behandeln des Load-Ereignisses und des Unload-Ereignisses von Anwendungen
Zum Behandeln des load-Ereignisses und des unload-Ereignisses des Application-Objekts ist es nicht erforderlich, einen Handler explizit an das Ereignis zu binden. Stattdessen können Sie Funktionen erstellen, die die reservierten Namen pageLoad und pageUnload verwenden. Im folgenden Beispiel wird gezeigt, wie mit diesem Ansatz ein Handler für das load-Ereignis des Application-Objekts hinzugefügt werden kann.
function pageLoad(sender, args) {
}
function pageLoad(sender, args) {
}
Ereignisse für andere Clientklassen
In diesem Thema werden nur die Ereignisse beschrieben, die von der Application-Klasse und der PageRequestManager-Klasse ausgelöst werden. Microsoft AJAX Library enthält auch Klassen zum Hinzufügen, Löschen und Entfernen von Handlern für DOM-Elementereignisse. Zu diesen Klassen gehören:
Die Sys.UI.DomEvent.addHandler-Methode bzw. die Verknüpfung $addHandler.
Die Sys.UI.DomEvent.clearHandlers-Methode bzw. die Verknüpfung $clearHandlers.
Die Sys.UI.DomEvent.removeHandler-Methode bzw. die Verknüpfung $removeHandler.
Von DOM-Elementen ausgelöste Ereignisse werden in diesem Thema nicht erläutert.
Clientereignisse der Application-Klasse und der PageRequestManager-Klasse
In der folgenden Tabelle werden die Clientereignisse der Application-Klasse und der PageRequestManager-Klasse aufgeführt, die Sie auf AJAX ASP.NET-fähigen Seiten behandeln können. Die Reihenfolge, in der die Ereignisse ausgelöst werden, wird weiter unten in diesem Thema beschrieben.
Ereignis |
Beschreibung |
|---|---|
Wird ausgelöst, nachdem alle Skripts geladen wurden, jedoch bevor Objekte erstellt werden. Wenn Sie eine Komponente schreiben, stellt das init-Ereignis einen Punkt im Lebenszyklus zur Verfügung, an dem Sie der Seite die Komponente hinzufügen können. Die Komponente kann anschließend zu einem späteren Zeitpunkt im Lebenszyklus von anderen Komponenten oder Skripts der Seite verwendet werden. Wenn Sie Seiten entwickeln, sollten Sie in den meisten Szenarien das load-Ereignis anstelle des init-Ereignisses verwenden. Das init-Ereignis wird nur ein Mal beim ersten Rendering der Seite ausgelöst. Durch nachfolgende Teilaktualisierungen von Seiten wird das init-Ereignis nicht ausgelöst. |
|
Wird ausgelöst, nachdem alle Skripts geladen und in der Anwendung alle Objekte initialisiert wurden, die mithilfe von $create erstellt werden. Das load-Ereignis wird für alle Postbacks an den Server ausgelöst, einschließlich asynchrone Postbacks. Als Seitenentwickler können Sie eine Funktion mit dem Namen pageLoad erstellen, die automatisch einen Handler für das load-Ereignis bereitstellt. Der pageLoad-Handler wird nach den Handlern aufgerufen, die dem load-Ereignis durch die add_load-Methode hinzugefügt wurden. Das load-Ereignis verwendet einen eventargs-Parameter, bei dem es sich um ein Sys.ApplicationLoadEventArgs-Objekt handelt. Anhand der Ereignisargumente können Sie bestimmen, ob die Seite durch eine Teilaktualisierung von Seiten aktualisiert wird und welche Komponenten seit dem Auslösen des vorherigen load-Ereignisses erstellt wurden. |
|
Wird ausgelöst, bevor alle Objekte freigegeben werden und bevor das window.unload-Ereignis des Browserfensters stattfindet. Als Seitenentwickler können Sie eine Funktion mit dem Namen pageUnload erstellen, die automatisch einen Handler für das unload-Ereignis bereitstellt. Das pageUnload-Ereignis wird aufgerufen, unmittelbar bevor die Seite aus dem Browser entladen wird. Während dieses Ereignisses sollten Sie alle Ressourcen freigeben, die der Code belegt. |
|
Kann ausgelöst werden, wenn sich eine Eigenschaft einer Komponente ändert. Dieses Ereignis wird nur ausgelöst, wenn ein Komponentenentwickler die Sys.Component.raisePropertyChange-Methode in einem set-Accessor der Eigenschaft aufgerufen hat. Weitere Informationen finden Sie unter Definieren von benutzerdefinierten Komponenteneigenschaften und Auslösen von PropertyChanged-Ereignissen. Das propertyChanged-Ereignis verwendet einen eventargs-Parameter, bei dem es sich um ein Sys.applicationLoadEventArgs-Objekt handelt. |
|
Wird ausgelöst, wenn die Application-Instanz freigegeben wird. |
|
Wird vor dem Start einer asynchronen Anforderung ausgelöst. Sie können dieses Ereignis zum Abbrechen eines Postbacks verwenden, um z. B. einem anderen asynchronen Postback Vorrang zu geben. Das initializeRequest-Ereignis verwendet einen eventargs-Parameter, bei dem es sich um ein Sys.WebForms.InitializeRequestEventArgs-Objekt handelt. Dieses Objekt stellt das Element zur Verfügung, von dem das Postback und das zugrunde liegende Anforderungsobjekt verursacht wurden. Durch InitializeRequestEventArgs wird zudem eine cancel-Eigenschaft verfügbar gemacht. Wenn Sie cancel auf true festlegen, wird das neue Postback abgebrochen. |
|
Wird vor dem Starten eines asynchronen Postback und dem Senden des Postbacks an den Server ausgelöst. Wird bereits ein Postback verarbeitet, wird dieses mithilfe der abortPostBack-Methode beendet. Sie können dieses Ereignis zum Festlegen von Anforderungsheadern oder zum Starten einer Animation auf der Seite verwenden, die anzeigt, dass die Anforderung verarbeitet wird. Das beginRequest-Ereignis verwendet einen eventargs-Parameter, bei dem es sich um ein Sys.WebForms.BeginRequestEventArgs-Objekt handelt. Dieses Objekt macht das Element verfügbar, von dem das Postback und das zugrunde liegende Anforderungsobjekt verursacht wurden. |
|
Wird nach dem Empfang der Antwort des Servers auf ein asynchrones Postback ausgelöst, jedoch vor der Aktualisierung von Inhalten auf der Seite. Mithilfe dieses Ereignisses können Sie einen benutzerdefinierten Übergangseffekt für aktualisierte Inhalte bereitstellen. Das pageLoading-Ereignis verwendet einen eventargs-Parameter, bei dem es sich um ein Sys.WebForms.PageLoadingEventArgs-Objekt handelt. Dieses Objekt stellt Informationen darüber zur Verfügung, welche Bereiche aufgrund des letzten asynchronen Postbacks gelöscht und aktualisiert werden. |
|
Wird nach der Aktualisierung des gesamten Inhalts der Seite durch ein synchrones oder asynchrones Postback ausgelöst. Bei synchronen Postbacks können Bereiche nur erstellt werden, bei asynchronen Postbacks können Bereiche jedoch sowohl erstellt als auch aktualisiert werden. Mithilfe dieses Ereignisses können Sie einen benutzerdefinierten Übergangseffekt für aktualisierte Inhalte verwalten. Das pageLoaded-Ereignis verwendet einen eventargs-Parameter, bei dem es sich um ein Sys.WebForms.PageLoadedEventArgs-Objekt handelt. Dieses Objekt macht Informationen darüber verfügbar, welche Bereiche im letzten Postback aktualisiert und erstellt wurden. |
|
Wird ausgelöst, nachdem die Antwort auf ein asynchrones Postback verarbeitet und die Seite aktualisiert wurde, oder während der Verarbeitung der Antwort, falls ein Fehler vorliegt. Wenn ein Fehler auftritt, wird die Seite nicht aktualisiert. Verwenden Sie dieses Ereignis, um benutzerdefinierte Fehlermeldungen für die Benutzer bereitzustellen oder Fehler zu protokollieren. Das endRequest-Ereignis verwendet einen eventargs-Parameter, bei dem es sich um ein Sys.WebForms.EndRequestEventArgs-Objekt handelt. Dieses Objekt stellt Informationen über aufgetretene Fehler sowie darüber zur Verfügung, ob der Fehler behandelt wurde. Außerdem macht es das Antwortobjekt verfügbar. |
Beispiel für eine Ereignisreihenfolge
Das folgende Beispiel werden die Clientereignisse dargestellt, die auf einer Seite mit zwei ineinander geschachtelten UpdatePanel-Steuerelementen ausgelöst werden. Beachten Sie, dass es einen Unterschied macht, ob auf die Schaltfläche im übergeordneten Bereich oder auf die Schaltfläche im geschachtelten Bereich geklickt wird. Beim Klicken auf die Schaltfläche im übergeordneten Bereich wird der übergeordnete Bereich aktualisiert, während der geschachtelte Bereich gelöscht und neu erstellt wird. Beim Klicken auf die Schaltfläche im geschachtelten Bereich wird nur der geschachtelte Bereich aktualisiert.
<%@ Page Language="VB" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<script >
</script>
<html xmlns="http://www.w3.org/1999/xhtml" >
<head >
<title>Client Event Example</title>
<style type="text/css">
#OuterPanel { width: 600px; height: 200px; border: 2px solid blue; }
#NestedPanel { width: 596px; height: 60px; border: 2px solid green;
margin-left:5 px; margin-right:5px; margin-bottom:5px;}
</style>
</head>
<body>
<form id="form1" >
<div>
<asp:ScriptManager ID="ScriptManager1" >
<Scripts>
<asp:ScriptReference Path="ClientEventTest.js" />
</Scripts>
</asp:ScriptManager>
<asp:UpdatePanel ID="OuterPanel" UpdateMode="Conditional" >
<ContentTemplate>
Postbacks from inside the outer panel and inner panel are
asynchronous postbacks. PRM = Sys.WebForms.PageRequestManager. APP = Sys.Application.
<br /><br />
<asp:Button ID="OPButton1" Text="Outer Panel Button" />
Last updated on
<%= DateTime.Now.ToString() %>
<br /><br />
<asp:UpdatePanel ID="NestedPanel" UpdateMode="Conditional" >
<ContentTemplate>
<asp:Button ID="NPButton1" Text="Nested Panel 1 Button" />
Last updated on
<%= DateTime.Now.ToString() %>
<br />
</ContentTemplate>
</asp:UpdatePanel>
</ContentTemplate>
</asp:UpdatePanel>
<input type="button" onclick="Clear();" value="Clear" />
<asp:Button ID="FullPostBack" Text="Full Postback" />
<a href="https://www.microsoft.com">Test Window Unload</a>
<br />
<span id="ClientEvents"></span>
</div>
</form>
</body>
</html>
<%@ Page Language="C#" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<script >
</script>
<html xmlns="http://www.w3.org/1999/xhtml" >
<head >
<title>Client Event Example</title>
<style type="text/css">
#OuterPanel { width: 600px; height: 200px; border: 2px solid blue; }
#NestedPanel { width: 596px; height: 60px; border: 2px solid green;
margin-left:5 px; margin-right:5px; margin-bottom:5px;}
</style>
</head>
<body>
<form id="form1" >
<div>
<asp:ScriptManager ID="ScriptManager1" >
<Scripts>
<asp:ScriptReference Path="ClientEventTest.js" />
</Scripts>
</asp:ScriptManager>
<asp:UpdatePanel ID="OuterPanel" UpdateMode="Conditional" >
<ContentTemplate>
Postbacks from inside the outer panel and inner panel are
asynchronous postbacks. PRM = Sys.WebForms.PageRequestManager. APP = Sys.Application.
<br /><br />
<asp:Button ID="OPButton1" Text="Outer Panel Button" />
Last updated on
<%= DateTime.Now.ToString() %>
<br /><br />
<asp:UpdatePanel ID="NestedPanel" UpdateMode="Conditional" >
<ContentTemplate>
<asp:Button ID="NPButton1" Text="Nested Panel 1 Button" />
Last updated on
<%= DateTime.Now.ToString() %>
<br />
</ContentTemplate>
</asp:UpdatePanel>
</ContentTemplate>
</asp:UpdatePanel>
<input type="button" onclick="Clear();" value="Clear" />
<asp:Button ID="FullPostBack" Text="Full Postback" />
<a href="https://www.microsoft.com">Test Window Unload</a>
<br />
<span id="ClientEvents"></span>
</div>
</form>
</body>
</html>
// Hook up Application event handlers.
var app = Sys.Application;
app.add_load(ApplicationLoad);
app.add_init(ApplicationInit);
app.add_disposing(ApplicationDisposing);
app.add_unload(ApplicationUnload);
// Application event handlers for component developers.
function ApplicationInit(sender) {
var prm = Sys.WebForms.PageRequestManager.getInstance();
if (!prm.get_isInAsyncPostBack())
{
prm.add_initializeRequest(InitializeRequest);
prm.add_beginRequest(BeginRequest);
prm.add_pageLoading(PageLoading);
prm.add_pageLoaded(PageLoaded);
prm.add_endRequest(EndRequest);
}
$get('ClientEvents').innerHTML += "APP:: Application init. <br/>";
}
function ApplicationLoad(sender, args) {
$get('ClientEvents').innerHTML += "APP:: Application load. ";
$get('ClientEvents').innerHTML += "(isPartialLoad = " + args.get_isPartialLoad() + ")<br/>";
}
function ApplicationUnload(sender) {
alert('APP:: Application unload.');
}
function ApplicationDisposing(sender) {
$get('ClientEvents').innerHTML += "APP:: Application disposing. <br/>";
}
// Application event handlers for page developers.
function pageLoad() {
$get('ClientEvents').innerHTML += "PAGE:: Load.<br/>";
}
function pageUnload() {
alert('Page:: Page unload.');
}
// PageRequestManager event handlers.
function InitializeRequest(sender, args) {
$get('ClientEvents').innerHTML += "<hr/>";
$get('ClientEvents').innerHTML += "PRM:: Initializing async request.<br/>";
}
function BeginRequest(sender, args) {
$get('ClientEvents').innerHTML += "PRM:: Begin processing async request.<br/>";
}
function PageLoading(sender, args) {
$get('ClientEvents').innerHTML += "PRM:: Loading results of async request.<br/>";
var updatedPanels = printArray("PanelsUpdating", args.get_panelsUpdating());
var deletedPanels = printArray("PanelsDeleting", args.get_panelsDeleting());
var message = "-->" + updatedPanels + "<br/>-->" + deletedPanels + "<br/>";
document.getElementById("ClientEvents").innerHTML += message;
}
function PageLoaded(sender, args) {
$get('ClientEvents').innerHTML += "PRM:: Finished loading results of async request.<br/>";
var updatedPanels = printArray("PanelsUpdated", args.get_panelsUpdated());
var createdPanels = printArray("PaneslCreated", args.get_panelsCreated());
var message = "-->" + updatedPanels + "<br/>-->" + createdPanels + "<br/>";
document.getElementById("ClientEvents").innerHTML += message;
}
function EndRequest(sender, args) {
$get('ClientEvents').innerHTML += "PRM:: End of async request.<br/>";
}
// Helper functions.
function Clear()
{
$get('ClientEvents').innerHTML = "";
}
function printArray(name, arr)
{
var panels = name + '=' + arr.length;
if(arr.length > 0)
{
panels += "(";
for(var i = 0; i < arr.length; i++)
{
panels += arr[i].id + ',';
}
panels = panels.substring(0, panels.length - 1);
panels += ")";
}
return panels;
}
// Hook up Application event handlers.
var app = Sys.Application;
app.add_load(ApplicationLoad);
app.add_init(ApplicationInit);
app.add_disposing(ApplicationDisposing);
app.add_unload(ApplicationUnload);
// Application event handlers for component developers.
function ApplicationInit(sender) {
var prm = Sys.WebForms.PageRequestManager.getInstance();
if (!prm.get_isInAsyncPostBack())
{
prm.add_initializeRequest(InitializeRequest);
prm.add_beginRequest(BeginRequest);
prm.add_pageLoading(PageLoading);
prm.add_pageLoaded(PageLoaded);
prm.add_endRequest(EndRequest);
}
$get('ClientEvents').innerHTML += "APP:: Application init. <br/>";
}
function ApplicationLoad(sender, args) {
$get('ClientEvents').innerHTML += "APP:: Application load. ";
$get('ClientEvents').innerHTML += "(isPartialLoad = " + args.get_isPartialLoad() + ")<br/>";
}
function ApplicationUnload(sender) {
alert('APP:: Application unload.');
}
function ApplicationDisposing(sender) {
$get('ClientEvents').innerHTML += "APP:: Application disposing. <br/>";
}
// Application event handlers for page developers.
function pageLoad() {
$get('ClientEvents').innerHTML += "PAGE:: Load.<br/>";
}
function pageUnload() {
alert('Page:: Page unload.');
}
// PageRequestManager event handlers.
function InitializeRequest(sender, args) {
$get('ClientEvents').innerHTML += "<hr/>";
$get('ClientEvents').innerHTML += "PRM:: Initializing async request.<br/>";
}
function BeginRequest(sender, args) {
$get('ClientEvents').innerHTML += "PRM:: Begin processing async request.<br/>";
}
function PageLoading(sender, args) {
$get('ClientEvents').innerHTML += "PRM:: Loading results of async request.<br/>";
var updatedPanels = printArray("PanelsUpdating", args.get_panelsUpdating());
var deletedPanels = printArray("PanelsDeleting", args.get_panelsDeleting());
var message = "-->" + updatedPanels + "<br/>-->" + deletedPanels + "<br/>";
document.getElementById("ClientEvents").innerHTML += message;
}
function PageLoaded(sender, args) {
$get('ClientEvents').innerHTML += "PRM:: Finished loading results of async request.<br/>";
var updatedPanels = printArray("PanelsUpdated", args.get_panelsUpdated());
var createdPanels = printArray("PaneslCreated", args.get_panelsCreated());
var message = "-->" + updatedPanels + "<br/>-->" + createdPanels + "<br/>";
document.getElementById("ClientEvents").innerHTML += message;
}
function EndRequest(sender, args) {
$get('ClientEvents').innerHTML += "PRM:: End of async request.<br/>";
}
// Helper functions.
function Clear()
{
$get('ClientEvents').innerHTML = "";
}
function printArray(name, arr)
{
var panels = name + '=' + arr.length;
if(arr.length > 0)
{
panels += "(";
for(var i = 0; i < arr.length; i++)
{
panels += arr[i].id + ',';
}
panels = panels.substring(0, panels.length - 1);
panels += ")";
}
return panels;
}
Ereignisreihenfolge in gängigen Szenarien
Die Reihenfolge der Ereignisse hängt von der Art der auf der Seite verwendeten Steuerelemente und vom Typ der Anforderung ab (ursprüngliche Anforderung, Postback oder asynchrones Postback). In diesem Abschnitt wird die Reihenfolge der Ereignisse für verschiedene gängige Szenarien beschrieben.
Ursprüngliche Anforderung
Während der ursprünglichen Anforderung für die Seite wird eine begrenzte Anzahl von Clientereignissen ausgelöst. Gehen Sie bei der ursprünglichen Anforderung von folgendem Szenario aus:
Die Seite enthält ein ScriptManager-Steuerelement, und die SupportsPartialRendering-Eigenschaft sowie die EnablePartialRendering-Eigenschaft des Steuerelements haben jeweils den Wert true.
Die Anforderung ist eine GET-Anforderung.
Es wird eine Antwort des Servers zurückgegeben.
Die folgenden Clientereignisse treten in der folgenden Reihenfolge auf:
Die ursprüngliche Anforderung wird an den Server gesendet.
Die Antwort wird vom Client empfangen.
Die Application-Instanz löst das init-Ereignis aus.
Die Application-Instanz löst das load-Ereignis aus.
Das init-Ereignis der Application-Instanz wird während der Lebensdauer der Seite im Browser nur ein Mal ausgelöst. Bei nachfolgenden asynchronen Postbacks wird es nicht ausgelöst. Während einer ursprünglichen Anforderung werden keine PageRequestManager-Ereignisse ausgelöst.
Asynchrones Postback
Ein asynchrones Postback sendet einige Seitendaten an den Server, empfängt eine Antwort und aktualisiert einen Teil der Seite. Gehen Sie bei einem asynchronen Postback von folgendem Szenario aus:
Die Seite enthält ein ScriptManager-Steuerelement, und die SupportsPartialRendering-Eigenschaft sowie die EnablePartialRendering-Eigenschaft des Steuerelements haben jeweils den Wert true.
Die Seite enthält ein UpdatePanel-Steuerelement, und die ChildrenAsTriggers-Eigenschaft des Steuerelements hat den Wert true.
Eine Schaltfläche im UpdatePanel-Steuerelement initiiert ein asynchrones Postback.
Es wird eine Antwort des Servers zurückgegeben.
Die folgenden Clientereignisse treten in der folgenden Reihenfolge auf:
Beim Klicken auf die Schaltfläche im UpdatePanel wird ein asynchrones Postback initiiert.
Die PageRequestManager-Instanz löst das initializeRequest-Ereignis aus.
Die PageRequestManager-Instanz löst das beginRequest-Ereignis aus.
Die Anforderung wird an den Server gesendet.
Die Antwort wird vom Client empfangen.
Die PageRequestManager-Instanz löst das pageLoading-Ereignis aus.
Die PageRequestManager-Instanz löst das pageLoaded-Ereignis aus.
Die Application-Instanz löst das load-Ereignis aus.
Die PageRequestManager-Instanz löst das endRequest-Ereignis aus.
Weitere Informationen finden Sie unter Arbeiten mit PageRequestManager-Ereignissen.
Beachten Sie, dass das load-Ereignis der Application-Instanz nach dem PageRequestManagerpageLoaded-Ereignis und vor dem endRequest-Ereignis ausgelöst wird.
Mehrere asynchrone Postbacks
Mehrere asynchrone Postbacks können auftreten, wenn Benutzer eine neue Anforderung initiieren, bevor eine zuvor initiierte Anforderung auf dem Server oder im Browser verarbeitet wurde. Gehen Sie bei mehreren asynchronen Postbacks von folgendem Szenario aus:
Die Seite enthält ein ScriptManager-Steuerelement, und die SupportsPartialRendering-Eigenschaft sowie die EnablePartialRendering-Eigenschaft des Steuerelements haben jeweils den Wert true.
Die Seite enthält ein UpdatePanel-Steuerelement.
Es wird zweimal auf eine Schaltfläche in dem UpdatePanel-Steuerelement geklickt, das ein asynchrones Postback initiiert. Der zweite Klick erfolgt, während der Server die durch den ersten Klick initiierte Anforderung verarbeitet.
Eine Antwort auf die erste Anforderung wird vom Server zurückgegeben.
Die folgenden Clientereignisse treten in der folgenden Reihenfolge auf:
Beim Klicken auf eine Schaltfläche in UpdatePanel wird ein asynchrones Postback initiiert.
Die PageRequestManager-Instanz löst das initializeRequest-Ereignis aus.
Die PageRequestManager-Instanz löst das beginRequest-Ereignis aus.
Die Anforderung wird an den Server gesendet.
Auf die Schaltfläche wird erneut geklickt, wodurch ein zweites asynchrones Postback initiiert wird.
Die PageRequestManager-Instanz löst das initializeRequest-Ereignis für den zweiten Klick auf die Schaltfläche aus.
Die PageRequestManager-Instanz löst das endRequest-Ereignis für den ersten Klick auf die Schaltfläche aus.
Die PageRequestManager-Instanz löst das beginRequest-Ereignis für den zweiten Klick auf die Schaltfläche aus.
Die durch den zweiten Klick initiierte Anforderung wird an den Server gesendet.
Die Antwort für den zweiten Klick wird empfangen.
Die PageRequestManager-Instanz löst das pageLoading-Ereignis aus.
Die PageRequestManager-Instanz löst das pageLoaded-Ereignis aus.
Die Application-Instanz löst das load-Ereignis aus.
Die PageRequestManager-Instanz löst das endRequest-Ereignis aus.
Im Standardverhalten für asynchrone Postbacks hat das aktuellste asynchrone Postback Vorrang. Wenn zwei asynchrone Postbacks nacheinander auftreten und das erste Postback noch im Browser verarbeitet wird, wird das erste Postback abgebrochen. Wenn das erste Postback an den Server gesendet wurde, verarbeitet der Server die zweite Anforderung, sobald diese eintrifft, und gibt die erste Anforderung nicht zurück. Informationen darüber, wie Sie einem bestimmten asynchronen Postback Vorrang geben, finden Sie unter Einem bestimmten asynchronen Postback Vorrang gewähren.
Verlassen einer Seite
Wenn der Benutzer eine Seite verlässt, wird die aktuelle Seite aus dem Browser entladen, und Sie können das unload-Ereignis behandeln, um Ressourcen freizugeben. Gehen Sie beim Verlassen einer Seite von folgendem Szenario aus:
Die Seite enthält ein ScriptManager-Steuerelement, und die SupportsPartialRendering-Eigenschaft sowie die EnablePartialRendering-Eigenschaft des Steuerelements haben jeweils den Wert true.
Die Zielseite ist vorhanden.
Die folgenden Clientereignisse werden in der folgenden Reihenfolge ausgelöst:
Die Anforderung für die neue Seite wird initiiert.
Die Antwort für die neue Seite wird vom Browser empfangen.
Die Application-Instanz löst das unload-Ereignis aus.
Die neue Seite wird angezeigt.
Wenn die Anforderung für die neue Seite einen Fehler enthält, wird dennoch das unload-Ereignis ausgelöst, die neue Seite wird jedoch nicht angezeigt.
Siehe auch
Konzepte
Übersicht über den Lebenszyklus von ASP.NET-Seiten