Inleiding tot ASP.NET webprogrammering met behulp van de Razor-syntaxis (C#)

door Tom FitzMacken

In dit artikel vindt u een overzicht van programmeren met ASP.NET webpagina's met behulp van de Razor-syntaxis. ASP.NET is de technologie van Microsoft voor het uitvoeren van dynamische webpagina's op webservers. Deze artikelen zijn gericht op het gebruik van de C#-programmeertaal.

Wat u leert:

• De belangrijkste 8 programmeertips om aan de slag te gaan met programmeren ASP.NET webpagina's met behulp van Razor-syntaxis.
• Basisconcepten voor programmeren die u nodig hebt.
• Waar ASP.NET servercode en de Razor-syntaxis om draait.

Softwareversies

• ASP.NET Webpagina's (Razor) 3

Dit leerprogramma werkt ook met ASP.NET Webpagina's 2.

De belangrijkste 8 programmeertips

In deze sectie vindt u een aantal tips die u absoluut moet weten wanneer u begint met het schrijven van ASP.NET servercode met behulp van de Razor-syntaxis.

Verderop in het artikel vindt u meer informatie over de meeste van deze programmeertechnieken.

1. U voegt code toe aan een pagina met het @-teken

Het @ teken begint inlineexpressies, enkelvoudige instructieblokken en blokken met meerdere instructies:

<!-- Single statement blocks  -->
@{ var total = 7; }
@{ var myMessage = "Hello World"; }

<!-- Inline expressions -->
<p>The value of your account is: @total </p>
<p>The value of myMessage is: @myMessage</p>

<!-- Multi-statement block -->
@{
    var greeting = "Welcome to our site!";
    var weekDay = DateTime.Now.DayOfWeek;
    var greetingMessage = greeting + " Today is: " + weekDay;
}
<p>The greeting is: @greetingMessage</p>

Dit is hoe deze instructies eruitzien wanneer de pagina wordt uitgevoerd in een browser:

2. U plaatst codeblokken tussen accolades

Een codeblok bevat een of meer code-instructies en staat tussen accolades.

<!-- Single statement block.  -->
@{ var theMonth = DateTime.Now.Month; }
<p>The numeric value of the current month: @theMonth</p>

<!-- Multi-statement block. -->
@{
    var outsideTemp = 79;
    var weatherMessage = "Hello, it is " + outsideTemp + " degrees.";
}
<p>Today's weather: @weatherMessage</p>

Het resultaat dat wordt weergegeven in een browser:

3. Binnen een blok beëindigt u elke code-instructie met een puntkomma

In een codeblok moet elke volledige code-instructie eindigen met een puntkomma. Inline-expressies eindigen niet met een puntkomma.

<!-- Single-statement block -->
@{ var theMonth = DateTime.Now.Month; }

<!-- Multi-statement block -->
@{
    var outsideTemp = 79;
    var weatherMessage = "Hello, it is " + outsideTemp + " degrees.";
}

<!-- Inline expression, so no semicolon -->
<p>Today's weather: @weatherMessage</p>

4. U gebruikt variabelen om waarden op te slaan

U kunt waarden opslaan in een variabele, waaronder tekenreeksen, getallen en datums, enzovoort. U maakt een nieuwe variabele met behulp van het var trefwoord. U kunt variabele waarden rechtstreeks op een pagina invoegen met behulp van @.

<!-- Storing a string -->
@{ var welcomeMessage = "Welcome, new members!"; }
<p>@welcomeMessage</p>

<!-- Storing a date -->
@{ var year = DateTime.Now.Year; }

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

Het resultaat dat wordt weergegeven in een browser:

5. U plaatst letterlijke tekenreekswaarden tussen dubbele aanhalingstekens

Een tekenreeks is een reeks tekens die als tekst worden behandeld. Als u een tekenreeks wilt opgeven, plaatst u deze tussen dubbele aanhalingstekens:

@{ var myString = "This is a string literal"; }

Als de tekenreeks die u wilt weergeven, een backslashteken () of dubbele aanhalingstekens ( \" ) bevat, gebruikt u een letterlijke tekenreeks die wordt voorafgegaan door de @ operator. (In C# heeft het teken \ een speciale betekenis, tenzij U een letterlijke tekenreeks gebruikt.)

<!-- Embedding a backslash in a string -->
@{ var myFilePath = @"C:\MyFolder\"; }
<p>The path is: @myFilePath</p>

Als u dubbele aanhalingstekens wilt insluiten, gebruikt u een verbatim string literaal en herhaalt u de aanhalingstekens.

<!-- Embedding double quotation marks in a string -->
@{ var myQuote = @"The person said: ""Hello, today is Monday."""; }
<p>@myQuote</p>

Dit is het resultaat van het gebruik van beide voorbeelden op een pagina:

6. Code is hoofdlettergevoelig

In C# zijn trefwoorden (zoals var, trueen if) en variabelenamen hoofdlettergevoelig. Met de volgende regels code maakt u twee verschillende variabelen en lastNameLastName.

@{
    var lastName = "Smith";
    var LastName = "Jones";
}

Als u een variabele declareert als var lastName = "Smith"; en probeert te verwijzen naar die variabele op uw pagina @LastName, krijgt u de waarde "Jones" in plaats van "Smith".

7. Veel van uw codering omvat objecten

Een object vertegenwoordigt iets waarmee u kunt programmeren: een pagina, een tekstvak, een bestand, een afbeelding, een webaanvraag, een e-mailbericht, een klantrecord (databaserij), enzovoort. Objecten hebben eigenschappen die hun kenmerken beschrijven en die u kunt lezen of wijzigen: een tekstvakobject heeft een Text eigenschap (onder andere), een aanvraagobject heeft een Url eigenschap, een e-mailbericht heeft een From eigenschap en een klantobject heeft een FirstName eigenschap. Objecten hebben ook methoden die de 'werkwoorden' zijn die ze kunnen uitvoeren. Voorbeelden hiervan zijn de methode van Save een bestandsobject, de methode van Rotate een afbeeldingsobject en de methode van Send een e-mailobject.

U werkt vaak met het Request object, waarmee u informatie krijgt zoals de waarden van tekstvakken (formuliervelden) op de pagina, welk type browser de aanvraag heeft gedaan, de URL van de pagina, de gebruikersidentiteit, enzovoort. In het volgende voorbeeld ziet u hoe u toegang krijgt tot eigenschappen van het Request object en hoe u de MapPath methode van het Request object aanroept, waarmee u het absolute pad van de pagina op de server krijgt:

<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>

Het resultaat dat wordt weergegeven in een browser:

8. U kunt code schrijven die beslissingen neemt

Een belangrijke functie van dynamische webpagina's is dat u kunt bepalen wat u moet doen op basis van voorwaarden. De meest voorkomende manier om dit te doen, is met de if instructie (en optionele else instructie).

@{
   var result = "";
   if(IsPost)
   {
      result = "This page was posted using the Submit button.";
   }
   else
   {
      result = "This was the first request for this page.";
   }
}

<!DOCTYPE html>
<html>
    <head>
        <title></title>
    </head>
<body>
<form method="POST" action="" >
  <input type="Submit" name="Submit" value="Submit"/>
  <p>@result</p>
</form>
</body>
</html>

De verklaring if(IsPost) is een verkorte manier van schrijven if(IsPost == true). if Naast instructies zijn er verschillende manieren om voorwaarden te testen, codeblokken te herhalen, enzovoort, die verderop in dit artikel worden beschreven.

Het resultaat dat wordt weergegeven in een browser (nadat u op Verzenden hebt geklikt):

Een voorbeeld van eenvoudige code

In deze procedure ziet u hoe u een pagina maakt die eenvoudige programmeertechnieken illustreert. In het voorbeeld maakt u een pagina waarmee gebruikers twee getallen kunnen invoeren, waarna ze worden toegevoegd en het resultaat wordt weergegeven.

1. Maak in uw editor een nieuw bestand en geef het de naam AddNumbers.cshtml.

2. Kopieer de volgende code en markeringen naar de pagina en vervang alles wat zich al op de pagina bevindt.

   @{
       var total = 0;
       var totalMessage = "";
       if(IsPost) {
   
           // Retrieve the numbers that the user entered.
           var num1 = Request["text1"];
           var num2 = Request["text2"];
   
           // Convert the entered strings into integers numbers and add.
           total = num1.AsInt() + num2.AsInt();
           totalMessage = "Total = " + total;
       }
   }
   
   <!DOCTYPE html>
   <html lang="en">
     <head>
       <title>Add Numbers</title>
       <meta charset="utf-8" />
       <style type="text/css">
         body {background-color: beige; font-family: Verdana, Arial;
               margin: 50px; }
         form {padding: 10px; border-style: solid; width: 250px;}
       </style>
     </head>
   <body>
     <p>Enter two whole numbers and then click <strong>Add</strong>.</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>
   

   Hier volgen enkele dingen die u kunt noteren:

   • Het @ teken start het eerste codeblok op de pagina en gaat vooraf aan de totalMessage variabele die onder aan de pagina is ingesloten.
   • Het blok bovenaan de pagina staat tussen accolades.
   • In het blok bovenaan eindigen alle regels met een puntkomma.
   • De variabelen total, num1, num2en totalMessage slaan verschillende getallen en een tekenreeks op.
   • De letterlijke tekenreekswaarde die aan de totalMessage variabele is toegewezen, bevindt zich tussen dubbele aanhalingstekens.
   • Omdat de code hoofdlettergevoelig is en de totalMessage variabele onder aan de pagina wordt gebruikt, moet de naam exact overeenkomen met de variabele bovenaan.
   • De expressie num1.AsInt() + num2.AsInt() laat zien hoe u met objecten en methoden kunt werken. Met AsInt de methode voor elke variabele wordt de tekenreeks die door een gebruiker is ingevoerd, geconverteerd naar een getal (een geheel getal), zodat u er rekenkundige bewerkingen op kunt uitvoeren.
   • De <form> tag bevat een method="post" kenmerk. Hiermee geeft u op dat wanneer de gebruiker op Toevoegen klikt, de pagina wordt verzonden naar de server met behulp van de HTTP POST-methode. Wanneer de pagina wordt verzonden, wordt de if(IsPost) test geëvalueerd als waar en wordt de voorwaardelijke code uitgevoerd, waarbij het resultaat van het optellen van de getallen wordt weergegeven.

3. Sla de pagina op en voer deze uit in een browser. (Zorg ervoor dat de pagina is geselecteerd in de werkruimte Bestanden voordat u deze uitvoert.) Voer twee hele getallen in en klik vervolgens op de knop Toevoegen .

   

Basisconcepten voor programmeren

Dit artikel bevat een overzicht van ASP.NET webprogrammering. Het is geen uitgebreid onderzoek, slechts een korte rondleiding door de programmeerconcepten die u het vaakst zult gebruiken. Zelfs dit omvat bijna alles wat u nodig hebt om aan de slag te gaan met ASP.NET webpagina's.

Maar eerst een beetje technische achtergrond.

De Razor-syntaxis, servercode en ASP.NET

Razor-syntaxis is een eenvoudige programmeersyntaxis voor het insluiten van servercode op een webpagina. Op een webpagina die gebruikmaakt van de Razor-syntaxis, zijn er twee soorten inhoud: clientinhoud en servercode. Clientinhoud is de dingen die u gewend bent in webpagina's: HTML-opmaak (elementen), stijlgegevens zoals CSS, misschien een clientscript zoals JavaScript en tekst zonder opmaak.

Met razor-syntaxis kunt u servercode toevoegen aan deze clientinhoud. Als er servercode op de pagina staat, wordt die code eerst uitgevoerd voordat de pagina naar de browser wordt verzonden. Door op de server uit te voeren, kan de code taken uitvoeren die veel complexer kunnen zijn om alleen clientinhoud te gebruiken, zoals het openen van serverdatabases. Het belangrijkste is dat servercode dynamisch clientinhoud kan maken: het kan html-markeringen of andere inhoud tegelijk genereren en deze vervolgens naar de browser verzenden, samen met elke statische HTML die de pagina kan bevatten. Vanuit het perspectief van de browser is clientinhoud die door uw servercode wordt gegenereerd, niet anders dan andere clientinhoud. Zoals u al hebt gezien, is de vereiste servercode vrij eenvoudig.

ASP.NET webpagina's met de Razor-syntaxis hebben een speciale bestandsextensie (.cshtml of .vbhtml). De server herkent deze extensies, voert de code uit die is gemarkeerd met razor-syntaxis en verzendt de pagina vervolgens naar de browser.

Waar past ASP.NET in?

Razor-syntaxis is gebaseerd op een technologie van Microsoft genaamd ASP.NET, die op zijn beurt is gebaseerd op microsoft .NET Framework. The.NET Framework is een groot, uitgebreid programmeerframework van Microsoft voor het ontwikkelen van vrijwel elk type computertoepassing. ASP.NET is het onderdeel van .NET Framework dat speciaal is ontworpen voor het maken van webtoepassingen. Ontwikkelaars hebben ASP.NET gebruikt om veel van de grootste en hoogste verkeerswebsites ter wereld te maken. (Telkens wanneer u de bestandsnaamextensie ziet .aspx als onderdeel van de URL op een site, weet u dat de site is geschreven met behulp van ASP.NET.)

De Razor-syntaxis biedt u alle kracht van ASP.NET, maar het gebruik van een vereenvoudigde syntaxis die gemakkelijker te leren is als u een beginner bent en dat u productiever maakt als u een expert bent. Hoewel deze syntaxis eenvoudig te gebruiken is, betekent de familierelatie met ASP.NET en .NET Framework dat wanneer uw websites geavanceerder worden, u de kracht hebt van de grotere frameworks die voor u beschikbaar zijn.

Basissyntaxis

Eerder hebt u een basisvoorbeeld gezien van het maken van een pagina met ASP.NET webpagina's en hoe u servercode kunt toevoegen aan HTML-markeringen. Hier leert u de basisprincipes van het schrijven van ASP.NET servercode met behulp van de Razor-syntaxis, dat wil weten de programmeertaalregels.

Als u ervaring hebt met programmeren (vooral als u C, C++, C#, Visual Basic of JavaScript hebt gebruikt), is veel van wat u hier leest bekend. Waarschijnlijk moet u uzelf alleen vertrouwd maken met de wijze waarop servercode wordt toegevoegd aan markeringen in .cshtml-bestanden .

Tekst, markeringen en code combineren in codeblokken

In servercodeblokken wilt u vaak tekst of markeringen (of beide) uitvoeren op de pagina. Als een servercodeblok tekst bevat die geen code is en die in plaats daarvan als zodanig moet worden weergegeven, moet ASP.NET die tekst van code kunnen onderscheiden. Er zijn verschillende manieren om dit te doen.

• Plaats de tekst in een HTML-element zoals<p></p>:<em></em>

  @if(IsPost) {
      // 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: <br /> </p>  @DateTime.Now
  }
  

  Het HTML-element kan tekst, extra HTML-elementen en servercode-expressies bevatten. Wanneer ASP.NET het openings-HTML-element ziet (bijvoorbeeld <p>), wordt alles, inclusief het element en de inhoud ervan, exact weergegeven zoals het is aan de browser, waarbij servercode-uitdrukkingen worden opgelost.

• Gebruik de @: operator of het <text> element. De @: geeft één regel met platte tekst of niet-overeenkomende HTML-tags weer; het <text> element omhult meerdere regels voor uitvoer. Deze opties zijn handig als u geen HTML-element wilt weergeven als onderdeel van de uitvoer.

  @if(IsPost) {
      // Plain text followed by an unmatched HTML tag and server code.
      @: The time is: <br /> @DateTime.Now
      <br/>
      // Server code and then plain text, matched tags, and more text.
      @DateTime.Now @:is the <em>current</em> time.
  }
  

  Als u meerdere regels tekst of niet-overeenkomende HTML-tags wilt uitvoeren, kunt u aan elke regel @: voorafgaan, of kunt u de regel in een <text> element plaatsen. Net als de @: operator<text> worden tags gebruikt door ASP.NET om tekstinhoud te identificeren en worden ze nooit weergegeven in de pagina-uitvoer.

  @if(IsPost) {
      // Repeat the previous example, but use <text> tags.
      <text>
      The time is: <br /> @DateTime.Now
      <br/>
      @DateTime.Now is the <em>current</em> time.
      </text>
  }
  
  @{
      var minTemp = 75;
      <text>It is the month of @DateTime.Now.ToString("MMMM"), and
      it's a <em>great</em> day! <br /><p>You can go swimming if it's at
      least @minTemp degrees. </p></text>
  }
  

  In het eerste voorbeeld wordt het vorige voorbeeld herhaald, maar wordt één paar <text> tags gebruikt om de tekst te omsluiten. In het tweede voorbeeld plaatsen de <text> en </text> tags drie regels, die allemaal een aantal niet-gecodeerde tekst en niet-overeenkomende HTML-codes (<br />) bevatten, samen met servercode en overeenkomende HTML-codes. Ook hier kunt u elke regel afzonderlijk vooraf laten gaan door de @: operator. Beide manieren werken.

  Opmerking

  Wanneer u tekst uitvoert zoals wordt weergegeven in deze sectie, met behulp van een HTML-element, de @: operator of het <text> element, zal ASP.NET de uitvoer niet HTML-coderen. (Zoals eerder vermeld, codeerde ASP.NET de uitvoer van servercode-expressies en servercodeblokken die voorafgaan door @, behalve in de speciale gevallen die in deze sectie worden vermeld.)

Witte ruimte

Extra spaties in een instructie (en buiten een letterlijke tekenreeks) hebben geen invloed op de instructie:

@{ var lastName =    "Smith"; }

Een regeleinde in een instructie heeft geen effect op de instructie en u kunt instructies verpakken voor leesbaarheid. De volgende instructies zijn hetzelfde:

@{ var theName =
"Smith"; }

@{
    var
    personName
    =
    "Smith"
    ;
}

Echter, u kunt geen regel in het midden van een letterlijke tekenreeks afbreken. Het volgende voorbeeld werkt niet:

@{ var test = "This is a long
    string"; }  // Does not work!

Als u een lange tekenreeks wilt combineren die terugloopt op meerdere regels zoals de bovenstaande code, zijn er twee opties. U kunt de samenvoegingsoperator (+), die u verderop in dit artikel ziet, gebruiken. U kunt het @ teken ook gebruiken om een letterlijke tekenreeks te maken, zoals u eerder in dit artikel hebt gezien. U kunt letterlijke letterlijke tekenreeksen tussen regels verbreken:

@{ var longString = @"This is a
    long
    string";
}

Opmerkingen bij code (en opmaak)

Met opmerkingen kunt u notities voor uzelf of anderen achterlaten. U kunt ook een sectie met code of markeringen uitschakelen die u niet wilt uitvoeren, maar voorlopig op de pagina wilt blijven.

Er zijn verschillende syntaxis voor opmerkingen voor Razor-code en voor HTML-markeringen. Net als bij alle Razor-code worden Razor-opmerkingen verwerkt (en vervolgens verwijderd) op de server voordat de pagina naar de browser wordt verzonden. Met de razor-syntaxis voor opmerkingen kunt u opmerkingen in de code plaatsen (of zelfs in de opmaak) die u kunt zien wanneer u het bestand bewerkt, maar die gebruikers niet zien, zelfs niet in de paginabron.

Voor ASP.NET Razor-opmerkingen begint u de opmerking met @* en beëindigt u deze met *@. De opmerking kan op één regel of meerdere regels staan:

@*  A one-line code comment. *@

@*
    This is a multiline code comment.
    It can continue for any number of lines.
*@

Hier volgt een opmerking in een codeblok:

@{
    @* This is a comment. *@
    var theVar = 17;
}

Hier volgt hetzelfde codeblok, waarbij de regel code als commentaar is toegevoegd, zodat deze niet wordt uitgevoerd:

@{
    @* This is a comment. *@
    @* var theVar = 17;  *@
}

In een codeblok kunt u, als alternatief voor het gebruik van razor-syntaxis voor opmerkingen, de syntaxis van de opmerking gebruiken van de programmeertaal die u gebruikt, zoals C#:

@{
    // This is a comment.
    var myVar = 17;
    /* This is a multi-line comment
    that uses C# commenting syntax. */
}

In C# worden opmerkingen met één regel voorafgegaan door de // tekens en beginnen met /* opmerkingen met meerdere regels en eindigen met */. (Net als bij Razor-opmerkingen worden C#-opmerkingen niet weergegeven in de browser.)

Voor markeringen kunt u, zoals u waarschijnlijk weet, een HTML-opmerking maken:

<!-- This is a comment.  -->

HTML-opmerkingen beginnen met <!-- tekens en eindigen met -->. U kunt HTML-opmerkingen gebruiken om niet alleen tekst te plaatsen, maar ook html-markeringen die u mogelijk op de pagina wilt bewaren, maar die u niet wilt weergeven. Deze HTML-opmerking verbergt de volledige inhoud van de tags en de tekst die ze bevatten:

<!-- <p>This is my paragraph.</p>  -->

In tegenstelling tot Razor-opmerkingen worden HTML-opmerkingen weergegeven op de pagina en kan de gebruiker deze zien door de paginabron te bekijken.

Razor heeft beperkingen voor geneste blokken van C#. Zie Benoemde C#-variabelen en geneste blokken Verbroken code genereren voor meer informatie

Variabelen

Een variabele is een benoemd object dat u gebruikt om gegevens op te slaan. U kunt variabelen een naam geven, maar de naam moet beginnen met een alfabetisch teken en mag geen spaties of gereserveerde tekens bevatten.

Variabelen en gegevenstypen

Een variabele kan een specifiek gegevenstype hebben, wat aangeeft welk type gegevens in de variabele wordt opgeslagen. U kunt tekenreeksvariabelen hebben waarin tekenreekswaarden (zoals 'Hallo wereld'), gehele getallen worden opgeslagen (zoals 3 of 79) en datumvariabelen die datumwaarden opslaan in verschillende notaties (zoals 12-4-2012 of maart 2009). En er zijn veel andere gegevenstypen die u kunt gebruiken.

Over het algemeen hoeft u echter geen type voor een variabele op te geven. Meestal kan ASP.NET het type bepalen op basis van hoe de gegevens in de variabele worden gebruikt. (Af en toe moet u een type opgeven; u ziet voorbeelden waar dit waar is.)

U declareert een variabele met behulp van het var trefwoord (als u geen type wilt opgeven) of door de naam van het type te gebruiken:

@{
    // Assigning a string to a variable.
    var greeting = "Welcome!";

    // Assigning a number to a variable.
    var theCount = 3;

    // Assigning an expression to a variable.
    var monthlyTotal = theCount + 5;

    // Assigning a date value to a variable.
    var today = DateTime.Today;

    // Assigning the current page's URL to a variable.
    var myPath = this.Request.Url;

    // Declaring variables using explicit data types.
    string name = "Joe";
    int count = 5;
    DateTime tomorrow = DateTime.Now.AddDays(1);
}

In het volgende voorbeeld ziet u enkele typische toepassingen van variabelen op een webpagina:

@{
    // Embedding the value of a variable into HTML markup.
    <p>@greeting, friends!</p>

    // Using variables as part of an inline expression.
    <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>
}

Als u de vorige voorbeelden op een pagina combineert, ziet u dit in een browser:

Gegevenstypen converteren en testen

Hoewel ASP.NET meestal automatisch een gegevenstype kan bepalen, kan dat soms niet. Daarom moet u mogelijk helpen ASP.NET door een expliciete conversie uit te voeren. Zelfs als u geen typen hoeft te converteren, is het soms handig om te testen met welk type gegevens u mogelijk werkt.

Het meest voorkomende geval is dat u een tekenreeks moet converteren naar een ander type, bijvoorbeeld naar een geheel getal of datum. In het volgende voorbeeld ziet u een typisch geval waarin u een tekenreeks moet converteren naar een getal.

@{
    var total = 0;

    if(IsPost) {
        // Retrieve the numbers that the user entered.
        var num1 = Request["text1"];
        var num2 = Request["text2"];
        // Convert the entered strings into integers numbers and add.
        total = num1.AsInt() + num2.AsInt();
    }
}

In de regel krijgt u gebruikersinvoer als tekenreeksen. Zelfs als u gebruikers hebt gevraagd een getal in te voeren en zelfs als ze een cijfer hebben ingevoerd, wanneer gebruikersinvoer wordt verzonden en u deze in code leest, hebben de gegevens de tekenreeksindeling. Daarom moet u de tekenreeks converteren naar een getal. Als u in het voorbeeld rekenkundige bewerkingen probeert uit te voeren op de waarden zonder deze te converteren, worden de volgende foutresultaten weergegeven, omdat ASP.NET geen twee tekenreeksen kan toevoegen:

Kan het type 'tekenreeks' niet impliciet converteren naar 'int'.

Als u de waarden wilt converteren naar gehele getallen, roept u de AsInt methode aan. Als de conversie is geslaagd, kunt u de getallen toevoegen.

De volgende tabel bevat enkele algemene conversie- en testmethoden voor variabelen.

var myIntNumber = 0;
var myStringNum = "539";
if(myStringNum.IsInt()==true){
    myIntNumber = myStringNum.AsInt();
}

var myStringBool = "True";
var myVar = myStringBool.AsBool();

var myStringFloat = "41.432895";
var myFloatNum = myStringFloat.AsFloat();

var myStringDec = "10317.425";
var myDecNum = myStringDec.AsDecimal();

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

int num1 = 17;
int num2 = 76;
// myString is set to 1776
string myString = num1.ToString() +
  num2.ToString();

Bedieners

Een operator is een trefwoord of teken dat aangeeft ASP.NET welk type opdracht moet worden uitgevoerd in een expressie. De C#-taal (en de Razor-syntaxis die erop is gebaseerd) ondersteunt veel operators, maar u hoeft er maar een paar te herkennen om aan de slag te gaan. De volgende tabel bevat een overzicht van de meest voorkomende operators.

@(5 + 13)
@{ var netWorth = 150000; }
@{ var newTotal = netWorth * 2; }
@(newTotal / 2)

var age = 17;

var myNum = 15;
if (myNum == 15) {
    // Do something.
}

var theNum = 13;
if (theNum != 15) {
    // Do something.
}

if (2 < 3) {
    // Do something.
}
var currentCount = 12;
if(currentCount >= 12) {
    // Do something.
}

// The displayed result is "abcdef".
@("abc" + "def")

int theCount = 0;
theCount += 1; // Adds 1 to count

var myUrl = Request.Url;
var count = Request["Count"].AsInt();

@(3 + 7)
@Request.MapPath(Request.FilePath);

var income = Request["AnnualIncome"];

bool taskCompleted = false;
// Processing.
if(!taskCompleted) {
    // Continue processing
}

bool myTaskCompleted = false;
int totalCount = 0;
// Processing.
if(!myTaskCompleted && totalCount < 12) {
    // Continue processing.
}

Werken met bestands- en maplocaties in code

U werkt vaak met bestands- en mappaden in uw code. Hier volgt een voorbeeld van een fysieke mapstructuur voor een website, zoals deze kan worden weergegeven op uw ontwikkelcomputer:

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

Hier volgen enkele essentiële informatie over URL's en paden:

• Een URL begint met een domeinnaam (http://www.example.com) of een servernaam (http://localhost, http://mycomputer).
• Een URL komt overeen met een fysiek pad op een hostcomputer. Kan bijvoorbeeld http://myserver overeenkomen met de map C:\websites\mywebsite op de server.
• Een virtueel pad is een verkorte notatie om paden in code weer te geven zonder dat het volledige pad hoeft te worden gespecificeerd. Het bevat het gedeelte van een URL die de naam van het domein of de server volgt. Wanneer u virtuele paden gebruikt, kunt u uw code verplaatsen naar een ander domein of een andere server zonder dat u de paden hoeft bij te werken.

Hier volgt een voorbeeld om inzicht te verkrijgen in de verschillen:

De virtuele root is /, net als de root van uw C:-schijf. (Virtuele mappaden gebruiken altijd schuine strepen.) Het virtuele pad van een map hoeft niet dezelfde naam te hebben als de fysieke map; het kan een alias zijn. (Op productieservers komt het virtuele pad zelden overeen met een exact fysiek pad.)

Wanneer u met bestanden en mappen in code werkt, moet u soms verwijzen naar het fysieke pad en soms naar een virtueel pad, afhankelijk van de objecten waarmee u werkt. ASP.NET biedt u deze hulpprogramma's voor het werken met bestands- en mappaden in code: de Server.MapPath methode en de ~ operator en Href methode.

Virtuele naar fysieke paden converteren: de methode Server.MapPath

Met de Server.MapPath methode wordt een virtueel pad (zoals /default.cshtml) geconverteerd naar een absoluut fysiek pad (zoals C:\WebSites\MyWebSiteFolder\default.cshtml). U gebruikt deze methode op elk moment dat u een volledig fysiek pad nodig hebt. Een typisch voorbeeld is wanneer u een tekstbestand of afbeeldingsbestand op de webserver leest of schrijft.

Normaal gesproken weet u niet het absolute fysieke pad van uw site op de server van een hostingsite, dus deze methode kan het pad dat u kent , het virtuele pad, converteren naar het bijbehorende pad op de server voor u. U geeft het virtuele pad door aan een bestand of map aan de methode en retourneert het fysieke pad:

@{
    var dataFilePath = "~/dataFile.txt";
}
<!-- Displays a physical path C:\Websites\MyWebSite\datafile.txt  -->
<p>@Server.MapPath(dataFilePath)</p>

Verwijzen naar de virtuele root: de ~-operator en de Href-methode

In een .cshtml - of .vbhtml-bestand kunt u verwijzen naar het virtuele hoofdpad met behulp van de ~ operator. Dit is erg handig omdat u pagina's in een site kunt verplaatsen en koppelingen die ze naar andere pagina's bevatten, niet worden verbroken. Het is ook handig voor het geval u uw website ooit naar een andere locatie verplaatst. Hieronder vindt u enkele voorbeelden:

@{
    var myImagesFolder = "~/images";
    var myStyleSheet = "~/styles/StyleSheet.css";
}

Als de website is http://myserver/myapp, behandelt ASP.NET deze paden als volgt wanneer de pagina wordt uitgevoerd:

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

(U ziet deze paden niet als de waarden van de variabele, maar ASP.NET behandelt de paden alsof dat het was.)

U kunt de ~ operator zowel in servercode (zoals hierboven) als in markeringen gebruiken, zoals deze:

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

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

In markeringen gebruikt u de ~ operator om paden te maken naar resources zoals afbeeldingsbestanden, andere webpagina's en CSS-bestanden. Wanneer ASP.NET de pagina uitvoert, kijkt het door de pagina (zowel code als markup) en zet het alle ~ verwijzingen om naar het juiste pad.

Voorwaardelijke logica en lussen

Met ASP.NET-servercode kunt u taken uitvoeren op basis van voorwaarden en code schrijven waarmee instructies een bepaald aantal keren worden herhaald (oftewel code die een lus uitvoert).

Testvoorwaarden

Als u een eenvoudige voorwaarde wilt testen, gebruikt u de if instructie, die waar of onwaar retourneert op basis van een test die u opgeeft:

@{
  var showToday = true;
  if(showToday)
  {
    @DateTime.Today;
  }
}

Het if trefwoord start een blok. De werkelijke test (voorwaarde) staat tussen haakjes en retourneert waar of onwaar. De instructies die worden uitgevoerd als de test waarheidsgetrouw is, staan tussen accolades. Een if instructie kan een else blok bevatten waarmee instructies worden opgegeven die moeten worden uitgevoerd als de voorwaarde onwaar is:

@{
  var showToday = false;
  if(showToday)
  {
    @DateTime.Today;
  }
  else
  {
    <text>Sorry!</text>
  }
}

U kunt meerdere voorwaarden toevoegen met behulp van een else if blok:

@{
    var theBalance = 4.99;
    if(theBalance == 0)
    {
        <p>You have a zero balance.</p>
    }
    else if (theBalance  > 0 && theBalance <= 5)
    {
        <p>Your balance of $@theBalance is very low.</p>
    }
    else
    {
        <p>Your balance is: $@theBalance</p>
    }
}

Als in dit voorbeeld de eerste voorwaarde in het if-blok niet waar is, wordt de else if voorwaarde gecontroleerd. Als aan deze voorwaarde wordt voldaan, worden de instructies in het else if blok uitgevoerd. Als aan geen van de voorwaarden wordt voldaan, worden de instructies in het else blok uitgevoerd. U kunt een willekeurig aantal else if blokken toevoegen en vervolgens afsluiten met een else blok als de 'alles anders' voorwaarde.

Als u een groot aantal voorwaarden wilt testen, gebruikt u een switch blok:

@{
    var weekday = "Wednesday";
    var greeting = "";

    switch(weekday)
    {
        case "Monday":
            greeting = "Ok, it's a marvelous Monday";
            break;
        case "Tuesday":
            greeting = "It's a tremendous Tuesday";
            break;
        case "Wednesday":
            greeting = "Wild Wednesday is here!";
            break;
        default:
            greeting = "It's some other day, oh well.";
            break;
    }

    <p>Since it is @weekday, the message for today is: @greeting</p>
}

De te testen waarde staat tussen haakjes (in het voorbeeld de weekday variabele). Elke afzonderlijke test maakt gebruik van een case instructie die eindigt op een dubbele punt (:). Als de waarde van een case instructie overeenkomt met de testwaarde, wordt de code in die blok uitgevoerd. U sluit elke case-instructie af met een break instructie. (Als u vergeet onderbreking in elk case blok op te nemen, wordt de code uit de volgende case instructie ook uitgevoerd.) Een switch blok heeft vaak een default instructie als laatste geval voor een 'alles anders'-optie die wordt uitgevoerd als geen van de andere gevallen waar is.

Het resultaat van de laatste twee voorwaardelijke blokken die worden weergegeven in een browser:

Code lus

Vaak moet u dezelfde instructies herhaaldelijk uitvoeren. U doet dit door een lus te maken. U voert bijvoorbeeld vaak dezelfde instructies uit voor elk item in een verzameling gegevens. Als u precies weet hoe vaak u wilt herhalen, kunt u een for lus gebruiken. Dit soort lus is vooral handig voor het optellen of aftellen:

@for(var i = 10; i < 21; i++)
{
    <p>Line #: @i</p>
}

De lus begint met het for trefwoord, gevolgd door drie instructies tussen haakjes, elk beëindigd met een puntkomma.

• Binnen de haakjes zet de eerste instructie (var i=10;) een teller op en stelt deze in op 10. U hoeft de teller i geen naam te geven. U kunt elke variabele gebruiken. Wanneer de for lus wordt uitgevoerd, wordt de teller automatisch verhoogd.
• Met de tweede instructie (i < 21;) wordt de voorwaarde ingesteld voor hoe ver u wilt tellen. In dit geval wilt u dat deze naar maximaal 20 gaat (dat wil gezegd, ga door terwijl de teller kleiner is dan 21).
• De derde instructie (i++ ) maakt gebruik van een incrementeeroperator, die eenvoudigweg aangeeft dat er 1 bij de teller moet worden opgeteld telkens wanneer de lus wordt uitgevoerd.

Binnen de accolades bevindt zich de code die voor elke iteratie van de lus wordt uitgevoerd. De markering maakt elke keer een nieuwe alinea (<p> element) en voegt een regel toe aan de uitvoer, waarbij de waarde van i (de teller) wordt weergegeven. Wanneer u deze pagina bekijkt, creëert het voorbeeld 11 regels met uitvoer, waarbij de tekst op elke regel het itemnummer aangeeft.

Als u met een verzameling of matrix werkt, gebruikt u vaak een foreach lus. Een verzameling is een groep vergelijkbare objecten en met de foreach lus kunt u een taak uitvoeren op elk item in de verzameling. Dit type lus is handig voor verzamelingen, omdat u, in tegenstelling tot een for lus, de teller niet hoeft te verhogen of een limiet hoeft in te stellen. In plaats daarvan gaat de foreach luscode gewoon door de verzameling totdat deze is voltooid.

Met de volgende code worden bijvoorbeeld de items in de Request.ServerVariables verzameling geretourneerd. Dit is een object dat informatie over uw webserver bevat. Er wordt een foreac h-lus gebruikt om de naam van elk item weer te geven door een nieuw <li> element in een HTML-lijst met opsommingstekens te maken.

<ul>
@foreach (var myItem in Request.ServerVariables)
{
    <li>@myItem</li>
}
</ul>

Het foreach trefwoord wordt gevolgd door haakjes waar u een variabele declareert die één item in de verzameling vertegenwoordigt (in het voorbeeld var item), gevolgd door het in trefwoord, gevolgd door de verzameling die u wilt doorlopen. In de hoofdtekst van de foreach lus hebt u toegang tot het huidige item met behulp van de variabele die u eerder hebt gedeclareerd.

Als u een algemenere lus wilt maken, gebruikt u de while instructie:

@{
    var countNum = 0;
    while (countNum < 50)
    {
        countNum += 1;
        <p>Line #@countNum: </p>
    }
}

Een while lus begint met het while trefwoord, gevolgd door haakjes waar u opgeeft hoe lang de lus doorgaat (zolang countNum kleiner is dan 50), en vervolgens volgt het blok dat herhaald moet worden. Lussen verhogen (optellen) of verlagen (aftrekken) een variabele of object dat wordt gebruikt om te tellen. Elke keer dat de lus wordt uitgevoerd, wordt in het voorbeeld met de += operator 1 aan countNum toegevoegd. (Als u een variabele in een lus wilt verlagen die aftelt, gebruikt u de operator -=voor verlagen).

Objecten en verzamelingen

Bijna alles op een ASP.NET website is een object, inclusief de webpagina zelf. In deze sectie worden enkele belangrijke objecten besproken waarmee u regelmatig in uw code werkt.

Paginaobjecten

Het meest eenvoudige object in ASP.NET is de pagina. U kunt rechtstreeks toegang krijgen tot eigenschappen van het paginaobject zonder een in aanmerking komend object. Met de volgende code wordt het bestandspad van de pagina opgehaald met behulp van het Request object van de pagina:

@{
    var path = Request.FilePath;
}

Om duidelijk te maken dat u verwijst naar eigenschappen en methoden op het huidige paginaobject, kunt u desgewenst het trefwoord this gebruiken om het paginaobject in uw code weer te geven. Hier volgt het vorige codevoorbeeld, dat this is toegevoegd om de pagina weer te geven:

@{
    var path = this.Request.FilePath;
}

U kunt eigenschappen van het Page object gebruiken om veel informatie op te halen, zoals:

• Request. Zoals u al hebt gezien, is dit een verzameling informatie over de huidige aanvraag, waaronder welk type browser de aanvraag heeft gedaan, de URL van de pagina, de gebruikersidentiteit, enzovoort.

• Response. Dit is een verzameling informatie over het antwoord (pagina) dat naar de browser wordt verzonden wanneer de servercode is uitgevoerd. U kunt deze eigenschap bijvoorbeeld gebruiken om informatie naar het antwoord te schrijven.

  @{
      // Access the page's Request object to retrieve the Url.
      var pageUrl = this.Request.Url;
  }
  <a href="@pageUrl">My page</a>
  

Verzamelingsobjecten (matrices en woordenlijsten)

Een verzameling is een groep objecten van hetzelfde type, zoals een verzameling Customer objecten uit een database. ASP.NET bevat veel ingebouwde verzamelingen, zoals de Request.Files verzameling.

U werkt vaak met gegevens in verzamelingen. Twee algemene verzamelingstypen zijn de matrix en de woordenlijst. Een matrix is handig als u een verzameling vergelijkbare items wilt opslaan, maar geen afzonderlijke variabele wilt maken om elk item op te slaan:

@* Array block 1: Declaring a new array using braces. *@
@{
    <h3>Team Members</h3>
    string[] teamMembers = {"Matt", "Joanne", "Robert", "Nancy"};
    foreach (var person in teamMembers)
    {
        <p>@person</p>
    }
}

Met matrices declareert u een specifiek gegevenstype, zoals string, intof DateTime. Als u wilt aangeven dat de variabele een matrix kan bevatten, voegt u vierkante haken toe aan de declaratie (zoals string[] of int[]). U kunt items in een matrix openen met behulp van hun positie (index) of met behulp van de foreach instructie. Matrixindexen zijn gebaseerd op nul, dus het eerste item bevindt zich op positie 0, het tweede item bevindt zich op positie 1, enzovoort.

@{
    string[] teamMembers = {"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>
    foreach (var name in teamMembers)
    {
        <p>@name</p>
    }
    <h3>Reversed order of team members in the list</h3>
    Array.Reverse(teamMembers);
    foreach (var reversedItem in teamMembers)
    {
        <p>@reversedItem</p>
    }
}

U kunt het aantal items in een matrix bepalen door de Length eigenschap op te halen. Gebruik de Array.IndexOf methode om de positie van een specifiek item in de matrix op te halen (om de matrix te doorzoeken). U kunt ook dingen doen zoals de inhoud van een matrix (de Array.Reverse methode) omkeren of de inhoud (de Array.Sort methode) sorteren.

De uitvoer van de tekenreeksmatrixcode die wordt weergegeven in een browser:

Een woordenlijst is een verzameling sleutel-/waardeparen, waarbij u de sleutel (of naam) opgeeft om de bijbehorende waarde in te stellen of op te halen:

@{
    var myScores = new Dictionary<string, int>();
    myScores.Add("test1", 71);
    myScores.Add("test2", 82);
    myScores.Add("test3", 100);
    myScores.Add("test4", 59);
}
<p>My score on test 3 is: @myScores["test3"]%</p>
@{myScores["test4"] = 79;}
<p>My corrected score on test 4 is: @myScores["test4"]%</p>

Als u een woordenlijst wilt maken, gebruikt u het new trefwoord om aan te geven dat u een nieuw woordenlijstobject maakt. U kunt een woordenlijst toewijzen aan een variabele met behulp van het var trefwoord. U geeft de gegevenstypen van de items in de woordenlijst aan met punthaken ( < > ). Aan het einde van de declaratie moet u een paar haakjes toevoegen, omdat dit eigenlijk een methode is waarmee een nieuwe woordenlijst wordt gemaakt.

Als u items wilt toevoegen aan de woordenlijst, kunt u de methode van de Add woordenlijstvariabele aanroepen (myScores in dit geval) en vervolgens een sleutel en een waarde opgeven. U kunt ook vierkante haken gebruiken om de sleutel aan te geven en een eenvoudige toewijzing uit te voeren, zoals in het volgende voorbeeld:

myScores["test4"] = 79;

Als u een waarde uit de woordenlijst wilt ophalen, geeft u de sleutel tussen vierkante haken op:

var testScoreThree = myScores["test3"];

Methoden aanroepen met parameters

Zoals u eerder in dit artikel hebt gelezen, kunnen de objecten waarmee u programmat methoden hebben. Een object kan bijvoorbeeld Database een Database.Connect methode hebben. Veel methoden hebben ook een of meer parameters. Een parameter is een waarde die u doorgeeft aan een methode om de methode in staat te stellen de taak te voltooien. Bekijk bijvoorbeeld een declaratie voor de Request.MapPath methode, die drie parameters gebruikt:

public string MapPath(string virtualPath, string baseVirtualDir, 
    bool allowCrossAppMapping);

(De regel is verpakt om deze beter leesbaar te maken. Houd er rekening mee dat u regeleinden bijna elke plaats kunt plaatsen, behalve binnen tekenreeksen die tussen aanhalingstekens staan.)

Met deze methode wordt het fysieke pad op de server geretourneerd dat overeenkomt met een opgegeven virtueel pad. De drie parameters voor de methode zijn virtualPath, baseVirtualDiren allowCrossAppMapping. (In de declaratie worden de parameters vermeld met de gegevenstypen van de gegevens die ze accepteren.) Wanneer u deze methode aanroept, moet u waarden opgeven voor alle drie de parameters.

De Razor-syntaxis biedt twee opties voor het doorgeven van parameters aan een methode: positionele parameters en benoemde parameters. Als u een methode wilt aanroepen met behulp van positionele parameters, geeft u de parameters door in een strikte volgorde die is opgegeven in de methodedeclaratie. (Normaal gesproken kent u deze volgorde door de documentatie voor de methode te lezen.) U moet de volgorde volgen en u kunt een van de parameters niet overslaan. Indien nodig geeft u een lege tekenreeks ("") door of null voor een positionele parameter waarvoor u geen waarde hebt.

In het volgende voorbeeld wordt ervan uitgegaan dat u een map met de naam scripts op uw website hebt. De code roept de Request.MapPath methode aan en geeft waarden door voor de drie parameters in de juiste volgorde. Vervolgens wordt het resulterende toegewezen pad weergegeven.

@{
    // Pass parameters to a method using positional parameters.
    var myPathPositional = Request.MapPath("/scripts", "/", true);
}
<p>@myPathPositional</p>

Wanneer een methode veel parameters heeft, kunt u uw code beter leesbaar houden met behulp van benoemde parameters. Als u een methode wilt aanroepen met behulp van benoemde parameters, geeft u de parameternaam op gevolgd door een dubbele punt (:) en vervolgens de waarde. Het voordeel van benoemde parameters is dat u ze in elke gewenste volgorde kunt doorgeven. (Een nadeel is dat de method-call niet zo compact is.)

In het volgende voorbeeld wordt dezelfde methode aangeroepen als hierboven, maar worden benoemde parameters gebruikt om de waarden op te geven:

@{
    // Pass parameters to a method using named parameters.
    var myPathNamed = Request.MapPath(baseVirtualDir: "/", 
        allowCrossAppMapping: true, virtualPath: "/scripts");
}
<p>@myPathNamed</p>

Zoals u ziet, worden de parameters in een andere volgorde doorgegeven. Als u echter het vorige voorbeeld uitvoert en dit voorbeeld, retourneren ze dezelfde waarde.

Fouten afhandelen

Try-Catch-instructies

U hebt vaak instructies in uw code die om redenen buiten uw controle kunnen mislukken. Voorbeeld:

• Als uw code probeert een bestand te maken of te openen, kunnen er allerlei fouten optreden. Het gewenste bestand bestaat mogelijk niet, het is mogelijk vergrendeld, de code heeft mogelijk geen machtigingen, enzovoort.
• Als uw code records in een database probeert bij te werken, kunnen er problemen zijn met machtigingen, kan de verbinding met de database worden verbroken, zijn de gegevens die moeten worden opgeslagen mogelijk ongeldig, enzovoort.

In programmeertermen worden deze situaties uitzonderingen genoemd. Als uw code een uitzondering tegenkomt, wordt er een foutbericht gegenereerd (genereert) dat in het beste stadium vervelend is voor gebruikers:

In situaties waarin uw code uitzonderingen kan tegenkomen en om foutberichten van dit type te voorkomen, kunt u instructies gebruiken try/catch . In de try verklaring voert u de code uit die u controleert. In een of meer catch instructies kunt u zoeken naar specifieke fouten (specifieke soorten uitzonderingen) die mogelijk zijn opgetreden. U kunt zoveel catch verklaringen opnemen als u nodig hebt om fouten te vinden die u verwacht.

In het volgende voorbeeld ziet u een pagina waarmee een tekstbestand wordt gemaakt op de eerste aanvraag en vervolgens een knop wordt weergegeven waarmee de gebruiker het bestand kan openen. In het voorbeeld wordt bewust een ongeldige bestandsnaam gebruikt, zodat deze een uitzondering veroorzaakt. De code bevat catch instructies voor twee mogelijke uitzonderingen: FileNotFoundException, wat optreedt als de bestandsnaam slecht is en DirectoryNotFoundException, wat optreedt als ASP.NET de map niet eens kan vinden. (U kunt opmerkingen bij een instructie in het voorbeeld verwijderen om te zien hoe deze wordt uitgevoerd wanneer alles goed werkt.)

Als uw code de uitzondering niet heeft verwerkt, ziet u een foutpagina zoals de vorige schermafbeelding. De try/catch sectie helpt echter te voorkomen dat de gebruiker deze typen fouten ziet.

@{
    var dataFilePath = "~/dataFile.txt";
    var fileContents = "";
    var physicalPath = Server.MapPath(dataFilePath);
    var userMessage = "Hello world, the time is " + DateTime.Now;
    var userErrMsg = "";
    var errMsg = "";

    if(IsPost)
    {
        // When the user clicks the "Open File" button and posts
        // the page, try to open the created file for reading.
        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 (FileNotFoundException ex) {
            // You can use the exception object for debugging, logging, etc.
            errMsg = ex.Message;
            // Create a friendly error message for users.
            userErrMsg = "A file could not be opened, please contact "
                + "your system administrator.";
        }
        catch (DirectoryNotFoundException ex) {
            // Similar to previous exception.
            errMsg = ex.Message;
            userErrMsg = "A directory was not found, please contact "
                + "your system administrator.";
        }
    }
    else
    {
        // The first time the page is requested, create the text file.
        File.WriteAllText(physicalPath, userMessage);
    }
}

<!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>

Aanvullende bronnen

Programmeren met Visual Basic

Bijlage: Visual Basic Taal en Syntaxis

Referentiedocumentatie

ASP.NET

C#-taal