ASP - Active Server Pages


I cookies

Il cookie: questo sconosciuto!

A parte gli scherzi, attorno ai cookies é nato e cresciuto col passare del tempo una specie di alone mistico, che ha fatto diventare questi dolci biscottini dei biscotti da cane.

I cookies altro non sono che dei file di solo testo che vengono mandati dal server al client per conservarci diverse informazioni. In molti casi sono davvero utili, specie per applicazioni con un budget molto basso, o che necessitano di velocità. Oramai oltre il 98% dei browser in giro li supporta (tra Internet Explorer 3.x, Navigator 2.x e Opera 2.x più le versioni successive).

A questo punto dunque, é necessaria una svolta: far capire finalmente ai nostri utenti che i cookie li usiamo solo per rendere la loro navigazione migliore. Per fare questo basta una piccola nota alla fine di ogni pagina con una spiegazione dell'uso che se ne fa sul nostro sito.

Preparati i nostri visitatori, adesso prepariamo tutto quello che ci serve. Naturalmente il modo migliore per scrivere codice ASP a mano é proprio il vecchio e caro Blocco Note (alias Notepad). Apriamolo ed incominciamo la nostra avventura.

Questo é un esempio del codice necessario per creare il cookie:

Response.Cookies("miosito").Expires=#January 1, 2000#
Response.Cookies("miosito").Path="/miadir/"
Response.Cookies("miosito").Secure=FALSE

Il significato non é molto complicato. In Expires va indicata la data in cui il cookie scadrà. In Path il percorso che ha il privilegio di scrivere/leggere sul cookie (se omesso viene preso quello corrente), mentre con Secure si specifica se il cookie é sicuro (crittografato, via SSL, etc...) oppure no. Nella maggior parte dei casi si deve impostare su FALSE.
Queste tre righe sono obbligatorie per far generare il cookie in maniera corretta.

A questo punto, per salvarci dentro dei valori si deve proseguire in questo modo:

Response.Cookies("miosito")("nome")="Daniele"
Response.Cookies("miosito")("cognnome")="Bochicchio"

insomma, seguire una sintassi del genere

Response.Cookies("nomecookie")("nomedellachiave")="valore"

Il codice deve essere inserito prima di ogni altro tag HTML (quindi prima di <html> o eventuali commenti) altrimenti il server genererà un errore, a meno che non abbiamo inpostato su True il comando Response.Buffer.

Invece per avere il valore di una chiave del nostro cookie, ad esempio per inserirla come valore in una campo di una form, basterà fare una cose del genere:

<input name="nome" type="text" value="<%=Request.Cookies("miosito")("nome")%>">
<input name="nome" type="text" value="<%=Request.Cookies("miosito")("cognnome")%>">

A questo punto siamo perfettamente in grado di manipolare un cookie. Ci restano due cose da imparare. Come fare a sapere se il cookie contiene già delle chiavi, e come cancellarlo.

Per sapere se abbia o meno delle chiavi, bisogna usare

Request.Cookies("miosito").HasKeys

che conterrà una risposta booleana (TRUE o FALSE) che indica se il cookie ha chiavi oppure no.

Invece per cancellarlo, basterà far eseguire un comando del genere:

Response.Cookies("miosito")=""

Attenzione quindi ad impostare direttamente il valore di un cookie senza la chiave, perché ad esempio scrivendo

Request.Cookies("miosito")="Daniele"

tutte le chiavi precedentemente memorizzate (nome e cognome) andranno perse, dato che si va a scrivere sulla chiave principale che cancella tutte le altre. Lo stesso vale se io ho impostato solo la chiave principale e vado ad impostare altre chiavi.

I cookie, come dicevamo, sono un ottimo modo per aiutarvi, l'importante é usarli con parsimonia, spiegare ai visitatori che non fanno male, e sopratutto fare tanta pratica. Sembra facile, ma ci potrebbero essere delle difficoltà dietro l'angolo... E' sempre meglio provare e riprovare. Solo allora si potrà essere sicuri di aver imparato a maneggiare i nostri biscottini!


L'oggetto Session

L'oggetto Session é molto utile nella realizzazione di applicazioni ASP avanzate (e non) per la sua potenza. Infatti tramite questo oggetto é possibile memorizzare per tutta la durata della navigazione dell'utente in alcune variabile dei valori che saranno poi disponibili alle pagine successive in maniera (quasi) trasparente per l'utente finale (il visitatore).

Questo perché praticamente l'oggetto Session si serve di un cookie dove memorizza il numero (chiamato ID) del visitatore, che é unico per ognuno e che non verrà mai ripetuto.
Perciò su alcuni browser particolarmente vecchi potrebbe non funzionare. Comunque su questi browser anche le tue pagine non dovrebbero essere visualizzate correttamente, dato l'arretratezza delle funzioni che supportano, per cui il gioco vale la candela, eccome!

Questo modo di memorizzare le informazioni può essere molto ma molto utile ad esempio per far scegliere all'utente una lingua e mantenerla per tutta la sessione, senza bisogno di creare sottodirectory speciali per le diverse lingue, ma gestendo il tutto all'interno della stessa pagina, che una volta letto il valore dell'oggetto Session fornirà il contenuto localizzato in base a quanto specificato.
Ovviamente questo é solo un esempio, ma si possono fare molte altre cose utili e divertenti per migliorare la navigabilità del proprio sito, come cambiare il contenuto di una pagina ad ogni nuovo accesso del proprio visitatore, ruotare banner e così via...

Questo oggetto, nel suo utilizzo é molto simile all'oggetto application, essendo entrambi oggetti built-in, cioé richiamabili direttamente nello script.
Quindi per assegnare un varole ad una variabile Session, basterà scrivere:

Session("miavar")="ciao!"

E questo é tutto quello che serve per scrivere su una variabile Session. Nient'altro. Molto semplice, più semplice dell'oggetto Application.

Analogamente, l'unica cosa da scrivere per leggerne il contenuto é:

miavar=Session("miavar")

Come si é avuto modo di vedere, l'oggetto Session é molto facile da usare, molto potente e molto versatile. L'unica raccomandazione necessaria da fare é di non abusare della sua potenza, anche perché un eccessivo uso di variabili Session può portare ad un decadimento delle prestazione (riferimento).


L'oggetto Application

L'oggetto Application può essere molto utile in diverse implementazioni, dato che serve per condividere informazioni tra tutti gli utenti di tutte le pagine .asp di una applicazione, dove per applicazione si intende l'insieme di tutte le pagine che si trovano sotto una virtual directory.

Questo sistema può ritornare molto utile ad esempio quando bisogna tenere traccia di azioni compiute dagli utenti connessi in quel determinato momento, oppure se si hanno particolari necessità e, non per ultimo, per migliorare le prestazioni generali delle proprie pagine (riferimento).

In ogni caso, l'utilizzo dell'oggetto Application é molto simile a quello dell'oggetto Session.
Entrambi sono oggetti built-in, cioé richiamabili direttamente nello script.
Così per assegnare un varole ad una variabile Application, basterà scrivere:

Application("miavar")="ciao!"

Con un semplice comando del genere, però, si rischia di generare degli errori, dato che può scrivere in una variabile Application un utente per volta. Per ovviare a questi problemi, é necessario quindi usare dei comandi che vadano a bloccare la variabile Application, ci scrivano sopra, e la rilascino per altri cambiamenti da parte di altre pagine. Tutto ciò viene effettuato molto velocemente, in maniera del tutto trasparente per l'utente che legge la pagina. Il codice da inserire in questo caso é quindi:

Application.Lock
Application("miavar")="ciao!"
Application.UnLock

Il primo comando non fa altro che bloccare la modifica (non la lettura, perché quella é disponibile a tutti in qualsiasi momento), scrivere sulla variabile, quindi sbloccare la variabile stessa e metterla al servizio di altre richieste. I due metodi usati sono Lock ed UnLock. Il loro funzionamento é molto semplice tanto da non meritarsi una spiegazione particolare.

Adesso che abbiamo imparato a scrivere su una variabile Application, non ci resta che imparare a ricavarne il valore. Niente di più semplice. L'unica cosa da scrivere é:

miavar=Application("miavar")

A questo punto avremo memorizzato nella variabile miavar il contentuto della variabile Application miavar, e da questo punto in poi, tramite questa variabile locale, sarà possibile usarne il valore a nostro piacimento, essendo pronta per essere stampata, manipolata, convertita come più riteniamo utile.


I dati di una Form

Tramite i famosi oggetti built-in é possibile manipolare diversi dati presenti nelle pagine web, e non ultimo quello relativo ai dati contenuti in una form, un semplice modulo web che può contenere tutte le informazioni che vogliamo.

Per farlo le ASP mettono a disposizione i comandi

Request.Form("nomeinput")
e
Request.QueryString("nomeinput")

che servono, rispettivamente, per ricavare il valore contenuto nel campo "nomeinput" nel caso si sia usato come metodo il post (che inserisce i valori direttamente nella pagina) o quello get (che aggiunge i valori all'indirizzo della pagina che processerà la richiesta).

Un generico

Request("nomeinput")

dovrebbe andare bene se si usano entrambi i medodi, a seconda della tipologia di uso che se ne fa in quel momento della pagina.

Usare i dati di una form é quanto di più facile sia possibile fare tramite le ASP. Omettendo il nome del campo di cui si vuole ricavare il valore, si ottiene la lista di tutti i campi e dei rispettivi valori.

Per fare questo bastano

Request.Form
e
Request.QueryString

i quali ci daranno, come già detto, la lista di tutti i campi con i rispettivi valori.

Questo uso può essere molto utile se ad esempio si vuole prima accertarsi che si sia inserito qualcosa. Ad esempio per rifiutare che l'utenti passi dei parametri col metodo get, si può usare uno script del genere:

if Len(Request.QueryString)>1 then

  Redirect("errore.asp")

end if

In questo caso se si tenta di passare tramite il metodo get dei parametri alla pagina, si genererà un errore che rimanderà alla pagina errore.asp, dove dovrà essere contenuto un testo di spiegazione. E' anche possibile modificare a proprio piacimento lo script, facendogli compiere determinati comandi al verificarsi di tale situazione.


L'accesso ai files sul Server

Tramite il controllo Scripting.FileSystemObject é possibile accedere a qualsiasi file che si trova sul server su cui viene eseguito il codice ASP.
Quindi non solo i canonici file che sono inseriti nelle directories effettivamente mappate sotto il web server, ma qualsiasi file.
Questa caratteristica é molto utile in diverse circostanze, specie quando non si ha altro modo di accedere a questi dati se non di caricarli da file esterni.

E si sa, quando si vuole fare qualcosa facilmente e senza perdere troppo tempo, le ASP sono imbattibili. Per accedere in lettura ad un file, serve solamente questi due comandi.

Set FileObject=CreateObject("Scripting.FileSystemObject")
Set InStream=FileObject.OpenTextFile(MyFile,tipo,true)

Naturalmente al posto di MyFile deve essere inserito il nome del file, digitando il suo percorso completo (tipo c:\tempo\prova.txt) oppure facendolo mappare direttamente al server, nel caso il file in questione risieda in una delle directory accessibile al web server, tramite il comando MyFile=Server.MapPath("/aspoint/prova.txt") che in questo caso indica al server di mappare (cioé tradurre nel corrispondente indirizzo DOS) l'indirizzo della virtual directory "/aspoint", dando come risultato una cosa del tipo "c:\web\ospiti\aspoint\".
A questo punto, però, siamo solo all'inizio. Infatti abbiamo un altro parametro da specificare, e cioé la variabile tipo, che va ad indicare allo script con quale metodo si intende aprire il file. Abbiamo a disposizione le seguenti opzioni: 1 apre in lettura, 2 apre in scrittura, 8 apre ed aggiunge in scrittura dopo la fine del file.

Una volta specificate queste informazioni, i metodi usati per leggere o scrivere sul file appena aperto sono semplicissimi.
Per leggere una riga basta il comando:

testo=InStream.ReadLine()

che naturalmente legge una sola linea. Se si ha bisogno di leggere tutto il file, si usa invece il comando

testo=InStream.ReadAll

Per far si che il contenuto del file letto non vada perso, é sempre meglio associare il valore ad una variabile (nel nostro caso la variabile "testo") che potrà essere facilmente manipolata in seguito a nostro piacimento.

testo=InStream.ReadLine() va bene nel caso io debba leggere un numero prefissato di linee. Ma se io non so quante linee possa contenere il mio file, come faccio?
Con questo script si risolve anche questo problema:

Do While not InStream.AtEndOfStream
  testo=InStream.ReadLine
  Response.Write("<br>Il contenuto della linea é: "&testo)
loop

Naturalmente si possono fare tutte le modifiche necessarie per adattare lo script alle proprie esigenze.

Se invece si vuole saltare una linea, il comando é InStream.SkipLine()

Per scrivere su un file, abbiamo due possibili strade: aggiungere il testo da scrivere in coda a quanto già contenuto nel file aperto, oppure scrivere su un file nuovo.

Nel primo caso, si usa lo stesso codice di cui sopra per iniziare l'oggetto ed aprire il file, mentre per scriverci si usa

testo="prova testo"
InStream.WriteLine(testo)

La sintassi va bene anche per il secondo caso, in cui cambia il tipo di inizializzazione del file, che sarà:

Set FileObject=CreateObject("Scripting.FileSystemObject")
Set OutStream=FileObject.CreateTextFile(MyFile,true)

in cui MyFile ha lo stesso valore che ha nel primo caso.
L'unica differenza sta nel nome che abbiamo dato all'oggetto che ci permette di accedere al nostro file, per cui per scriverci sopra dobbiamo usare

testo="prova testo"
OutStream.WriteLine(testo)

data appunto la diversità nel nome dell'oggetto che usiamo per accedere al file.

Dopo aver fatto i nostri comodi, esiste anche un comando per chiudere il file e liberare risorse, che nella fattispecie é

OutStream.Close

E' da notare che prima di ogni metodo (quello che sta a destra del punto) é necessario inserire il nome dell'oggetto così come é stato creato tramite l'istruzione

Set oggetto=FileObject.OpenTextFile(MyFile,tipo,true)

o l'istruzione equivalente

Set oggetto=FileObject.CreateTextFile(MyFile,true)

e che é appunto oggetto.

Ed ora, sei finalmente pronto per manipolare i tuoi files! Ma stai attento, perché non é poi così facile come potrebbe sembrare, perché potrebbe bastare sbagliare un percorso per avere risultati non richiesti.
Perciò quando lavori con l'accesso ai file, occhio al codice!


Ottimizzare il carico sul Server

Sicuramente tutti gli sviluppatori ASP si sono imbattutti prima o poi in questa domanda: "ma quale impatto in termini di carico ha la mia pagina ASP sul server?".

Questa é una serie di consigli da usare per migliorare le performance delle tue pagine:

1 -Usare GLOBAL.ASA per file a livello application

Se le tue pagine leggono su file che non cambiano spesso o quasi mai, invece di usare l'ogetto FileSystem Object, é più performante caricare i files in questione in un array a livello Application in GLOBAL.ASA. GLOBAL.ASA é un file (opzionale) dove si possono specificare eventi e quindi assegnare script e dichiarare oggetti a livello session o application. GLOBAL.ASA non visualizza testo all'utente ma conserva informazioni ed oggetti, gestendo gli eventi a livello application e session.

Quindi basta richiamare dalle tue pagine l'array con i dati. Questo implica leggere sul file una volta per server, anziché una volta per ogni pagina per ogni utente. E' necessario poi creare comunque una pagina speciale per permettere eventuali aggiornamenti, in quanto una volta caricato in una variabile a livello application, questa rimarrà identica a se stessa fino a quando non verrà aggiornata.

E' possibile implementare il tutto tramite un array oppure un oggetto Dictionary. Il file sarà letto solo una volta e ciò permetterà di accedere alle informazioni tramite l'array o l'oggetto Dictionary senza aver bisogno di fare una richiesta ogni volta che fosse necessario leggere informazioni da quel file.

Nel caso fosse necessario aggiornare il contenuto dei dati, é possibile creare una pagina riservata contenente uno script che esegue il comando Application.Lock, aggiorna le informazioni ed infine esegue il comando Application.Unlock che mette a disposizione di tutti i dati.

2 - Rimuovere i commenti HTML

I commenti HTML (quelli contenuti nella pagine tra <!-- e -->) rallentano le prestazioni, specie con IIS 3. Rimuovendoli si rende il tutto più veloce.

3 - Concentrare i comandi Response.Write

Se usi molti <%=...%> per scrivere in diverse parti del codice, prova a concentrare il tutto in un unico Response.Write.

E' un buon sistema cercare di dividere la pagina in blocchi di HTML e script, in modo da velocizzare il caricamento. Per ogni coppia di <% %> il server esegue un comando che va a rallentare le prestazioni globali del server.

4 - Evitare di ridimensionare gli arrays

Per non togliere risorse al server, é più indicato usare come dimensione di un array quella più bassa o meglio ancora a quella ottimale, e solo se necesario, usando Redim portarla alla dimensione necessaria. Tutto ciò significa risparmiare un po' di memoria, invece di allocarla e spendere qualche mega di ram.

5 - Evitare le variabili pubbliche

Se stai scrivendo in VBScript oppure stai accendo a qualche controllo ActiveX o script java, cerca di non usare le "Public variables". Questa chiave é al momento usata solo per compatibilità future, per cui é meglio usare Dim, dato che non esiste nessun vantaggio nell'usare l'altro metodo.

6 - Usare percorsi di ricerca completi

Cerca di evitare di usare MapPath se possibile, cercando di usare il percorso completo. Usando MapPath IIS deve andare a leggere il percorso con una speciale richiesta che tradotto vuol dire decadimento delle prestazioni.

7 - Evitare di usare intensivamente le "Server Variables"

Ogni volta che si accede alle cosidette "Server Variables", il web server le richiede tutte, per poi fornire alla pagina ASP solo quella desiderata. Quindi se io voglio ad esempio sapere solamente il valore dell'header HTTP_ACCEPT, il server andrà per prima cosa a richiedere tutta lista delle variabili, quindi ritornerà la variabile che ho chiesto. Tutto questo influsice sulle prestazioni. Naturalmente nel corso di una pagina, dopo aver ricevuto la prima variabile, per le altre non ci sarà un decadimento delle prestazioni, dato che il server le ha già memorizzate tutte.

8 - Usare "Option Explicit"

Usando Option Explicit Visual Basic genererà un messaggio d'errore qualora si cerchi di accedere a variabili non dichiarate. Le variabili local non dichiarate sono lente più delle global. Inoltre questa opzione può essere utile per scovare variabili non dichiarate nel tuo codice.

9 - Non abusare dell'oggetto "Session"

L'ogetto Session serve per memorizzare durante la sessione di navigazione di un singolo utente, diverse informazioni. Le variabili contenute in questo oggetto vengono mantenute durante la navigazione dell'utente da una pagina all'altra.

Il web server crea automaticamente un ogetto Session ogniqualvolta viene richiesta per la prima volta una pagina all'interno di una determinata application e la distrugge quando non ci sono più richieste (di solito dopo 10 minuti, ma il valore é impostabile tramite il commando Session.Timeout=15, dove in questo caso abbiamo impostato il TimeOut della session a 15 min).

E' possibile disattivare l'oggetto Session, ma si perdono molte caratteristiche avanzate delle ASP in questo modo. E' meglio usarlo con parsimonia, evitando di memorizzarci tante variabili.

10 - Ed infine...

... testa le tue modifiche! Testare la velocità di risposta di una pagina é il modo migliore per capire se tutto il tuo lavoro ha dato i frutti che hai sperato, oppure si é trattato solo di una perdita di tempo.

Un'ultimo consiglio: scrivi le tue pagine ASP con stile! Cerca di essere il più chiaro possibile con te stesso, in modo da rendere divertente e veloce il lavoro di aggiornamento delle pagine stesse!


Il tuo Server ha ASP

Hai tanto sentito parlare delle Active Server Pages, aka ASP, ma non hai proprio idea se il tuo server le supporta? Allora questo articolo é dedicato a te!

Il modo migliore per vedere se il tuo server le usa é provare! prova a caricare sul tuo server via FTP (o nel metodo che usi) una pagina dal nome prova.asp che abbia come contenuto

<%="Ciao!! Questa é la mia prima pagina ASP!"%>
A questo punto, se effettivamente sulla vostra pagina vedrete apparire Ciao!! Questa é la mia prima pagina ASP! senza nessun altro codice, allora il vostro server supporta pienamente le ASP! Adesso puoi finalmente buttarti su materiale, help in linea, documentazione e naturalemente su questo sito, per riuscire a trarre il massimo vantaggio da questa fantastica tecnologia!

Questa é una lista dei server che supportano direttamente le ASP

Nome del serverSistema operativo
MS Internet Information Server 4Windows NT Srv 4
MS Internet Information Server 3Windows NT Srv 3.51 o sup.
MS Personal Web Server 4Windows NT Wrks 4 - Windows 95/98
MS Personal Web Server 1.xWindows 95

E' possibile però usare le ASP anche con altri web server, tramite un estensione nota come Chili!ASP, prodotta dalla Chili!Soft, che però é a pagamento!

Queste sono le istruzioni per far funzionare Chili!ASP sotto Apache 1.3b6

1) Installa Chili!ASP come se stessi lavorando con il server MS IIS. Scegli la configurazione di default. Se non hai installato IIS riceverai un messaggio di errore che ti avverte di tale mancanza. Ignoralo e procedi con l'installazione.

2) Dopo aver completato l'installazione ed effettuato i vari reboot necessari, esegui WebSite Pro.

  • a) Sotto "Association Mapping", mappa sia l'estensione ".asa" che quella ".asp" sul file "C:\ChiliASP\chiliasp.dll":.
  • b) Sotto "Content Type Mapping", mappa entrambe le estensioni come "wwwserver/isapi".
  • c) Sotto "Documents Mapping", mappa le seguenti directories:
    "/chili/" su "C:\ChiliASP"
    "/CAspSamp/" su "C:\ChiliASP\Samples\"

    NOTA: "/chili/" é il nome di una directory a scelta, corta e facile da ricordare. "/CAspSamp/" deve essere inserito così com'é scritto, dato che é case sensitive.
  • Adesso sei finalmente pronto ad usare le ASP sul tuo server!


    MIME type

    Con le ASP, non mi stancherò mai di ripeterlo, si può fare tutto quello che la vostra mente é in grado di immaginare, specie se si usano i server component.

    Comunque lo scopo di questo articolo é di spiegare in maniera il più completa possibile come sia facile, ad esempio, generare delle immagini automatiche tramite una pagina asp, in modo che, per esempio, facendo riferimento direttamente a questa pagina tramite il tag HTML img sia possibile richiamare un'apposita pagina in modo che esegua delle operazioni, come memorizzare in un db quale sia l'immagine servita, quindi impostare il MIME type su image/gif e come ultima operazione andare a recuperare l'immagine. Semplice, non é vero?

    A dire il vero, questo é un caso limite, molto molto limite. Infatti esistono dei server component in grado di fare questo in modo migliore. Ma l'importante é sapere che si può fare!

    Un esempio più utile (e che io uso nei miei siti qualora mi serva) può essere quello di inserire i propri script client-side (tipo JavaScript o VBScript) in un file separato, con estensione .asp, e dargli come MIME type application/x-javascript". Tutto quello che dobbiamo fare per una cosa del genere é scrivere nel file in questione, il più in alto possibile:

    Response.ContentType="application/x-javascript"

    In questo modo il browser saprà (indipendentemente dall'estensione) che in quel file c'é uno script JS. I browser, infatti, non si basano sull'estensione di un programma per capire di cosa si tratti, ma si rifanno sia all'estensione che al MIME type, qualora la prima sia sconosciuta.

    In questo modo si possono creare molti "giochetti" davvero divertenti. Praticamente si può assegnare qualsiasi MIME type ad una pagina ASP, sempre a patto di conoscerlo e che il sistema che richiederà la pagina sia in grado di suppportarlo.

    Quella che segue é una lista dei MIME type più utili.

    E' necessario attenersi alle specifiche del formato per avere un risultato funzionante e privo di errori. Per fare questo é consigliato approfondire gli aspetti legati ai vari formati, al fine di evitare di incappare in inutili errori.

    Per tutti i formati vale la seguente sintassi:

    Response.ContentType="tipo/sottotipo"

    Tipo/Sottotipo (Estensione)Descrizione
    text/html (.htm)Semplice testo html. Non é necessario specificarlo, in quanto é il tipo di default.
    text/plain (.txt)Testo semplice, leggibile con qualsiasi computer.
    text/css (.css)File di testo contenente informazioni per la formattazione delle pagine HTML tramite CSS.
    image/gif (.gif)Immagine GIF (graphic interlaced file).
    image/jpeg - image/pjpeg (.jpg)Immagine JPEG. Il secondo é di tipo progressive.
    image/tiff (.tif)Immagine TIFF. Molto usata nel DTP.
    image/xbm - image/x-xbitmap (.xbm)Immagine in formato xbm. Poco usato.
    image/x-png - image/png (.png)Immagine in formato PNG (ping). Dovrebbe essere il nuovo formato standard per lo scambio di immagini sulla rete.
    image/bmp (.bmp)Immagine in formato bitmap, in assoluto il formato per le immagini più diffuso in ambiente Windows.
    image/x-wmf (.wmf)Immagine in formato Windows MetaFile. Attualmente poco usato.
    audio/wav - audio/x-wav (.wav)File audio wave. Molto usati in ambito PC.
    audio/aiff - audio/x-aiff (.aiff)Formato audio molto diffuso in ambiente UNIX.
    audio/basic (.au)Formato audio comparabile al wave, molto diffuso in rete.
    audio/x-pn-realaudio (.ram)Formato molto diffuso in rete per lo streaming (trasmissione in diretta) di audio.
    audio/mid (.mid)Formato audio contenente le informazioni per essere riprodotto in qualsiasi strumento MIDI (come la scheda audio di un computer).
    video/quicktime (.qt)File video QuickTime, molto diffuso in ambiente MAC e Windows.
    video/mpeg (.mpeg)File video MPEG. Sono caratteristici per la loro alta qualità ed il loro minimo ingomrbo.
    video/avi - video/x-msvideo (.avi)Formato video standard per gli utenti Windows.
    video/vdo (.vdo)Formato VDOLive, utilizzato per la trasmissione video in Internet.
    message/rfc822File contenente le informazione necessarie per la ricezione/spedizione in un messaggio di posta elettronica.
    application/x-javascript (.js)File contenente il codice JavaScript. Viene richiamato dall'interno di una pagina HTML.
    application/x-x509-ca-cert (.crt)File con certificato digitale. Utilizzato per l'autenticazione, anche in ambito e-commerce.
    application/x-zip-compressed (.zip)Archivio compresso. Molto utilizzato per lo scambio di dati.
    application/x-internet-signup (.ins)File contenente i comandi per l'iscrizione automatica ad un provider tramite Internet Explorer.
    application/msword (.doc)File di Microsoft Word
    application/pdf (.pdf)Portable Document Format é un formato universale per lo scambio di dati (immagini, testi, etc).
    application/x-iphone (.iii)File di Internet Phone. Utilizzato per videotelefonate via Internet.
    application/x-cdf - application/cdf (.cdf)File contenente le specifiche per l'utilizzo di un canale di Internet Explorer.
    model/vrml - x-world/x-vrml (.wrl)Modello Virtual Reality Markup Language per la realtà virtuale.
    Tra parentesi é specificata l'estensione predefinita.


    Script Client sicuri

    Mettere il proprio script JS in una pagina ASP può essere utile per proteggere il proprio lavoro da occhi indiscreti.
    Si può fare servendosi del MIME type.
    Basta inserire nella pagina ASP che richiama il nostro script, una linea del genere:

    Session("js")="ok"

    e farla seguire dal richiamo al file .asp che contiene lo script,

    <script language="JavaScript" src="js.asp"></script>

    A questo punto, inserendo nella nostra pagina ASP una semplice routine di verifica dell'oggetto Session, tutto dovrebbe andare a gonfie vele!

    if Session("js")="ok" then

    Response.ContentType="application/x-javascript"

    ...codice da eseguire...

    else

    ...messaggio di errore in HTML puro

    end if

    Session("js")="ko"

    In qualsiasi caso, sia che venga richiamato da una pagina autorizzata (che abbia in sostanza il comando Session("js")="ok" al proprio interno), sia che si cerchi di accedervi direttamente o senza permesso, lo script va ad impostare su ko il valore dell'oggetto Session, in modo che sia impossibile, se non tramite la sola pagina .asp che richiama la nostra JS-ASP accedere al suo contenuto!

    Ed il nostro lavoro sarà al sicuro da occhi indiscreti. Sfido chiunque a trovare una soluzione ad una cosa del genere...


    access Counter

    Questa pagina dimostra come creare un semplice contatore di accesso (testuale o con immagini) tramite ASP. Con l'aiuto di alcuni oggetti per creare/scrivere/leggere file sul server, é possibile farlo in pochi secondi.

    L'oggetto FileSystem é usato per accedere al file in cui vanno memorizzati gli accessi. L'oggetto TextStream é usato per leggere e scrivere sul file in questione.

    Per un contatore testuale questo codice é più che sufficiente:

    myfile="c:\inetpub\www\mypath\counter_mysite.txt"

    Set fs=CreateObject("Scripting.FileSystemObject")
    Set a=fs.OpenTextFile(myfile)
    visita=CInt(a.ReadLine)

    if Len(Session("visita"))=0 then
      Session("visita")=visita
      visita=visita+1
      a.close
      Set a=fs.CreateTextFile(myfile, True)
      a.WriteLine(visita)
    end if

    a.Close
    Response.Write visita

    La prima azione effettuata da questo script é aprire il file (il percorso deve essere adattato al proprio caso, anche con l'ausilio di un MapPath), leggere l'ultimo valore, convertirlo in interi, quindi verificare che questa sia la prima visita effettuata alla pagina e solo in questo caso aggiungere 1 al numero. In questo modo si ottine un contatore di solo testo. L'ultima parte dello script scrive sul file l'incremento e chiude il tutto, visualizzando il numero delle visite. Per far funzionare il tutto deve essere inserito nel percorso che viene dichiarato nella variabile myfile un file con lo stesso nome specificato nella variabile e che abbia come contentuo 0 (a numeri) oppure il numero di visitatori da cui si vuole partire.

    Se invece serve un contatore che visualizzi dei numeri come immagini, si può usare questo script

    myfile="c:\inetpub\www\mypath\counter_mysite.txt"

    Set fs=CreateObject("Scripting.FileSystemObject")
    Set a=fs.OpenTextFile(myfile) visita=CInt(a.ReadLine)

    if Len(Session("visita"))=0 then
      Session("visita")=visita
      visita=visita+1
    a.close

    Set a=fs.CreateTextFile(myfile, True)
    a.WriteLine(visita)
    end if

    a.Close

    lung=CInt(Len(visita))
    visita=CStr(visita)

    Response.Write "<img src=""immagini/contdx.gif"">"

    for i=1 to lung
      Response.Write "<img src=""immagini/cont"&Mid(visita, i, 1)&".gif"">"
    next

    Response.Write <"img src=""immagini/contsx.gif"">"

    Il funzionamento di questo script é simile al precedente, con la sola differenza che questo ha bisogno che sotto la cartella immagini, si trovino dei file con nome cont0.gif....etc fino a cont9.gif che rappresentino i vari numeri. Sono anche necessari i file contdx.gif che rappresenta il bordo destro ed il file contsx.gif che rappresenta il border sinistro. Il funzionamento é del tutto simile allo script precedente, escluso la routine di visualizzazione delle immagini. L'incoveniente di uno script di questo tipo rispetto ad un cgi é che i numeri vengono richiamati come singole immagini, per cui ci può essere un caricamento non proprio sincronizzato, a differenza di quanto avviene con gli script CGI. Il punto di forza é che si può praticamente cambiare di tutto ed in più usare come immagini quelle che si preferisce, oltre al fatto di appesantire di meno il server, riuscendo ad occupare minori risorse, grazie al fatto che il tutto viene generato direttamente dal file .asp


    Database e ASP

    Introduzione

    Microsoft Active Server Pages (ASP) consente la creazione di applicazioni lato server utilizzabili da diversi tipi di browser. Essenzialmente, ASP non è altro che VBScript eseguito sul server. Quando viene richiesta una pagina, il codice script genera l'HTML. Questa è la chiave dell'ASP: un client non vede mai il codice, ma solo l'HTML risultante, riconoscibile da tutti i browser.

    Un aspetto fondamentale di ASP è l'utilizzo dei componenti, che non sono altro che ActiveX come quelli che si possono creare con Visual Basic, Visual C++, Visual J++ , Delphi, eccetera.
    Il più utile tra tutti i componenti ASP è Database Access, detto anche ActiveX Data Object, o ADO. Nella pubblicazione di database su Web si utilizza questo componente e gli oggetti in esso contenuti per leggere e scrivere su fonti dati Open Database Connectivity (ODBC).

    Come interrogare un database con ASP

    COSA OCCORE:

    Cosa conoscere di ADO

    Come detto prima, ADO è lo strumento necessario per operare sulla fonte di dati ODBC (il vostro database). Di questo componente bisogna assolutamente conoscere l'oggetto Connection, indispensabile per il suo utilizzo.

    L'oggetto Connection viene creato tramite il metodo CreateObject dell'oggetto Server e utilizza una variabile per ricevere il riferimento ad un'oggetto. Una volta creato, l'oggetto Connection può essere utilizzato per aprire una connessione con qualsiasi fonte di dati ODBC.

    Sorgente di dati ODBC di Windows

    Quest'operazione avviene con l'ODBC Data Source Administrator, generalmente localizzato nel Pannello di controllo. La realizzazione della sorgente di dati avviene selezionando la pagina System DNS nel property sheet ODBC data source Administrator. In questa pagina premere il pulsante Add... per visualizzare un elenco di tutti i driver ODBC disponibili. Dopo aver selezionato il driver ODBC appropriato premere il pulsante Finish che introduce un nuovo oggetto.

    Il codice seguente stabilisce una connessione con una fonte di dati ODBC Microsoft Access Driver chiamata Registrazioni.

    <%

    ' dichiaro la variabile che conterrà l'oggetto Connection

    Dim conn

    'creo l'oggetto Connection

    Set conn = Server.CreateObject("ADOBD.Connection")

    'apro la connessione con la fonte di dati

    conn.Open "Registrazioni"

    %>

    Connessione DSN-less

    In alcuni casi, ad esempio per non costringere il proprio amministratore a creare una quantità elevata di sorgenti ODBC, è possibile creare, ma solo nel caso in cui il database sia Access, una connessione DSN-less.

    Tutto quello per compiere un'operazione di questo tipo è usare al posto del codice precedente, quest'altro:

    <%

    ' dichiaro la variabile che conterrà l'oggetto Connection

    Dim conn

    'creo l'oggetto Connection

    Set conn = Server.CreateObject("ADOBD.Connection")

    'apro la connessione con la fonte di dati

    conn.Open "driver={Microsoft Access Driver (*.mdb)};dbq="&Server.MapPath("/data/database.mdb")

    %>

    Naturalmente al posto di "/data/database.mdb" va inserito l'esatto percorso di ricerca in cui è stato salvato il file mdb.

    Ed ora...

    Una volta aperta la connessione con la fonte di dati, è possibile utilizzare un oggetto Recordset per recuperare le informazioni. L'oggetto Recordset consente di eseguire le istruzioni SQL restituendo un insieme di record filtrati tramite la query. Come l'oggetto Connection, Recordset viene creato utilizzando l'oggetto Server.

    <%

    ' dichiaro la variabile che conterrà l'oggetto Recordset

    Dim rs

    'creo l'oggetto Recordset

    Set rs = Server.CreateObject("ADOBD.Recordset")

    'Eseguo la query SQL SELECT

    rs.Open "SELECT *", conn

    %>

    Dopo aver recuperato i record è possibile leggerli con i metodi MoveFirst, MoveLast, MoveNext e MovePrevious. Il metodo Write dell'oggetto Response consente di dare in output i dati sulla pagina in HTML.

    <TABLE>

    <%

        Do While not rs.EOF

    %>

        <TR>

            <TD><% rs.Fields("colonna").Value %></TD>

        </TR>

    <%

        rs.MoveNext

        Loop

    %>

    </TABLE>

    ESEMPIO DI INTERROGAZIONE DI DATABASE

     

    PAGINAZIONE

    Spesso una query restituisce molte più righe di quante possano essere visualizzate. Ad esempio un motore di ricerca Internet può avere migliaia di riferimenti rispetto alla parola chiave cercata ed è chiaro che non è consigliabile visualizzare tutti i dati in un'unica pagina.

    La paginazione consente di distribuire i risultati su più pagine. ADO supporta la paginazione tramite le proprietà PageSize, PageCount a AbsolutePage dell'oggetto Recordset.
    La proprietà PageSize specifica quante ennuple devono essere contenute nella pagina, e tramite la proprietà PageCount, è possibile determinare il numero complessivo di pagine. E' Possibile accedere ad una determinata pagina tramite la proprietà AbsolutePage. Il programma richiede un solo file ASP per eseguire tutto il processo di navigazione.

    ESEMPIO DI INTERROGAZIONE CON PAGINAZIONE

    Torna all'inizio della pagina

    Cosa conoscere di SQL

    SQL  (che si pronuncia sequel) è l'abbreviazione di Structured Query Language e rappresenta lo standard per la definizione, l'interrogazione e l'aggiornamento di database relazionali. In questo tutorial mi limiterò nel spiegare la più semplice e generale struttura del linguaggio SQL.

    Le istruzioni in SQL vengono raggruppate a blocchi; ciascun blocco contiene tre tipi di clausole, la clausola SELECT, la clausola FROM, e la clausola WHERE.

    SELECT nomi di attributi

    FROM nomi di relazioni

    WHERE condizione di ricerca sui dati,

    Ad esempio, l'interrogazione per trovare il valore di IDENTIFICATIVO per l'azienda TRANSISTOR è espressa come segue:

    SELECT IDENTIFICATIVO

    FROM AZIENDE

    WHERE NOMEAZIENDA = TRANSISTOR

    Le tre clausole individuano rispettivamente:

    1. Gli attributi da includere nel risultato.
    2. Le relazioni su cui operare.
    3. La condizione di ricerca. In particolare, questa condizione potrebbe essere più complessa e coinvolgere al suo interno altri blocchi.

    Un'altra importante parola chiave è DISTINCT che prevede l'eliminazione delle ripetizioni dai risultati. Si utilizza immediatamente dopo la parola chiave SELECT.

    SELECT DISTINCT Provincia
    FROM Indirizzo

    Le condizioni elementari che compaiono nella clausola WHERE possono avere altre forme, oltre a quelle già viste per l'operatore di selezione. Esse sono le seguenti.

    I primi due casi selezionano rispettivamente i records in cui il valore dell'attributo è uguale ad uno dei valori elencati nella lista, e i records in cui il valore dell'attributo è compreso fra i due valori specificati o uguale ad uno di essi.

    IN seleziona i records della relazione in cui il valore dell'attributo sia uno di quelli elencati nella lista di valori.

    La parola chiave LIKE esegue un confronto selezionando i records in cui l'attributo specificato nella stringa <stringa incompleta> ha come valore una stringa che può essere rappresentara dalla stringa incompleta.

    Molto comoda è la parola chiave COUNT, che calcola il numero di records oppure il numero di valori distinti che soddisfano una certa condizione.

     

    OPERAZIONI DI INSERIMENTO

    Le operazioni di inserimento vengono specificate per mezzo dell'istruzione  INSERT che ha due possibili strutture:

    INSERT INTO <nome relazione> (<lista attributi>)
    VALUES (<lista valori>)

    INSERT INTO <nome relazione> (<lista attributi>)
    SELECT (<lista valori>)

    ESEMPIO DI INSERIMENTO DATI

     

    OPERAZIONI DI ELIMINAZIONE

    L'eliminazione di records viene specificata per mezzo dell'istruzione DELETE.

    DELETE FROM <nome relazione>
    WHERE <condizione>

    che elimina dalla relazione tutti i records che soddisfano la condizione.

    ESEMPIO DI ELIMINAZIONE

    OPERAZIONI DI MODIFICA

    La modifica di records viene specificata per mezzo dell'istruzione UPDATE.

    UPDATE <nome relazione>
    SET <attributo> = <espressione>
            <attributo> = <espressione>
            <attributo> = <espressione>
            .......
    WHERE <condizione>

    Torna all'inizio della pagina

    COSA CONOSCERE DI VBScript

    Per una semplice interrogazione non serve conoscere molto di VBScript. Comunque il liguaggio è un insieme di semplici caratteristiche basilari di Visual Basic for Application.
    VBScript supporta l'accesso ai dati usando sia Data Access Object (DAO) e Remote Data Object (RDO).

    Un componente che vi puo' essere utile per costruire il vostro archivio è il File Access.
    Questo componente, consente l'accesso ai file di testo nel sito web. E' composto da due oggetti:

    Il primo serve per aprire e chiudere il file, TextStream serve per leggere e scrivere sul file. Per creare l'oggetto FileSystem si usa sempre il metodo CreateObject dell'oggetto Server.
    CreateTextFile crea un nuovo file e OpenTextFile ne apre uno esistente.
    Per accedere al file db.txt:

    Set objFile = Server.CreateObject("Scripting.FileSystemObject")
    Set objStream = objFile.OpenTextFile("db.txt")

    Per leggere nel file si usa il metodo ReadLine.

    Per ulteriori informazioni sulla manipolazione dei files, è disponibile questo articolo.

    Torna all'inizio della pagina

    Server Components in Visual Basic

    Questo articolo spiega agli sviluppatori ASP come raggiungere un livello di conoscenza superiore sulle ASP. I component server-side (da ora server component) sono utili per moltissime ragioni; le più importanti: un componente migliora la velocità e la portabilità di una soluzione, protegge tutto il vostro lavoro, dato che si tratta di una DLL (Dynamic Link Library) e che quindi non espone direttamente il codice sorgente.

    Ma cos'è esattamente un server component? E' una specie di controllo Active-X, ma invece di essere client side, come quelli sviluppati per Internet Explorer o lo stesso ambiente Visual Basic, sono usati in ambiente server. La differenza fondamentale tra client e server component è che l'ultimo ha l'assoluto divieto di esporre interfaccia utente, trattandosi di un componente che gira sulla macchina server, e che quindi non deve esporre finestre o pulsanti, in quando queste verrebbero visualizzate sullo schermo della macchina server.

    Cosa serve per creare un server component? Un linguaggio che supporti lo standard COM, come ad esempio, Java, Visual C++, Delphi, o Visual Basic. Tutti i linguaggi menzionati, escluso VB, richiedono una mole di lavoro impressionante per iniziare a conoscere i fondamenti. Visual Basic è molto più semplice da usare e da imparare di qualsiasi altro linguaggio, tant'è che molta gente confonde il Visual Basic Script, quello che si usa nelle pagine ASP, con le ASP stesse, che invece di essere un linguaggio è un contenitore, una tecnologia.
    Detto questo, per operare serve un sistema operativo a 32 bit (Window 95, 98 or NT) su cui devono girare le ASP, tramite IIS o Personal Web Server (PWS). E' necessario avere installato Visual Basic (dalla ver. 5 in poi) sullo stesso computer su cui dovranno essere sviluppati i components, altrimenti sarà impossibile per VB usare il riferimento agli oggetti ASP.

    A questo punto è necessario far partire Visual Basic. Apparirà una finestra che chiede come partire. Selezionare "ActiveX DLL".

    Dopo aver fatto doppio click su ActiveX DLL, Visual Basic crea per te un progetto ed una classe predefinite. E' consigliabile rinominare sia Project1 che Class1 secondo i nostri gusti. E' importante scegliere bene il nome, dato che per richiamare il component nelle nostre pagine sarà necessario usare Project1.Class1.
    Fatto questo, è necessario fare un riferimento a "Microsoft Active Server Pages Object Library", la libreria necessaria per usare gli oggetti built-in ASP nel component. Dal menu di Visual Basic, bisogna scegliere "Project", quindi "References". Una finestra mostrerà tutti i riferimenti disponibili sul tuo sistema. Questo riferimento si trova solo se sul sistema è installato PWS o IIS. Nel caso in cui non lo trovaste, sarà necessario reinstallarli.

    Nel nostro esempio, il nome del progetto sarà "Comp1", quello della classe "MyClass". La sintassi con cui è necessario dichiarare componenti ASP in una pagina è:

    Set ObjReference = Server.CreateObject("Comp1.MyClass")

    Ora, una volta impostato un riferimento nella pagina ASP, sarà possibile accedere a tutte le Sub o le Function del component, mediante una sintassi del tipo:

    
    <%
    Set ObjReference = Server.CreateObject("Comp1.MyClass")
    ObjReference.Prova
    %>

    Naturalmente affinchè tutto funzioni, è necessario che nel nostro component sia presente una Sub o una Function pubblica dal nome "Prova".

    Prima dicevamo della libreria per l'accesso agli oggetti built-in. Bene, si tratta di una libreria molto importante, in quanto si rivela molto utile per queste ragioni. Si può accedere dal component agli oggetti Session, Application, Request, Response. Per usarlo nel component, oltre ad aver dovuto impostare un riferimento (come prima specificato) alla libreria ASP, è necessario inserire una Sub OnStartPage nel codice della classe. La Sub OnStartPage viene eseguita ogni volta che viene creata un'istanza del component, per cui può essere utile anche per altri scopi, come quello di impostare variabili condivise da alcune function/sub.
    Risulterà una cosa del genere:

    Public Sub OnStartPage(ASPScriptingContext As ScriptingContext)
        Set MyScriptingContext = ASPScriptingContext
        Set MyApplication = MyScriptingContext.Application
        Set MyRequest = MyScriptingContext.Request
        Set MyResponse = MyScriptingContext.Response
        Set MyServer = MyScriptingContext.Server
        Set MySession = MyScriptingContext.Session
    End Sub

    Non è tutto. E' anche necessario scrivere prima di questa sub, questo codice, per permettere a VB di non generare un errore:

    
       Private MyScriptingContext As ScriptingContext
       Private MyApplication As Application
       Private MyRequest As Request
       Private MyResponse As Response
       Private MyServer As Server
       Private MySession As Session

    A questo punto creeremo anche una Sub che scarichi dalla memoria questi riferimenti, in modo da non appesantire il sistema. Per fare questo useremo la Sub OnEndPage, che viene richiamata alla chiusura della classe.

    Public Sub OnEndPage()
        Set MyScriptingContext = Nothing
        Set MyApplication = Nothing
        Set MyRequest = Nothing
        Set MyResponse = Nothing
        Set MyServer = Nothing
        Set MySession = Nothing
    End Sub

    Ora possiamo accedere dal codice VB del nostro component, a tutti i metodi e le proprietà offerte dagli oggetti built-in ASP. Ad esempio, per scrivere in una pagina ASP, potrai usare il codice MyResponse.Write, che equivale in tutto e per tutto a scrivere in una pagina ASP Response.Write.

    Dopo questa lunga (e necessaria) premessa, scriviamo il nostro metodo Prova. Lo faremo tramite questa sub:

    Public Sub Prova()
       MyResponse.Write ("

    Il mio primo component in VB.

    ") End Sub

    Come è chiaro dal messaggio, si può inserire tranquillamente codice HTML, proprio come nelle pagine ASP.
    Per richiamare questo component nella nostre pagine ASP useremo:

    <%
    
    Set ObjReference = Server.CreateObject("Comp1.MyClass")
    ObjReference.Prova
    %>
    che va messo nella pagina prova.asp, da creare.

    A questo punto, tramite il menu "File/Save Project" di VB, salva il tutto. Questa operazione salva il codice, ma non crea la DLL. Per farlo, è necessario stoppare PWS (o IIS) per compilare di nuovo la DLL, altrimenti sarà impossibile usare lo stesso nome. Si tratta di un bug di cui non si conosce una soluzione. Praticamente se si compila la DLL e la si usa, anche dopo aver stoppato PWS, non sarà possibile sovrascrivere quel file, perchè PWS continuerà a richiederlo (anche stoppato).

    Dal menu File, ci sarà un'opzione "Make comp1.dll". Selezionandola verrà creata la DLL.
    Usando il codice ASP di cui sopra (prova.asp), sarà possibile testare la DLL.
    Dall'indirizzo http://127.0.0.1/prova/prova.asp sarà possibile vederne i risultati.

    Da ora in poi sai come creare component. Con i component è possibile fare di tutto, da interi siti automatizzati, a semplici component che calcolino dei dati particolari. Il vantaggio di usare component, è che il codice diventa più gestibile, e rimane totalmente sicuro, perchè trattandosi di codice compilato, è impossibile risalire dalla DLL al codice che è stato usato.

    Il server component, per funzionare, deve essere registrato nel sistema. In quello su cui è stato sviluppato, viene registrato direttamente da VB, ma nel caso debba essere usato su un altro sistema, sarà necessario utilizzare il comando regsvr32.exe, che si trova in genere in c:\windows\system. E' necessario fare seguire al richiamo a questo file, il nome del component da registrare. Quindi, nel caso il nostro comp1.dll si trovi in c:\inetpub\wwwroot\prova, dovremo lanciare questo comando:
    regsvr32.exe c:\inetpub\wwwroot\prova\comp1.dll.

    Finalmente sappiamo come fare a creare un oggetto COM che faccia da server component per le pagine ASP. Non ci resta che buttarci a capofitto ed iniziare a fare qualche prova. E' utile sapere che, in generale, è possibile avere dei risultati soddisfacenti solo usando delle chiamate alle API (Application Program Interface), che permettono di accedere a tutte le funzioni per cui in genere si decide di usare un server component.