So entwickeln Sie serverseitige Controls für ASP-Seiten

  • Artikel

Veröffentlicht: 15. Dez 2001 | Aktualisiert: 16. Jun 2004

Von George Shepherd

Mit ASP.NET können Sie auf elegante Weise serverseitige Steuerelemente erstellen, mit denen der Aufbau einer Benutzerschnittstelle standardisiert und gekapselt wird. Dieser Beitrag zeigt ein Einsatzbeispiel dafür.

Auf dieser Seite

Serverseitige Steuerelemente Serverseitige Steuerelemente
Einfache, nicht zusammengesetzte Steuerelemente Einfache, nicht zusammengesetzte Steuerelemente
Die Steuerelementeklasse Die Steuerelementeklasse
Schnittstellen der serverseitigen Steuerelemente Schnittstellen der serverseitigen Steuerelemente
Fahrenheit und Celsius Fahrenheit und Celsius
Anzeige des Steuerelements Anzeige des Steuerelements
Erzeugung eines Rücksendeskripts Erzeugung eines Rücksendeskripts
Annahme der zurückgeschickten Daten Annahme der zurückgeschickten Daten
Rückmeldung von Ereignissen Rückmeldung von Ereignissen
Einbau des Steuerelements in eine Seite Einbau des Steuerelements in eine Seite
Der erzeugte HTML-Code Der erzeugte HTML-Code

Diesen Artikel können Sie hier lesen dank freundlicher Unterstützung der Zeitschrift:

sys.gif

Im letzten Heft beschäftigte ich mich mit der Frage, wie man serverseitige ASP.NET-Steuerelemente aus anderen Steuerelementen zusammensetzt. Als Beispiel wählte ich einen Temperaturkonverter, der Fahrenheit in Grad Celsius umrechnet und umgekehrt. Er setzte sich aus zwei Schaltflächen und zwei Eingabefeldern zusammen.

Statt nun serverseitige Steuerelemente aus verschiedenen Standard-Steuerelementen zusammenzusetzen, wie ich es in der letzten Ausgabe tat, möchte ich sie diesmal während der Laufzeit via HTML zusammenstellen. In dieser Kolumne möchte ich die serverseitigen Steuerelemente wieder etwas genauer untersuchen, insbesondere in Hinblick auf die Rundgänge zwischen Browser und Server, die Übermittlung von Daten und die Entwicklung einer Anwenderschnittstelle mit herkömmlichen Web-Methoden.

Serverseitige Steuerelemente

Einer der wichtigen Gründe für die Einführung von serverseitigen Steuerelementen ist, dass man sich heutzutage nicht mehr auf ein oder zwei wohlbekannte Client-Umgebungen stützen kann. Beim Client kann es sich um irgendeines aus einer sehr großen Anzahl von verschiedenen Geräten handeln, angefangen bei kleinen portablen Geräten bis hin zu voll ausgebauten Desktop-Computern, die heutzutage ja fast schon kleine Rechenzentren sind.

Mit dem .NET Framework können Sie dieses Problem lösen, indem Sie die Zusammenstellung der Programmoberfläche auf den Server verlagern. Der Server generiert die Schnittstelle zum Anwender als HMTL-Code und schickt diesen HTML-Code zum Browser. Da jeder Browser per Definition irgendeine Form von HTML versteht, ist es durchaus vernünftig, die Anwenderschnittstelle in dieser Form zu generieren, zumal der Server bei Bedarf auch die Leistungsfähigkeit des jeweiligen Browsers berücksichtigen kann. Natürlich war es auch bisher immer möglich, zum Beispiel vom ASP-Code aus den HTML-Code zu generieren, der für die Anzeige von Steuerelementen auf dem Bildschirm sorgt. Was ist nun an den serverseitigen Steuerelementen im ASP.NET so besonders? Nun, das ASP.NET bietet ein Grundgerüst für die Standardisierung und Kapselung der Schnittstellengenerierung.

In dem einfachen Steuerelement, das ich Ihnen in Heft 3 vorstellte, fasste die C#-Klasse, die das serverseitige Steuerelement repräsentierte, mehrere Standard-Steuerelemente zusammen, die in Form von CLR-Klassen (Common Language Runtime) verfügbar waren. Die C#-Klasse enthielt die Eingabefelder und Schaltflächen als Variablen. Das zusammengesetzte Steuerelement leitete sich zudem von der CLR-Klasse Control ab und implementierte eine Schnittstelle namens INamingContainer. Das Konzept der zusammengesetzten Steuerelemente wird vom ASP.NET ziemlich überschaubar umgesetzt. Sie brauchen in den zusammengesetzten Steuerelementen nicht die Render-Methode zu überschreiben, weil die eingebetteten Steuerelemente bereits ihre eigene Anzeigelogik enthalten. Die simple Deklaration der Standard-Steuerelemente und ihre Aufnahme ins serverseitige Steuerelement veranlasst das serverseitige Steuerelement, den korrekten HTML-Code an den Browser zu schicken. Stattet man die Standard-Steuerelemente noch mit den Funktionen aus, die für die Reaktion auf Ereignisse zuständig sind, wird das Steuerelement interaktiv. Das Ergebnis ist eine Gruppe von Standard-Steuerelementen, die nach außen hin als zusammengehörige Einheit auftritt.

Einfache, nicht zusammengesetzte Steuerelemente

In dieser Folge erscheint das serverseitige Steuerelement als ganz normales, nicht zusammengesetztes Steuerelement. Es wird also nicht aus mehreren Standard-Steuerelementen (wie Schaltflächen oder Eingabefeldern) zusammengesetzt, sondern erscheint wie ein ganz normales Standard-Steuerelement auf dem Bildschirm, wobei die Anzeige allerdings wieder via HTML-Code erfolgt. Der HTML-Code wird in der Render-Methode des Steuerelements generiert.

Der Temperaturkonverter fasst zwei Eingabefelder und zwei Schaltflächen zu einer Einheit zusammen, die wie ein unteilbares Steuerelement erscheint. Geben Sie im Fahrenheit-Feld eine Zahl ein, drücken Sie auf die Schaltfläche "Fahrenheit To Centigrade" und schon rechnet das Steuerelement die Temperatur in Grad Celsius um. Celsiusgrade werden im Centigrade-Feld eingegeben und nach dem Klick auf die Schaltfläche "Centigrade To Fahrenheit" in Fahrenheit umgerechnet. Bild B1 zeigt, wie das Steuerelement im Internet Explorer 5.5 aussieht.

17Server01.GIF

B1 Der Temperaturkonverter ist einsatzbereit

Die Wahl fiel für den Temperaturkonverter zwar auf C#, aber Visual Basic wäre ebenfalls geeignet gewesen. Listing L1 zeigt den Code des gesamten Steuerelements. Wenn sie den Code dieses Steuerelements mit dem des zusammengesetzten Steuerelements aus Heft 3 vergleichen, wird Ihnen auffallen, dass diese "Normalversion" des Steuerelements mehr Code erfordert. Das liegt einfach daran, dass die Normalversion die Verantwortung für die Anzeige und die Datenverwaltung nicht an andere delegiert. Im Folgenden möchte ich kurz auf die wichtigeren Aspekte des Codes eingehen, auf die Verwaltung der Properties im Steuerelement und darauf, wie das Haupt-Steuerelement mit seinen Kindern umgeht.

L1 Diese Version übernimmt die Anzeige selbst

using System; 
using System.Web; 
using System.Web.UI; 
using System.Collections; 
using System.Web.UI.WebControls; 
namespace MSDNSamples { 
 public class TemperatureConverterCtl2 :  
    Control,  
    IPostBackDataHandler,  
    IPostBackEventHandler { 
  private double _FahrenheitValue = 0.0; 
  private double _CentigradeValue = 0.0; 
  public double FahrenheitValue { 
   get { 
    return _FahrenheitValue; 
   } 
   set { 
    _FahrenheitValue = value; 
   } 
  } 
  public double CentigradeValue { 
   get { 
    return _CentigradeValue; 
   } 
   set { 
    _CentigradeValue = value; 
   } 
  } 
  public void  
   ParseControlValues(String controlValues,  
                      ref double FahrenheitVal,  
                      ref double CentigradeVal) { 
   // Lies die Fahrenheit-Angabe ein 
   int commaPos =  
     controlValues.IndexOf(','); 
   String FahrenheitString =  
    (controlValues.Substring(0, commaPos)); 
   FahrenheitVal =  
    FahrenheitString.ToDouble(); 
   // Lies die Grad-Celsius-Angabe ein 
   String CentigradeString; 
   CentigradeString =  
    (controlValues.Substring(commaPos + 1,  
                   controlValues.Length-commaPos-1)); 
   CentigradeVal =  
    CentigradeString.ToDouble(); 
  } 
  public bool LoadPostData(String postDataKey,  
                           NameValueCollection values) { 
   String controlValues; 
   controlValues = values[postDataKey]; 
   // lies die Werte bis zum ersten Komma ein 
   double newFahrenheitValue = 0.0; 
   double newcentigradeValue = 0.0; 
   ParseControlValues(controlValues,  
                      ref newFahrenheitValue,  
                      ref newcentigradeValue); 
   if((newfahrenheitValue != FahrenheitValue) ||  
      (newcentigradeValue != _CentigradeValue)) { 
         _FahrenheitValue = newfahrenheitValue; 
         _CentigradeValue = newcentigradeValue; 
         return true; 
   } else { 
     return false; 
   } 
  } 
  public void RaisePostDataChangedEvent() { 
    // hier tun wir nichts... 
  } 
  public double C2F(double c) { 
   return (1.8 * c) + 32; 
  } 
  public double F2C(double f) { 
   return (f - 32) / 1.8; 
  } 
  public void RaisePostBackEvent(String eventArgument) { 
   if (eventArgument == null) { 
    return; 
   } 
   if (String.Compare("FahrenheitToCentigrade",  
                      eventArgument,  
                      true) == 0) { 
    this._CentigradeValue =  
    F2C(this._FahrenheitValue); 
   } else if (String.Compare("CentigradeToFahrenheit",  
                             eventArgument,  
                             true) == 0)  { 
    this._FahrenheitValue =  
     C2F(this._CentigradeValue); 
   } 
  } 
  protected override void OnPreRender() { 
   Page.RegisterPostBackScript(); 
  } 
  protected override void Render(HtmlTextWriter output) { 
   output.Write("<h3>Fahrenheit: <input name=" +  
                this.UniqueID +  
                " id = FahrenheitValueKey" +  
                " type=text value=" +  
                this.FahrenheitValue +  
                "> </h3>"); 
   output.Write("<h3>Centigrade: <input name=" +  
                this.UniqueID +  
                " id = CentigradeValue" +  
                " type=text value=" +  
                this.CentigradeValue +  
                "> </h3>"); 
   output.Write("<input type=button " +  
                "value=FahrenheitToCentigrade OnClick=\"jscript:" + 
       Page.GetPostBackEventReference(this, "FahrenheitToCentigrade") +  
                "\">   "); 
   output.Write("<input type=button " +  
                "value=CentigradeToFahrenheit OnClick=\"jscript:" + 
       Page.GetPostBackEventReference(this, "CentigradeToFahrenheit")+  
                "\">"); 
   output.WriteLine(""); 
   output.WriteLine("<br>"); 
   output.WriteLine("<br>"); 
  } 
 } 
}

Die Steuerelementeklasse

Die .NET-CLR dürfte wohl die Klassenbibliothek der nächsten Jahre darstellen. Statt die Software mit speziellen Bibliotheken von C++ oder Visual Basic zu erstellen, kann der Entwickler nun auf eine Klassenbibliothek zurückgreifen, die bereits vom Betriebssystem zur Verfügung gestellt wird. Zu dieser Bibliothek gehören natürlich auch einige Klassen, mit denen sich die Steuerelemente für die Schnittstelle zum Anwender erstellen lassen.

Die Klasse System.Web.UI.Control definiert die Properties, Methoden und Ereignisse, die es in allen Server-Steuerelementen aus dem Web Forms-Grundgerüst gibt. Die Control-Klasse hat einen Konstruktor, enthält eine Sammlung mit den anzuzeigenden Kindelementen, kümmert sich um die Initialisierung und die Ausgabe auf den Bildschirm und bietet auch die Gelegenheit zum Einbau von Ereignisfunktionen. Ich möchte mich für die aktuelle Version des Temperaturkonverters auf die Render-Methode konzentrieren.

Der Temperaturkonverter leitet sich nicht nur von der CLR-Klasse Control ab, sondern implementiert darüber hinaus auch noch zwei Standardschnittstellen der Serverseite.

Schnittstellen der serverseitigen Steuerelemente

Das zusammengesetzte Steuerelement aus der letzten Folge leitete sich von der Control-Klasse der CLR ab und hatte eine einzige Schnittstelle, nämlich INamingContainer. Die Control-Klasse führt eine Liste mit den Standard-Steuerelementen, die anzuzeigen sind, und kümmert sich automatisch um die Datenübertragungen zwischen Browser und Server.

Die einfachen Steuerelemente erfordern ein wenig mehr Programmierung, weil nun der Entwickler des Steuerelements für die Datenübertragung zuständig ist. Sobald der Anwender zum Beispiel eine Schaltfläche drückt, um die Temperatur umzurechnen, muss die Webseite die aktuellen Werte ans Steuerelement zurückschicken, damit es die Daten bearbeiten kann. Die Datenübermittlung erfolgt mit Hilfe zweier Schnittstellen, nämlich mit IPostBackDataHandler und IPostBackEventHandler.

Eine Rücksendung (postback) erfolgt, sobald eine Webseite Daten an den Server zurückschicken möchte. IPostBackDataHandler wird von Steuerelementen implementiert, die auf solche Datensendungen warten. Nach dem Eingang einer Datensendung kann das Steuerelement seinen Zustand aktualisieren und/oder aus der Datenänderung eine Ereignismeldung ableiten. Der Temperaturkonverter benutzt IPostBackDataHandler, um sich den aktuellen Temperaturwert zu beschaffen, der umgewandelt werden soll.

IPostBackDataHandler hat zwei Methoden, nämlich LoadPostData und RaisePostDataChangedEvent. LoadPostData bearbeitet die Daten, die ans Steuerelement zurückgeschickt werden. RaisePostDataChangedEvent sorgt dafür, dass das Steuerelement alle heimlichen Zuhörer informiert, die an Zustandsänderungen des Steuerelements interessiert sind.

IPostBackEventHandler definiert den Vertrag, den die Steuerelemente für die Bearbeitung der zurückgeschickten Ereignismeldungen implementieren. IPostBackEventHandler hat eine einzige Methode namens RaisePostBackEvent. Sie versetzt das Steuerelement in die Lage, die Ereignismeldungen zu verarbeiten, die vom Formular zurückgeschickt werden. Auf diese Methoden werde ich später noch näher eingehen.

Fahrenheit und Celsius

Im Normalfall dient ein Steuerelement zur leichten Bearbeitung der Nutzdaten in einer angemessenen Form. Die Nutzdaten wiederum werden im Steuerelement zum Beispiel als Property verwaltet. Der Temperaturkonverter hält die Temperaturangaben in zwei Properties, und zwar als doubles. Der Zugriff auf Properties kann in C# in einer speziellen Form erfolgen. Listing L1 zeigt die C#-Syntax für die Zugriffs- und Änderungsfunktionen am Beispiel der Celsius- und Fahrenheit-Properties.

Die Fahrenheit- und Celsius-Properties des Temperaturkonverters werden als private Datenelemente deklariert und mit den entsprechenden set- und get-Funktionen ausgelesen oder geändert. Listing L1 zeigt die Zugriffsfunktionen (die get-Funktionen), die aufgerufen werden, wenn die Werte aus den Properties FahrenheitValue oder CentigradeValue ausgelesen werden sollen. Dieses Steuerelement liest den aktuellen Fahrenheitwert aus dem Textfeld aus, das den Fahrenheitwert darstellt. In entsprechender Weise werden die Änderungsfunktion (die set-Funktion) aufgerufen, sobald die Properties FahrenheitValue und CentigradeValue neue Werte erhalten sollen. Sie speichern die neuen Werte im jeweils zuständigen Textfeld ab. Dadurch wird die Verwaltung der Werte sehr einfach.

L2 So wird das Steuerelement in einer ASP.NET-Seite eingesetzt

<%@ Register TagPrefix="MSDNSamples" Namespace="MSDNSamples" %> 
<html> 
   <body bgcolor="yellow"> 
   <center> 
      <h3><font face="Verdana" color="black"> 
      Temperature Control</font> 
      </h3>  
      <form method="POST" action="test5.aspx" runat=server> 
         <MSDNSamples:TemperatureConverterCtl2  
         id="TempCvtCtl2" runat=server/> 
      </form> 
   </center> 
   </body> 
</html>

Anzeige des Steuerelements

Die Control-Klasse der CLR bietet zur Anzeige der Steuerelemente eine Render-Klasse an, die ihren Text normalerweise in HTML-Form an den Browser schickt. Die Control-Klasse schickt den HTML-Text mit Hilfe eines HtmlTextWriter-Objekts, das sich um den Versand kümmert, an den Browser. Die wichtigsten Ausgabemethoden des HtmlTextWriter-Objekts sind Write und WriteLine. Im Listing L1 überschreibt der Temperaturkonverter die Render-Methode, damit er den HTML-Code für die beiden Textfelder und die beiden Schaltflächen an den Browser schicken kann. Die Schaltflächen werden mit einer Methode der Page-Klasse aus der CLR in die Seite eingebunden, nämlich mit GetPostBackEventReference. Sehen wir uns einmal näher an, wie das funktioniert.

L3 Dieser HTML-Code wird vom Steuerelement generiert

<html> 
 <body bgcolor="yellow"> 
  <center> 
   <h3> 
     <font face="Verdana" color="black">Temperature Control 
     </font> 
   </h3>  
   <form name="ctrl1" method="POST" action="test5.aspx" id="ctrl1"> 
    <input type="hidden" name="__EVENTTARGET" value="" /> 
    <input type="hidden" name="__EVENTARGUMENT" value="" /> 
    <input type="hidden"  
       name="__VIEWSTATE"  
       value="YTB6LTEwNjMyNDk1OTlfX194319a9a63"  
    /> 
    <script language="javascript"> 
    <!-- 
      function __doPostBack(eventTarget, eventArgument) { 
        var theform = document.ctrl1 
        theform.__EVENTTARGET.value = eventTarget 
        theform.__EVENTARGUMENT.value = eventArgument 
        theform.submit() 
      } 
    // --> 
    </script> 
    <h3> 
      Fahrenheit:  
      <input name=TempCvtCtl2 id = FahrenheitValueKey type=text value=0>  
    </h3> 
    <h3> 
      Centigrade:  
      <input name=TempCvtCtl2 id = CentigradeValue type=text value=0>    
    </h3> 
    <input type=button  
      value=FahrenheitToCentigrade 
      OnClick= 
        "jscript:__doPostBack('TempCvtCtl2','FahrenheitToCentigrade')"> 
    <input type=button  
      value=CentigradeToFahrenheit  
      OnClick= 
        "jscript:__doPostBack('TempCvtCtl2','CentigradeToFahrenheit')"> 
   </form> 
  </center> 
 </body> 
</html>

Erzeugung eines Rücksendeskripts

Manche der per HTML generierten Steuerelemente lösen die Rücksendung von Daten an den Server aus (zum Bespiel Schaltflächen), während andere dies nicht tun (zum Beispiel Textfelder). Wenn Sie das Formularelement dazu bringen wollen, eine Rücksendung an den Server einzuleiten, können Sie das mit ASP.NET tun. ASP.NET kümmert sich auf der Clientseite mit JavaScript um die anwenderdefinierten Rücksendungen. Damit das bei serverseitigen Steuerelementen funktioniert, müssen Sie auf der Serverseite in den Methoden Render und OnPreRender Ihre Vorbereitungen treffen. Die Render-Methode im HTML-Code verknüpft entsprechende Ereignisfunktionen mit den Schaltflächen, indem sie die GetPostBackEventReference-Methode des Page-Objekts aufruft, das die Host-Seite repräsentiert. GetPostBackEventReference richtet eine Referenz auf eine Skriptfunktion auf der Clientseite ein, die vom serverseitigen Steuerelement durch den Aufruf von Page.RegisterPostBackScript installiert wurde. Dieser Code auf Seiten des Clients ist für die Rücksendungen des Formulars zuständig.

Da der Code für die Anwenderschnittstelle vom serverseitigen Steuerelement generiert wird, ist es auch dessen Aufgabe, für das Skript zu sorgen. Tatsächlich generiert also das serverseitige Steuerelement die Ereignisfunktionen, von denen im vorigen Absatz die Rede war. Wenn Sie Ihren eigenen Code in der Klasse unterbringen möchten, überschreiben Sie die Methode OnPreRender. Der Temperaturkonverter aus Listing L1 beschränkt sich in OnPreRender aber auf den Aufruf von Page.RegisterPostBackScript. Auf den HTML-Code, der dadurch zum Browser geschickt wird, komme ich später noch zurück.

Annahme der zurückgeschickten Daten

Nachdem das serverseitige Steuerelement die Formularelemente an den Browser geschickt hat, steht es dem Anwender frei, in den Textfeldern die gewünschten Zahlen einzutippen und die Schaltflächen zu betätigen. Was geschieht nun nach solch einem Druck auf eine Schaltfläche? Der Browser muss das Ereignis an den Server melden.

Mit dem Druck auf die Schaltfläche löst der Anwender also die Rücksendung einer entsprechenden Meldung an den Server aus. Das serverseitige Steuerelement nimmt die Meldung in der Methode LoadPostData an. Der Browser meldet den Namen des betreffenden Steuerelements und eine Sammlung mit den relevanten Werten aus den Formularelementen. Die Werte aus den Textfeldern können Sie in der Values-Sammlung nachschlagen, wobei Sie den Schlüssel aus dem ersten Parameter benutzen. Die aus dem Formular ausgelesenen Werte werden als Liste übertragen, wobei die einzelnen Werte jeweils durch ein Komma voneinander getrennt werden. Aus dieser Liste können Sie die gewünschten Werte auslesen. Listing L1 zeigt, wie der Temperaturkonverter die Temperaturangaben aus den Parametern der Funktion LoadPostData isoliert.

Rückmeldung von Ereignissen

Sobald der Temperaturkonverter die Daten angenommen hat, die ihm vom Browser zugeschickt wurden, muss er seinen internen Zustand aktualisieren. Im Zuge dieser Aktualisierung können Aufrufe von RaisePostDataChangedEvent und RaisePostBackEvent erforderlich werden. Der Ablauf ist im Wesentlichen so, wie im Folgenden beschrieben.

Sollte das serverseitige Steuerelement feststellen, dass sich die übermittelten Daten von seinen eigenen Daten unterscheiden, kehrt LoadPostData mit true zum Aufrufer zurück. Die Seitensteuerung erfasst alle Steuerelemente, deren LoadPostData-Methoden mit true zurückgekommen sind, und ruft die RaisePostDataChangedEvent-Methoden dieser Steuerelemente auf. An diesem Punkt kann das serverseitige Steuerelement alles tun, was für den Abgleich des eigenen internen Zustands mit den Daten aus dem Browser erforderlich ist. Der Temperaturkonverter ignoriert diese Ereignismeldung einfach.

Außerdem ruft die Seitensteuerung RaisePostBackEvent auf, sobald der Browser eine Rücksendung an den Server vornimmt. Dabei nennt der Browser den Namen des Formularelements, das die Rücksendung veranlasst hat. Der Temperaturkonverter überprüft, ob die Rücksendung von der Schaltfläche FahrenheitToCentigrade oder von CentigradeToFahrenheit ausgelöst wurde. In beiden Fällen nimmt er die entsprechende Umrechnung der Daten vor, die vom Browser geschickt und in LoadPostData angenommen wurden.

Einbau des Steuerelements in eine Seite

Sobald das Steuerelement kompiliert und in einer Baugruppe untergebracht wurde, können Sie es im ASP.NET einsetzen. Listing L2 zeigt ein paar Zeilen ASP.NET-Code, der eine Instanz des Temperaturkonverters deklariert. Sobald das ASP.NET-Grundgerüst diese Seite lädt, schreibt ASP.NET die body-, center- und font-Etiketten für den Browser. Das form-Etikett ist für die Steuerelemente zuständig, die vom serverseitigen Steuerelement angezeigt werden. Schauen wir uns die Sache noch einmal etwas genauer an und werfen einen Blick auf den HTML-Code, den das serverseitige Steuerelement erzeugt.

Der erzeugte HTML-Code

Die wichtigste Aufgabe des serverseitigen Steuerelements ist es, den gewünschten HTML-Code zusammenzustellen, mit dem der Browser umgehen kann. Listing L3 zeigt, was der Temperaturkonverter an HTML ausgibt. Im Wesentlichen ist es ganz normaler HTML-Code, der auf dem Browser für die Anzeige von Textfeldern und Schaltflächen sorgt.

Mit den Schaltflächen ist eine JavaScript-Funktion namens __doPostBack verknüpft. Wenn Sie wissen wollen, wie das funktioniert, schauen Sie sich etwas weiter oben im Listing L3 die verborgenen Felder und den JavaScript-Code an. Diese Elemente wurden vom ASP.NET-Grundgerüst eingefügt. Aus den verborgenen Formularfeldern geht hervor, welches Server-Steuerelement anzusprechen ist. Außerdem können sie auch ein zu übergebendes Argument nennen. Die JavaScript-Methode setzt die verborgenen Felder und veranlasst die Übermittlung des Formulars an den Server.

Das Schöne an dieser Architektur mit den serverseitigen Steuerelementen ist, dass Sie dafür keinen eigenen Code zu schreiben brauchen. Wann immer Sie einen Temperaturkonverter brauchen, setzen Sie einfach das serverseitige Steuerelement ein, das ich Ihnen hier vorgestellt habe.