AJAX Aktionen

2 Beispiele für AJAX Aktionen sind bereits auf der Beispiel Website http://www.mathertel.de/AJAXEngine/ veröffentlicht.

Der tatsächliche Code, der für eine AJAX Aktion zu implementieren ist befindet sich in den beiden Dateien CalcFactorsAJAX.htm bzw. OrteLookup.htm und umfass jeweils nur einige Zeilen. Der Rest wird von der Engine automatisch erledigt.

Jede notwendige Aktion auf der Seite wird mit der Hilfe eines Objektes beschrieben das alle Informationen zusammenhält. Die Elemente dieses Objektes sind:

prepare: Mit dieser Eigenschaft wird eine Funktion definiert die unmittelbar vor dem Absenden des SOAP Paketes verwendet wird um den Parameter für den Aufruf zu ermitteln Diese Funktion liefert den Parameterwert als Ergebnis zurück. Wenn diese Funktion nicht definiert wird, dann wird eine serverseitige Methode ohne Parameter aufgerufen.

call: Diese Eigenschaft verweist auf eine Funktion eines generierten Proxies zu einem WebService.

finish: Mit dieser Eigenschaft wird eine Funktion definiert mit der das Ergebnis des Aufrufs weiterverwendet werden wird. Diese Eigenschaft darf null sein.

onException: Mit dieser Eigenschaft wird eine Funktion definiert der eine eventuell aufgetretene Exception mitgegeben wird. Diese Eigenschaft darf null sein.

delay: Mit dieser Eigenschaft kann festgelegt werden um wie viele Millisekunden der Start der Aktion verzögert werden soll. Dies ist im Zusammenhang mit Events sinnvoll die in schneller Reihenfolge auftreten. Der Default Wert von 0 deaktiviert diese Möglichkeit und die Aktion startet sofort.

timeout: Mit dieser Eigenschaft kann eine Zeit in Sekunden angegeben werden die für den Serveraufruf maximal verwendet werden darf. Läuft diese Zeit ab ohne dass eine Antwort vom Server gekommen ist wird das http Objekt abgebrochen. Der defaultwert von 0 deaktiviert diese Möglichkeit.

Ein Timeout von mehr als ca. 60 Sekunden funktioniert ebenfalls nicht zuverlässig, da aufgrund der Verwendung von http Verbindungen Abfragen bei so langen Zeiten von sich aus beendet werden.

queueClear: Mit dieser Eigenschaft kann angegeben werden ob die Warteschlange vor der Ausführung dieser Aktion geleert wird. Dazu muss die Eigenschaft auf true gesetzt werden. Der Defaultwert ist false.

queueTop: Mit dieser Eigenschaft kann festgelegt werden ob die Aktion vor allen anderen Aktionen in der Warteschlange auszuführen ist. Dazu muss die Eigenschaft auf true gesetzt werden. Der Defaultwert ist false.

queueMultiple: Mit dieser Eigenschaft kann festgelegt werden ob eine Aktion mehrfach in der Warteschlange enthalten sein darf. Dazu muss die Eigenschaft auf true gesetzt werden. Der Defaultwert ist false.

// declare an AJAX action
var action1 = {
  prepare: function() { return (document.getElementById("inputField").value); },
  call: proxies.CalcService.CalcPrimeFactors,
  finish: function (p) { document.getElementById("outputField").value = p; },
  onException: alertException
} // action1

In dem Beispiel kann man erkennen dass es nicht zwingend notwendig ist eigenständige Funktionen zu schreiben. Die Festlegung einer Funktion für prepare und finish ist bei einfachen Aktionen auch inline möglich.

Wichtig: Die letzte Eigenschaft einer Definition eines Javascript Objektes darf nicht mit einem Komma abgeschlossen werden. Der sonst recht tolerante Microsoft Internet Explorer beanstandet diesen Fehler während der Firefox ihn toleriert.

posted by MatHertel @ 6/30/2005,   0 comments links to this post  

Überblick über die AJAX Engine

Wie man anhand den letzten Posts erkennen kann, sind die prinzipiell notwendigen Elemente einer Programmierung einer Applikation unter Verwendung des AJAX Prinzips nicht schwer zu realisieren. Die Auswahl aus den zur Verfügung stehenden Technologien sowie eine passende Abstraktion für die eingesetzten Elemente ist für den Erfolg der Realisierung einer Applikation aber entscheidend.

Wenn man nur eine Web Applikation realisiert in der nur einer oder wenige WebServices vom Browser aus aufgerufen werden sollen ist es durchaus sinnvoll bei der im vorangegangenen Beispiel verwendeten Realisierungsart zu bleiben.

Meine beruflichen Erfahrungen liegen dagegen im Bereich von Applikationen mit einigen hundert Seiten und WebServices mit in Summe einigen tausend Methoden. Bei mehr als einigen wenigen anzusprechenden Web Methoden muss dem Entwickler eine klarere und einfachere Art der Realisierung des Javascript Codes auf dem Client zur Verfügung stehen um Fehler zu vermeiden und bei der Realisierung nicht über alle Implementierungsdetails nachdenken zu müssen. Nur so kann eine gute Qualität und Wartbarkeit erreicht werden.

Der Sinn einer AJAX Engine auf dem Client ist die Vereinfachung der Implementierung des Codes, der für eine spezifische Funktion auf dem Client benötigt wird. Wie das WebService Framework von ASP.NET auf dem Server die Details der Kommunikation über SOAP dem Entwickler komplett abnimmt so soll auch auf dem Client der wiederkehrende Codeanteil nur einmal und zwar zentral realisiert sein.

Grob betrachtet ergibt sich daraus eine Aufteilung in einige miteinander arbeitende Komponenten:

HTML Form Elemente

Die statischen oder dynamisch erstellten HTML Objekte wie z.B. <input> Elementen werden für die Interaktion mit dem Benutzer verwendet.

Buttons

Die Schaltfläche, die eine AJAX Funktionalität starten müssen nur eine einfache Javascript Funktion aufrufen, die z.B. auch inline im onclick Attribut untergebracht werden kann. Diese startet dann die Abarbeitung der auszuführenden Schritte.

AJAX – Aktionen

Zum Aufruf einer serverseitigen Funktionalität müssen die Parameter zusammengestellt und das Ergebnis auf dem Client verarbeitet werden. Diese Elemente bilden zusammen eine AJAX Aktion.

AJAX – Funktion

Die nacheinander auszuführenden einzelnen Schritte einer AJAX Funktionalität wird durch ein schlankes aber auch effizientes Javascript Framework unterstützt um browserspezifische Details aus der Implementierung herauszuhalten.

Web Methoden und Proxies

Um die Methoden auf dem Server aufzurufen werden auf dem Client passende Proxy Objekte erzeugt.

Ajax-Engine

Die Ausführung der einzelnen Schritte einer Funktionalität mit der Hilfe von Timer und XMLHTTP Objekten wird von der AJAX Engine koordiniert und überwacht.

Die Sammlung der Methoden für die Implementierung der AJAX Engine stehen in ajax.js zur Verfügung.

Auch die AJAX Engine benötigt ähnlich wie die Proxies zu den WebServices auch nur eine einzige Variable mit dem Namen Ajax um dadurch Namenskonflikte zu minimieren.

In vielen Fällen ist es sinnvoll die auszuführenden Aktionen über eine Wartesachlange gesteuert hintereinander auszuführen. Dies ist auch kommunikationstechnisch notwendig, da bei http Verbindungen nur maximal 2 gleichzeitige Abfragen pro Server gemacht werden sollen.

Deshalb stellt die AJAX Engine eine Warteschlange zur Verfügung. Wie dabei mit den vorhandenen Einträgen beim Starten einer neuen Aktion umgegangen werden soll kann bei der Definition der AJAX Aktion angegeben werden.

2 Beispiele für AJAX Aktionen sind auf der Beispiel Website http://www.mathertel.de/AJAXEngine/ bereits veröffentlicht.

posted by MatHertel @ 6/29/2005,   0 comments links to this post  

Proxies für WebServices in JavaScript

Um bei AJAX Applikationen die Kommunikation von JavaScript aus über webServices und SOAP durchzuführen ist es wichtig, dass nur ein geringer Aufwand im Browser notwendig ist. Komplizierte und lange Scripte tendieren dazu Fehlerquellen zu haben.

Bei den großen Programmiersprachen und Laufzeitumgebungen wie C, der .NET CLR und Java gibt es den Mechanismus der Generierung von Proxy-Objekten und Methoden schon lange Zeit (IDL, PRC). Diese ermöglichen einen einfachen Aufruf von entsprechenden Methoden auf dem Server durch einen einfachen Aufruf einer gleichartigen Funktion auf dem Client. Die Implementierung der dazu notwendigen Übertragung auf dem Netzwerk, wird dadurch aus der dem Code Anwendung herausgenommen.

Für WebServices basiert dieser Mechanismus auf dem WSDL Standard http://www.w3.org/TR/wsdl, der eine vollständige Beschreibung eines WebServices darstellt. WSDL Compiler können daraus entsprechende Klassen für den Client als source code oder als binaries erzeugen.

Javascript Objekte auf dem Client

Auch in JavaScript sind solche Proxy-Objekte realisierbar und zwar so, dass ein ganz normal aussehender Aufruf einer JavaScript Funktion dazu führt, dass die Funktion auf dem Server mit den gleichen Parametern aufgerufen werden und das Ergebnis zurück auf den Client gesendet wird.

Um solche Proxy Objekte für einen WebService zu bekommen reicht, wie wir unten sehen werden, eine einzige Zeile Code aus.

Die Implementierung der tatsächlichen Kommunikation ist in das JavaScript include file ajax.js im Abschnitt "WebService" ausgelagert. In dieser Datei wird die Variable proxies angelegt und ihr wird ein noch leeres Objekt zugewiesen. An dieses Objekt werden die einzelnen Services angehängt, an denen selbst wiederum die Methoden angehängt werden.

Ein Aufruf einer serverseitigen Methode vom Client aus sieht dann z.B. so aus:

proxies.CalcService.func = displayFactors; // async result
proxies.CalcService.CalcPrimeFactors(12); // call

Auch eine synchrone Version ist verfügbar. Dazu darf der Eigenschaft "func" keine Methode zugewiesen werden und das Ergebnis der serverseitigen Methode wird als Ergebnis der clientseitigen Methode zurückgegeben.

var factors = proxies.CalcService.CalcPrimeFactors(12);

Durch diese Vorgehensweise ist proxies die einzige Variable die global definiert sein muss und Konflikte mit anderen globalen Variable sind minimiert. Die Verwendung weiterer Proxies von anderen WebServices is möglich.

Um die zur Kommunikation mit dem Server notwendigen Parameter verfügbar zu haben werden dem Funktionsobjekt auf dem Client einige Properties angehängt mit denen die Kommunikationsparameter der Funktion beschrieben werden. Ein weiteres Objekt zur Beschreibung der globalen Parameter des WebServices wird für alle Methoden eines WebServices gemeinsam angelegt. Eine zusätzliche Eigenschaft des Funktionsobjektes verweist darauf.

Verwendung der Eigenschaften der WebService Objekte

Eigenschaft	Verwendung
proxies.service.url	URL des WebServices
proxies.service.ns	Namespace des WebServices
proxies.service.function()	Aufruf einer serverseitigen Methode
proxies.service.function.fname	Name der Methode
proxies.service.function.action	soapaction der Methode
proxies.service.function.params	Array mit den Namen der Parameter
proxies.service.function.func	Funktion für das Ergebnis
proxies.service.function.onException	Funktion für die Verarbeitung einer Exception
proxies.service.function.corefunc	Hilfsfunktion zum debuggen auf http Ebene
proxies.service.function.service	Rückverweis auf das Service Objekt

In JavaScript, auf der Ebene des Source-Codes sieht das so aus:

[in ajax.js:]
var proxies = new Object();

[pro WebService]
// JavaScript proxy for webservices
// A WebService for the calculation of prime factors.
proxies.CalcService = {
  url: "http://localhost:1049/CalcFactors/CalcService.asmx",
  ns: "http://www.mathertel.de/CalcFactorsService/"
} // proxies.CalcService

[pro WebServiceMethode]
// Add 2 numbers.
proxies.CalcService.AddInteger = function () { return(callSoap(arguments)); }
proxies.CalcService.AddInteger.fname = "AddInteger";
proxies.CalcService.AddInteger.service = proxies.CalcService;
proxies.CalcService.AddInteger.action = "http://www.mathertel.de/CalcFactorsService/AddInteger";
proxies.CalcService.AddInteger.params = new Array("number1", "number2");

Wenn nur eine kleine Anwendung realisiert wird kann man diesen Code recht leicht von Hand pflegen indem man die entsprechenden Parameter als der WSDL Beschreibung des WebServices überträgt. An eine WSDL Beschreibung eines Webservices zu kommen ist bei einer in ASP.NET realisierten WebService einfach möglich. Man navigiert mit dem Browser zur URL des WebServices und klickt dort auf den zur Verfügung stehenden Hyperlink. Alternativ kann man auch den Parameter WSDL anhängen.

See: http://localhost/CalcFactors/CalcService.asmx?WSDL

Ein Proxy Generator für JavaScript

Die einfachste Form eines solchen WSDL nach JavaScript Compilers besteht aus einer XSLT Transformation, die aus dem WSDL Dokument das notwendige JavaScript erzeugt.

Die Seite GetJavaScriptProxy.aspx implementiert dies indem sie eine Abfrage nach der WSDL Definition an die URL des WebServices abschickt und das erhaltene XML Dokument anhand der Transformation mit wsdl.xslt in ein Javascript Fragment umwandelt.

Um einen Proxy für einen WebService zu erhalten reich es ein <script> Element mit der passenden URL auf die GetJavaScriptProxy.aspx Seite zu verwenden.

<script type="text/javascript" src="GetJavaScriptProxy.aspx?CalcService.asmx"></script>

Anstatt ein umfangreiches Script pflegen zu müssen reicht es so aus ein Tag für den Server zu schreiben und die URL zum WebService als Parameter zu hinterlegen.

Die Beispiele finder man auf der Beispiel WebSite: http://www.mathertel.de/AJAXEngine/.

posted by MatHertel @ 6/20/2005,    

Hoster gefunden !

Nach einigem Suchen habe ich einen Hoster gefunden, der das Beispiel hostet (umsonst vorerst :-)

Jetzt laufen auch die serverseitigen Methoden und man kann bekommt einen echten Eindruck. Die noch nicht dokumentierten Dateien sind vorläufig und werden sich in den nächsten Tagen ggf. noch ändern.

http://mathertel.devhost1.centron.net/CalcFactors

Anmerkung 05.02.2006:
Inzwischen ist meine WebSite auf diesen Provider umgezogen: http://www.mathertel.de. Das Angebot ist recht günstig.

posted by MatHertel @ 6/14/2005,   0 comments links to this post  

Verwenden von WebServices in AJAX Applikationen

Es bestehen einige Nachteile bei den auf dem Web verfügbaren AJAX Frameworks wie auch bei der vorangegangenen Lösung:

• Für jede benötigte Funktionalität muss eine spezielle Seite realisiert werden.
• Die Verwendung von URLs mit einer Länge über einigen 100 Zeichen bereiten Probleme.
• Bei der Implementierung auf dem Server ist der Codeanteil der die Kommunikation der

Parameter und des Ergebnisses implementiert mit dem anwendungsspezifischen Code verbacken. Deshalb liegt es nahe dafür die verfügbare Infrastruktur und serverseitige Unterstützung von WebServices zu nutzen. Das bringt auch weitere Vorteile mit sich:

• Die Funktionalität dann auch von anderen Applikationen heraus wie z.B. Excel verwendet werden.
• Mehrere Methoden sind in einem WebService zusammenfassbar so dass die Applikation übersichtlich gestaltet werden kann.
• Es können Datentypen auf der Serverseite verwendet werden.
• Es gibt Exception Handling
• Anhand der erzeugten WSDL kann ein Proxy auf dem Client generiert werden.
• Der existierende verabschiedete SOAP und WSDL Standard ist in der aktuellen Version (Anfang 2005) auf die Verwendung von http und einer direkten Verbindung zugeschnitten. Das ist exakt die Situation, die ein Web Browser und ein Web Server zueinander haben so dass in einem solchen Einsatz die Randbedingungen für WebServices optimal stimmen. Die aktuell diskutierten Erweiterungen, insbesondere die Verwendung von anderen Protokollen, von erweiterten Sicherheitsfeatures und von SOAP Routern spielt in diesem Szenario keine Rolle, da z.B. eine gesicherte Verbindung (https) verwendet werden kann. SOAP ist bei dieser Verwendung eben genau so sicher wie das Web.

WebServices sind in ASP.NET ebenfass sehr einfach zu realisieren so dass ich diese Plattform bevorzuge.

Die Realisierung eines WebServices zur Berechnung der Primfaktoren findet man in Service.asmx auf meiner Web Site http://www.mathertel.de/AJAXEngine/. Im Kern wird die gleiche Funktion wie in Request.aspx verwendet.

<%@ WebService Language="C#" Class="Service" %>
using System;
using System.Web;
using System.Web.Services;
using System.Web.Services.Protocols;

[WebService(Namespace = "http://www.mathertel.de/CalcFactorsService",
  Description="A WebService for the calculation of prime factors.")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
public class Service : System.Web.Services.WebService {

  ...

  [WebMethod(Description="Calculate all prime factors of a given number.")]
  public string CalcPrimeFactors(string inputText) {
    string outputText = String.Empty;
    UInt64 prime;  // try this factor (only primes will match!)
    UInt64 number; // product of the remaining factors

    if ((inputText == null) || (inputText.Length == 0) || (inputText == "0"))
      return (null);

    prime = 2; // start with 2
    number = UInt64.Parse(inputText);

    while ((number > 1) && (prime * prime <= number)) {
      if (number % prime != 0) {
        // try the next factor (slowly)
        prime += (prime == 2UL ? 1UL : 2UL);

      } else {
        // found a factor !
        outputText = outputText + " " + prime;
        number = number / prime;
      } // if
    } // while

    if (number > 1) {
      // the last factor (a prime) is here.
      outputText = outputText + " " + number;
    }

    return (outputText);

  } // CalcPrimeFactors

  ...

} // class

Die Besonderheit im Gegensatz zu dem vorangegangenen Beispiel einer Implementierung als http GET Aufruf in Request.aspx besteht darin, dass hier der funktionale Charakter dessen, was auf dem Server ausgeführt werden soll auch programmtechnisch klar wird. Als Programmiere muss man sich nicht mehr um die Details der Kommunikation kümmern.

Um von Javascript im Browser aus die Methode aufrufen zu können ist ein wenig mehr Aufwand notwendig, denn heute unterstützen keine Browser den Aufruf von Methoden in WebServices direkt. Im Firefox Browser ist zwar eine entsprechende Schnittstelle realisiert, doch ist bislang nur teilweise und auch nicht vollständig korrekt implementiert.

Das Zusammenstellen einer SOAP Anfrage an einen Server und das Auswerten der Antwort ist aber auch mit dem bereits bekanten XMLHTTP Objekt möglich.

// call the server using the SOAP encoding
xmlObj = new ActiveXObject("Microsoft.XMLHTTP");
xmlObj.Open("POST", "http://localhost/CalcFactors/Service.asmx", true);
xmlObj.setRequestHeader("SOAPAction",
  "http://www.mathertel.de/CalcFactorsService/CalcPrimeFactors");
xmlObj.setRequestHeader("Content-Type", "text/xml; charset=utf-8");
xmlObj.onreadystatechange = RetrievePrimeFactors;
var soapText = "<?xml version='1.0' encoding='utf-8'?>"
  + "<soap:Envelope xmlns:soap='http://schemas.xmlsoap.org/soap/envelope/'>"
  + "<soap:Body>"
    + "<CalcPrimeFactors xmlns='http://www.mathertel.de/CalcFactorsService'>"
      + "<inputText>" + inputText + "</inputText>"
    + "</CalcPrimeFactors>"
  + "</soap:Body>"
+ "</soap:Envelope>";
xmlObj.Send(soapText);

...

// the response is inside the <CalcPrimeFactorsResult> tag
outputText = xmlObj.ResponseText;
p = outputText.indexOf("<CalcPrimeFactorsResult>");
if (p > 0) {
  outputText = outputText.substr(p+24);
  outputText = outputText.substr(0, outputText.indexOf("<"));
} // if

In der Datei CalcFactorsServerSoap.htm auf meiner Web Site http://www.mathertel.de/AJAXEngine/ findet man diese verkürzte Version, die nur zum Zweck der Anschauung des prinzipiell notwendigen Codes existiert und nur IE kompatibel implementiert ist.

Während der Serverseitige Code mit der Verwendung von WebServices sehr vereinfacht wird, entsteht mehr JavaScript Code für den Browser. Aber auch hier gibt es Lösungen.

Stay tuned.

posted by MatHertel @ 6/05/2005,    

Direkte AJAX Programmierung

Bei dem Ajax Modell wird die Ausführung einer Web Seite in 2 Phasen durchgeführt:

Phase 1: Laden der Seite

Das Ziel dieser synchron ausgeführten Phase liegt darin, dass der „statische“ Anteil der Applikation auf den Client kommt. Das entspricht dem Aufbau eines Formulars oder einer Liste ohne die konkreten Nutzdaten.

Der Code für den Browser wird zusammengestellt und ausgeliefert. Ob dabei HTML oder generisches Javascript oder auch Javascript Includes verwendet ist nicht wesentlich.

Die http Antwort dieses ersten Aufrufs kann in vielen Fällen mit dem Hinweis auf den Client ausgeliefert werden, dass der lokale Cache verwendet werden kann. Damit wird erreicht, dass der Server nicht wiederholt nach diesen Informationen gefragt wird. Der Aufbau durch Laden der Seite aus dem Cache ohne Verzögerung durch das Netzwerk wird sehr effizient durchgeführt.

See http://msdn.microsoft.com/library/en-us/dnwebgen/html/ie_introfiddler2.asp

Phase 2: Laden der serverseitig ermittelten Daten

Das Ziel dieser Phase, die auch mehrfach verwendet werden kann, liegt darin die Daten vom Server abzuholen und in den statischen Rahmen der ersten Phase einzubauen. Das kann die aktuelle Liste der eMails, (Outlook Web Access, GMail) oder die seit dem letzten Abruf geänderten Daten (GMail) oder eine Liste der zu einem Suchbegriff passenden Treffer (Google Suggest) sein.

Google Maps verwendet in dieser Phase einfach eine stark parametrierte URL um eine Grafikdatei in einer Kachel anzuzeigen.

Das AJAX Modell muss in beiden Phasen berücksichtigt werden. In der ersten Phase geht es darum den notwendigen (Javascript) Code auf den Client zu liefern, der in der Lage ist die Abfragen der 2. Phase durchzuführen.

Der Kern des begonnen Beispiels, die Berechnung der Primfaktoren einer Zahl, kann recht einfach auch auf dem Server ausgeführt werden, z.B. als Antwort auf eine HTML Abfrage, der die Zahl als Parameter übergeben wird.

Die JavaScript Methode aus CalcFactorsAsync1.htm kann recht leicht in C# konvertiert werden und wird dann über eine URL aufgerufen. Beispiel:

http://www.mathertel.de/AJAXengine/S01_AsyncSamples/CalcFactorsRequest.aspx?number=266712

Der Quellcode dieser serverseitigen ist auf meiner Web Seite http://www.mathertel.de/AJAXEngine/ verfügbar.

Das ist die einfache Version der Funktion zur Berechnung der Primfaktoren. Die deutlich komplexere Variante des Codes aus CalcFactorsAsync2.htm wird nicht benötigt. Damit vereinfacht sich die Programmierung bei der serverseitigen Ausführung wieder.

Um eine solche Abfrage vom Client aus durchzuführen reicht ein recht einfacher Code aus:

var xmlObj = new ActiveXObject("Microsoft.XMLHTTP");
xmlObj.Open("GET", "http://localhost/CalcFactors/Request.aspx?number=" + inputText, false);
xmlObj.send();
outputText = xmlObj.responseText;

Den Quellcode einer vollständigen Implementierung (IE only) findet man in CalcFactorsServer1.htm auf meiner Web Site http://www.mathertel.de/AJAXEngine/.

Damit erreicht man einen Aufruf des Servers. Die Antwort einer solchen Abfrage kann, wie wir erfahren haben, einige (CPU-)Zeit in Anspruch nehmen und wird ggf. erst nach einigen Sekunden vom Server an den Client geliefert. Die Send() Methode wartet auf die Antwort des Servers. Während dieser Zeit soll der Client aber nicht einfrieren sondern die Eingabe soll weiterhin möglich sein.

Das Senden der Parameter und Empfangen der Antwort muss also in 2 unterschiedlichen Methoden implementiert werden so dass zwischenzeitlich die Events der Tastatur und der Maus im Browser ausgeführt werden können.

Das XMLHTTP Objekt muss global definiert werden um zum Zeitpunkt der Übermittlung der Antwort noch zur Verfügung zu stehen. Die neue Methode RetrievePrimeFactors wird aufgerufen, wenn ein Ergebnis vorliegt und kann dann die Anzeige aktualisieren. Den Quellcode einer vollständigen Implementierung findet man in CalcFactorsServer2.htm auf meiner Web Site http://www.mathertel.de/AJAXEngine/.

Mit dieser Implementierung erreicht man die Art der Browser Applikation, die man als AJAX Applikationen bezeichnet werden. Mit XML selbst hat das zwar noch nichts zu tun, erreicht aber im Endeffekt das gleiche Ziel erreicht.

posted by MatHertel @ 6/04/2005,