L'Altruiste : Le guide des langages Web

La technologie Active Server Pages a été élaborée par Microsoft dans le but de concevoir des applications Internet totalement dynamiques.

Les applications ASP sont des programmes conçus à partir de plusieurs sources : du Visual Basic Script (VBScript), voire du JScript (le javascript de Microsoft) et des fonctionnalités propres au serveur IIS (Internet Information Server) de Microsoft telles que les composants et objets ASP mais aussi les objets Scripting Runtime et ActiveX Data Objects (ADO).

Les scripts ASP peuvent effectuer de nombreuses tâches comme accéder à des bases de données, générer un contenu HTML, gérer des dossiers et autres fichiers directement sur le serveur hôte, faire du commerce électronique, etc..

L'implémentation des applications ASP, en réalité des scripts écrits directement dans des pages HTML portant l'extension .asp plutôt que les habituels .htm ou .html, s'effectue du côté serveur. C'est effectivement, ce-dernier qui s'occupe du traîtement du code source et non le navigateur client.

Néanmoins, l'ASP est incapable de fonctionner sur des plateformes différentes de celles de Microsoft, c'est-à-dire les serveurs IIS de Windows NT ou 2000 ou encore sur le PWS (Personal Web Server) de Windows 95, 98, Millenium et XP.

Par ailleurs, en principe n'importe n'importe quel navigateur est capable d'afficher correctement des pages HTML contenant des scripts ASP. Puisque ces-derniers sont pré-traités par le serveur, le navigateur Internet n'a plus qu'à interpréter le résultat, soit du code HTML.
Evidemment, ce code doit être parfaitement compatible avec le logiciel de navigation, en évitant, notamment, tout balisage propriétaire comme <marquee> et <iframe> qui ne fonctionnent que sous Internet Explorer.

Les possiblités qu'offrent l'Active Server Pages sont multiples et témoignent d'un fort potentiel pour un site web professionnel.

En s'appuyant sur les requêtes HTTP (Hyper Text Transfert Protocol), le serveur peut récupérer des données auprès de l'utilisateur, les traiter, puis lui envoyer une réponse adaptée.

L'ouverture d'une session sur le serveur permet de créer un espace virtuel destiné à mémoriser les actions d'un utilisateur, une fonctionnalité très utile dans le domaine de l'e-commerce.

La génération dynamique d'informations apporte une grande souplesse dans la gestion du contenu d'un site Web et pour l'affichage dans un navigateur client.

• Le contenu d'un site peut alors être créer dans des bases de données spécifiques, sans se soucier d'y associer un balisage HTML.
• Les données indépendantes de tout artifice de présentation fixe, peuvent alors être affichées selon les souhaits des utilisateurs.

Ne se contentant pas de se cantonner à son environnement de programmation habituel, certes déjà très puissant, l'ASP accepte également l'utilisation des composants COM (Component Object Model) écrit par exemple en Visual Basic, C++ ou Java, destinés à fournir de multiples services logiciels tels que des contrôles personnalisés de données ou de transferts, ainsi que des liaisons dynamiques entre différentes applications ASP.

Travailler sur la technologie ASP, il est nécessaire de disposer d'un environnment de développement approprié.

Dans un premier temps, le système d'exploitation de prédilection de l'ASP est évidemment Microsoft Windows dans l'une des versions :

• Windows 95,
• Windows 98,
• Windows Millenium,
• Windows XP,
• Windows NT 4.0,
• Windows 2000.

Ensuite, un serveur Internet spécifique à chaque système d'exploitation doit être installé et configuré proprement.

• PWS (Personal Web Server) sur Windows 95, 98, Millenium et XP,
• Services d'administration Web sur NT 4.0 Workstation ou Windows 2000 Professional,
• IIS 4.0 (Internet Information Server) sur NT 4.0 Server,
• IIS 5.0 sur NT 2000 Server.

L'installation d'un système de base de données est également souhaitable. Il est possible d'utiliser un logiciel comme Access ou SQL Server, mais également d'autres comme Oracle ou MySQL peuvent constituer une alternative intéressante.

Enfin, bien qu'un éditeur de texte conventionnel soit suffisant pour rédiger des pages ASP, il est préférable pour des travaux plus ambitieux, d'employer des éditeurs spécialisés tels que :

• Visual InterDev édité par Microsoft,
• Dreamweaver édité par Macromedia,
• HomeSite édité par Allaire,
• FrontPage édité par Microsoft,
• WebExpert édité par Visicom.

Les scripts écrits en VBScript ou en JScript doivent être intégrés dans une page HTML par le biais d'un balisage spécifique.

<!-- Insertion de scripts -->
<script language="VBScript | JScript" 
             type="text/vbscript | jscript"
             runat="Server | Client">
    ' Script...
</script>

L'attribut language indique le moteur de script à utiliser pour implémenter le code. L'ASP autorise deux langages de script, soit Visual Basic Script, soit une version spécifique de Microsoft de l'ECMAScript, JScript, d'ailleurs activée par défaut.

L'attribut runat spécifie le type d'exécution du script, c'est à dire au niveau du serveur (Server) ou au niveau du client (Client), lequel est activé par défaut.

Des scripts externes peuvent être utilisés dans une page ASP par l'intermédiaire de la commande suivante :

<script 
            language="VBScript | JScript"
            src="Adresse.url"
            type="text/vbscript | jscript"
            runat="Server | Client">
</script>

La forme ci-dessous, est également une alternative plus simple et plus rapide permettant d'insérer du code directement dans le balisage HTML.

<%
  Script...
%>

En entête de page, on peut également utiliser la balise suivante afin d'indiquer le langage de script par défaut au serveur.

<%@ LANGUAGE="VBScript | JScript"%>

Toutes les pages HTML, comportant ces balisages précités, doivent impérativement porter l'extension .asp afin que le serveur traite correctement l'ensemble des scripts VBScript ou JScript.

Les directives de traitement sont utilisées dans les scripts afin d'envoyer à Internet Information Server (IIS), des indications sur la manière de traiter un fichier ASP.

Les directives obéissent à la forme énoncée ci-dessous et en outre se placent au sommet du document et en particulier avant le code.

<% @Directive = Valeur %>

<% @LANGUAGE = "JScript" %>
<html>
  <body>
    <% 
      Response.Write("Ceci est un programme JScript !");
    %>
  </body>
</html>

Les directives d'inclusion côté serveur (Server Side Includes) permettent de construire des pages Web avant leurs envoi à l'agent utilisateur.

<!--#Directive Instructions...-->

Les directives SSI sont capables d'exécuter diverses tâches à partir du serveur hôte :

• Insertion directe dans la page Web de valeurs de variables d'environnement HTTP.
• Exécution d'une commande de Shell ou d'une application CGI dans les pages.
• Insertion des valeurs résultants d'une commande ou d'une application.
• Insertion de la date, de l'heure et de la dernière modification d'une page.
• Insertion de la taille d'un fichier.
• Insertion d'une page dans une autre.

Selon la localisation du fichier, il faut utiliser soit file, si un chemin physique (\rep\fichier.asp)est utilisé ou si la cible se trouve dans le même répertoire, sinon virtual (rep/fichier.asp) dans le cas où un chemin virtuel est employé.

En ce qui concerne l'inclusion des fichiers par la directive #include, couramment il est fait appel à l'extension inc pour différencier les fichiers à inclure des fichiers ASP. Cependant, cette pratique peut provoquer des problèmes de sécurités, c'est-pourquoi, il est préférable de conserver une extension asp pour tous les fichiers contenant du code sensible.

La directive #exec peut également provoquer de graves problèmes de sécurités puisqu'il est possible de lancer des commandes de Shell sur le serveur avec toutes les conséquences que cela comporte. En conséquence, l'utilisation de tels instructions doivent se faire avec le maximum de précautions.

<!-- #config errmsg="Une erreur est survenue sur la page !"-->
<!-- retourne le message d'erreur. -->
Une erreur est survenue sur la page !

<!-- #config timefmt="%d/%m/%Y"-->
<!-- retourne la date selon le format JJ/MM/AA -->
10/11/2001

<!-- #echo var="PATH_INFO" -->
<!-- retourne -->
/laltruiste/coursado/exemple_ado/directive_ssi.asp

<!-- #exec cmd="dir *.zip"-->
<!-- retourne -->
fichier.zip
...
fichierN.zip

<!-- #exec cgi="cgi-bin/application.exe"-->
<!-- exécute le fichier application.exe -->

<!-- #config timefmt="%d/%m/%Y %H:%M:%S"-->
<!-- #flastmod file="index.html"-->
<!-- retourne la date de dernière modification selon le format spécifié. -->
10/11/2001 20:45:20

<!-- #config sizefmt="BYTE"-->
<!-- #fsize file="\download\fichier.zip"-->
'retourne la taille en octet -->
1245800

<!-- #include virtual="../rep/fichier.asp"-->
<!-- Incorpore tout le contenu dans la page courante. -->

Les codes de formatage de dates et heures permettent de retourner une date ou une heure selon un format spécifié à partir de la directive d'inclusion côté serveur (SSI) #config.

<!-- Affiche la date et l'heure selon le format JJ/MM/AA HH:MM:SS. -->
<!-- #config timefmt="%d/%m/%y %H:%M:%S" -->
'retourne
12/12/2001 21:50:30

Le langage ASP possède plusieurs objets permettant de manipuler diverses données entre la station cliente et le serveur, mais aussi de gérer des erreurs, des sessions ou encore des transactions.

L'objet Application permet de partager des informations entre plusieurs utilisateurs d'une application.

Application.[méthode | propriété]

Dans le langage ASP, une application représente un ensemble de fichiers .asp situés dans un même répertoire.

Ainsi, l'objet Application se comporte comme un conteneur d'objets partagés susceptibles d'être accédés et modifiés par les utilisateurs connectés aux fichiers concernées, soit les fichiers formant une application.

Application.Contents("Identificateur") = expression

L'expression suivante est équivalente à la seconde, mais est plus courte.

Application("Identificateur") = expression

Cet exemple permet de partager le modèle d'objet FileSystemObject entre les différents documents ASP d'une application.

Set Application("fso") = _
                          Server.CreateObject("Scripting.FileSystemObject")

Désormais, l'objet Application identifié par fso peut utiliser les méthodes et propriétés du modèle d'objet FileSystemObject.

Set fichier = Application("fso").GetFile(chemin)

Il est également possible pour des raisons de commodités d'affecter l'objet Application à une variable.

objet_fso = Application("fso")

Puisqu'un objet Application peut être utilisé par plusieurs personnes simultanément, il est souhaitable qu'un seul et unique utilisateur puisse modifier la valeur de l'objet à la fois, comme dans le cas d'un compteur notamment.

Application.Lock
Application("Compteur_visite") = Application("Compteur_visite") + 1
Application.Unlock

Response.Write "Nb de visites : " & Application("Compteur_visite")

C'est pourquoi, deux méthodes Lock et Unlock permettent de vérouiller la variable lors de son utilisation puis de la dévérouiller suite à la modification.

<script language="..." runat="server">
    Sub Application_OnEnd
        ' Instructions...
    End Sub
</script>

<script language="..." runat="server">
    Sub Application_OnStart
      ' Instructions...
    End Sub
</script>

<-- Fichier : departement.asp -->
<html>
  <body>
    <form action="reponse.asp" method="POST">
      <%
        Application("00") = "Province"
        Application("75") = "Paris"
        Application("77") = "Seine-et-Marne"
        Application("78") = "Yvelines"
        Application("91") = "Essonne"
        Application("92") = "Hauts-de-Seine"
        Application("93") = "Seine-Saint-Denis"
        Application("94") = "Val-de-Marne"
        Application("95") = "Val-d'Oise"

        Dim i, departement, liste_choix
        liste_choix = "<select name='dep'>"
        For Each departement In Application.Contents
          liste_choix = liste_choix & "<option value='" & departement _
                             & "'>" & Application.Contents(departement) & "</option>"
        Next
        liste_choix = liste_choix + "</select>"
        Response.Write liste_choix
      %>
      <input type="submit" id="soumission" value="Soumettre">
    </form>
  </body>
</html>
<-- Fichier réponse : reponse.asp -->
<html>
  <body>
    <%
      Session("choix") = Request("dep")
    %>
    <p>Le département de votre choix est :</p>
    <h3><% = Application.Contents(Session("choix")) %></h3>
    <p>parmi cette liste :</p>
    <%
      Dim i, departement
      i = 0
      For Each departement In Application.Contents
        Response.Write i & " : " & departement & " - " _
                                   & Application(departement) & "<br>"
        i = i + 1
      Next

      Application.Contents.RemoveAll
    %>
    <br>
    <a href="confirmation.asp">Confirmez ce choix</a>
  </body>
</html>
<-- Fichier réponse : confirmation.asp -->
<html>
  <body>
    <%
      Response.Write "<h3>Vous avez bien confirmé votre choix.</h3>" _
                           & "<h4>Département : " & Session("choix") & " - " _
                           &  Application.Contents(Session("choix")) & "</h4>"
    %>
  </body>
</html>

L'objet Response a pour rôle de retransmettre des informations au client par l'intermédiaire d'un affichage à l'écran ou par la transmission d'un cookie.

Response.[méthode | propriété]

L'utilisation la plus courante de cet objet consiste à employer la méthode Write,

Response.Write "Texte" & variable_chaîne

ou le signe d'égalité pour insérer un contenu textuel dans une page résultante.

<% = variable_chaîne%>

Il est également possible d'envoyer une réponse à un client par l'intermédiaire de cookies.

Response.Cookies("Identificateur") = Informations

L'objet Response permet de placer diverses ressources soit en mémoire cache, c'est-à-dire dans une zone tampon situé sur un serveur proxy,

Response.CacheControl = "Public"

soit dans un dossier tampon de la station cliente, Temporary Internet Files.

Response.CacheControl = "Private"

Cela a pour avantage de considérablement accélérer le chargement des pages Web et de soulager le traitement des requêtes clientes par le serveur Internet.

Dans le cas d'un site Web dynamique et mis à jour fréquemment, les documents possèdent une durée de vie limitée. C'est pourquoi, l'objet Response dispose de deux propriétés permettant d'indiquer une période limite de validité.

Les propriétés d'expiration ne peuvent s'appliquer qu'au cache local d'un ordinateur client.

La première propriété Expires spécifie une durée en minutes de validité de la page avant son expiration.

Response.Expires = Nombre_minutes

La seconde ExpiresAbsolute étend la validité d'un document à une date et une heure précises.

Response.ExpiresAbsolute = #MM/JJ/AA HH:MM PM|AM#

Enfin, une propriété Buffer associée deux méthodes Clear et Flush permettent de contrôler la construction d'une page ASP dans une mémoire tampon.

Response.Buffer = True ' Activation du tampon.
....Flush ' Envoi des données présentes dans le tampon.
....Clear ' Vidage du contenu du tampon.

<html>
<body>
  <%
    Response.CacheControl = "Private"
    Response.Expires = 15
    Response.Buffer = True

    For i = 0 To 1000

      If i Mod 20 = 0 Then
        separateur = "<br>"
      Else
        separateur = " | "
      End If

      For j = 1000 To 0 Step -1
        Response.Write i - j & separateur
      Next
    Next

    If Response.IsClientConnected() = False Then
      Response.Clear
      Response.End
    Else
      Response.Flush
    End If
  %>
</body>
</html>

L'objet Request permet la récupération d'informations en provenance d'une station cliente.

Request.[méthode | propriété]

Les informations fournies par le client peuvent provenir soit de :

• formulaires,
• cookies,
• chaînes de requêtes (QueryStrings) dans l'adresse URL (Uniform Resource Locator),
• variables d'environnement HTTP (Hyper Text Transfert Protocol), des données relatives à l'ordinateur client,
• certificats clients pour la sécurisation des transactions en ligne.

<!-- Formulaire -->
<html>
  <head>
    <%
      Response.Cookies("Visite")("Date") = Date & " " & Time
      Response.Cookies("Visite")("Adresse") = _
                             Request.ServerVariables("PATH_INFO")
      Response.Cookies("Visite")("Hote") = _
                             Request.ServerVariables("REMOTE_HOST")
      Response.Cookies("Visite")("Identite") = _
                             Request.ServerVariables("REMOTE_USER")
      Response.Cookies("Visite")("Navigateur") = _
                             Request.ServerVariables("HTTP_USER_AGENT")
    %>
  </head>
  <body>
    <form
         action="traitement_request.asp?Formulaire=Description&Partie=Première"
         method="POST">

      <u>Nom et Prénom(s) :</u><br>
      <input type="text" name="nom" size="20"><br>

      <u>Adresse complète :</u><br>
      <textarea name="paragraphe" cols="20" rows="3">
      </textarea>
      <br>
      <u>Tranche d'âge :</u><br>
      <input type="radio" name="age" value="Moins de 18 ans" checked>
        Moins de 18 ans<br>
      <input type="radio" name="age" value="19 - 30 ans">
        19 - 30 ans<br>
      <input type="radio" name="age" value="31 - 40 ans">
        31 - 40 ans<br>
      <input type="radio" name="age" value="41 - 50 ans">
        41 - 50 ans<br>
      <input type="radio" name="age" value="51 - 60 ans">
        51 - 60 ans<br>
      <input type="radio" name="age" value="Plus de 61 ans">
        Plus de 61 ans<br>
      <br>
      <u>Situation familiale :</u><br>
      <select name="situation" size="1">
        <option value="Célibataire" selected>Célibataire</option>
        <option value="Marié(e)">Marié(e)</option>
        <option value="Concubinage">Concubinage</option>
        <option value="Pacs">Pacs</option>
        <option value="Veuf(ve)">Veuf(ve)</option>
        <option value="Divorcé(e)">Divorcé(e)</option>
      </select>
      <br>
      <u>Type d'emploi :</u><br>
      <select name="emploi" size="6" multiple>
        <option value="Sans emploi">Sans emploi</option>
        <option value="Cadre" selected>Cadre</option>
        <option value="Artisan">Artisan</option>
        <option value="Employé">Employé</option>
        <option value="Sportif">Sportif</option>
        <option value="Artiste">Artiste</option>
      </select>
      <br>
      <u>Loisirs :</u><br>
      <input type="checkbox" name="loisirs" value="Informatique">
        Informatique<br>
      <input type="checkbox" name="loisirs" value="Musique">
        Musique<br>
      <input type="checkbox" name="loisirs" value="Cinéma">
        Cinéma<br>
      <input type="checkbox" name="loisirs" value="Littérature">
        Littérature<br>
      <input type="checkbox" name="loisirs" value="Sport">
        Sport<br>
      <input type="checkbox" name="loisirs" value="Art">
        Art<br>

      <input type="submit" name="soumission" value="Soumettre">
      <input type="reset" name="annulation" value="Annuler">
    </form>
  </body>
</html>
<!-- Fichier de traitement traitement.asp -->
<html>
  <head>
    <%
      Response.Cookies("Visite")("client") = Request.Form("nom")
      Response.Cookies("Visite")("Emloi") = Request.Form("emploi")
    %>
  </head>
  <body>
    <h2>La Collection Request.Form</h2>
    <table>
    <%
      For Each elt_form In Request.Form
        Response.Write "<tr><td>" & elt_form _
                     & "</td><td>" & Request.Form(elt_form) _
                     & "</td></tr>"
      Next
    %>
    </table>

    <h2>La Collection Request.QueryString</h2>
    <table>
    <%
      For Each chaine_requete In Request.QueryString
        Response.Write "<tr><td>" & chaine_requete & "</td><td>" _
                     & Request.QueryString(chaine_requete) & "</td></tr>"
      Next
    %>
    </table>

    <h2>La Collection Request.Cookies </h2>
    <table>
    <%
      For Each nom_cookie In Request.Cookies
        If Request.Cookies(nom_cookie).HasKeys Then
          For Each cle_cookie in Request.Cookies(nom_cookie)
            Response.Write "<tr><td>" & nom_cookie _
                       & "(" & cle_cookie & ")</td><td>" _
                       & Request.Cookies(nom_cookie)(cle_cookie) _
                       & "</td></tr>"
          Next
        Else
          Response.Write "<tr><td>" & nom_cookie & "</td><td>" _
                       & Request.Cookies(nom_cookie) & "</td></tr>"
        End If
      Next
    %>
    </table>

    <h2>La Collection Request.ServerVariables</h2>
    <table>
    <%
      For Each var_http In Request.ServerVariables
        Response.Write "<tr><td>" & var_http & "</td><td>" _
                      & Request.ServerVariables(var_http) & "</td></tr>"
      Next
    %>
  </table>

    <h2>La Collection Request.ClientCertificate</h2>
    <table>
    <%
      For Each certificat In Request.ClientCertificate
        Response.Write "<tr><td>" & certificat & "</td><td>" _
                     & Request.ClientCertificate(certificat) & "</td></tr>"
      Next
    %>
  </table>

    <h2>Valeurs</h2>
    Request.TotalBytes = <% = Request.TotalBytes %><p>
  </body>
</html>

L'objet Server permet d'accéder à plusieurs fonctions utilitaires.

Server.[méthode | propriété]

L'une des fonctions les plus importantes de l'objet Server consiste à la création d'instance d'objet.

La méthode CreateObject en s'appuyant sur un argument ClassID ou sur une chaîne ProgID, crée un nouvel objet correspondant.

Set Objet = Server.CreateObject("ClassID | ProgID")

Set Obj_IISLog = Server.CreateObject("MSWC.IISLog")

Puis, la fonction GetObject s'occupe de créer une instance d'objet adéquate pour certains types de document.

Set Objet = GetObject([Chemin,] [Classe])

Set Obj_Excel = GetObject("C:\Doc\prevision.xsl", Excel.Application)

Cependant, la création d'objet par les moteurs de script est déconseillée dans certaines conditions, car l'objet ne peut faire appel à aucun objet ASP intrinsèque du contexte en cours, et partant ne peut accèder à aucune des valeurs concernées.
Ne pouvant faire référence à l'objet ObjectContext, il devient impossible de terminer une transaction en cours en cas de défaillance.

<-- Fichier server.asp -->
<html>
  <body>
    <%
      Response.Write "<h2>BrowserType</h2>" _
              & "<h3>Adresse encodée du composant ASP</h3>" _
              & Server.URLEncode("http://msdn.microsoft.com/library/en-us" _
              & "/iisref/html/psdk/asp/comp3xx0.asp?frame=true") & "<br>" _
              & Server.HTMLEncode("<title>Configuration de votre navigateur<title>")
      Server.Execute("server2.asp")
    %>
  </body>
</html>
<-- Fichier browsertype.asp -->
<html>
  <body>
    <%
      Set Session("Configuration") = Server.CreateObject("MSWC.BrowserType")
      Set config = Session("Configuration")
    %>
    <h3>Les treize propriétés du composant <i>BrowserType</i></h3>
    <table border="0">
      <tr>
        <th>Propriété</th>
        <th>Valeur</th>
      </tr>
      <tr>
        <td>ActiveXControls</td>
        <td><%=config.ActiveXControls%></td>
      </tr>
      <tr>
        <td>Backgroundsounds</td>
        <td><%=config.Backgroundsounds%></td>
      </tr>
      <tr>
        <td>Beta</td>
        <td><%=config.Beta%></td>
      </tr>
      <tr>
        <td>Browser</td>
        <td><%=config.Browser%></td>
      </tr>
      <tr>
        <td>Cdf</td>
        <td><%=config.Cdf%></td>
      </tr>
      <tr>
        <td>Cookies</td>
        <td><%=config.Cookies%></td>
      </tr>
      <tr>
        <td>Frames</td>
        <td><%=config.Frames%></td>
      </tr>
      <tr>
        <td>Javaapplets</td>
        <td><%=config.Javaapplets%></td>
      </tr>
      <tr>
        <td>Javascript</td>
        <td><%=config.Javascript%></td>
      </tr>
      <tr>
        <td>Platform</td>
        <td><%=config.Platform%></td>
      </tr>
      <tr>
        <td>Tables</td>
        <td><%=config.Tables%></td>
      </tr>
      <tr>
        <td>Vbscript</td>
        <td><%=config.Vbscript%></td>
      </tr>
      <tr>
        <td>Version</td>
        <td><%=config.Version%></td>
      </tr>
    </table>
  </body>
</html>

L'objet Session contient des informations relatives à la session d'un utilisateur sur le serveur.

Session.[méthode | propriété]

Dans le langage ASP, une session représente une période de temps dans laquelle un utilisateur navigue dans un ensemble de pages ASP.

Ainsi, l'objet Session se comporte comme un conteneur d'objets partagés devant être conservés tant que l'utilisateur concerné agît sur un ensemble de pages ou pour mener une opération à son terme, comme dans le cas d'une transaction en ligne.

Session.Contents("Identificateur") = expression

L'expression suivante est équivalente à la seconde, mais est plus courte.

Session("Identificateur") = expression

Cet exemple permet de conserver pendant toute la durée d'une transaction, une information relative à la configuration que possède le navigateur d'un utilisateur.

Session("Config_Utilisateur") = _
                                      Server.Createobject(MSWC.BrowserType)

Désormais, l'objet Session identifié par Config_Utilisateur peut utiliser les méthodes et propriétés du modèle du composant ASP BrowserType.

fichier = Session("Config_Utilisateur").Platform

Il est également possible pour des raisons de commodités d'affecter l'objet Session à une variable.

configuration = Session("Config_Utilisateur")

Le contrôle des sessions s'effectue principalement par l'intermédiaire d'une propriété contrôlant le temps d'expiration en minutes de la session en cours (TimeOut)

Session.TimeOut = 10

et d'une méthode chargée de la terminer immédiatement (Abandon).

Session.Abandon

La durée de vie par défaut d'une session est de vingt minutes. Son ouverture est assurée automatiquement par le serveur.

<script language="..." runat="server">
    Sub Session_OnEnd
        ' Instructions...
    End Sub
</script>

<script language="..." runat="server">
    Sub Session_OnStart
        ' Instructions...
    End Sub
</script>

<-- Fichier : departement.asp -->
<html>
  <body>
    <form action="reponse.asp" method="POST">
      <%
        Application("00") = "Province"
        Application("75") = "Paris"
        Application("77") = "Seine-et-Marne"
        Application("78") = "Yvelines"
        Application("91") = "Essonne"
        Application("92") = "Hauts-de-Seine"
        Application("93") = "Seine-Saint-Denis"
        Application("94") = "Val-de-Marne"
        Application("95") = "Val-d'Oise"

        Dim i, departement, liste_choix
        liste_choix = "<select name='dep'>"
        For Each departement In Application.Contents
          liste_choix = liste_choix & "<option value='" & departement _
                             & "'>" & Application.Contents(departement) & "</option>"
        Next
        liste_choix = liste_choix + "</select>"
        Response.Write liste_choix
      %>
      <input type="submit" id="soumission" value="Soumettre">
    </form>
  </body>
</html>
<-- Fichier réponse : reponse.asp -->
<html>
  <body>
    <%
      Session("choix") = Request("dep")
    %>
    <p>Le département de votre choix est :</p>
    <h3><% = Application.Contents(Session("choix")) %></h3>
    <p>parmi cette liste :</p>
    <%
      Dim i, departement
      i = 0
      For Each departement In Application.Contents
        Response.Write i & " : " & departement & " - " _
                                 & Application(departement) & "<br>"
        i = i + 1
      Next

      Application.Contents.RemoveAll
   %>
    <br>
    <a href="confirmation.asp">Confirmez ce choix</a>
  </body>
</html>
<-- Fichier réponse : confirmation.asp -->
<html>
  <body>
    <%
      Response.Write "<h3>Vous avez bien confirmé votre choix.</h3>" _
                           & "<h4>Département : " & Session("choix") & " - " _
                           &  Application.Contents(Session("choix")) & "</h4>"
    %>
  </body>
</html>

L'objet ASPError contient des informations relatives à une erreur dans un script ASP.

ASPError.propriété

L'objet ASPError est créé à partir de l'instruction suivante :

Set objet = Server.GetLastError()

Cet objet a été spécialement conçu pour la gestion personnalisée d'erreurs du côté serveur (erreurs 500).

Dans une configuration par défaut, les erreurs 500 sont redirigées automatiquement vers une page spéciale dénommée 500-100.asp située dans le répertoire unité:\windows\Help\iisHelp\common.

<html>
  <body>
    <%
      Dim erreur
      Set erreur = Server.GetLastError()
    %>
    <h3>Caractéristiques de l'erreur :</h3>
    <table border="0" align="center">
      <tr>
        <td>Propriété</td>
        <td>Erreur</td>
      </tr>
      <tr>
        <td>ASPCode</td>
        <td><% = erreur.ASPCode %></td>
      </tr>
      <tr>
        <td>Number</td>
        <td><% = erreur.Number %></td>
      </tr>
      <tr>
        <td>Source</td>
        <td><% = erreur.Source %></td>
      </tr>
      <tr>
        <td>Category</td>
        <td><% = erreur.Category %></td>
      </tr>
      <tr>
        <td>File</td>
        <td><% = erreur.File %></td>
      </tr>
      <tr>
        <td>Line</td>
        <td><% = erreur.Line %></td>
      </tr>
      <tr>
        <td>Column</td>
        <td><% = erreur.Column %></td>
      </tr>
      <tr>
        <td>Description</td>
        <td><% = erreur.Description %></td>
      </tr>
      <tr>
        <td>ASPDescription</td>
        <td><% = erreur.ASPDescription %></td>
      </tr>
    </table>
  </body>
</html>

L'objet ObjectContext correspond en quelque sorte à un objet racine autour duquel s'articulent les objets intrinsèques comme Response, Request, Application, Session, Server et ASPError ainsi que tout objet COM (Component Object Model) créé pour des besoins spécifiques.

ObjectContext est un objet COM fournissant un accès aux propriétés d'exécution incluses dans le contexte d'un objet.

Si un objet fait référence à ObjectContext, il aura la possibilité d'accéder aux valeurs des collections Request, Response, Application et Session.

L'objet ObjectContext permet de gérer des transactions initialisées par un script ASP.

ObjectContext.méthode

Les méthodes de ObjectContext permettent de valider (SetCommit) ou d'abandonner (setAbort) une transaction en cours.

Les événements OnTransactionAbort et OnTransactionCommit se produisent lorsque l'événement lié intervient, respectivement, l'abandon ou la validation d'une transaction.

La mise en oeuvre de ces commandes s'effectue par l'intermédiaire d'une procédure chargée de capter l'événement.

Sub OnTransactionAbort | OnTransactionCommit
  Instructions...
end sub

<%@ LANGUAGE="VBScript" TRANSACTION=Required %>
<%
  ObjectContext.SetAbort
  Sub OnTransactionAbort
    Response.Write "<h2>La transaction a été abandonnée</h2>." 
  end sub
%>

<%@ LANGUAGE="VBScript" TRANSACTION=Required %>
<%
  ObjectContext.SetComplete
  Sub OnTransactionCommit
    Response.Write "<h2>La transaction a été accomplie avec succès</h2>." 
  end sub
%>

Par ailleurs, la directive @TRANSACTION doit toujours accompagner l'objet ObjectContext en s'inscrivant au sommet de la page concernée.

<%@ LANGUAGE="VBScript" TRANSACTION=Required %>

Cette instruction spécifique indique que le script doit être traité conformément à une transaction afin que les Services Composants du serveur agissent en conséquence.

<%@ LANGUAGE=VBScript TRANSACTION=Required %>
<%
  Dim obj_Transfert
  Dim Transfert_Montant
  Dim Num_Compte_origine
  Dim Num_Compte_Destinataire

  ' Récupération des informations à partir du

  ' formulaire initial de demande de transfert de Compte.

  Transfert_Montant = Request.QueryString("Montant")

  Num_Compte_origine = Request.QueryString("NumCmptOri")

  Num_Compte_Destinataire = Request.QueryString("NumCmptDest")


  ' Création de l'objet COM+ utilisé pour les transferts

  ' transfert.dll se trouve dans un répertoire ex: c:\banque\transfert\.

  ' Auparavant transfert.dll est enregistré par regsvr32.exe.

  ' ex: c:\winnt\system32\regsvr32.exe c:\banque\transfert\tranfert.dll.


  Set obj_Transfert = Server.CreateObject("transfert.AcctTransfer")

  ' Déduction de la somme en utilisant la méthode Retrait.

  If obj_Transfert.Retrait(CInt(Num_Compte_origine), _
                       CInt(Transfert_Montant)) <> 0 Then

    ' Annulation de la transaction si le retrait a échoué.

    ObjectContext.SetAbort

    ' Si le retrait réussi, alors la somme est déposée sur le compte 

    ' destinataire en utilisant la méthode Depot.

    Response.Write "Abandon de la procédure de retrait !"

  Elseif  obj_Transfert.Depot(CInt(Num_Compte_Destinataire), _
                       CInt(Transfert_Montant)) <> 0 Then

    ' Annulation de la transaction si le dépot a échoué.

    ObjectContext.SetAbort 

    Response.Write "Abandon de la procédure de dépot !"

  Else

    ' Terminer la transaction lorsque le retrait et le dépot ont réussi.

    ObjectContext.SetComplete

    Response.Write "Réussite de la procédure !"

  End If

  Set Transfert_Montant = Nothing
%>

Le langage ASP possède plusieurs composants Active Server implémentés par des fichiers librairie (DLL) localisés sur le serveur.

Les composants serveur effectuent diverses tâches utiles pour le fonctionnement dynamique des pages Web.

Le dernier composant ASPSmartUpload n'est pas directement inclus dans ASP, néanmoins il propose des services relatifs au téléchargement.

Le composant AdRotator permet d'afficher des annonces différentes à chaque affichage d'une page ASP.

La déclaration ci-dessous, permet de créer une instance du composant AdRotator sous VBScript.

Set objet = Server.CreateObject("MSWC.AdRotator")

Sous JScript, il suffit de remplacer l'instruction Set par var si l'objet n'a pas été préalablement déclaré, sinon supprimer la simplement.

Les annonces sont spécifiées dans un fichier texte spécifique pointé par la méthode GetAdvertissement(fichier).

objet.GetAdvertissement(nom_fichier)

Ce fichier de planification d'annonces possède le format suivant :

REDIRECT URL du fichier de redirection
WIDTH largeur
HEIGHT hauteur
BORDER taille
*
URL de l'annonce
URL Cible de l'annonce
Commentaire
Importance
...

Le paramètre REDIRECT permet de faire appel à un fichier tiers utilisé pour rediriger les liens.

Les paramètres width, height et border sont optionnels et définissent les dimensions de l'ensemble des annonces présentes dans le fichier.

L'adresse URL Cible de l'annonce correpond donc à un lien pointant vers le document à atteindre en cliquant sur l'image de l'annonce. Si aucune cible ne doit être indiquée, alors, un tiret (-) doit être spécifié.

Le paramètre Importance est représenté par un nombre représentant le pourcentage d'affichage de l'annonce à chaque chargement de la page. Ainsi plus une annonce est importante, plus le nombre est élevé par rapport aux autres. Dans l'exemple en bas du document, la première annonce sera affichée sur 25 pourcent des pages chargées, et pour les deux autres respectivement sur 20 et 15 pourcent.

<html>
  <body>
    <%
      ' Page hôte affichant les bannières aléatoires.

      Dim objet

      ' Création de l'objet
      Set objet = Server.CreateObject("MSWC.AdRotator")

      Response.Write objet.GetAdvertisement("liste.txt")

      ' Destruction de l'objet
      Set objet = Nothing
    %>
    <a href="adrotator.asp">Recharger la page</a>
  </body>
</html>

<%
  ' Fichier de redirection des liens : lien.asp
  Response.Redirect Request.QueryString("url")
%>
Fichier présentant le liste des bannières et liens : liste.txt
REDIRECT lien.asp
WIDTH 468
HEIGHT 60
BORDER 0
*
http://www.laltruiste.com/coursasp/images/alapage.gif
http://www.alapage.com/
Visitez la librairie en ligne!
5
http://www.laltruiste.com/coursasp/images/blackorange.gif
http://www.blackorange.com/
Découvrez la logithèque en ligne !
4
http://www.laltruiste.com/coursasp/images/oreilly.gif
http://www.editions-oreilly.com/
Découvrez le célèbre éditeur de livres !
3

Le composant BrowserType permet d'indiquer les caractéristiques du navigateur du client.

La déclaration ci-dessous, permet de créer une instance du composant BrowserType sous VBScript.

Set objet = Server.CreateObject("MSWC.BrowserType")

Sous JScript, il suffit de remplacer l'instruction Set par var si l'objet n'a pas été préalablement déclaré, sinon supprimer la simplement.

Le composant BrowserType fonctionne conjointement avec les valeurs de différentes propriétés comprises dans le fichier browscap.ini situé dans le répertoire unité:\windows\system32\inetsrv.

...
[IE 5.0]
browser=IE
Version=5.0
majorver=#5
minorver=#0
frames=True
tables=True
cookies=True
backgroundsounds=True
vbscript=True
javaapplets=True
javascript=True
ActiveXControls=True
Win16=False
beta=True
AK=False
SK=False
AOL=False
Update=False

[Mozilla/4.0 (compatible; MSIE 5.*; Windows NT*)]
parent=IE 5.0
platform=WinNT
beta=True
...

Le fichier ci-dessus est un extrait du fichier browscap.ini, définissant les caractéristiques du navigateur du client, dont certaines propriétés en gras représentent des caractéristiques utiles pour le traîtement de pages ASP.

La propriété Value de l'objet BrowserType permet d'obtenir les valeurs des différentes caractéristiques énoncées dans le fichier browscap.ini du navigateur Internet d'un client.

valeur = objet.Value("Caractéristique")

<html>
  <body>
    <%
      Set Session("Configuration") = Server.CreateObject("MSWC.BrowserType")
      Set config = Session("Configuration")
    %>
    <h3>Les treize propriétés du composant <i>BrowserType</i></h3>
    <table border="0">
      <tr>
        <th>Propriété</th>
        <th>Valeur</th>
      </tr>
      <tr>
        <td>ActiveXControls</td>
        <td><%=config.ActiveXControls%></td>
      </tr>
      <tr>
        <td>Backgroundsounds</td>
        <td><%=config.Backgroundsounds%></td>
      </tr>
      <tr>
        <td>Beta</td>
        <td><%=config.Beta%></td>
      </tr>
      <tr>
        <td>Browser</td>
        <td><%=config.Browser%></td>
      </tr>
      <tr>
        <td>Cdf</td>
        <td><%=config.Cdf%></td>
      </tr>
      <tr>
        <td>Cookies</td>
        <td><%=config.Cookies%></td>
      </tr>
      <tr>
        <td>Frames</td>
        <td><%=config.Frames%></td>
      </tr>
      <tr>
        <td>Javaapplets</td>
        <td><%=config.Javaapplets%></td>
      </tr>
      <tr>
        <td>Javascript</td>
        <td><%=config.Javascript%></td>
      </tr>
      <tr>
        <td>Platform</td>
        <td><%=config.Platform%></td>
      </tr>
      <tr>
        <td>Tables</td>
        <td><%=config.Tables%></td>
      </tr>
      <tr>
        <td>Vbscript</td>
        <td><%=config.Vbscript%></td>
      </tr>
      <tr>
        <td>Version</td>
        <td><%=config.Version%></td>
      </tr>
    </table>
  </body>
</html>

Le composant ContentRotator permet d'afficher un texte différent à chaque affichage d'une page ASP.

La déclaration ci-dessous, permet de créer une instance du composant ContentRotator sous VBScript.

Set objet = Server.CreateObject("MSWC.ContentRotator")

Sous JScript, il suffit de remplacer l'instruction Set par var si l'objet n'a pas été préalablement déclaré, sinon supprimer la simplement.

L'objet ContentRotator fonctionne conjointement avec un fichier contenant des chaînes de caractères à afficher.

%% [#Importance] [//Remarques]
  Chaîne de caractères...
...

Le paramètre optionnel Importance doit être un nombre compris entre 0 et 10000. Par défaut la valeur est 1, et le 0 signifie que la chaîne de caractères ne doit pas être affichée. Enfin, la somme des paramètres du fichier de contenu ne peut dépasser 10000. Dans l'exemple en bas du document, les contenus s'afficheront respectivement, 5, 1, 5 et 5 fois sur leur somme soit 16 pages affichées.

La chaîne de caractères peut être un simple contenu textuel ou bien du HTML.

<html>
  <body>
    <%
      Set message = Server.CreateObject("MSWC.ContentRotator") 
    %>
    <% = message.ChooseContent("contenu.txt") %>
  </body>
</html>
<-- Fichier de contenu <i>contenu.txt</i> -->
%% #5 // l'éditeur de livres informatiques O'Reilly
<a href="http://www.editions-oreilly.com">
  <img src="images/oreilly.gif">
</a>
<h3>Découvrez le célèbre éditeur de livres !</h3>

%% #1 // Commentaire avec un minimum d'importance...
<h3>Démonstration de ContentRotator...</h3>

%% #5 // La librairie en ligne Alapage.com
<a href="http://www.alapage.com/">
  <img src="images/alapage.gif">
</a>
<h3>Visitez la librairie en ligne!</h3>

%% #5 // Le vendeur de logiciels BlackOrange.com
<a href="http://www.blackorange.com/">
  <img src="images/blackorange.gif">
</a>
<h3>Découvrez la logithèque en ligne !</h3>

Le composant Counters permet de gérer des compteurs permanents.

Le code ci-dessous, permet de déclarer une instance du composant Counters pour l'ensemble d'un site Web.

<object
              RUNAT = "Server"
              SCOPE = "Application"
              ID = "Objet_Compteur"
              PROGID = "MSWC.Counters">
</object>

Cette déclaration doit être insérée dans le fichier global.asa du répertoire racine.

Les noms et les valeurs des compteurs sont stockés dans un fichier dénommé counters.txt situé dans un répertoire où se trouve le fichier counters.dll.

<-- Fichier Global.asa situé sous la racine du site Web -->
<object 
                 runat="Server" 
                 scope="Application" 
                 id="compteur" 
                 progid="MSWC.Counters">
</object>
...

<-- Fichier Counter.asp -->
<html>
  <body>
    <h3>Cette page a été ouverte 
            <%= compteur.Get("compte_page") %> fois.</h3>
    <h4>L'incrémentation : 
            <%= compteur.Increment("compte_page") %></h4>
    <a href="counters.asp">Recharger la page</a>
  </body>
</html>

Le composant IISLog permet d'administrer ou d'explorer un fichier journal généré par le serveur Internet Information Server (IIS).

La déclaration ci-dessous, permet de créer une instance du composant IISLog sous VBScript.

Set objet = Server.CreateObject("MSWC.IISLog")

Sous JScript, il suffit de remplacer l'instruction Set par var si l'objet n'a pas été préalablement déclaré, sinon supprimer la simplement.

L'inclusion d'une directive METADATA dans l'entête du document ASP, est impérative en raison de l'utilisation des constantes ForReading, ForWriting et AllOpenFiles, servant de paramètres d'ouverture d'un fichier journal avec l'instruction OpenLogFiles.

<!-- METADATA type="typelib"
                         FILE="C:\WINNT\system32\inetsrv\logscrpt.dll" -->

Le composant IISLog dépend de la librairie logscrpt.dll, c'est pourquoi la directive d'u=inclusion pointe vers ce fichier.

L'utilisation du composant IISLog dans une document Web nécessite de désactiver l'Accès anonyme dans les paramètres de sécurité concernant la page.

Le fichier journal par défaut de Internet Information Server (IIS) est localisé dans le répertoire suivant :

C:\WINNT\system32\LogFiles\W3SVC1\

Le fichier Log énumère l'ensemble des accès effectués sur le serveur courant.

<!-- METADATA type="typelib" FILE="C:\WINNT\system32\inetsrv\logscrpt.dll" -->
<html>
  <body>
    <%
      Dim objJournal
      Set objJournal = Server.CreateObject("MSWC.IISLog")
      objJournal.OpenLogFile _
                  "C:\WINNT\system32\LogFiles\W3SVC1\extend1.log", _
                               ForReading, "W3SVC", 1, 0
      objJournal.ReadFilter DateAdd("d", -1, Now), Now
    %>
    <table cellpadding="10">
      <tr>
        <th>Date/Heure</th>
        <th>Adresse IP</th>
        <th>Nom d'utilisateur</th>
        <th>Agent utilisateur</th>
        <th>Page demandée</th>
      </tr>
      <%
        Do While Not objJournal.AtEndOfLog
        objJournal.ReadLogRecord
      %>
      <tr>
        <td><% = objJournal.DateTime %></td>
        <td><% = objJournal.ClientIP %></td>
        <td><% = objJournal.UserName %></td>
        <td><% = objJournal.UserAgent %></td>
        <td><% = objJournal.URIStem %></td>
      </tr>
      <%
        Loop
        objJournal.CloseLogFiles(ForReading)
      %>
    </table>
  </body>
</html>

Le composant MyInfo permet de stocker diverses valeurs de propriétés qui peuvent être créées dynamiquement.

La déclaration ci-dessous, permet de créer une instance du composant MyInfo dans le fichier global.asa du répertoire racine du site Web.

<object
           runat="Server"
           scope="Session"
           id="Objet_Information"
           progid="MSWC.MyInfo">
</object>

Les informations contenues dans le composant MyInfo sont stockées dans un fichier spécifique au format XML (eXtended Markup Language) dénommée myinfo.xml situé dans le répertoire winnt\system32\inetsrv où se trouve le fichier myinfo.dll pour Windows 2000 et sous le répertoire Windows pour la version 9X.

D'ailleurs avec Windows 9X, il est possible de déclarer le composant MyInfo comme un objet programmé à l'image de PageCounter par exemple.

Set Objet_Information = Server.CreateObject("MSWC.MyInfo")

Le composant MyInfo en possède pas de propriétés propres en ce qui concerne les serveurs IIS, mais peuvent être créées en leurs affectant un nom et une valeur.

Objet_Information.Propriété = Valeur

Sous Windows 9X, plusieurs propriétés sont définies et concernent généralement des données personnelles comme l'illustre le tableau ci-dessous.

<-- Fichier global.asa situé sous le répertoire racine du site -->
<object
          runat="Server"
          scope="Session"
          id="obj_info"
          progid="MSWC.MyInfo">
</object>
...

<-- Fichier myinfo.asp -->
<html>
  <body>
    <%
      obj_info.auteur = "Jean-Chritophe Debré"
      obj_info.service = "Développement"
      obj_info.societe = "IngDev Org"
      obj_info.email = "jc.debre@yahoo.fr"
      obj_info.editeur = "WebExpert 2000"
    %>
    Auteur : <%= obj_info.auteur %> <br>
    Service : <%= obj_info.service %> <br>
    Société : <%= obj_info.societe %> <br>
    eMail : <%= obj_info.email %> <br>
    Editeur : <%= obj_info.editeur %> <br>
  </body>
</html>

Le composant NextLink permet de gérer une liste d'adresses URL (Uniform Resource Locator) dans un fichier texte.

La déclaration ci-dessous, permet de créer une instance du composant NextLink sous VBScript.

Set objet = Server.CreateObject("MSWC.NextLink")

Sous JScript, il suffit de remplacer l'instruction Set par var si l'objet n'a pas été préalablement déclaré, sinon supprimer la simplement.

Le composant NextLink dépend du fichier librairie NextLink.dll et d'un fichier textuel spécifique contenant une liste d'adresses URL.

Le fichier texte contenant la liste d'adresses URL doit obéir à la construction suivante :

Adresse.urlDescriptionCommentaire
...
AdresseN.urlDescriptionNCommentaireN

Une tabulation doit obligatoirement apparaître entre chaque élément et chaque URL doit commencer une nouvelle ligne.

Seules des adresses virtuelles relatives (rep/page.asp) ou physiques (rep\page.asp) sont acceptées par le composant NextLink.

Les adresses absolues (http://www.adresse.com) ne peuvent être utilisées telles quelles dans le fichier précité. Néanmoins, l'instruction Redirect peut permettre de s'affranchir de cette limitation.

redirection.asp?url=http://adresse.com
                 DescriptionCommentaire

Le fichier de redirection redirection.asp permet de récupérer l'adresse absolue et de la rediriger par l'intermédiaire de l'instruction Redirect.

<%
  Response.Clear
  Response.Redirect Request.QueryString("url")
%>

<!-- Fichier nextlink.asp -->
<%@LANGUAGE="VBScript"%>
<html>
  <body>
    <%
      Set objLiens = Server.CreateObject("MSWC.Nextlink")
    %>
    <h2>Sommaire</h2>
    <h3>
      <a href="<% = objLiens.GetNthURL("liste_liens.txt", 1) %>">
        <% = objLiens.GetNthDescription("liste_liens.txt", i) %>
      </a>
    </h3>
    <ol>
    <%
      nbLiens = objLiens.GetListCount("liste_liens.txt")
      For i = 2 To nbLiens
    %>
      <li>
        <a href="<% = objLiens.GetNthURL("liste_liens.txt", i) %>">
          <% = objLiens.GetNthDescription("liste_liens.txt", i) %>
        </a>
      </li>
    <%
      Next
    %>
    </ol>
  </body>
</html>
<!-- Fichier liste_liens.txt -->
composant.html Les composants
objet_adrotator.html AdRotator
objet_browsertype.html BrowserType
objet_contentrotator.html ContentRotator
objet_counters.html Counters
objet_iislog.html IISLog
objet_myinfo.html MyInfo
objet_nexlink.html NextLink
objet_permissionchecker.html PermissionChecker
objet_tools.html Tools

Le composant PageCounter permet de comptabiliser le nombre d'ouverture d'une page ASP.

La déclaration ci-dessous, permet de créer une instance du composant PageCounter sous VBScript.

Set objet = Server.CreateObject("MSWC.PageCounter")

Sous JScript, il suffit de remplacer l'instruction Set par var si l'objet n'a pas été préalablement déclaré, sinon supprimer la simplement.

Les données recueillies par PageCounter sont stockées dans un fichier texte.

Le composant PageCounter dépend de la librairie pagecnt.dll.

<html>
  <body>
    <%
      Dim compteur_page
      Set compteur_page = Server.CreateObject("MSWC.PageCounter")
      compteur_page.PageHit()
    %>
    <h3>Le nombre de visites sur cette page est égale à 
                                    <%= compteur_page.Hits() %></h3>
    <a href="pagecounter.asp">Recharger la page</a>
  </body>
</html>

Le composant PermissionChecker permet de vérifier si un utilisateur à le droit d'accéder à un fichier précisé.

La déclaration ci-dessous, permet de créer une instance du composant PermissionChecker sous VBScript.

Set objet = Server.CreateObject("MSWC.PermissionChecker")

Sous JScript, il suffit de remplacer l'instruction Set par var ou de l'enlever si l'objet est déjà déclaré.

Ce composant n'est utilisable que sous les serveurs IIS (Internet Information server). En effet, la méthode d'authentification d'un utilisateur dépend de la désélection de l'option Accès anonyme, située dans les Propriétés de PermissionChecker du gestionnaire de service Internet.

Ensuite, les utilisateurs autorisés doivent être déclarés dans les paramètres de sécurité des propriétés de la page à restreindre.

Enfin, le composant PermissionChecker pourra désormais comparer les données d'authentification du compte IUSR_nom_machine à celles enregistrées dans les propriétés de sécurités afin d'autoriser le cas échéant l'accès à une page ASP restreinte.

<html>
  <body>
    <%
      Set autorisation = Server.CreateObject("MSWC.PermissionChecker")
      If autorisation.HasAccess("acces_special.asp") Then
    %>
      <a href="acces_special.asp">Page réservée</a>
    <%
      Else
    %>
      <h3>Vous n'êtes pas autorisé à continuer la procédure !</h3>
    <%
      End If
    %>
  </body>
</html>

Le composant Tools possède différentes méthodes utilitaires, permettant de tester l'existence d'un fichier, de traiter un formulaire HTML, de générer une valeur entière aléatoire, et plus spécifiquement pour Macintosh de détecter un module d'extension du serveur ou encore de vérifier si l'utilisateur est proprétaire du site.

La déclaration ci-dessous, permet de créer une instance du composant Tools sous VBScript.

Set objet = Server.CreateObject("MSWC.Tools")

Sous JScript, il suffit de remplacer l'instruction Set par var si l'objet n'a pas été préalablement déclaré, sinon supprimer la simplement.

Le composant Tools dépend de la librairie tools.dll.

<html>
  <head>
    <script language="JScript" runat="server">
      var obj_Outil = Server.CreateObject("MSWC.Tools");
      var Fichier = Request.Form("adresse");
      if ((IsEmpty(Fichier) != True) And (IsNull(Fichier) != True))
      {
        if (obj_Outil.FileExists(Fichier))
        {
          Response.Write("Le fichier <b>" + Fichier + "</b> est présent.");
        }
        else
        {
          Response.Write("Le fichier <b>" + Fichier + "</b> n'existe pas.");
        }
      }
      delete obj_Outil;
    </script>
  </head>
  <body>
    <form action="tools.asp" method="POST">
      Saisissez une adresse vers un fichier : 
      <input type="text" name="adresse"><br>
      <input type="SUBMIT" name="soumettre"><br>
    </form>
  </body>
</html>

Le composant ASPSmartUpload permet de gérer les téléchargements de fichiers ou de données en Upload ou en Download à partir d'un serveur hôte.

Ce composant puissant et gratuit offre une gestion avancée des transferts de fichiers en flux montant ou descendant, avec notamment un contrôle des fichiers en Upload, la restriction sur leurs caractéristiques en Download ou encore a gestion des formulaires en mode mixte.

L'installation du composant ASPSmartUpload s'effectue selon les étapes suivantes :

• Télécharger les fichiers sur le site de ASPSmart.
• Décompresser le fichier ZIP.
• Copier les fichiers DLL dans le répertoire C:\WINNT\SYSTEM32.
• Exécuter à partir de l'invite MS-DOS
  REGSVR32.EXE C:\WINNT\SYSTEM32\aspSmartUpload.dll .

Le composant ASPSmartUpload comporte un objet principal appelé SmartUpload, lui même comprenant deux collections Files et Form contenant respectivement des objets File et des objets Item.

Objet_SmartUpload
        ¦¦
          = >   Collection_Files
                  ¦¦
                  = >   Objet_File
        ¦¦
         = >   Collection_Form
                  ¦¦
                  = >   Objet_Item

L'objet SmartUpload peut être créé directement à partir d'un script ASP.

Set Objet_Upload = Server.CreateObject("AspSmartUpload.SmartUpload")

Ensuite comme tous les objets intrinsèques à ASP, l'utilisation de l'objet SmartUpload s'effectue come suit :

Objet_Upload.Collections | Propriété | Méthode

La collection Files contient l'ensemble des objets File représentant des fichiers spécifiés dans les éléments HTML de transfert de fichier.

Coll_Files.Collection | Propriété | Méthode

L'objet File correspond au fichier désigné par la valeur d'un champ de l'élément HTML de transfert de fichier.

Objet_File.Propriété | Méthode

La collection Form représente le formulaire et contient les objets Item.

Objet_Fom.Collection | Propriété | Méthode

L'objet Item correspond aux champs de transfert de fichiers compris dans le formulaire.

Objet_Item.Propriétés

<!-- Formulaire de saisie -->
<html>
  <body>
    <form 
              method="POST"
              action="traitement.asp"
              enctype="multipart/form-data">
      <input type="file" name="fichier1" size="50"><br>
      <input type="file" name="fichier2" size="50"><br>
      <input type="file" name="fichier3" size="50"><br>
      <input type="file" name="fichier4" size="50"><br>
      <input type="submit" value="Upload">
    </form>
  </body>
</html>
<!-- Fichier de traitement traitement.asp -->
<html>
  <body>
    <%
      Dim Objet_SmartUpload
      Dim Fichier
      Dim i
      i = 0
      Set Objet_SmartUpload = _
              Server.CreateObject("aspSmartUpload.SmartUpload")
      Objet_SmartUpload.Upload
      For each Fichier In Objet_SmartUpload.Files
        If not Fichier.IsMissing Then
          Fichier.SaveAs("/aspSmartUpload/Upload/" & Fichier.FileName)
          Fichier.SaveAs("c:\temp\" & Fichier.FileName)
          Response.Write "" _
              & "<table>" _
                & "<tr><th>Nom complet</th><td>" _
                  & Fichier.Name & "</td></tr>" _
                & "<tr><th>Taille</th><td>" _
                  & Fichier.Size & "</td></tr>" _
                & "<tr><th>Nom</th><td>" _
                  & Fichier.FileName & "</td></tr>" _
                & "<tr><th>Extension</th><td>" _
                  & Fichier.FileExt & "</td></tr>" _
                & "<tr><th>Chemin</th><td>" _
                  & Fichier.FilePathName & "</td></tr>" _
                & "<tr><th>Type de contenu</th><td>" _
                  & Fichier.ContentType & "</td></tr>" _
                & "<tr><th>Disposition de contenu</th><td>" _
                  & Fichier.ContentDisp & "</td></tr>" _
                & "<tr><th>Type MIME</th><td>" _
                  & Fichier.TypeMIME & "</td></tr>" _
                & "<tr><th>Sous-Type MIME</th><td>" _
                  & Fichier.SubTypeMIME & "</td></tr>" _
              & "</table>"
          i = i + 1
        End If
      Next
      Response.Write "<p>" & Objet_SmartUpload.Files.Count _
                            & " fichiers pouvaient être uploadés.</p>"
      Response.Write "<p>" & i & " fichiers uploadés.</p>"
    %>
  </body>
</html>

L'objet CDONTS.NewMail donne la possiblité d'envoyer un message directement à partir d'une page ASP.

L'objet NewMail fait parti de la librairie CDO (Collaboration Data Objects) permettant d'émettre et de recevoir des messages à partir des serveurs Microsoft.

La librairie CDO est installée avec les logiciels Microsoft® Exchange Client and Server, et Outlook 98.

L'instanciation de l'objet NewMail s'effectue comme suit :

Set Objet_eMail = Server.CreateObject("CDONTS.NewMail")

L'encodage des méthodes AttachFile et AttachURL peuvent être :

• la constante CdoEncodingUUencode égale à 1, indiquant une méthode d'encodage au format UUEncode,
• CdoEncodingBase64 égale à 2, spécifiant une méthode d'encodage au format base 64.

<%
  Dim objet_NewMail

  Set objet_NewMail = Server.CreateObject("CDONTS.NewMail")

  objet_NewMail.From = "expediteur@serveur.com"
  objet_NewMail.To = "destinataire@serveur.com"
  objet_NewMail.Subject = "Courrier électronique"
  objet_NewMail.Body = "Le corps du message..."
  objet_NewMail.BodyFormat = 0 
  objet_NewMail.MailFormat = 0 
  objet_NewMail.Send

  Set objet_NewMail = Nothing
%> 

<%
  Dim objet_NewMail

  Set objet_NewMail = CreateObject("CDONTS.NewMail") 

  Contenu = "" _
          & "<html>" _
          & "<head>" _
          & "<title>Courrier électronique</title>" _
          & "</head>" _
          & "<body>" _
          & "<h1>Sujet du message</h1>" _
          & "<p>Le corps du message...</p>" _
          & "</body>" _
          & "</html>"
  objet_NewMail.From = "expediteur@serveur.com" 
  objet_NewMail.To = "destinataire"
  objet_NewMail.Subject = "Courrier électronique" 
  objet_NewMail.BodyFormat = 1
  objet_NewMail.MailFormat = 1
  objet_NewMail.Body = Contenu
  objet_NewMail.Importance = 2
  objet_NewMail.AttachFile = "c:\piecejointe.doc", "Pièce jointe"
  objet_NewMail.Send

  Set objet_NewMail = Nothing
%> 

Le fichier Global.asa permet le lancement de certaines tâches préalables ou consécutives, nécessaires au fonctionnement d'une application ASP.

Effectivement, le fichier Global.asa localisé sous la racine du site Web, peut contenir des instructions qui s'exéctueront avant ou après que des pages ASP soit accédées par un utilsateur. Ainsi, des objets peuvent être créés, ou des variables initialisés, avant le début de l'implémentation du code ASP dans les pages Web ou après de réinitialiser des variables par exemple.

Plus précisément, le fichier Global.asa permet :les actions énoncées dans la liste ci-dessous.

<!-- Fichier Global.asa -->
<!--METADATA type="TypeLib" FILE="Composant.tlb"-->

<object 
             runat="Server"
             scope="Application" 
             id="Compteur"
             progid="MSWC.Counters">
</object>

<object 
             runat="Server"
             id="Liste_Lien"
             scope="Session"
             progid="MSWC.NextLink">
</object>

<script language="VBScript" runat="Server">
  Sub Application_onStart()
    Set Application("oConnection") = Server.CreateObject("ADODB.Connection")
    Dim Tableau(6)
    Tableau(0) = "Nom"
    Tableau(1) = "Prénom"
    Tableau(2) = "Adresse"
    Tableau(3) = "Code Postal"
    Tableau(4) = "Ville"
    Tableau(5) = "Adresse eMail"
    Application("Individu") = Tableau
    Application("Depart") = CStr(Now)
    Application("Compteur_Visite") = 0
  End Sub

  Sub Application_onEnd()
    Set Application("oConnection") = Nothing
  End Sub

  Sub Session_onStart()
    Set Session("oAdRotator") = Server.CreateObject("MSWC.AdRotator")
    Dim Tableau(6)
    Tableau(0) = "Nom"
    Tableau(1) = "Prénom"
    Tableau(2) = "Adresse"
    Tableau(3) = "Code Postal"
    Tableau(4) = "Ville"
    Tableau(5) = "Adresse eMail"
    Session("Individu") = Tableau
    Session("Depart") = CStr(Now)
    Session("Adresse_IP") = Request.ServerVariables("REMOTE_ADDR")
    Application.Lock  
    intVisits = Application("Compteur_Visite") + 1
    Application("Compteur_Visite") = intVisits
    Application.Unlock
  End Sub

  Sub Session_onEnd()
    Set Session("oASPAdRotator") = Nothing
  End Sub
</script>

Le code événementiel des objets Application et Session se place dans des gestionnaires d'événements définissant daux états sensibles.

Les deux événements précités sont utilisés accolés à l'objet par l'intermédiaire d'un caractère souligné (_), dans le fichier Global.asa selon la syntaxe suivante :

<script language="Langage_Script" runat="Server">
  Sub Application | Session_OnStart()
    ' Instructions...
  End Sub
  
  Sub Application | Session_OnEnd()
    ' Instructions...
  End Sub
</script>

En ce qui concerne Application_OnStart | OnEnd, seuls les objets Application et Server peuvent être utilisés à l'intérieur des procédures événementielles, les autres objets provoquant des erreurs.

Par contre, Session_OnStart permet l'utilisation de tous les objets ASP (Application, ObjectContext, Request, Response, Session et Server).

Enfin, Session_OnEnd n'accepte que les objets Application, Session et Server.

<script language="VBScript" runat="Server">
  Sub Session_OnStart
  End Sub

  Sub Session_OnEnd
  End Sub

  Sub Application_OnStart
    Application("ConnectString") = "dsn=personnel"
  End Sub

  Sub Application_OnEnd
    Application("ConnectString") = ""
  End Sub
</script>

La déclaration des objets dans le fichier Global.asa, s'effectue par l'intermédiaire de la balise object.

L'utilisation de la balise object doit se faire à l'extérieur des balises de script (<script...>...</script>) et obéït à la construction suivante :

<object 
             runat="Server"
             scope="Application | Session"
             id="Identificateur"
             {progid="progID"| classid="ClassID"}>
</object>

Les objets, ainsi déclarés, possèdent une portée dans le domaine, soit d'un objet Application, soit d'un objet Session.

L'identificateur permet de faire référence à l'objet à partir d'une page ASP.

Les attributs progid ou classid pointent vers des valeurs spécifiques et connues relatives aux objets à créer.

Les objets ne sont réellement créés qu'à partir du moment où un script, y faisant référence, est exécuté par le serveur.

La destruction de ces objets s'accomplit automatiquement, ainsi, il est inutile de mobiliser des ressources pour cette opération.

<object 
             runat="Server"
             scope="Application" 
             id="Fichier_Journal"
             progid="MSWC.IISLog">
</object>

<object 
             runat="Server"
             id="ObjConnection"
             scope="Session"
             progid="ADODB.Connection">
</object>

<script language="VBScript" runat="Server">
  Sub Application_onStart()
  End Sub

  Sub Application_onEnd()
  End Sub

  Sub Session_onStart()
  End Sub

  Sub Session_onEnd()
  End Sub
</script>

Le référencement des bibliothèques de type permet de rendre disponible des informations sur des objets.

Cette commande se révèle particulièrement utile lorsqu'une application ASP doit faire appel à des bibliothèques d'objets personnellement développées ou provenant d'un tiers.

Les instructions ci-dessous permettent de faire référence à une bibliothèque de type.

<:!--METADATA type="TypeLib"
                         FILE="Fichier"
                         [UUid="Type_UUID"]
                         [version="Version"]
                         [LCID="ID_Local"]-->

Pour de meilleures performances, il est conseillé de placer la commande au sommet du fichier Global.asa.

La valeur de l'attribut UUID correspond à un identificateur unique universel pour la bibliothèque de type.

Le dernier attribut LCID demande un identificateur local de la bibliothèque de type.

<!-- Fichier Global.asa -->
<!--METADATA type="TypeLib" FILE="MesAutorisation.tlb"-->
<!--METADATA type="TypeLib" FILE="Compteur.tlb"-->

<object 
             runat="Server"
             scope="Application" 
             id="objPermission"
             progid="MSWC.PermissionChecker">
</object>

<script language="VBScript" runat="Server">
  Sub Application_onStart()
  End Sub

  Sub Application_onEnd()
  End Sub

  Sub Session_onStart()
  End Sub

  Sub Session_onEnd()
  End Sub
</script>

Les formulaires sont employés pour transmettre des informations saisies par un client à une application Web.

<form action="page.asp" method="post|get">
  Eléments du formulaire...
</form>

L'attribut action pointe un fichier destinataire des données saisies par le client. Cette cible, une page ASP, posséde des scripts VBScript ou JScript permettant de traiter les informations contenues dans le formulaire.

Les méthodes POST ou GET définissent le type de transmission à utiliser dans le traîtement du formulaire vers le serveur. POST envoie le fichier complet au serveur alors que GET se sert de la variable QUERY_STRING pour transmettre les informations.

Les informations saisies par un utilisateur dans les éléments d'un formulaire peuvent être récupérées par l'intermédiaire de l'objet Request.

La collection Form contient toutes les valeurs entrées dans les éléments d'un formulaire.

L'extraction des données à partir d'une collection Form s'effectue comme suit :

Request.Form

Les données retournées par l'utilisateur répondent à la construction suivante :

NomElt=Valeur&Nom_Elt2=Valeur2&...&Nom_EltN=ValeurN

Cette forme semble peu pratique pour une utilisation ultérieure des valeurs dans des programmes ASP.

Une autre forme permet d'extraire les valeurs plus précisément.

Request.Form(Nom_Elément)

Il est également possible de remplacer le nom de l'élément par un indice représentant la position de l'élément concerné, en sachant que l'élément le plus haut dans le formulaire, possède un indice égal à 1.

Request.Form(Indice)

Dans les deux cas, la valeur retournée est unique et se réfère exactement à l'élément spécifiée.

...
<input type="text" name="Nom">
<input type="text" name="Prénom">
<input type="text" name="Pseudonyme">
...
'Retourne la valeur de l'élément Nom
Response.Write Request.Form("Nom")
'Retourne la valeur de l'élément Prénom
Response.Write Request.Form("Prénom")
'Retourne la valeur de l'élément Pseudonyme
Response.Write Request.Form(3)
...

Par ailleurs, deux méthodes permettent de parcourir les éléments de la collection Form.

• La première utilise la propriété Count associé à une boucle For...To...Next.

For increment = 1 To Request.Form.Count
  Element = Element & Request.Form(increment) & "<br>"
Next

• La seconde consiste à utiliser une boucle For Each...In...Next.

For Each objElement In Request.Form
  Element = Element & Request.Form(objElement) & "<br>"
Next

Enfin, la gestion des élements à valeurs multiples d'un formulaire peut s'effectuer également par l'intermédiaire de la structure ci-dessous.

<!-- Formulaire -->
<html>
  <body>
    <form action="reponse.asp" method="post">

      <input type="text" name="PrenomFrereSoeur">
      <input type="text" name="PrenomFrereSoeur">
      <input type="text" name="PrenomFrereSoeur">
      <input type="text" name="PrenomFrereSoeur">
      <input type="text" name="PrenomFrereSoeur">

    </form>
  </body>
</html>
<!-- Page de réponse reponse.asp -->
<html>
  <body>
    For Each objElement In Request.Form
      If Request.Form(objElement).Count > 1 Then
        For increment = 1 To Request.Form(objElement).Count
          Element = Element & Request.Form(objElement)(increment) _
                           & "<br>"
        Next
      Else
        Element = Element & Request.Form(objElement) & "<br>"
      End If
    Next
  </body>
</html>

Les formulaires peuvent contenir divers champs de saisie textuels.

<input type="type_champs" name="Identifiant">

Trois types de zone de saisie existent, il s'agit de :

• Les champs de saisie :

<input type="text" name"identifiant" size="20">

• Les champs de saisies multilignes :

<textarea name="identifiant" cols="20" rows="3">
  ...
</textarea>

• Les champs mots de passe :

<input type="password" name"identifiant" size="20">

Les champs de saisie doivent possèder chacun un nom permettant au fichier de traitement d'identifier chaque élément d'un formulaire.

<!-- Formulaire -->
<html>
  <body>
    <form action="traitement.asp" method="post">

      <u>Saisir un titre :</u><br>
      <input type="text" name="mot" size="20"><br>

      <textarea name="paragraphe" cols="20" rows="3">
        Saisissez un texte...
      </textarea>

      <input type="submit" name="Soumettre" value="Soumission">

    </form>
  </body>
</html>
<!-- Fichier destinataire traitement.asp -->
<html>
  <body>

    <u>Le mot saisi par l'utilisateur est :</u><br>
    <h2><% = Request.Form("mot") %></h2>

    <u>Le texte saisi par l'utilisateur est :</u><br>
    <p><% = Request.Form("paragraphe") %></p>

  </body>
</html>

Les formulaires peuvent contenir des cases à cocher offrant plusieurs options possibles à l'utilisateur.

<input type="checkbox" name="Identifiant" value="Valeur">

Le nom de la case à cocher permet au fichier destinataire d'identifier l'élément du formulaire afin d'opérer un traitement approprié.

En général, les cases à cocher, autorisant le client à sélectionner plusieurs options, possèdent un identifiant unique avec des valeurs différentes.

<input type="checkbox" name="loisirs" value="Informatique">
<input type="checkbox" name="loisirs" value="Musique">
<input type="checkbox" name="loisirs" value="Cinéma">
<input type="checkbox" name="loisirs" value="Littérature">
<input type="checkbox" name="loisirs" value="Sport">
<input type="checkbox" name="loisirs" value="Art">

Les cases à cocher sélectionnées retournent ainsi, le nom des éléments suivi par chacune des valeurs concernées.

loisirs = Informatique, Littérature

Dans le cas où aucune valeur n'est spécifiée pour chacune des cases à cocher, il est nécessaire de dénommer différemment les éléments optionnels.

<input type="checkbox" name="Informatique">
<input type="checkbox" name="Musique">
<input type="checkbox" name="Cinéma">
<input type="checkbox" name="Littérature">
<input type="checkbox" name="Sport">
<input type="checkbox" name="Art">

Ici, les options sélectionnées se démarquent par un renvoi automatique d'une valeur on, les autres options étant simplement ignorées. En conséquence, en cas d'itérations, seulement les cases activées sont prises en compte dans le dénombrement. Ci-dessous seules les options Informatique et Littérature ont été côchées par le client.

Informatique = on 'correspond à 1
Littérature = on 'correspond à 2

L'extraction des données fournies par le client s'effectue par l'intermédiaire de l'objet Request associée à sa collection Form et le cas échéant l'identifiant des cases à cocher pour plus de précision.

Response.Write Request.Form
'retourne
loisirs = Informatique, Littérature

Response.Write Request.Form("loisirs")
'retourne
Informatique, Littérature

<!-- Formulaire -->
<html>
  <body>
    <form action="traitement.asp" method="post">

      <input type="checkbox" name="loisirs" value="Informatique">
        Informatique<br>
      <input type="checkbox" name="loisirs" value="Musique">
        Musique<br>
      <input type="checkbox" name="loisirs" value="Cinéma">
        Cinéma<br>
      <input type="checkbox" name="loisirs" value="Littérature">
        Littérature<br>
      <input type="checkbox" name="loisirs" value="Sport">
        Sport<br>
      <input type="checkbox" name="loisirs" value="Art">
        Art<br>
      <br>

      <input type="submit" name="Soumettre" value="Soumission">

    </form>
  </body>
</html>
<!-- Fichier destinataire traitement.asp -->
<html>
  <body>

    <u>Les options sélectionnées par l'utilisateur sont :</u><br>
    <h2><% = Request.Form("loisirs") %></h2>
    <p>
    <%
      For Each objElement In Request.Form
          If Request.Form(objElement).Count > 1 Then
            For increment = 1 To Request.Form(objElement).Count
              Response.Write increment & " : " & _
                           Request.Form(objElement)(increment) & "<br>"
            Next
          Else
            Response.Write Request.Form(objElement) & "<br>"
          End If
      Next
    %>
    </p>
  </body>
</html>

Les formulaires peuvent contenir des cases radio proposant un choix parmi plusieurs options possibles.

<input type="radio" name="Identifiant" value="Valeur">

Le nom de la case radio permet au fichier destinataire d'identifier l'élément du formulaire afin d'opérer un traitement approprié.

En général, les cases radio, autorisant le client à sélectionner une seule et unique option, possèdent un identifiant unique avec des valeurs différentes.

<input type="radio" name="situation" value="Célibataire">
<input type="radio" name="situation" value="Marié(e)">
<input type="radio" name="situation" value="Concubinage">
<input type="radio" name="situation" value="Pacs">
<input type="radio" name="situation" value="Veuf(ve)">
<input type="radio" name="situation" value="Divorcé(e)">

La case radio sélectionnée retourne ainsi, le nom de l'élément suivi par la valeur concernée.

situation = Célibataire

Dans le cas où aucune valeur n'est spécifiée pour chacune des cases radio, il est nécessaire de dénommer différemment les éléments optionnels.

<input type="radio" name="Célibataire">
<input type="radio" name="Marié(e)">
<input type="radio" name="Concubinage">
<input type="radio" name="Pacs">
<input type="radio" name="Veuf(ve)">
<input type="radio" name="Divorcé(e)">

Ici, les options sélectionnées se démarquent par un renvoi automatique d'une valeur on, les autres options étant simplement ignorées.

Célibataire = on 

L'extraction des données fournies par le client s'effectue par l'intermédiaire de l'objet Request associée à sa collection Form et le cas échéant l'identifiant des cases radio pour plus de précision.

Response.Write Request.Form
'retourne
situation = Célibataire

Response.Write Request.Form("situation")
'retourne
Célibataire

<!-- Formulaire -->
<html>
  <body>
    <form action="traitement.asp" method="post">

      <input type="radio" name="situation" value="Célibataire">
        Célibataire<br>
      <input type="radio" name="situation" value="Marié(e)">
        Marié(e)<br>
      <input type="radio" name="situation" value="Concubinage">
        Concubinage<br>
      <input type="radio" name="situation" value="Pacs">
        Pacs<br>
      <input type="radio" name="situation" value="Veuf(ve)">
        Veuf(ve)<br>
      <input type="radio" name="situation" value="Divorcé(e)">
        Divorcé(e)<br>
      <br>

      <input type="submit" name="Soumettre" value="Soumission">

    </form>
  </body>
</html>
<!-- Fichier destinataire traitement.asp -->
<html>
  <body>

    <u>L'option sélectionnée par l'utilisateur est :</u><br>
    <h2><% = Request.Form("situation") %></h2>
    <p>Vous serez redirigé vers :</p>
    <%
      Select Case Request.Form("situation")
        Case "Célibataire"
          Response.Redirect "celibataire.asp"
        Case "Marié(e)"
          Response.Redirect "marie.asp"
        Case "Concubinage"
          Response.Redirect "concubinage.asp"
        Case "Pacs"
          Response.Redirect "pasc.asp"
        Case "Veuf(ve)"
          Response.Redirect "veuf.asp"
        Case "Divorcé(e)"
          Response.Redirect "divorce.asp"
      End Select
    %>
  </body>
</html>

Les formulaires peuvent contenir des listes de choix proposant un ou plusieurs items parmi une série d'options possibles.

<select name="Identifiant" size="taille" [multiple]>
  <option value="Valeur">Label</option>
  ...
</select>

Le nom de la liste de choix permet au fichier destinataire d'identifier l'élément du formulaire afin d'opérer un traitement approprié.

Si la taille de l'élément select est égale à 1, alors une liste déroulante apparaît. Si la taille est supérieure à 1, alors une liste simple apparaît. Dans ce dernier cas, l'attribut multiple permet de créer une liste simple à choix multiples.

Les liste de choix, autorisant le client à sélectionner une seule ou plusieurs options, possèdent un identifiant unique avec des valeurs différentes pour chacun des éléments optionnels.

<select name="situation" size="1">
  <option value="Célibataire">Célibataire</option>
  <option value="Marié(e)">Marié(e)</option>
  <option value="Concubinage">Concubinage</option>
  <option value="Pacs">Pacs</option>
  <option value="Veuf(ve)">Veuf(ve)</option>
  <option value="Divorcé(e)">Divorcé(e)</option>
</select>

<select name="loisirs" size="6" multiple>
  <option value="Informatique">Informatique</option>
  <option value="Musique">Musique</option>
  <option value="Cinéma">Cinéma</option>
  <option value="Littérature">Littérature</option>
  <option value="Sport">Sport</option>
  <option value="Art">Art</option>
</select>

Le (ou les) option(s) sélectionnée(s) retourne(nt) ainsi, le nom de l'élément suivi par la (ou les) valeur(s) concernée(s).

Dans le cas d'une sélection multiples, les options non-sélectionnées sont simplement ignorées. En conséquence, en cas d'itérations, seulement les options activées sont prises en compte dans le dénombrement.

situation = Célibataire
loisirs = Informatique, Musique, Cinéma

Dans le cas où aucune valeur n'est spécifiée pour chacune des options, alors les labels feront offices de valeur implicites.

<select name="loisirs" size="6" multiple>
  <option>Informatique</option>
  <option>Musique</option>
  <option>Cinéma</option>
  <option>Littérature</option>
  <option>Sport</option>
  <option>Art</option>
</select>
loisirs = Informatique, Musique, Cinéma

L'extraction des données fournies par le client s'effectue par l'intermédiaire de l'objet Request associée à sa collection Form et le cas échéant l'identifiant de la liste de choix pour plus de précision.

Response.Write Request.Form
'retourne
situation = Célibataire

Response.Write Request.Form("situation")
'retourne
Célibataire

<!-- Formulaire -->
<html>
  <body>
    <form action="traitement.asp" method="post">

      <select name="situation" size="1">
        <option value="Célibataire">Célibataire</option>
        <option value="Marié(e)">Marié(e)</option>
        <option value="Concubinage">Concubinage</option>
        <option value="Pacs">Pacs</option>
        <option value="Veuf(ve)">Veuf(ve)</option>
        <option value="Divorcé(e)">Divorcé(e)</option>
      </select>

      <select name="loisirs" size="6" multiple>
        <option value="Informatique">Informatique</option>
        <option value="Musique">Musique</option>
        <option value="Cinéma">Cinéma</option>
        <option value="Littérature">Littérature</option>
        <option value="Sport">Sport</option>
        <option value="Art">Art</option>
      </select>
      <br>

      <input type="submit" name="Soumettre" value="Soumission">

    </form>
  </body>
</html>
<!-- Fichier destinataire traitement.asp -->
<html>
  <body>

    <u>L'option sélectionnée par l'utilisateur est :</u><br>
    <h2><% = Request.Form("situation") %></h2>
    <h2><% = Request.Form("loisirs") %></h2>

    <p>
    <%
      For Each objElement In Request.Form
        If Request.Form(objElement).Count > 1 Then
          For increment = 1 To Request.Form(objElement).Count
            Response.Write increment & " : " & _
                           Request.Form(objElement)(increment) & "<br>"
          Next
        Else
          Response.Write Request.Form(objElement) & "<br>"
        End If
      Next
    %>
    </p>

  </body>
</html>

Les formulaires peuvent contenir plusieurs boutons permettant d'accomplir différentes actions telles que la soumission ou la réinitialisation.

Un formulaire HTML a la possiblité de contenir cinq types spécifiques de boutons.

<input type="submit" name="Identifiant">
<input type="reset" name="Identifiant">
<input type="image" name="Identifiant">
<input type="button" name="Identifiant">
<button name="Identifiant">...</button>

Parmi, ces éléments HTML, seuls les boutons de type submit et image sont capables de renvoyer des informations à une application ASP.

Les noms de ces boutons permettent au fichier destinataire d'identifier l'élément sur lequel l'utilisateur a cliqué.

Par ailleurs, la valeur du bouton est renvoyée à une application ASP, au même titre que toutes les autres valeurs d'éléments de la collection Form.

Ainsi, il devient possible de connaître quel bouton a été actionné et adapté en conséquence la réponse au client.

<form action="traitement.asp" method="post">
  ...
  <input type="submit" name="navigation" value="sommaire">
  <input type="submit" name="navigation" value="précédent">
  <input type="submit" name="navigation" value="suivant">
  <input type="submit" name="navigation" value="sommaire général">
</form>

Dans l'exemple ci-dessous, un clic sur le bouton ayant la valeur précédent provoque la soumission du formulaire, et partant, de ces données ainsi que de la valeur du bouton lui-même.

navigation = précédent

Dans le cas où chaque bouton doit posséder la même apparence sans label, la longueur de la chaîne de caractères retournée détient un rôle central. La méthode permettant de repérer facilement le bouton cliqué des autres peut se faire comme ceci :

<!-- Formulaire -->
<form action="traitement.asp" method="post">
  ...
  <input type="submit" name="sommaire" value="&nbsp;&nbsp;">
  Retourner au sommaire...
  <input type="submit" name="précédent" value="&nbsp;&nbsp">
  Aller à la page précédente...
  <input type="submit" name="suivant" value="&nbsp;&nbsp">
  Aller à la page suivante...
  <input type="submit" name="somm_gen" value="&nbsp;&nbsp">
  Retourner au sommaire principal...
</form>
<!-- Fichier de traîtement traitement.asp -->
If Len(Request.Form("sommaire")) Then
  Response.Write "Vous avez cliqué sur le bouton sommaire !"
ElseIf Len(Request.Form("précédent")) Then
  Response.Write "Vous avez cliqué sur le bouton précédent !"
ElseIf Len(Request.Form("suivant")) Then
  Response.Write "Vous avez cliqué sur le bouton suivant !"
ElseIf Len(Request.Form("somm_gen")) Then
  Response.Write "Vous avez cliqué sur le bouton sommaire général !"
EndIf

L'instruction Len() permet de tester la longueur de la chaîne de caractère retournée. Si la longueur est non-nul, les instructions s'exécutent sinon elles sont ignorées.

Les boutons de type image fonctionnent d'une manière différente.

<input 
           type="image"
           name="Identifiant"
           src="Adresse.url"
           alt="Texte">

Un clic sur ce genre de bouton, provoque l'envoi d'une chaîne de caractères, indiquant le nom du bouton et les coordonnées horizontale et verticale du point cliqué.

sommaire.x=3&sommaire.y=7

Ainsi, la récupération des données s'effectue par l'intermédaire de l'objet QueryString. Ainsi, il est possble de déterminer quel bouton a été actionné en testant la présence de son nom dans la chaîne de requête ou encore en s'appuyant sur sa zone cliquable.

<!-- Formulaire -->
<html>
  <body>
    <form action="traitement.asp" method="get">

      <input 
           type="image" 
           src="../../images/interface/fleche.gif"
           name="sommaire"
           alt="Retourner au sommaire"> 
      <input 
           type="image"
           src="../../images/interface/flecheg.gif"
           name="precedent"
           alt="Aller au document précédent"> 
      <input 
           type="image" 
           src="../../images/interface/fleched.gif"
           name="suivant"
           alt="Aller au document suivant"> 
      <input 
           type="image"
           src="../../images/interface/flechedbl.gif"
           name="som_gen"
           alt="Retourner au sommaire général">

    </form>
  </body>
</html>
<!-- Fichier destinataire traitement.asp -->
<html>
  <body>
    <%
      If Instr(Request.QueryString, "sommaire") > 0 Then
        Response.Redirect "../formulaire.html"
      End If
      If Instr(Request.QueryString, "precedent") > 0 Then
        Response.Redirect "../form_listechoix.html"
      End If
      If Instr(Request.QueryString, "suivant") > 0 Then
        Response.Redirect "../form_exemple.html"
      End If
      If Instr(Request.QueryString, "som_gen") > 0 Then
        Response.Redirect "../sommaire.html"
      End If
    %>
  </body>
</html>

Les formulaires peuvent contenir un ou plusieurs éléments HTML de transfert de fichier.

<input type="file" name="Nom" size="Taille">

De tels éléments sont utilisés pour joindre des fichiers attachés aux informations textuelles d'un formulaire dans le cadre de messagerie électronique ou pour envoyer des fichiers directement sur le serveur.

L'élément de transfert de fichier comporte un champ de saisie destiné à contenir un chemin vers le fichier et un bouton permettant de parcourir l'arborescence de la machine cliente.

Différents composants COM (Components Object Model) permettent de traiter facilement les fichiers provenant des éléments d'envoi de fichier. Les deux premiers composants de la liste ci-dessous, permettent une utilisation gratuite, les autres sont payants.

• ASPUpload édité par Persits Software, Inc,
• ASPSmartUpload édité par la société Advantys.
• ActiveFile édité par Frontstep Solutions Group, Inc..
• FileUpload édité par VisualSoft Technologies,
• SA-FileUp édité par la société Artisans,

Ces composants prennent en charge l'ensemble des fonctions nécessaires à la gestion et à la réception sur le serveur hôte, d'un fichier envoyé par un client.

<!-- Formulaire de saisie telechargement.asp -->
<html>
  <body>
    <%
      Option Explicit

      Dim objet_Upload, Nouveau_Fichier 

      Set objet_Upload = Server.CreateObject("ASPSimpleUpload.Upload")

      If Len(objet_Upload.Form("Fichier")) > 0 Then
        Nouveau_Fichier = "/Uploads/" _
            & objet_Upload.ExtractFileName(objet_Upload.Form("Fichier"))
        If objet_Upload.SaveToWeb("Fichier", Nouveau_Fichier) Then
          Response.Write "Le fichier a été transféré correctement sur le serveur."
        Else
          Response.Write "" _
              & "Une erreur s'est produite lors de la sauvegarde du fichier.")
        End If
      End If
    %> 
    <form 
              method="POST" 
              action="telechargement.asp"
              enctype="multipart/form-data">
      <p>Sélectionnez un fichier pour un téléchargement :</p>
      <input type="file" name="Fichier" size="30">
      <input type="submit" name="upload" value="Télécharger">
    </form>
  </body>
</html>

Le formulaire ci-dessous permet de mettre en oeuvre certains éléments à l'image des champs de saisie, d'une liste de choix de cases à cocher ainsi que de boutons.

Le formulaire permet de soumettre des informations fournies par le client, de plus, il contrôle également la validité des données transmises. Ainsi, un champs de saisie attendant des chiffres ne doit être composé que d'unbe valeur numérique sous peine de voir apparaître un message d'erreur, c'est le cas, notamment, du code postal.

<html>
  <body>
    <%
      Function Validation(Val_Champs, Type_Champs)
        Dim Champs_Valide

        Champs_Valide = True

        Select Case LCase(Type_Champs)

          Case "sexe"
            If Len(Val_Champs) = 0 Then Champs_Valide = False

          Case "nom"
            If Len(Val_Champs) = 0 Then Champs_Valide = False

          Case "prénom"
            If Len(Val_Champs) = 0 Then Champs_Valide = False

          Case "situation"
            If Len(Val_Champs) = 0 Then Champs_Valide = False

          Case "email"
            If Len(Val_Champs) < 5 Or _
               Instr(1, Val_Champs, " ") <> 0 Or _
               InStr(1, Val_Champs, "@") < 2 Or _
              (InStrRev(Val_Champs, ".") < InStr(1, Val_Champs, "@") + 2) _
            Then
              Champs_Valide = False
            End If

          Case "adresse"
            If Len(Val_Champs) = 0 Then Champs_Valide = False

          Case "cp"
            If Len(Val_Champs) <> 5 Or Not IsNumeric(Val_Champs) Then
              Champs_Valide = False
            End If

          Case "ville"
            If Len(Val_Champs) = 0 Then Champs_Valide = False

          Case "pays"
            If Len(Val_Champs) < 2 Then Champs_Valide = False

          Case "commentaire"
            If Len(Val_Champs) = 0 Then Champs_Valide = False

        End Select

        Validation = Champs_Valide
      End Function

      Sub Affiche_Champs(Txt_Champs, index)
    %>
      <tr>
        <td align="right"><b><%= Txt_Champs %> : </b></td>
        <td>
          <input 
                 name="<%= Txt_Champs %>" 
                 type="text" 
                 value="<%= Request.Form(Txt_Champs) %>" 
                 tabindex="index">
        </td>
        <td>
        <%
          If champs_Errone(LCase(Txt_Champs)) Then
            Response.Write "<img src=""../../images/interface/erreur.gif""" _
                 & " border=""0"" width=""20"" height=""20"" alt=""Erreur !"">"
          End If
        %>
        </td>
      </tr>
    <%
      End Sub

      Sub Affiche_Bouton()
    %>
        <input type="submit" value="Soumettre" name="soumission">
        <input type="reset" value="Annuler" name="annulatiuon">
    <%
      End Sub

      Dim Champs
      Dim champs_Errone

      Set champs_Errone = Server.CreateObject("Scripting.Dictionary")

      For Each Champs in Request.Form
        If Validation(Request.Form(Champs), Champs) = False Then
          champs_Errone.Add LCase(Champs), True
        End If
      Next

      If Request.Form.Count <> 0 And champs_Errone.Count = 0 Then
    %>
    <form action="" method="post">
        <h2>Vous allez soumettre ces informations :</h2>
    <%
          For Each Champs In Request.Form
            Response.Write Champs & " : <b>" & Request.Form(Champs) _
                        & "</b><br>"
          Next
          Affiche_Bouton
    %>
      </form>
    <%
        Else
          If Request.Form.Count <> 0 Then
    %>
        <h2 style="color: #FF0000">
           Des erreurs ont été détectées !
        </h2>
        <p>
          Veuillez modifier les champs de saisie repérés par un icône.
        </p>
    <%
          End If
    %>
    <form 
          action="formulaire.asp" 
          method="post"
          name="formulaire">
      <table 
             border="0" 
             cellspacing="0"
             cellpadding="0">
        <tr>
          <td> </td>
          <td>
            <input 
                   type="radio"
                   name="sexe"
                   value="Mr"
                   CHECKED
                   tabindex="1">Monsieur<br>
            <input 
                   type="radio"
                   name="sexe" 
                   value="Mme">Madame<br>
            <input 
                   type="radio"
                   name="sexe"
                   value="Mlle">Mademoiselle
          </td>
        </tr>
        <tr>
          <td>
          <%
            Affiche_Champs "Nom", 2
            Affiche_Champs "Prénom", 3
          %>
          </td>
        </tr>
        <tr>
          <td><b>Situation :</b></td>
          <td>
            <select name="situation" size="1" tabindex="4">
              <option value="Célibataire" CHECKED>
                Célibataire
              </option>
              <option value="Marié(e)">
                Marié(e)
              </option>
              <option value="Concubinage">
                Concubinage
              </option>
              <option value="Pacs">
                Pacs
              </option>
              <option value="Veuf(ve)">
                Veuf(ve)
              </option>
              <option value="Divorcé(e)">
                Divorcé(e)
              </option>
            </select>
          </td>
        </tr>
        <tr>
           <td>
           <%
             Affiche_Champs "Email", 5
             Affiche_Champs "Adresse", 6
             Affiche_Champs "CP", 7
             Affiche_Champs "Ville", 8
             Affiche_Champs "Pays", 9
            %>
          </td>
        </tr>
        <tr>
          <td colspan="2" align="right">
            <textarea 
                  name="commentaire"
                  cols="23"
                  rows="3"
                  tabindex="10">
              Commentaire...
            </textarea>
          </td>
        </tr>
        <tr>
          <td colspan="2" align="center">
            <% Affiche_Bouton %>
          </td>
        </tr>
      </table>
    </form>
    <%
      End If
    %>
  </body>
</html>

Les cookies sont des fichiers textuels transmis par une application Web dans le but de stocher des informations sur l'ordinateur de l'utilisateur.

Visite
Identite=MILLON%2DMARC%5CAdministrateur&Hote=127%2
E0%2E0%2E1&Choix=Veuf%28ve%29&Date=23%2F10%2F2
001+16%3A00%3A13&Navigateur=Mozilla%2F4%2E0+%28co
mpatible%3B+MSIE+6%2E0%3B+Windows+NT+5%2E0%3B+
%2ENET+CLR+1%2E0%2E2914%29&Adresse=%2FLAltruiste
%2Fcoursasp%2Fexemple%2Fcreation%5Fcookie%2Easp
localhost/
1024
257617920
29449230
154276752
29449163
*

Ces informations permettent de conserver des données relatives à l'identité du client et ses actions sur un site.

Bien que les cookies aient une mauvaise réputation auprès de certains internautes, les informations recélées par eux, ne concernent la plupart du temps que des activités préférentielles afin d'adapter le fonctionnement du site au client sans que ce-dernier n'ait à recommencer sempiternellement les mêmes processus pour parvenir à son but.

La création ou la mise à jour d'un cookie s'opère par l'intermédiaire de l'objet ASP Response associé à sa méthode Cookies().

Response.Cookies("nom_cookie")[("clé") | .Attribut] = Valeur

L'argument nom_cookie correspond à une chaîne de caractères qui représente le nom de l'élément et partant permet de lui affecter la ou les valeurs associées.

L'argument clé optionnel représente le nom d'une nouvelle entrée dans le cookie.

Les attributs de la collection cookies permettent d'accomplir certaines actions (voir ci-dessous).

La valeur peut être de n'importe quel type à condition qu'elle soit traduisible textuellement.

La lecture des informations contenues dans un cookie, s'effectue par l'intermédiaire de l'objet Request associé à sa méthode cookies().

Request.Cookies("nom_cookie")[("clé") | .Attribut]

Les différents éléments fonctionnent de la même façon que ci-dessous, hormis que dans ce cas, ils sont utilisés pour retrouver les valeurs associées aux cookies ou à leurs clés.

D'autre part, il existe un seul attribut valable dans ce contexte. En effet, l'unique attribut Haskeys vérifie si le cookie contient une ou plusieurs clés (voir ci-dessous).

<table>
<%
  For Each nom_cookie In Request.Cookies
    If Request.Cookies(nom_cookie).HasKeys Then
      For Each cle_cookie in Request.Cookies(nom_cookie)
         Response.Write "<tr><td>" & nom_cookie _
                              & "(" & cle_cookie & ") = " _
                              & Request.Cookies(nom_cookie)(cle_cookie) _
                              & "</td></tr>"
      Next
    Else
      Response.Write "<tr><td>" & nom_cookie & " = " _
                              & Request.Cookies(nom_cookie) _
                              & "</td></tr>"
    End If
  Next
%>
</table>

Dans l'exemple ci-dessous, l'instruction conditionnelle If...Then détermine si la collection de cookies contient des clés en utilisant l'attribut HasKeys.
En outre, les boucles For Each permettent de parcourir les éléments et sous-éléments de la collection cookies().

Par ailleurs, la propriété Count permet de comptabiliser le nombre d'éléments de la collection Cookies.

Response.Cookies.Count

Elle permet également de dénombrer le nombre de clés présentes dans un cookie particulier.

Response.Cookies("nom").Count

La suppression de toutes les clés d'un cookie s'effectue par l'intermédiaire d'une affectation d'une chaîne de caractère vide.

Response.Cookies("nom") = ""

Suite à cette action, la propriété count appliquée au cookie retourne une valeur nulle et l'attribut HasKeys retourne False.

Lorsqu'un cookie arrive à expiration, en principe, le cookie est supprimé de la machine cliente.

Les cookies sont transmis dans un fichier unique placé dans le répertoire temporaire (temporary internet files) et dans un autre répertoire dénommé Cookies. S'il existe plusieurs cookies, les informations sont séparés par un astérisque (*).

<%
  Response.Cookies("Visite") = Date & " " & Time
  Response.Cookies("Visite")("Choix") = Request.Form("situation")
  Response.Cookies("Visite").Expires = DateAdd("d", 1, Date)
  Response.Cookies("Visite").path = "/"

  Response.Cookies("Adresse").Expires = DateAdd("d", 1, Date)
  Response.Cookies("Adresse").path = "/"
  Response.Cookies("Adresse") = Request.ServerVariables("PATH_INFO")
%>
Contenu du fichier cookie:mon_compte@hote
Visite
08%2F11%2F2002+13%3A44%3A32%5C&Choix=Veuf%28ve%29
localhost/
1024
2424444928
29525882
2518072384
29525796
*
Adresse
%2Fcoursasp%2F%2Fcookie%2Ftraitement%5Fcookie%2Easp
localhost/
1024
2424444928
29525882
2518472384
29525796
*

<!-- Formulaire -->
<html>
  <head>
    <%
      Response.Cookies("Visite") = ""
    %>
  </head>
  <body>
    <h2>Faites un choix pour créer un cookie</h2>
    <form action="creation_cookie.asp" method="post">

      <input type="radio" name="situation" value="Célibataire">
        Célibataire<br>
      <input type="radio" name="situation" value="Marié(e)">
        Marié(e)<br>
      <input type="radio" name="situation" value="Concubinage">
        Concubinage<br>
      <input type="radio" name="situation" value="Pacs">
        Pacs<br>
      <input type="radio" name="situation" value="Veuf(ve)">
        Veuf(ve)<br>
      <input type="radio" name="situation" value="Divorcé(e)">
        Divorcé(e)<br>
      <br>

      <input type="submit" name="soumission" value="Soumettre">

    <table border="1" cellpadding="1" cellspacing="2">
      <tr>
        <td>Nombre de Cookies</td>
        <td><% Response.Write Request.Cookies.Count %></td>
      </tr>
      <tr>
        <td>Présence de clés dans Visite</td>
        <td><% Response.Write Request.Cookies("Visite").HasKeys %></td>
      </tr>
      <tr>
        <td>Nombre de Clés dans Visite</td>
        <td><% Response.Write Request.Cookies("Visite").Count %></td>
      </tr>
    </table>
  </body>
</html>
<!-- Fichier de traitement traitement.asp -->
<html>
  <head>
    <%
      Response.Cookies("Visite")("Date") = Date & " " & Time
      Response.Cookies("Visite").Expires = DateAdd("d", 1, Date)
      Response.Cookies("Visite").Domain = "www.laltruiste.com"
      Response.Cookies("Visite").path = "/"
      Response.Cookies("Visite")("Choix") = _
                      Request.Form("situation")
      Response.Cookies("Visite")("Adresse") = _
                      Request.ServerVariables("PATH_INFO")
      Response.Cookies("Visite")("Hote") = _
                      Request.ServerVariables("REMOTE_HOST")
      Response.Cookies("Visite")("Navigateur") = _
                      Request.ServerVariables("HTTP_USER_AGENT")
      Response.Cookies("Identite") = _
                      Request.ServerVariables("REMOTE_USER")
    %>
  </head>
  <body>
    <h2>Le cookie a été correctement créé.</h2>
    <table border="1" cellpadding="1" cellspacing="2">
      <tr>
        <td>Nombre de Cookies</td>
        <td><% Response.Write Request.Cookies.Count %></td>
      </tr>
      <tr>
        <td>Présence de Clés dans le cookie <i>Visite</i></td>
        <td><% Response.Write Request.Cookies("Visite").HasKeys %></td>
      </tr>
      <tr>
        <td>Nombre de Clés dans le cookie <i>Visite</i></td>
        <td><% Response.Write Request.Cookies("Visite").Count %></td>
      </tr>
      <tr>
        <td>Contenu du Cookie</td>
        <td><% Response.Write Request.Cookies("Visite") %></td>
      </tr>
      <tr>
        <td>Date Visite</td>
        <td><% Response.Write Request.Cookies("Visite")("Date") %></td>
      </tr>
      <tr>
        <td>Situation familiale</td>
        <td><% Response.Write Request.Cookies("Visite")("Choix") %></td>
      </tr>
      <tr>
        <td>Adresse URL</td>
        <td><% Response.Write Request.Cookies("Visite")("Adresse") %></td>
      </tr>
      <tr>
        <td>Hôte distant</td>
        <td><% Response.Write Request.Cookies("Visite")("Hote") %></td>
      </tr>
      <tr>
        <td>Navigateur Client</td>
        <td><% Response.Write Request.Cookies("Visite")("Navigateur") %></td>
      </tr>
      <tr>
        <td>Identité Client</td>
        <td><% Response.Write Request.Cookies("Identite") %></td>
      </tr>
    </table>
  </body>
</html>

L'ensemble des variables d'environnement HTTP est contenu dans la collection de l'objet Request.

Request.ServerVariables

Diverses informations peuvent être récupérées par l'objet Request, associé à sa collection ServerVariables pointant des variables d'environnement HTTP.

Request.ServerVariables("VARIABLE_HTTP")

Les différentes données ainsi extraites, permettent de mettre en place des mécanismes particuliers, comme l'adaptation d'une application ASP à la configuration de l'ordinateur client ou à d'autres paramètres.

If InStr(Request.ServerVariables("HTTP_USER_AGENT"), "MSIE 6.0") > 0 Then
  'Accomplir certaines actions pour Internet Explorer 6...
Else
  'Accomplir d'autres actions...
End If

<html>
  <body>

    <table>
    <%
      For Each var_http In Request.ServerVariables
        Response.Write "<tr><td>" & var_http & "</td><td>" _
                      & Request.ServerVariables(var_http) & "</td></tr>"
      Next
    %>
    </table>

  </body>
</html>

Les chaînes de requêtes (QueryStrings) correspondent à des informations associées à l'adresse URL avec un point d'interrrogation comme séparateur.

http://www.laltruiste.com/page.asp?chaine_de_requete

Une chaîne de requête doit être constituée d'un ou plusieurs éléments dont chacun est associé à une valeur.Si la chaîne de requête contient plusieurs éléments, alors chaque couple élément/valeur doit être séparé par un caractère esperluette (&).

?element=valeur&element2=valeur2&...&elementN=valeurN

L'inconvénient principal des chaînes de requêtes réside dans le fait que les données transmises au serveur par ce biais sont visibles par les utilisateurs dans le champ Adresse de leur navigateur.

De plus, une chaîne de requêtes ne peut dépasser le maximum de 255 caractères.

Ainsi, l'utilisation de cette technique peut générer des problèmes de sécurité et des limitations quant à la taille des données à transmettre à une application Web.

Il existe deux méthodes pour l'utilisation des chaînes de requêtes :

• L'insertion des informations directement après l'adresse URL de la page à atteindre.

  <form action="page.asp?element=valeur" method="post"> <input type="text" name="nom" value="DUPUIS"> <input type="text" name="prenom" value="Michel"> <input type="submit" name="Soumettre" value="Soumission"> </form>

• L'application de la valeur GET à l'attribut method d'un formulaire.

  <form action="page.asp" method="get"> <input type="text" name="nom" value="DUPUIS"> <input type="text" name="prenom" value="Michel"> <input type="submit" name="Soumettre" value="Soumission"> </form>

Dans le premier cas, seules les informations contenues dans l'adresse indiquée par l'attribut action, seront envoyées par l'intermédiaire de la collection QueryString.

element=valeur

Dans le second cas, tous les éléments du formulaire seront transmis au moyen de la collection QueryString, à la page destinataire soit page.asp.

nom=DUPUIS&prenom=Michel

En conséquence, l'expression method="get" provoque la transmission complète et automatique d'un formulaire à partir d'une chaîne de requête.

L'objet Request associé à la collection QueryString permet d'extraire d'une chaîne de requêtes, l'ensemble des éléments et leur valeur y compris celle du bouton de soumission.

Request.QueryString
'Retourne
nom=DUPUIS&prenom=Michel&Soumettre=Soumission

Plus précisément, en spécifiant un nom d'élément en tant qu'argument de la collection QueryString, il devient possible de récupérer essentiellement la valeur liée.

Request.QueryString("nom_element")
'Retourne pour prenom
Michel

Un unique élément de chaînes de requêtes peut posséder plusieurs valeurs.

URL?element=valeur1&element=valeur2&...&element=valeurN

L'extraction des valeurs s'opère en employant l'instruction suivante :

Request.QueryString("nom_element")(index)

L'argument index correspond à une valeur entière.

Le nombre total de valeurs d'un élément est accessible à partir de la propriété Count.

Request.QueryString("nom_element").Count

Afin d'éviter d'éventuels problèmes d'encodage de caractères, l'objet Server associé à sa méthode URLEncode() permet d'appliquer une conversion adéquate d'une chaîne de caractères destinées à devenir une chaîne de requêtes.

Server.URLEncode("chaînes de caractères")

<!-- Formulaire -->
<html>
  <body>
    <h2>Formulaire avec method="POST"</h2>
    <form 
          action="traitement_querystring.asp
                             ?type=post&form=un&form=deux&form=trois"
          method="post"
          name="formPost">

      <u>Saisir un titre :</u><br>
      <input type="text" name="Titre" value="Fatrasie" size="20"><br>

      <textarea name="Paragraphe" cols="30" rows="4">
        La chose va très mal
        Où point n'a de justice
        La chose va très mal
        Dit un veau de métal
      </textarea>

      <input type="submit" name="Soumettre" value="Soumission">

    </form>

    <h2>Formulaire avec method="GET"</h2>
    <form 
          action="traitement.asp"
          method="get"
          name="formGet">

      <u>Saisir un titre :</u><br>
      <input type="text" name="Titre" value="Fatrasie" size="20"><br>

      <textarea name="Paragraphe" cols="30" rows="4">
        La chose va très mal
        Où point n'a de justice
        La chose va très mal
        Dit un veau de métal
      </textarea>

      <input type="submit" name="Soumettre" value="Soumission">

    </form>

  </body>
</html>

<html>
  <body>
    <table>
      <tr>
        <th>Elément</th>
        <th>Valeur</th>
      </tr>
      <%
        For Each chaine In Request.QueryString

          If Request.QueryString(chaine).Count > 1 Then

            For index = 1 To Request.QueryString(chaine).Count

              Response.Write "<tr><td><u>" & chaine & "(" & index _
                                   & ") </u></td><td><b>" _
                                   & Request.QueryString(chaine)(index) _
                                   & "</b></td></tr>"

            Next

          Else

            Response.Write "<tr><td><u>" & chaine _
                                   & "</u></td><td><b>" _
                                   & Request.QueryString(chaine) _
                                   & "</b></td></tr>"

          End If

        Next
      %>
    </table>
  </body>
</html>

L'authentification par certificat client demeure une méthode fiable pour contrôler l'accès à des applications ASP.

En effet, le système consiste à la transmission automatique du certificat client de l'utilisateur par le biais de son navigateur au serveur, après une tentative de connexion à une application Web sécurisée.

Pour cela, le serveur hôte doit évidemment être configuré en conséquence, c'est-à-dire, avoir sélectionné dans les propriétés d'un site web ou d'un répertoire virtuel, Activer certificat client et Requiert certificats client pour que le serveur demande les certificats clients.

Ensuite, le développeur doit écrire des programmes capables d'exploiter les informations contenues dans ces certificats clients.

Enfin, l'utilisateur doit également obtenir auprès d'un organisme tiers intègre, un certificat client, c'est-à-dire une méthode d'identification numérique contenant des informations relative à l'identité de l'utilisateur (nom, prénom, adresse, numéro de téléphone, etc.) en quelque sorte une carte d'identité électronique.

Evidemment, si toutes ces conditions ne sont pas réunies, alors la collection ClientCertificate demeurera vide.

La collection ClientCertificate contient l'ensemble des champs de certification provenant d'une certificat client émis par le navigateur Web de;l'utilisateur.

Request.ClientCertificate(Clé[Sous_Champs])

L'argument Clé représente le nom d'un champs de certification.

Request.ClientCertificate(ValidFrom)

Le paramètre optionnel Sous_Champs permet de retrouver un champs individuel dans le sujet (Subject) ou le distributeur (Issuer) des clés.

Request.ClientCertificate(IssuerCN)

<html>
  <body>
    <table>
      <%
        If Request.ClientCertificate("Flags") And ceCertPresent then
          For Each cle in Request.ClientCertificate
            Response.Write "<tr><td>" & cle & "</td><td>" _
                             & Request.ClientCertificate(cle) _
                             & "</td></tr>")
          Next
        Else
          Response.Write "Vous ne pouvez accéder aux " _
                                  & "informations du certificat client !"
        End If
      %>
    </table>
  </body>
</html>

Il existe deux types d'erreurs dans les scripts ASP, les erreurs de syntaxe et les erreurs d'exécution dont chacune provoque la plupart du temps l'arrêt du déroulement du programme et l'affichage d'une page expliquant l'erreur.

Les erreurs de syntaxe, généralement facile à détecter, consistent en des fautes de grammaire dans la structure du code comme un guillemet oublié dans une instruction en nécessitant, ou d'orthographe sur les éléments du langage comme Reponse.Write à la place de Response.Write.

Les erreurs d'exécution sont parfois plus insidieuses puisque le code semble correct, tout en provoquant un échec lors de l'interprétation. Cet échec pouvant être concrétisé par l'interruption du programme et la fameuse page d'explication de l'erreur, ou par l'affichage d'un résultat totalement imprévu sans que le déroulement du script ait été interrompu.

Il existe donc divers types d'erreurs d'exécution.

• Les erreurs logiques :
  • Les valeurs hors limites.
  • Les priorités d'opérateurs erronées.
  • Le formatage des données erroné.
• Les erreurs d'exécution :
  • de script côté serveur.
  • relatives à ASP.
  • relatives à SSI
  • relatives à ADO.
  • de script côté client.

Les erreurs logiques ne produisent généralement qu'un résultat erroné alors que les autres demeurent le plus souvent critiques.

<%
  dim i, j, k
  i = 10
  j = 2
  k = 20
  ' Ceci est une erreur logique dûe à
  ' des priorités d'opérateurs erronées
  Response.Write "Le produit de j * k auquel on ajoute i" _
                  & " est égal à : " & i + j * k
  ' retourne 240 alors qu'on attend 50
%>

<%
  Dim i, j
  i = 1000
  j = 0
  ' Ceci génére une erreur d'exécution de script
  Response.Write "La division de i par j est égal à : " _
                  & i / j
  ' L'erreur provoque l'interruption du programme
  ' et l'affichage d'une page descriptive de l'erreur
%>

Type d'erreur :
Erreur d'exécution Microsoft VBScript (0x800A000B)
Division par zéro
/laltruiste/coursasp/exemples/testerreur.asp, line 7

Ainsi, il existe une différence fondamentale entre les erreurs fatales au traitement d'une application ASP et celles produisant seulement des résultats imprévisibles. Les premières peuvent être rapidement localisées gràce au message d'erreur fournissant le fichier et le numéro de lignes où l'erreur s'est produite, alors que pour les secondes le déboguage peut devenir rapidement diffcile si le programme est complexe car aucune indication n'est fournie par l'interpréteur.

Le serveur IIS détecte automatiquement les erreurs et fait appel à la méthode Transfer associé à l'objet Server pour la génération d'une page explicative 500-100.asp. Cette dernière est un document prédéfini et stocké dans le répertoire C:\WINNT\Help\iisHelp\common. En outre, elle est reconnaissable au texte ci-dessous présent dans le message d'erreur affiché sur le navigateur du client.

HTTP 500.100 - Erreur interne au serveur - Erreur ASP
Services Internet (IIS)

Il est tout à fait possible d'éliminer certains bogues récurrents du code ASP en adoptant des méthodes d'écriture simples et efficaces.

L'indentation du code permet de déceler facilement diverses étourderies comme le montre l'exemple ci-dessous.

<%
Set obj_Recordset = Server.CreateObject("ADODB.Recordset")
obj_Recordset.Open "Select * from Fiche","DSN=personnel"
With Obj_Recordset
  Compteur = .Fields.Count - 1
  Dim i
  Do While Not .EOF
    For i = 0 To Compteur
      .Fields.Item(i)
    %Next
    .MoveNext
  Loop
  .Close
  Set obj_Recordset = Nothing
%>

<%
  Set obj_Recordset = Server.CreateObject("ADODB.Recordset")
  obj_Recordset.Open "Select * from Fiche","DSN=personnel"
    With Obj_Recordset
      Compteur = .Fields.Count - 1
      Dim i
      Do While Not .EOF
        For i = 0 To Compteur
            .Fields.Item(i)
        Next
        .MoveNext
      Loop
      .Close
  End With
  Set obj_Recordset = Nothing
%>

L'adoption de méthodes de convention pour nommer des variables peut être utile afin d'éviter des erreurs de nommage.

Dim Compteur
Dim CompteurOk
Dim CompteurNom

Dim IntCompteur
Dim BoolCompteur
Dim StrCompteur

La déclaration Option Explicit permet d'éviter les dysfonctionnements dûs à des variables déclarées implicitement, c'est-à-dire sans avoir utilisé auparavant l'instruction Dim.

Option Explicit
Dim IntCompte_total, IntTVA
IntCompte_total = 1000000

'Le calcul provoque une erreur d'exécution critique 
'dûe à deux variables mal orthographiées.
'Autrement, le résulat aurait été 0 à lap lace de 196000
Response.Write "Le taux de TVA permet de récupérer la somme de " _
             & IntCompte_total & " Francs : " _
             & (IntCompt_total * inttva) / 100 & " Francs"

La conversion des variables dans des types de données adéquats au moyen de fonctions VBScript, donne le moyen de se prémunir contre les erreurs relatives aux affectations avec de mauvais types de données étant donné le type de variable courant dans les langages de script, soit Variant.

Dim IntResultat, BoolResultat, Chaine
IntResultat = Cint(Variable_Variant)
BoolResultat = CBool(Variable_Variant)
Chaine = CStr(Variable_Variant)

Une lecture attentive et réfléchie de son code afin de détecter toutes les erreurs éventuelles dûes à la saisie de l'utilisateur ou à la transmission de valeurs de pages en pages ou encore à l'existence des pages ou fichiers pointées par des instructions demeure la meilleure solution d'éradication des erreurs.

<!-- Une erreur évidente s'est glissée dans le script -->
<%
  Dim objError
  Dim objConnection
  Dim objRecordset

  Set objConnection = Server.CreateObject("ADODB.Connection")
  Set objRecordset = Server.CreateObject("ADODB.Recordset")

  objConnection.Open strConnection

  objRecordset.Open "select Nom, Prénom from Personnel", objConn

  objRecordset.Close
  objConnection.Close
  Set objRecordset = Nothing
  Set objConnection = Nothing
%>

Enfin, la dernière étape avant de mettre l'application à la disposition des clients, reste essentielle est impérative. Elle consiste à tester rigoureusement l'ensemble de l'application en se mettant à la place de l'utilisateur final en se soumettant au parcours que ce-dernier aura à subir. Par la même occasion, cela donnera un aperçu de la convivialité et de l'ergonomie du site...

La gestion des erreurs sous VBScript se résume à l'utilisation de l'instruction On Error Resume Next et à un contrôle méticuleux du code afin de détecter tous les cas potentiels d'erreurs.

On Error Resume Next

En fait l'instruction VBScript On Error Resume Next placée au sommet du script, permet d'activer la gestion des erreurs dans des pages ASP.

Plus précisément, cette instruction évite l'interruption du déroulement d'un script lorsqu'une erreur se produit, et partant, les erreurs peuvent être traitées par le programmeur à l'aide de l'objet Err conservant les références de l'erreur en cours.

Une autre instruction On Error Goto 0 permet de désactiver la gestion d'erreur.

On Error Goto 0

L'objet Err constituant la solution de gestion des erreurs d'exécution ou de syntaxe, contient cinq informations, le numéro, la description et la source de l'erreur ainsi qu'un identificateur contextuel et l'adresse d'un fichier d'aide, toutes accessibles par des propriétés, et de plus possède la capacité de générer une erreur délibérément, ou d'effacer les information précitées par l'intermédiaire de deux méthodes.

Err.Propriété | Méthode

A l'aide de l'instruction On Error Resume Next pour la détection des erreurs et de l'objet Err pour leur gestion, il devient possible de concevoir des parades efficaces contre des dysfonctionnements prévisibles des applications ASP. Bien que la tâche se révéle fastidieuse, il est nécessaire de mettre en place un gestionnaire d'erreurs pour les programmes ASP, il n'y a rien de plus désagréable pour un utilisateur, surtout dans le cadre du commerce électronique, de se retrouver devant un affichage inattendu et de surcroît déplaisant.

<!-- METADATA type="typelib" 
             FILE="C:\Program Files\Fichiers communs\System\ado\msado15.dll" -->
<%@ LANGUAGE="VBScript" %>
<html>
  <head>
    <%
      Function Verif_coll_Errors (obj_Connection)
        Dim obj_Error
        If Err.Number <> obj_Connection.Errors(0).Number Then
          Exit Function
        End If
        If obj_Connection.Errors.Count > 0 Then
          For Each obj_Error in obj_Connection.Errors
            If obj_Error.Number <> 0 Then
              Response.Write "" & _
                "<table border=1 cellpadding=1 cellspacing=2>" & _
                "<tr><th>Propriété</th><th>Valeur</th>" & _
                "</tr><tr><th>Numéro</th><td>" & obj_Error.Number & "</td></tr>" & _
                "<tr><th>Erreur native</th><td>" & obj_Error.NativeError & "</td></tr>" & _
                "<tr><th>Etat SQL</th><td>" & obj_Error.SQLState & "</td></tr>" & _
                "<tr><th>Source</th><td>" & obj_Error.Source & "</td></tr>" & _
                "<tr><th>Description</th><td>" & obj_Error.Description & "</td></tr>" & _
                "</table>"
              Verif_coll_Errors = True
            End If
          Next
        Else
        Verif_coll_Errors = False
        End If
      End Function

      On Error Resume Next
    %>
  </head>
  <body>
    <%
      Dim Ch_SQL
      Ch_SQL = "SELECT Noms, Prenom, Age, Qualites," _
                  & " eMail, Adresse, Situation FROM Fiche"
      Set obj_Recordset = Server.CreateObject("ADODB.Recordset")
      obj_Recordset.Open Ch_SQL,"DSN=personnel"
        If Verif_coll_Errors(obj_Recordset.ActiveConnection) = False Then
    %>
      <table border="1" cellpadding="3" align="center">
        <tr>
          <td colspan="6">Fiches signalétiques des personnels</td>
        </tr>
        <tr>
          <td>Nom</td>
          <td>Prénom</td>
          <td>Age</td>
          <td>Qualité</td>
          <td>eMail</td>
          <td>Adresse</td>
        </tr>
    <%
        Do While Not obj_Recordset.EOF
    %>
        <tr>
          <td><%=obj_Recordset("Nom")%></td>
          <td><%=obj_Recordset("Prenom")%></td>
          <td><%=obj_Recordset("Age")%></td>
          <td><%=obj_Recordset("Qualite")%></td>
          <td><%=obj_Recordset("eMail")%></td>
          <td><%=obj_Recordset("Adresse")%></td>
        </tr>
    <%
          obj_Recordset.MoveNext
        Loop
      End If
      obj_Recordset.Close
      Set obj_Recordset = Nothing
    %>
      </tr>
    </table>
  </body>
</html>

D'aucuns affirment que la gestion des erreurs sous JScript se révèle plus performante que celle de VBScript. Cependant elle se révélerait plus difficle à mettre en oeuvre.

L'instruction try...catch permet un traitement des erreurs en désignant un bloc de code à essayer (try), un autre permettant de gérer les erreurs (catch) provenant du premier et un dernier est exécuté subséquemment au traitement des erreurs de façon non-conditionnelle.

try
{
  //Instructions à essayer;
  [throw Exception]
}
catch(Exception)
{
  //Instructions de gestion d'erreurs;
}
[finally
{
  //Instructions à exécuter suite au traitement des erreurs;
}]

L'instruction throw permet de déclencher une exception personnalisée dans le bloc d'instructions à essayer.

L'instruction try permet de tester un bloc d'instructions. Si ce dernier retourne une exception, c'est-à-dire a provoqué une erreur, alors l'instruction catch saisira le nom de l'exception par l'intermédiaire de son argument et la gérera, à l'aide de ses instructions.

L'objet Error permet de conserver diverses informations relatives à l'erreur. Ces informations sont accessibles à l'aide de deux propriétés, number et description indiquant respectivement le numéro et la description de l'erreur.

Le bloc de code de l'instruction finally est toujours exécuté, même si les blocs de try ou catch possèdent une instruction de renvoi ou que l'erreur a été regénéré dans ce-dernier. Toutefois, si une erreur d'exécution non traitée se produisait dans le bloc de catch notamment, alors le bloc de finally ne serait pas exécuté.

Objet_Error.Propriété

L'objet Error est utilisable dans le bloc de code de traitement des erreurs afin de connaître l'identité de l'erreur et éventuellement de lui appliquer en conséquence, une réponse adaptée.

Le langage JScript est sensible au niveau de la casse, ainsi, il faut veiller à rédiger systématiquement toutes les instructions en casse minuscule, pour le reste, il est possible de pratiquer selon les goûts et les couleurs de chacun.

...
catch(e)
{
  alert("Une erreur est survenue.\n Numéro : " + e.number 
           + " Description : " + e.description);
}
...

<!-- METADATA type="typelib" 
             FILE="C:\Program Files\Fichiers communs\System\ado\msado15.dll" -->
<%@ LANGUAGE="JScript" %>
<html>
  <head>
    <%
      var ch_Connection;
      ch_Connection = "Provider=Microsoft.Jet.OLEDB.4.0;"
                 + " Data Source=H:\personnel.mdb";

      function Verif_Error (oConn)
      {
        if (oConn.Errors.Count > 0)
        {
          for(var oError = new Enumerator(oConn.Errors);
            !oError.atEnd(); oError.moveNext())
          {
            Response.Write("" 
                  + "<table border=1 cellpadding=1 cellspacing=2>"
                  + "<tr><th>Propriété</th><th>Valeur</th>"
                  + "</tr><tr><th>Numéro</th><td>" 
                          + oError.item().Number + "</td></tr>"
                  + "<tr><th>Erreur native</th><td>" 
                          + oError.item().NativeError + "</td></tr>"
                  + "<tr><th>Etat SQL</th><td>" 
                          + oError.item().SQLState + "</td></tr>"
                  + "<tr><th>Source</th><td>" 
                          + oError.item().Source + "</td></tr>"
                  + "<tr><th>Description</th><td>" 
                          + oError.item().Description + "</td></tr>"
                  + "</table>");
          }
        }
      }
    %>
  </head>
  <body>
    <%
      var obj_Error;
      var Objet_Connection;
      var Objet_Recordset;

      Objet_Connection = Server.CreateObject("ADODB.Connection");
      Objet_Recordset = Server.CreateObject("ADODB.Recordset");

      Objet_Connection.Open(ch_Connection);

      try
      {
        Objet_Recordset.Open("select *Nom from Fiche", Objet_Connection);
        Response.Write("<table border='1' cellpadding='3' align='center'>"
         + "<tr>"
         + "  <td colspan='6'>Fiches signalétiques des personnels</td>"
         + "</tr>"
         + "<tr>"
         + "  <td>Nom</td>"
         + "  <td>Prénom</td>"
         + "  <td>Age</td>"
         + "  <td>Qualité</td>"
         + "  <td>eMail</td>"
         + "  <td>Adresse</td>"
         + "</tr>");
        while (!Objet_Recordset.EOF)
        {
          Response.Write("<tr>"
           +  "<td>" + Objet_Recordset("Nom") + "</td>"
           +  "<td>" + Objet_Recordset("Prenom") + "</td>"
           +  "<td>" + Objet_Recordset("Age") + "</td>"
           +  "<td>" + Objet_Recordset("Qualite") + "</td>"
           +  "<td>" + Objet_Recordset("eMail") + "</td>"
           +  "<td>" + Objet_Recordset("Adresse") + "</td>"
           + "</tr>");
          Objet_Recordset.MoveNext();
        }
        Response.Write("</table>");
      }
    catch (e)
      {
        Verif_Error(Objet_Connection);
      }
    finally
      {
        if (Objet_Recordset.State == adStateOpen)
        Objet_Recordset.Close();
        Objet_Connection.Close();
        Objet_Recordset = null;
        Objet_Connection = null;
      }
    %>
  </body>
</html>

Le langage ASP permet une personnalisation des pages d'erreur. Plutôt que d'utiliser celles fournies par défaut, il est possible de créer sa propre page d'erreur contenant des informations identiques.

En effet, l'objet ASPError a la fonction de fournir par l'intermédiaire de ses propriétés, les informations relatives à l'erreur qui s'est produite dans une application ASP.

ASPError.propriété

L'objet ASPError possède neuf propriétés dont quatre permettent de localiser le fichier, la ligne, la colonne et le code source où l'erreur s'est produite, et les autres identifient et décrivent l'erreur.

• ASPCode (code ASP)
• Number (numéro)
• Source (code source)
• Category (catégorie)
• File (adresse du fichier)
• Line (numéro de ligne)
• Column (numéro de colonne)
• Description (description courte)
• ASPDescription (description ASP)

La création de l'objet ASPError s'effectue par l'intermédiaire de la méthode GetLastError de l'objet Server.

Set objet_ASPError = Server.GetLastError()

Il suffit, désormais de créer une page capable d'extraire les informations relative à l'erreur à partir de l'objet ASPError et de ses propriétés en prenant toutefois certaines précautions de formatage ou dispositions conditionnelles.

La propriété ASPCode retourne régulièrement une valeur lorsque des composants COM externes sont impliqués dans des erreurs. Sinon pour la plupart des erreurs de script, cette valeur reste indéfinie.

A l'instar de ASPCode, la propriété ASPDescription retourne une valeur indéfinie pour la plupart des erreurs de script, sauf celles impliquant un appel de méthode non-valide vers un objet ASP intrinsèque.

La valeur retournée par la propriété Number étant de type hexadécimal, son formatage devrait ressembler à la ligne de code ci-dessous.

Response.Write "0x" & Hex(Objet_ASPError.Number)

Enfin, la propriété Source retourne une chaîne de caractères représentant le code source de l'erreur. Mais ce-dernier pouvant contenir des éléments HTML, il est recommandé d'appliquer à cette valeur la méthode HTMLEconde de l'objet Server.

Response.Write Server.HTMLEncode(Objet_ASPError.Description)

La page d'erreur réalisée, il faut maintenant configurer le serveur IIS afin qu'à chaque erreur HTTP de type 500;100 (code d'erreur 500 : sous-code d'erreur 100) la page d'erreur personnalisée apparaisse à la place de celle par défaut.

Pour cela, il suffit de sélectionner un répertoire dans le Gestionnaire de services Internet (IIS) (Démarrer -> Programmes -> Outils d'administration), puis d'actionner le bouton droit de la souris, afin d'afficher le menu contextuel, d'effectuer un clic sur Propriétés pour voir apparaître une boîte à onglet Propriétés [du répertoire] sur laquelle il faut, enfin, cliquer sur Messages d'erreur personnalisés.

A partir de cet onglet, il faut sélectionner tout en bas de la liste déroulante, la ligne 500;100 URL /iisHelp/common/500-100.asp, puis cliquer sur Modifier les propriétés... pour voir une boîte de dialogue Propriétés du mappage des erreurs invitant à saisir une adresse URL vers la page d'erreur personnalisée dans le champ URL.

Un clic sur le bouton OK valide le changement, et à partir de ce moment, la page d'erreur 500-100 personnalisée sera affichée en cas d'erreur de syntaxe ou d'exécution dans une application Active Server Pages fonctionnant dans le répertoire sélectionné dans le Gestionnaire de services Internet (IIS).

Il est possible de revenir à la configuration initiale en cliquant sur le bouton Utiliser les valeurs par défaut de l'onglet Messages d'erreur personnalisés.

La page d'erreur de type 500;100 par défaut reste le meilleur moyen d'apprendre comment construire correctement son propre fichier personnalisé. Elle se trouve à l'adresse physique suivante :

C:\WINNT\Help\iisHelp\common\500-100.asp

Les erreurs ASP surviennent en général lorsqu'un objet ou un composant est responsable de dysfonctionnement.

La liste des erreurs ci-dessous exposent les erreurs les plus courantes générées dans une application ASP.

Le Modèle d'Objet de Document (DOM) est une interface de programmation d'applications (API : Applications Programming Interface) permettant à l'Active Server Pages de traiter des documents XML.

Le modèle d'objet de document de Microsoft fournit pusieurs outils destinés à l'analyse, l'élaboration et la déconstruction d'un document XML.