Introduzione alla programmazione Web di ASP.NET tramite la sintassi Razor (Visual Basic)

di Tom FitzMacken

Questo articolo offre una panoramica della programmazione con ASP.NET pagine Web usando la sintassi Razor e Visual Basic. ASP.NET è la tecnologia Microsoft per l'esecuzione di pagine Web dinamiche nei server Web.

Cosa si apprenderà:

• I primi 8 suggerimenti per la programmazione per iniziare a programmare ASP.NET Pagine Web usando la sintassi Razor.
• Concetti di base di programmazione necessari.
• Di cosa tratta il codice del server di ASP.NET e la sintassi di Razor.

Versioni del software

• Pagine Web ASP.NET (Razor) 3

Questa esercitazione funziona anche con ASP.NET Pagine Web 2.

La maggior parte degli esempi di uso di pagine Web ASP.NET con la sintassi Razor usa C#. Ma la sintassi Razor supporta anche Visual Basic. Per programmare una pagina Web ASP.NET in Visual Basic, creare una pagina Web con estensione .vbhtml filename e quindi aggiungere codice Visual Basic. Questo articolo offre una panoramica dell'uso del linguaggio e della sintassi di Visual Basic per creare ASP.NET pagine Web.

I primi 8 suggerimenti per la programmazione

Questa sezione elenca alcuni suggerimenti che è assolutamente necessario conoscere quando si inizia a scrivere ASP.NET codice del server usando la sintassi Razor.

1. Aggiungere il codice a una pagina utilizzando il carattere @

Il @ carattere inizia espressioni inline, blocchi a istruzione singola e blocchi con più istruzioni:

<!-- Single statement blocks  -->
@Code  Dim total = 7  End Code
@Code  Dim myMessage = "Hello World" End Code

<!-- Inline expressions -->
<p>The value of your account is: @total </p>
<p>The value of myMessage is: @myMessage</p>        
    
<!-- Multi-statement block -->    
@Code 
    Dim greeting = "Welcome to our site!"
    Dim weekDay = DateTime.Now.DayOfWeek
    Dim greetingMessage = greeting & " Today is: " & weekDay.ToString()
End Code 
<p>The greeting is: @greetingMessage</p>

Risultato visualizzato in un browser:

2. Racchiudi i blocchi di codice con Codice... Fine Codice

Un blocco di codice include una o più istruzioni di codice ed è racchiuso tra le Code parole chiave e End Code. Posizionare la parola chiave di apertura Code immediatamente dopo il @ carattere, senza spazi vuoti tra di essi.

<!-- Single statement block.  -->
@Code
    Dim theMonth = DateTime.Now.Month
End Code
<p>The numeric value of the current month: @theMonth</p>

<!-- Multi-statement block. -->
@Code
    Dim outsideTemp = 79
    Dim weatherMessage = "Hello, it is " & outsideTemp & " degrees."
End Code 
<p>Today's weather: @weatherMessage</p>

Risultato visualizzato in un browser:

3. All'interno di un blocco, si termina ogni istruzione di codice con un'interruzione di riga

In un blocco di codice Visual Basic ogni istruzione termina con un'interruzione di riga. Più avanti nell'articolo verrà illustrato un modo per eseguire il wrapping di un'istruzione di codice lungo in più righe, se necessario.

<!-- Single statement block. -->
@Code
    Dim theMonth = DateTime.Now.Month
End Code

<!-- Multi-statement block. -->
@Code
    Dim outsideTemp = 79
    Dim weatherMessage = "Hello, it is " & outsideTemp & " degrees."
End Code 

<!-- An inline expression, so no line break needed. -->
<p>Today's weather: @weatherMessage</p>

4. Le variabili vengono usate per archiviare i valori

È possibile archiviare i valori in una variabile, incluse stringhe, numeri e date e così via. Si crea una nuova variabile usando la Dim parola chiave . È possibile inserire i valori delle variabili direttamente in una pagina usando @.

<!-- Storing a string -->
@Code 
    Dim welcomeMessage = "Welcome, new members!"
End Code
<p>@welcomeMessage</p>
    
<!-- Storing a date -->
@Code 
    Dim year = DateTime.Now.Year
End Code

<!-- Displaying a variable -->
<p>Welcome to our new members who joined in @year!</p>

Risultato visualizzato in un browser:

5. Racchiudere i valori letterali di stringa tra virgolette doppie

Una stringa è una sequenza di caratteri trattati come testo. Per specificare una stringa, racchiuderla tra virgolette doppie:

@Code 
    Dim myString = "This is a string literal"
End Code

Per incorporare virgolette doppie all'interno di un valore stringa, inserire due virgolette doppie. Se si desidera che la virgoletta doppia venga visualizzata una volta nell'output della pagina, immetterla come "" all'interno della stringa tra virgolette e, se si desidera che venga visualizzata due volte, immetterla come """" all'interno della stringa tra virgolette.

<!-- Embedding double quotation marks in a string -->
@Code 
    Dim myQuote = "The person said: ""Hello, today is Monday."""
End Code
<p>@myQuote</p>

Risultato visualizzato in un browser:

6. Il codice Visual Basic non fa distinzione tra maiuscole e minuscole

Il linguaggio Visual Basic non fa distinzione tra maiuscole e minuscole. Le parole chiave di programmazione (ad esempio Dim, Ife ) e Truei nomi delle variabili (ad esempio myString, o subTotal) possono essere scritti in qualsiasi caso.

Le righe di codice seguenti assegnano un valore alla variabile lastname usando un nome minuscolo e quindi restituisce il valore della variabile nella pagina usando un nome maiuscolo.

@Code 
    Dim lastName = "Smith"
    ' Keywords like dim are also not case sensitive.
    DIM someNumber = 7
End Code
<p>The value of the <code>lastName</code> variable is: @LASTNAME</p>

Risultato visualizzato in un browser:

7. Gran parte della codifica comporta l'uso di oggetti

Un oggetto rappresenta un elemento con cui è possibile programmare: una pagina, una casella di testo, un file, un'immagine, una richiesta Web, un messaggio di posta elettronica, un record cliente (riga del database) e così via. Gli oggetti hanno proprietà che descrivono le relative caratteristiche: un oggetto casella di testo ha una Text proprietà, un oggetto richiesta ha una Url proprietà, un messaggio di posta elettronica ha una From proprietà e un oggetto customer ha una FirstName proprietà. Gli oggetti dispongono anche di metodi che sono i "verbi" che possono eseguire. Alcuni esempi includono il metodo di Save un oggetto file, il metodo di Rotate un oggetto immagine e il metodo di un oggetto di Send posta elettronica.

Spesso si lavora con l'oggetto Request , che fornisce informazioni come i valori dei campi modulo nella pagina (caselle di testo e così via), quale tipo di browser ha effettuato la richiesta, l'URL della pagina, l'identità dell'utente e così via. In questo esempio viene illustrato come accedere alle proprietà dell'oggetto Request e come chiamare il MapPath metodo dell'oggetto Request , che fornisce il percorso assoluto della pagina nel server:

<table border="1"> 
    <tr>
        <td>Requested URL</td>
        <td>Relative Path</td>
        <td>Full Path</td>
        <td>HTTP Request Type</td>
    </tr>
    <tr>
        <td>@Request.Url</td>
        <td>@Request.FilePath</td>
        <td>@Request.MapPath(Request.FilePath)</td>
        <td>@Request.RequestType</td>
    </tr>
</table>

Risultato visualizzato in un browser:

8. È possibile scrivere codice che prende decisioni

Una caratteristica chiave delle pagine Web dinamiche è che è possibile determinare cosa fare in base alle condizioni. Il modo più comune per eseguire questa operazione consiste nell'istruzione If (e nell'istruzione Else facoltativa).

@Code
   Dim result = ""
   If IsPost Then
      result = "This page was posted using the Submit button."
   Else
      result = "This was the first request for this page."
   End If
End Code
<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="utf-8" />
        <title>Write Code that Makes Decisions</title>
    </head>
<body>
    
    <form method="POST" action="" >
        <input type="Submit" name="Submit" value="Submit"/>
        <p>@result</p>
    </form>
    
</body>
</html>

L'istruzione If IsPost è un modo abbreviato di scrivere If IsPost = True. If Oltre alle istruzioni, esistono diversi modi per testare le condizioni, ripetere blocchi di codice e così via, descritti più avanti in questo articolo.

Il risultato visualizzato in un browser (dopo aver fatto clic su Invia):

Esempio di codice semplice

Questa procedura illustra come creare una pagina che illustra le tecniche di programmazione di base. Nell'esempio viene creata una pagina che consente agli utenti di immettere due numeri, quindi li aggiunge e visualizza il risultato.

1. Nell'editor creare un nuovo file e denominarlo AddNumbers.vbhtml.

2. Copiare il codice e il markup seguenti nella pagina, sostituendo qualsiasi elemento già presente nella pagina.

   @Code
       Dim total = 0
       Dim totalMessage = ""
       if IsPost Then
           ' Retrieve the numbers that the user entered.
           Dim num1 = Request("text1")
           Dim num2 = Request("text2")
           ' Convert the entered strings into integers numbers and add.
           total = num1.AsInt() + num2.AsInt()
           totalMessage = "Total = " & total
       End If
   End Code
   <!DOCTYPE html>
   <html lang="en">
       <head>
           <meta charset="utf-8" />
           <title>Adding Numbers</title>
           <style type="text/css">
               body {background-color: beige; font-family: Verdana, Ariel; 
                   margin: 50px;
                   }
               form {padding: 10px; border-style: solid; width: 250px;}
           </style>
       </head>
   <body>
       <p>Enter two whole numbers and click <strong>Add</strong> to display the result.</p>
       <p></p>
       <form action="" method="post">
       <p><label for="text1">First Number:</label>
       <input type="text" name="text1" />
       </p>
       <p><label for="text2">Second Number:</label>
       <input type="text" name="text2" />
       </p>
       <p><input type="submit" value="Add" /></p>
       </form>
       <p>@totalMessage</p>
   </body>
   </html>
   

   Ecco alcuni aspetti da notare:

   • Il @ carattere avvia il primo blocco di codice nella pagina e precede la totalMessage variabile incorporata nella parte inferiore.
   • Il blocco nella parte superiore della pagina è racchiuso in Code...End Code.
   • Le variabili total, num1num2, e totalMessage archiviano diversi numeri e una stringa.
   • Il valore letterale stringa assegnato alla totalMessage variabile è tra virgolette doppie.
   • Poiché il codice visual Basic non fa distinzione tra maiuscole e minuscole, quando la totalMessage variabile viene usata nella parte inferiore della pagina, il nome deve corrispondere solo all'ortografia della dichiarazione della variabile nella parte superiore della pagina. La combinazione di maiuscole e minuscole non è importante.
   • L'espressione num1.AsInt() + num2.AsInt() mostra come usare oggetti e metodi. Il AsInt metodo in ogni variabile converte la stringa immessa da un utente in un numero intero (un numero intero) che può essere aggiunto.
   • Il <form> tag include un method="post" attributo. Specifica che quando l'utente fa clic su Aggiungi, la pagina verrà inviata al server usando il metodo HTTP POST. Quando la pagina viene inviata, il codice If IsPost restituisce true e il codice condizionale viene eseguito, visualizzando il risultato dell'aggiunta dei numeri.

3. Salvare la pagina ed eseguirla in un browser. Assicurarsi che la pagina sia selezionata nell'area di lavoro File prima di eseguirla. Immettere due numeri interi e quindi fare clic sul pulsante Aggiungi .

   

Linguaggio e sintassi di Visual Basic

In precedenza è stato illustrato un esempio di base su come creare una pagina Web ASP.NET e su come aggiungere codice server al markup HTML. Di seguito vengono fornite informazioni di base sull'uso di Visual Basic per scrivere ASP.NET codice del server usando la sintassi Razor, ovvero le regole del linguaggio di programmazione.

Se si ha esperienza con la programmazione (soprattutto se si usa C, C++, C#, Visual Basic o JavaScript), gran parte di ciò che si legge qui sarà familiare. Probabilmente sarà necessario acquisire familiarità solo con il modo in cui il codice WebMatrix viene aggiunto al markup nei file con estensione vbhtml .

Combinazione di testo, markup e codice in blocchi di codice

Nei blocchi di codice del server è spesso necessario restituire testo e markup alla pagina. Se un blocco di codice del server contiene testo che non è codice e che deve invece essere sottoposto a rendering così come è, ASP.NET deve essere in grado di distinguere il testo dal codice. Esistono diversi modi per eseguire questa operazione.

• Racchiudere il testo in un elemento di blocco HTML come <p></p> o <em></em>:

  @If IsPost Then
      ' This line has all content between matched <p> tags.
      @<p>Hello, the time is @DateTime.Now and this page is a postback!</p> 
  Else
      ' All content between matched tags, followed by server code.
      @<p>Hello, <em>Stranger!</em> today is: </p> @DateTime.Now
  End If
  

  L'elemento HTML può includere testo, elementi HTML aggiuntivi ed espressioni di codice server. Quando ASP.NET vede il tag HTML di apertura (ad esempio, <p>), esegue il rendering di tutto l'elemento e il relativo contenuto così com'è nel browser (e risolve le espressioni del codice server).

• Usare l'operatore @: o l'elemento <text> . Il @: restituisce una singola riga di contenuto contenente testo normale o tag HTML non corrispondenti; l'elemento <text> racchiude più righe per l'output. Queste opzioni sono utili quando non si vuole eseguire il rendering di un elemento HTML come parte dell'output.

  @If IsPost Then
      ' Plain text followed by an unmatched HTML tag and server code.
      @:The time is: <br /> @DateTime.Now
      ' Server code and then plain text, matched tags, and more text.
      @DateTime.Now @:is the <em>current</em> time.
  End If
  

  Nell'esempio seguente viene ripetuto l'esempio precedente, ma viene utilizzata una singola coppia di <text> tag per racchiudere il testo di cui eseguire il rendering.

  @If IsPost Then
      @<text>
      The time is: <br /> @DateTime.Now
      @DateTime.Now is the <em>current</em> time.
      </text>
  End If
  

  Nell'esempio seguente i <text> tag e </text> racchiudono tre righe, tutte con alcuni tag HTML non contenuti e senza corrispondenza (<br />), insieme al codice server e ai tag HTML corrispondenti. Anche in questo caso, puoi anche precedere ogni riga singolarmente con l'operatore @:; in entrambi i modi funziona.

  @Code
      dim minTemp = 75 
      @<text>It is the month of @DateTime.Now.ToString("MMMM"), and  
      it's a <em>great</em> day! <p>You can go swimming if it's at 
      least @minTemp degrees.</p></text>
  End Code
  

  Annotazioni

  Quando si visualizza il testo come illustrato in questa sezione, usando un elemento HTML, l'operatore @: o l'elemento <text>, ASP.NET non codifica in HTML l'output. Come indicato in precedenza, ASP.NET codifica l'output delle espressioni di codice server e dei blocchi di codice server preceduti da @, tranne nei casi speciali indicati in questa sezione.

Spazi vuoti

Gli spazi aggiuntivi in un'istruzione (e all'esterno di un valore letterale stringa) non influiscono sull'istruzione:

@Code Dim personName =    "Smith"    End Code

Interruzione di istruzioni lunghe in più righe

È possibile suddividere un'istruzione di codice lungo in più righe usando il carattere _ di sottolineatura (che in Visual Basic viene chiamato carattere di continuazione) dopo ogni riga di codice. Per interrompere un'istruzione nella riga successiva, alla fine della riga aggiungere uno spazio e quindi il carattere di continuazione. Continuare l'istruzione nella riga successiva. È possibile suddividere le istruzioni sulle righe necessarie per migliorare la leggibilità. Le seguenti affermazioni sono le stesse:

@Code
    Dim familyName _
    =  "Smith" 
End Code

@Code
    Dim _
    theName _
    = _
    "Smith"
End Code

Tuttavia, non è possibile eseguire il wrapping di una riga al centro di un valore letterale stringa. L'esempio seguente non funziona:

@Code 
    ' Doesn't work.
    Dim test = "This is a long _
      string"
End Code

Per combinare una stringa lunga che esegue il wrapping su più righe come il codice precedente, è necessario usare l'operatore di concatenazione (&), che verrà visualizzato più avanti in questo articolo.

Commenti del codice

I commenti ti permettono di lasciare le note per te o per gli altri. I commenti della sintassi Razor sono preceduti da @* e terminano con *@.

@* A single-line comment is added like this example. *@
    
@*
    This is a multiline code comment. 
    It can continue for any number of lines.
*@

All'interno dei blocchi di codice è possibile usare i commenti della sintassi Razor oppure è possibile usare un carattere di commento di Visual Basic comune, ovvero una virgoletta singola (') preceduta da ogni riga.

@Code
    ' You can make comments in blocks by just using ' before each line.
End Code
    
@Code
    ' There is no multi-line comment character in Visual Basic. 
    ' You use a ' before each line you want to comment. 
End Code

Variables

Una variabile è un oggetto denominato usato per archiviare i dati. È possibile assegnare un nome alle variabili, ma il nome deve iniziare con un carattere alfabetico e non può contenere spazi vuoti o caratteri riservati. In Visual Basic, come illustrato in precedenza, il caso delle lettere in un nome di variabile non è rilevante.

Tipi di dati e variabili

Una variabile può avere un tipo di dati specifico, che indica il tipo di dati archiviato nella variabile. È possibile avere variabili stringa che archiviano valori stringa (ad esempio "Hello world"), variabili intere che archiviano valori numerici interi (ad esempio 3 o 79) e variabili di data che archiviano i valori di data in un'ampia gamma di formati (ad esempio 4/12/2012 o marzo 2009). E sono disponibili molti altri tipi di dati che è possibile usare.

Non è tuttavia necessario specificare un tipo per una variabile. Nella maggior parte dei casi ASP.NET può determinare il tipo in base al modo in cui vengono usati i dati nella variabile. In alcuni casi è necessario specificare un tipo. Verranno visualizzati esempi in cui è vero.

Per dichiarare una variabile senza specificare un tipo, usare Dim più il nome della variabile , ad esempio Dim myVar. Per dichiarare una variabile con un tipo, usare Dim più il nome della variabile, seguito da As e quindi il nome del tipo (ad esempio, Dim myVar As String).

@Code
    ' Assigning a string to a variable.
    Dim greeting = "Welcome" 
    
    ' Assigning a number to a variable.
    Dim theCount = 3
    
    ' Assigning an expression to a variable.
    Dim monthlyTotal = theCount + 5
    
    ' Assigning a date value to a variable.
    Dim today = DateTime.Today
    
    ' Assigning the current page's URL to a variable.
    Dim myPath = Request.Url
    
    ' Declaring variables using explicit data types.
    Dim name as String = "Joe"
    Dim count as Integer = 5
    Dim tomorrow as DateTime = DateTime.Now.AddDays(1)
End Code

Nell'esempio seguente vengono illustrate alcune espressioni inline che usano le variabili in una pagina Web.

@Code
    ' Embedding the value of a variable into HTML markup.
    ' Precede the markup with @ because we are in a code block.
    @<p>@greeting, friends!</p>
End Code

<!-- Using a variable with an inline expression in HTML. --> 
<p>The predicted annual total is: @( monthlyTotal * 12)</p>

<!--  Displaying the page URL with a variable. --> 
<p>The URL to this page is:  @myPath</p>

Risultato visualizzato in un browser:

Conversione e test dei tipi di dati

Anche se ASP.NET in genere può determinare automaticamente un tipo di dati, a volte non può. Potrebbe quindi essere necessario aiutare a ASP.NET eseguendo una conversione esplicita. Anche se non è necessario convertire i tipi, a volte è utile testare il tipo di dati che si potrebbe usare.

Il caso più comune è che è necessario convertire una stringa in un altro tipo, ad esempio in un numero intero o una data. Nell'esempio seguente viene illustrato un caso tipico in cui è necessario convertire una stringa in un numero.

@Code
    Dim total = 0
    Dim totalMessage = ""
    if IsPost Then
        ' Retrieve the numbers that the user entered.
        Dim num1 = Request("text1")
        Dim num2 = Request("text2")
        ' Convert the entered strings into integers numbers and add.
        total = num1.AsInt() + num2.AsInt()
        totalMessage = "Total = " & total
    End If
End Code

Come regola, l'input dell'utente viene fornito come stringhe. Anche se viene richiesto all'utente di immettere un numero e, anche se ha immesso una cifra, quando viene inviato l'input dell'utente e lo si legge nel codice, i dati sono in formato stringa. Pertanto, è necessario convertire la stringa in un numero. Nell'esempio, se si tenta di eseguire operazioni aritmetiche sui valori senza convertirle, vengono restituiti i risultati dell'errore seguenti, perché ASP.NET non può aggiungere due stringhe:

Cannot implicitly convert type 'string' to 'int'.

Per convertire i valori in numeri interi, chiamare il AsInt metodo . Se la conversione ha esito positivo, è possibile aggiungere i numeri.

Nella tabella seguente sono elencati alcuni metodi di conversione e test comuni per le variabili.

Dim myIntNumber = 0
Dim myStringNum = "539"
If myStringNum.IsInt() Then
    myIntNumber = myStringNum.AsInt()
End If

Dim myStringBool = "True"
Dim myVar = myStringBool.AsBool()

Dim myStringFloat = "41.432895"
Dim myFloatNum = myStringFloat.AsFloat()

Dim myStringDec = "10317.425"
Dim myDecNum = myStringDec.AsDecimal()

Dim myDateString = "12/27/2012"
Dim newDate = myDateString.AsDateTime()

Dim num1 As Integer = 17
Dim num2 As Integer = 76

' myString is set to 1776
Dim myString as String = num1.ToString() & _
    num2.ToString()

Operatori

Un operatore è una parola chiave o un carattere che indica ASP.NET quale tipo di comando eseguire in un'espressione. Visual Basic supporta molti operatori, ma è sufficiente riconoscere alcuni per iniziare a sviluppare ASP.NET pagine Web. La tabella seguente riepiloga gli operatori più comuni.

@(5 + 13)

Dim netWorth = 150000
Dim newTotal = netWorth * 2
@(newTotal / 2)

Dim age = 17

Dim income = Request("AnnualIncome")

Dim theNum = 13
If theNum <> 15 Then
    ' Do something.
End If

If 2 < 3 Then
    ' Do something.
End If

Dim currentCount = 12
If currentCount >= 12 Then
    ' Do something.
End If

' The displayed result is "abcdef".
@("abc" & "def")

Dim theCount As Integer = 0
theCount += 1 ' Adds 1 to count

Dim myUrl = Request.Url
Dim count = Request("Count").AsInt()

@(3 + 7)

@Request.MapPath(Request.FilePath)

Dim taskCompleted As Boolean = False
' Processing.
If Not taskCompleted Then 
    ' Continue processing
End If

Dim myTaskCompleted As Boolean = false
Dim totalCount As Integer = 0          
' Processing.
If (Not myTaskCompleted) AndAlso _
         totalCount < 12 Then 
    ' Continue processing.
End If

Uso dei percorsi di file e cartelle nel codice

Spesso si usano percorsi di file e cartelle nel codice. Ecco un esempio di struttura di cartelle fisiche per un sito Web come potrebbe apparire nel computer di sviluppo:

C:\WebSites\MyWebSite default.cshtml datafile.txt \images Logo.jpg \styles Styles.css

Ecco alcuni dettagli essenziali sugli URL e i percorsi:

• Un URL inizia con un nome di dominio (http://www.example.com) o un nome server (http://localhost, http://mycomputer).
• Un URL corrisponde a un percorso fisico in un computer host. Ad esempio, http://myserver potrebbe corrispondere alla cartella C:\websites\mywebsite nel server.
• Un percorso virtuale è abbreviato per rappresentare i percorsi nel codice senza dover specificare il percorso completo. Include la parte di un URL che segue il nome di dominio o server. Quando si usano percorsi virtuali, è possibile spostare il codice in un dominio o un server diverso senza dover aggiornare i percorsi.

Ecco un esempio per comprendere le differenze:

La radice virtuale è /, proprio come la radice del tuo disco C: è . I percorsi delle cartelle virtuali usano sempre barre oblique. Il percorso virtuale di una cartella non deve avere lo stesso nome della cartella fisica; può costituire un alias. Nei server di produzione il percorso virtuale corrisponde raramente a un percorso fisico esatto.

Quando si lavora con file e cartelle nel codice, a volte è necessario fare riferimento al percorso fisico e talvolta a un percorso virtuale, a seconda degli oggetti usati. ASP.NET offre questi strumenti per l'uso dei percorsi di file e cartelle nel codice: il metodo Server.MapPath, l'operatore ~ e il metodo Href.

Conversione di percorsi virtuali in percorsi fisici: metodo Server.MapPath

Il Server.MapPath metodo converte un percorso virtuale (ad esempio /default.cshtml) in un percorso fisico assoluto,ad esempio C:\WebSites\MyWebSiteFolder\default.cshtml. Questo metodo viene usato ogni volta che è necessario un percorso fisico completo. Un esempio tipico è quando si legge o si scrive un file di testo o un file di immagine nel server Web.

In genere non si conosce il percorso fisico assoluto del sito in un server del sito di hosting, quindi questo metodo può convertire il percorso che si conosce, ovvero il percorso virtuale, nel percorso corrispondente nel server. Il percorso virtuale viene passato a un file o a una cartella al metodo e restituisce il percorso fisico:

@Code
    Dim dataFilePath = "~/dataFile.txt"
End Code    

<!-- Displays a physical path C:\Websites\MyWebSite\datafile.txt  --> 
<p>@Server.MapPath(dataFilePath)</p>

Riferimento alla radice virtuale: l'operatore ~ e il metodo Href

In un file .cshtml o .vbhtml, puoi fare riferimento alla radice virtuale usando l'operatore ~. Questo è molto utile perché è possibile spostare le pagine in un sito e tutti i collegamenti che contengono ad altre pagine non verranno interrotti. È utile anche nel caso in cui tu abbia mai spostato il tuo sito web in una posizione diversa. Ecco alcuni esempi:

@Code
    Dim myImagesFolder = "~/images"
    Dim myStyleSheet = "~/styles/StyleSheet.css"       
End Code

Se il sito Web è http://myserver/myapp, ecco come ASP.NET tratterà questi percorsi quando viene eseguita la pagina:

• myImagesFolder: http://myserver/myapp/images
• myStyleSheet : http://myserver/myapp/styles/Stylesheet.css

Questi percorsi non verranno visualizzati come valori della variabile, ma ASP.NET tratteranno i percorsi come se fossero così.

È possibile usare l'operatore ~ sia nel codice del server (come sopra) che nel markup, come illustrato di seguito:

<!-- Examples of using the ~ operator in markup in ASP.NET Web Pages -->

<a href="~/Default">Home</a>
<img src="~/images/MyImages.png" />

Nel markup si usa l'operatore ~ per creare percorsi per risorse come file di immagine, altre pagine Web e file CSS. Quando viene eseguita la pagina, ASP.NET esamina la pagina (sia il codice che il markup) e risolve tutti i ~ riferimenti al percorso appropriato.

Logica condizionale e cicli

ASP.NET codice del server consente di eseguire attività in base alle condizioni e scrivere codice che ripete istruzioni un numero specifico di volte, ovvero il codice che esegue un ciclo.

Condizioni di test

Per testare una condizione semplice, usare l'istruzione If...Then , che restituisce True o False in base a un test specificato:

@Code
    Dim showToday = True
    If showToday Then
        DateTime.Today
    End If
End Code

La If parola chiave avvia un blocco. Il test effettivo (condizione) segue la If parola chiave e restituisce true o false. L'istruzione If termina con Then. Le istruzioni che verranno eseguite se il test è true sono racchiuse tra If e End If. Un'istruzione If può includere un Else blocco che specifica le istruzioni da eseguire se la condizione è false:

@Code
    Dim showToday = False
    If showToday Then
        DateTime.Today
    Else
        @<text>Sorry!</text>
    End If
End Code

Se un'istruzione If avvia un blocco di codice, non è necessario usare le Code...End Code normali istruzioni per includere i blocchi. È sufficiente aggiungere @ al blocco e funzionerà. Questo approccio funziona anche con If altre parole chiave di programmazione di Visual Basic seguite da blocchi di codice, tra cui For, For Each, Do Whilee così via.

@If showToday Then
    DateTime.Today
Else
    @<text>Sorry!</text>
End If

È possibile aggiungere più condizioni usando uno o più ElseIf blocchi:

@Code
    Dim theBalance = 4.99
    If theBalance = 0 Then
        @<p>You have a zero balance.</p>
    ElseIf theBalance > 0 AndAlso theBalance <= 5 Then
        ' If the balance is above 0 but less than
        ' or equal to $5, display this message.
        @<p>Your balance of $@theBalance is very low.</p>
    Else
        ' For balances greater than $5, display balance.
        @<p>Your balance is: $@theBalance</p>
    End If    
End Code

In questo esempio, se la prima condizione nel blocco If non è vera, viene controllata la condizione ElseIf. Se tale condizione viene soddisfatta, vengono eseguite le istruzioni nel ElseIf blocco. Se nessuna delle condizioni viene soddisfatta, le istruzioni nel blocco Else vengono eseguite. È possibile aggiungere un numero qualsiasi di ElseIf blocchi e quindi chiudere con un Else blocco come condizione "tutto il resto".

Per testare un numero elevato di condizioni, usare un Select Case blocco:

@Code
    Dim weekday = "Wednesday"
    Dim greeting = ""
    
    Select Case weekday
        Case "Monday"
            greeting = "Ok, it's a marvelous Monday."
        Case "Tuesday"
            greeting = "It's a tremendous Tuesday."
        Case "Wednesday"
            greeting = "Wild Wednesday is here!"
        Case Else
            greeting = "It's some other day, oh well."
    End Select
End Code
<p>Since it is @weekday, the message for today is: @greeting</p>

Il valore da testare è racchiuso tra parentesi (nell'esempio la variabile giorno feriale). Ogni singolo test usa un'istruzione Case che elenca un valore. Se il valore di un'istruzione Case corrisponde al valore di test, viene eseguito il codice in tale Case blocco.

Risultato degli ultimi due blocchi condizionali visualizzati in un browser:

Codice di ciclo

Spesso è necessario eseguire ripetutamente le stesse istruzioni. A tale scopo, eseguire un ciclo. Ad esempio, spesso si eseguono le stesse istruzioni per ogni elemento in una raccolta di dati. Se si conosce esattamente il numero di volte che si vuole eseguire il ciclo, è possibile usare un For ciclo. Questo tipo di ciclo è particolarmente utile per contare in avanti o indietro.

@For i = 10 To 20
    @<p>Item #: @i</p>
Next i

Il ciclo inizia con la For parola chiave , seguito da tre elementi:

• Subito dopo l'istruzione For , si dichiara una variabile contatore (non è necessario usare Dim) e quindi si indica l'intervallo, come in i = 10 to 20. Ciò significa che la variabile i inizierà a contare a 10 e continuerà fino a raggiungere 20 (inclusi).
• Tra le For istruzioni e le Next, c'è il contenuto del blocco. Può contenere una o più istruzioni di codice eseguite con ogni ciclo.
• L'istruzione Next i termina il ciclo. Incrementa il contatore e avvia l'iterazione successiva del ciclo.

La riga di codice tra le For righe e Next contiene il codice eseguito per ogni iterazione del ciclo. Il markup crea un nuovo paragrafo (<p> elemento) ogni volta e aggiunge una riga all'output, visualizzando il valore di i (il contatore). Quando si esegue questa pagina, nell'esempio vengono create 11 righe che visualizzano l'output, con il testo in ogni riga che indica il numero di elemento.

Se lavori con una raccolta o un array, usi spesso un ciclo For Each. Una raccolta è un gruppo di oggetti simili e il For Each ciclo consente di eseguire un'attività su ogni elemento della raccolta. Questo tipo di ciclo è utile per le raccolte, perché a differenza di un For ciclo, non è necessario incrementare il contatore o impostare un limite. Al contrario, il For Each codice del ciclo procede semplicemente attraverso la raccolta fino al termine.

In questo esempio vengono restituiti gli elementi della Request.ServerVariables raccolta , che contiene informazioni sul server Web. Usa un For Each ciclo per visualizzare il nome di ogni elemento creando un nuovo elemento <li> in un elenco puntato HTML.

<ul>
@For Each myItem In Request.ServerVariables
    @<li>@myItem</li>
Next myItem
</ul>

La For Each parola chiave è seguita da una variabile che rappresenta un singolo elemento nella raccolta (nell'esempio , myItem), seguito dalla In parola chiave , seguita dalla raccolta che si vuole scorrere. Nel corpo del For Each ciclo è possibile accedere all'elemento corrente usando la variabile dichiarata in precedenza.

Per creare un ciclo più generico, usare l'istruzione Do While :

@Code
    Dim countNum = 0
    Do While countNum < 50
        countNum += 1
        @<p>Line #@countNum: </p>
    Loop
End Code

Questo ciclo inizia con la Do While parola chiave, seguita da una condizione, seguita dal blocco da ripetere. I cicli incrementano (aggiungono a) o decrementano (sottraggono da) una variabile o un oggetto utilizzato per il conteggio. Nell'esempio l'operatore += aggiunge 1 al valore di una variabile ogni volta che viene eseguito il ciclo. Per decrementare una variabile in un ciclo che esegue il conto alla rovescia, usare l'operatore -=di decremento .

Oggetti e raccolte

Quasi tutto in un sito Web ASP.NET è un oggetto, inclusa la pagina Web stessa. Questa sezione illustra alcuni oggetti importanti che verranno usati di frequente nel codice.

Oggetti Pagina

L'oggetto più semplice in ASP.NET è la pagina. È possibile accedere direttamente alle proprietà dell'oggetto pagina senza alcun oggetto idoneo. Il codice seguente ottiene il percorso del file della pagina, usando l'oggetto Request della pagina:

@Code
    Dim path = Request.FilePath
End Code

È possibile usare le proprietà dell'oggetto Page per ottenere molte informazioni, ad esempio:

• Request. Come si è già visto, si tratta di una raccolta di informazioni sulla richiesta corrente, tra cui il tipo di browser che ha effettuato la richiesta, l'URL della pagina, l'identità dell'utente e così via.

• Response. Si tratta di una raccolta di informazioni sulla risposta (pagina) che verrà inviata al browser al termine dell'esecuzione del codice del server. Ad esempio, è possibile usare questa proprietà per scrivere informazioni nella risposta.

  @Code
      ' Access the page's Request object to retrieve the URL.
      Dim pageUrl = Request.Url
  End Code
      <a href="@pageUrl">My page</a>
  

Oggetti raccolta (matrici e dizionari)

Un insieme è un gruppo di oggetti dello stesso tipo, ad esempio una raccolta di Customer oggetti di un database. ASP.NET contiene molte raccolte predefinite, ad esempio la Request.Files raccolta.

Lavorerai spesso con i dati nelle raccolte. Due tipi di raccolta comuni sono la matrice e il dizionario. Una matrice è utile quando si vuole archiviare una raccolta di elementi simili, ma non si vuole creare una variabile separata per contenere ogni elemento:

<h3>Team Members</h3>
@Code
    Dim teamMembers() As String = {"Matt", "Joanne", "Robert", "Nancy"}
    For Each name In teamMembers
        @<p>@name</p>
    Next name
End Code

Con le matrici, si dichiara un tipo di dati specifico, ad esempio String, Integero DateTime. Per indicare che la variabile può contenere una matrice, aggiungere parentesi al nome della variabile nella dichiarazione , ad esempio Dim myVar() As String. È possibile accedere agli elementi in una matrice usando la relativa posizione (indice) o usando l'istruzione For Each . Gli indici di matrice sono in base zero, ovvero il primo elemento si trova nella posizione 0, il secondo elemento si trova nella posizione 1 e così via.

@Code
    Dim teamMembers() As String = {"Matt", "Joanne", "Robert", "Nancy"}
    @<p>The number of names in the teamMembers array: @teamMembers.Length </p>
    @<p>Robert is now in position: @Array.IndexOf(teamMembers, "Robert")</p>
    @<p>The array item at position 2 (zero-based) is @teamMembers(2)</p>
    @<h3>Current order of team members in the list</h3>
    For Each name In teamMembers
        @<p>@name</p>
    Next name
    @<h3>Reversed order of team members in the list</h3>
    Array.Reverse(teamMembers)
    For Each reversedItem In teamMembers
        @<p>@reversedItem</p>
    Next reversedItem
End Code

È possibile determinare il numero di elementi in una matrice recuperandone la Length proprietà. Per ottenere la posizione di un elemento specifico nella matrice , ovvero per eseguire una ricerca nella matrice, usare il Array.IndexOf metodo . È anche possibile eseguire operazioni come invertire il contenuto di una matrice (il Array.Reverse metodo) o ordinare il contenuto (il Array.Sort metodo ).

Il risultato del codice dell'array di stringhe mostrato in un browser:

Un dizionario è una raccolta di coppie chiave/valore, in cui si specifica la chiave (o il nome) per impostare o recuperare il valore corrispondente:

@Code
    Dim myScores = New Dictionary(Of String, Integer)()
    myScores.Add("test1", 71)
    myScores.Add("test2", 82)
    myScores.Add("test3", 100)
    myScores.Add("test4", 59)
End Code
<p>My score on test 3 is: @myScores("test3")%</p>
@Code 
    myScores("test4") = 79
End Code
<p>My corrected score on test 4 is: @myScores("test4")%</p>

Per creare un dizionario, usare la New parola chiave per indicare che si sta creando un nuovo Dictionary oggetto. È possibile assegnare un dizionario a una variabile usando la Dim parola chiave . Si indicano i tipi di dati degli elementi nel dizionario usando le parentesi ( ( ) ). Alla fine della dichiarazione, è necessario aggiungere un'altra coppia di parentesi, perché si tratta in realtà di un metodo che crea un nuovo dizionario.

Per aggiungere elementi al dizionario, è possibile chiamare il Add metodo della variabile dizionario (myScores in questo caso) e quindi specificare una chiave e un valore. In alternativa, è possibile usare le parentesi per indicare la chiave ed eseguire un'assegnazione semplice, come nell'esempio seguente:

@Code
    myScores("test4") = 79
End Code

Per ottenere un valore dal dizionario, specificare la chiave tra parentesi:

@myScores("test4")

Chiamata di metodi con parametri

Come hai visto in precedenza in questo articolo, gli oggetti con cui programmi hanno metodi. Ad esempio, un Database oggetto potrebbe avere un Database.Connect metodo . Molti metodi hanno anche uno o più parametri. Un parametro è un valore passato a un metodo per consentire al metodo di completare l'attività. Ad esempio, esaminare una dichiarazione per il Request.MapPath metodo , che accetta tre parametri:

Public Overridable Function MapPath (virtualPath As String, _
    baseVirtualDir As String, _
    allowCrossAppMapping As Boolean)

Questo metodo restituisce il percorso fisico nel server che corrisponde a un percorso virtuale specificato. I tre parametri per il metodo sono virtualPath, baseVirtualDire allowCrossAppMapping. Si noti che nella dichiarazione i parametri vengono elencati con i tipi di dati che accetteranno. Quando si chiama questo metodo, è necessario specificare i valori per tutti e tre i parametri.

Quando si usa Visual Basic con la sintassi Razor, sono disponibili due opzioni per passare parametri a un metodo: parametri posizionali o parametri denominati. Per chiamare un metodo usando i parametri posizionali, passare i parametri in un ordine rigoroso specificato nella dichiarazione del metodo. In genere si conosce questo ordine leggendo la documentazione per il metodo . È necessario seguire l'ordine e non è possibile ignorare alcun parametro, se necessario, passare una stringa vuota ("") o null per un parametro posizionale per cui non si ha un valore.

Nell'esempio seguente si presuppone che nel sito Web sia presente una cartella denominata scripts . Il codice chiama il Request.MapPath metodo e passa i valori per i tre parametri nell'ordine corretto. Visualizza quindi il percorso mappato risultante.

@Code
    ' Pass parameters to a method using positional parameters.
    Dim myPathPositional = Request.MapPath("/scripts", "/", true)
End Code
<p>@myPathPositional</p>

Quando sono presenti molti parametri per un metodo, è possibile mantenere il codice più pulito e più leggibile usando i parametri denominati. Per chiamare un metodo usando parametri denominati, specificare il nome del parametro seguito da := e quindi specificare il valore. Un vantaggio dei parametri denominati è che è possibile aggiungerli in qualsiasi ordine desiderato. Uno svantaggio è che la chiamata al metodo non è così compatta.

Nell'esempio seguente viene chiamato lo stesso metodo precedente, ma vengono usati parametri denominati per fornire i valori:

@Code
    ' Pass parameters to a method using named parameters.
    Dim myPathNamed = Request.MapPath(baseVirtualDir:= "/", allowCrossAppMapping:= true, virtualPath:= "/scripts")
End Code
<p>@myPathNamed</p>

Come si può notare, i parametri vengono passati in un ordine diverso. Tuttavia, se si esegue l'esempio precedente e questo esempio, verranno restituiti lo stesso valore.

Gestione degli errori

istruzioni Try-Catch

Spesso nel codice sono presenti istruzioni che potrebbero non riuscire per motivi esterni al controllo. Per esempio:

• Se il codice tenta di aprire, creare, leggere o scrivere un file, è possibile che si verifichino tutti i tipi di errori. Il file desiderato potrebbe non esistere, potrebbe essere bloccato, il codice potrebbe non avere autorizzazioni e così via.
• Analogamente, se il codice tenta di aggiornare i record in un database, possono verificarsi problemi di autorizzazioni, la connessione al database potrebbe essere eliminata, i dati da salvare potrebbero non essere validi e così via.

In termini di programmazione, queste situazioni sono denominate eccezioni. Se il codice rileva un'eccezione, genera (genera) un messaggio di errore che è, al meglio, fastidioso per gli utenti.

In situazioni in cui il codice potrebbe riscontrare eccezioni e per evitare messaggi di errore di questo tipo, è possibile usare Try/Catch istruzioni. Nell'istruzione Try si esegue il codice che si sta controllando. In una o più Catch istruzioni è possibile cercare errori specifici (tipi specifici di eccezioni) che potrebbero essersi verificati. È possibile includere quante Catch istruzioni necessarie per individuare gli errori che si prevede di incontrare.

L'esempio seguente mostra una pagina che crea un file di testo nella prima richiesta e quindi visualizza un pulsante che consente all'utente di aprire il file. L'esempio usa deliberatamente un nome file non valido in modo che causi un'eccezione. Il codice include Catch istruzioni per due possibili eccezioni: FileNotFoundException, che si verifica se il nome del file non è valido e DirectoryNotFoundException, che si verifica se ASP.NET non riesce nemmeno a trovare la cartella. È possibile rimuovere il commento da un'istruzione nell'esempio per vedere come viene eseguito quando tutto funziona correttamente.

Se il codice non ha gestito l'eccezione, verrà visualizzata una pagina di errore simile alla schermata precedente. Tuttavia, la Try/Catch sezione consente di impedire all'utente di visualizzare questi tipi di errori.

@Code
    Dim dataFilePath = "~/dataFile.txt"
    Dim fileContents = ""
    Dim physicalPath = Server.MapPath(dataFilePath)
    Dim userMessage = "Hello world, the time is " + DateTime.Now
    Dim userErrMsg = ""
    Dim errMsg = ""
    
    If IsPost Then
        ' When the user clicks the "Open File" button and posts
        ' the page, try to open the file.
        Try
            ' This code fails because of faulty path to the file.
            fileContents = File.ReadAllText("c:\batafile.txt")
            
            ' This code works. To eliminate error on page, 
            ' comment the above line of code and uncomment this one.
            ' fileContents = File.ReadAllText(physicalPath)
            
        Catch ex As FileNotFoundException
            ' You can use the exception object for debugging, logging, etc.
            errMsg = ex.Message
            ' Create a friendly error message for users.
            userErrMsg = "The file could not be opened, please contact " _
                & "your system administrator."
                
        Catch ex As DirectoryNotFoundException
            ' Similar to previous exception.
            errMsg = ex.Message
            userErrMsg = "The file could not be opened, please contact " _
                & "your system administrator."
        End Try
    Else
        ' The first time the page is requested, create the text file.
        File.WriteAllText(physicalPath, userMessage)
    End If
End Code
<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="utf-8" />
        <title>Try-Catch Statements</title>
    </head>
    <body>  
    <form method="POST" action="" >
      <input type="Submit" name="Submit" value="Open File"/>
    </form>
    
    <p>@fileContents</p>
    <p>@userErrMsg</p>
    
    </body>
</html>

Risorse aggiuntive

Documentazione di riferimento

• ASP.NET
• Linguaggio Visual Basic