Introducción a la programación web de ASP.NET mediante la sintaxisC#Razor ()

por Tom FitzMacken

En este artículo se proporciona información general sobre la programación con ASP.NET Web Pages mediante el sintaxis Razor. ASP.NET es la tecnología de Microsoft para ejecutar páginas web dinámicas en servidores Web. Este artículo se centra en el C# uso del lenguaje de programación.

Lo que aprenderá:

• Las 8 mejores sugerencias de programación para empezar a programar ASP.NET Web Pages mediante sintaxis Razor.
• Conceptos de programación básicos que necesitará.
• Qué es el código del servidor de ASP.NET y el sintaxis Razor.

Versiones de software

• ASP.NET Web Pages (Razor) 3

Este tutorial también funciona con ASP.NET Web Pages 2.

Las 8 mejores sugerencias de programación

En esta sección se enumeran algunas sugerencias que es absolutamente necesario saber a medida que empieza a escribir código de servidor de ASP.NET mediante el sintaxis Razor.

Puede encontrar más detalles sobre la mayoría de estas técnicas de programación más adelante en el artículo.

1. Agregue código a una página mediante el carácter @.

El carácter @ inicia las expresiones en línea, los bloques de instrucción única y los bloques de varias instrucciones:

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

Este es el aspecto de estas instrucciones cuando la página se ejecuta en un explorador:

2. incluir los bloques de código entre llaves

Un bloque de código incluye una o varias instrucciones de código y está entre llaves.

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

Resultado mostrado en un explorador:

3. dentro de un bloque, finaliza cada instrucción de código con un punto y coma

Dentro de un bloque de código, cada instrucción de código completo debe terminar con un punto y coma. Las expresiones insertadas no finalizan con un punto y coma.

<!-- 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. Utilice variables para almacenar valores

Puede almacenar valores en una variable, como cadenas, números y fechas, etc. Cree una nueva variable mediante la palabra clave var. Los valores de las variables se pueden insertar directamente en una página mediante @.

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

Resultado mostrado en un explorador:

5. incluir valores de cadena literales entre comillas dobles

Una cadena es una secuencia de caracteres que se trata como texto. Para especificar una cadena, debe encerrarla entre comillas dobles:

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

Si la cadena que desea mostrar contiene un carácter de barra diagonal inversa (\) o comillas dobles ("), use un literal de cadena textual que tenga como prefijo el operador @. (En C#, el carácter \ tiene un significado especial a menos que use un literal de cadena textual).

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

Para insertar comillas dobles, use un literal de cadena textual y repita las comillas:

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

Este es el resultado de usar estos dos ejemplos en una página:

6. el código distingue mayúsculas de minúsculas

En C#, las palabras clave (como var, truey if) y los nombres de variable distinguen mayúsculas de minúsculas. Las siguientes líneas de código crean dos variables diferentes, lastName y LastName.

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

Si declara una variable como var lastName = "Smith"; e intenta hacer referencia a esa variable en la página como @LastName, obtendría el valor "Jones" en lugar de "Smith".

7. gran parte de la codificación implica objetos

Un objeto representa un elemento que puede programar con — una página, un cuadro de texto, un archivo, una imagen, una solicitud Web, un mensaje de correo electrónico, un registro de cliente (fila de base de datos), etc. Los objetos tienen propiedades que describen sus características y que puede leer o cambiar — un objeto de cuadro de texto tiene una propiedad Text (entre otros), un objeto de solicitud tiene una propiedad Url, un mensaje de correo electrónico tiene una propiedad From y un objeto Customer tiene una propiedad FirstName. Los objetos también tienen métodos que son los "verbos" pueden realizar. Entre los ejemplos se incluye el método de Save de un objeto de archivo, el método de Rotate de un objeto de imagen y el método Send de un objeto de correo electrónico.

A menudo, trabajará con el objeto Request, que le proporciona información como los valores de los cuadros de texto (campos de formulario) en la página, el tipo de explorador que realizó la solicitud, la dirección URL de la página, la identidad del usuario, etc. En el ejemplo siguiente se muestra cómo obtener acceso a las propiedades del objeto Request y cómo llamar al método MapPath del objeto Request, que proporciona la ruta de acceso absoluta de la página en el servidor:

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

Resultado mostrado en un explorador:

8. puede escribir código que tome decisiones

Una característica clave de las páginas web dinámicas es que puede determinar qué hacer en función de las condiciones. La forma más común de hacerlo es con la instrucción if (y la instrucción else opcional).

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

La instrucción if(IsPost) es una forma abreviada de escribir if(IsPost == true). Junto con las instrucciones if, hay varias maneras de probar condiciones, repetir bloques de código, etc., que se describen más adelante en este artículo.

El resultado mostrado en un explorador (después de hacer clic en submit):

Un ejemplo de código simple

En este procedimiento se muestra cómo crear una página que muestra las técnicas básicas de programación. En el ejemplo, creará una página que permite a los usuarios escribir dos números y, después, los agregará y mostrará el resultado.

1. En el editor, cree un nuevo archivo y asígnele el nombre AddNumbers. cshtml.

2. Copie el código y el marcado siguientes en la página, reemplazando todo lo que ya está en la página.

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

   A continuación se indican algunas cosas que debe tener en cuenta:

   • El carácter @ inicia el primer bloque de código de la página y precede a la variable totalMessage que está incrustada cerca de la parte inferior de la página.
   • El bloque situado en la parte superior de la página se incluye entre llaves.
   • En el bloque de la parte superior, todas las líneas terminan con un punto y coma.
   • Las variables total, num1, num2y totalMessage almacenan varios números y una cadena.
   • El valor de cadena literal asignado a la variable totalMessage está entre comillas dobles.
   • Dado que el código distingue entre mayúsculas y minúsculas, cuando la variable de totalMessage se usa cerca de la parte inferior de la página, su nombre debe coincidir exactamente con la variable en la parte superior.
   • La expresión num1.AsInt() + num2.AsInt() muestra cómo trabajar con objetos y métodos. El método AsInt de cada variable convierte la cadena especificada por un usuario en un número (un entero) para que pueda realizar operaciones aritméticas en ella.
   • La etiqueta <form> incluye un atributo method="post". Esto especifica que cuando el usuario haga clic en Agregar, la página se enviará al servidor mediante el método http post. Cuando se envía la página, la prueba if(IsPost) se evalúa como true y se ejecuta el código condicional, mostrando el resultado de sumar los números.

3. Guarde la página y ejecútela en un explorador. (Asegúrese de que la página esté seleccionada en el área de trabajo archivos antes de ejecutarla). Escriba dos números enteros y, a continuación, haga clic en el botón Agregar .

   

Conceptos básicos de la programación

En este artículo se proporciona información general sobre la programación web de ASP.NET. No es un examen exhaustivo, solo un paseo rápido por los conceptos de programación que usará con mayor frecuencia. Incluso así, cubre casi todo lo que necesita para empezar a trabajar con ASP.NET Web Pages.

Pero en primer lugar, un poco de conocimientos técnicos.

La sintaxis de Razor, el código de servidor y ASP.NET

Sintaxis Razor es una sintaxis de programación sencilla para insertar código basado en servidor en una página web. En una página web que utiliza el sintaxis Razor, hay dos tipos de contenido: contenido del cliente y código del servidor. El contenido del cliente es el material que se usa en las páginas web: marcado HTML (elementos), información de estilo como CSS, quizás algún script de cliente como JavaScript y texto sin formato.

Sintaxis Razor le permite agregar código de servidor a este contenido de cliente. Si hay código de servidor en la página, el servidor ejecuta primero ese código, antes de enviar la página al explorador. Mediante la ejecución de en el servidor, el código puede realizar tareas que pueden ser mucho más complejas de utilizar solo el contenido del cliente, como el acceso a bases de datos basadas en el servidor. Lo más importante es que el código de servidor puede crear dinámicamente el contenido — del cliente y puede generar marcado HTML u otro contenido sobre la marcha y, a continuación, enviarlo al explorador junto con cualquier código HTML estático que pueda contener la página. Desde la perspectiva del explorador, el contenido de cliente generado por el código del servidor no es diferente de ningún otro contenido de cliente. Como ya ha visto, el código de servidor necesario es bastante sencillo.

Las páginas web de ASP.NET que incluyen la sintaxis Razor tienen una extensión de archivo especial ( . cshtml o . vbhtml). El servidor reconoce estas extensiones, ejecuta el código que está marcado con sintaxis Razor y, a continuación, envía la página al explorador.

¿Dónde encaja ASP.NET?

Sintaxis Razor se basa en una tecnología de Microsoft llamada ASP.NET, que a su vez se basa en el marco de Microsoft .NET. The.NET Framework es un marco de programación amplio y completo de Microsoft para desarrollar prácticamente cualquier tipo de aplicación de equipos. ASP.NET es la parte de la .NET Framework que está diseñada específicamente para la creación de aplicaciones Web. Los desarrolladores han usado ASP.NET para crear muchos de los sitios web de mayor y mayor tráfico del mundo. (Siempre que vea la extensión de nombre de archivo . aspx como parte de la dirección URL de un sitio, sabrá que el sitio se escribió con ASP.net).

El sintaxis Razor le proporciona toda la eficacia de ASP.NET, pero con una sintaxis simplificada que es más fácil de aprender si es un principiante y que le permite ser más productivo si es un experto. Aunque esta sintaxis es fácil de usar, su relación de familia con ASP.NET y el .NET Framework significa que, a medida que sus sitios web son más sofisticados, tiene la capacidad de los marcos de trabajo más grandes a su disposición.

Sintaxis básica

Antes vio un ejemplo básico de cómo crear una página ASP.NET Web Pages y cómo puede agregar código de servidor al marcado HTML. Aquí aprenderá los conceptos básicos de la escritura de código de servidor ASP.NET mediante — el sintaxis Razor es decir, las reglas del lenguaje de programación.

Si tiene experiencia con la programación (especialmente si ha usado C, C++, C#, Visual Basic o JavaScript), gran parte de lo que Lee aquí le resultará familiar. Probablemente necesitará familiarizarse solo con el modo en que se agrega el código de servidor al marcado en los archivos . cshtml .

Combinar texto, marcado y código en bloques de código

En los bloques de código de servidor, a menudo desea que se genere texto o marcado (o ambos) en la página. Si un bloque de código de servidor contiene texto que no es código y que, en su lugar, se debe representar como es, ASP.NET debe poder distinguir ese texto del código. Existen varias formas de hacerlo.

• Incluya el texto en un elemento HTML como <p></p> o <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
  }
  

  El elemento HTML puede incluir texto, elementos HTML adicionales y expresiones de código de servidor. Cuando ASP.NET ve la etiqueta HTML de apertura (por ejemplo, <p>), representa todo lo que incluye el elemento y su contenido tal como está en el explorador, resolviendo las expresiones de código de servidor a medida que van.

• Use el operador @: o el elemento <text>. El @: genera una sola línea de contenido que contiene texto sin formato o etiquetas HTML no coincidentes; el elemento <text> incluye varias líneas para la salida. Estas opciones son útiles cuando no desea representar un elemento HTML como parte de la salida.

  @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.
  }
  

  Si desea generar varias líneas de texto o etiquetas HTML no coincidentes, puede preceder cada línea con @:, o puede incluir la línea en un elemento <text>. Al igual que el operador de @:, las etiquetas de<text> se usan en ASP.NET para identificar el contenido de texto y nunca se representan en el resultado de la página.

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

  En el primer ejemplo se repite el ejemplo anterior, pero se usa un solo par de etiquetas <text> para incluir el texto que se va a representar. En el segundo ejemplo, las etiquetas <text> y </text> incluyen tres líneas, todas ellas tienen un texto no contenida y etiquetas HTML no coincidentes (<br />), junto con el código del servidor y las etiquetas HTML coincidentes. De nuevo, también podría preceder cada línea individualmente con el operador @:; ambos métodos funcionan.

  Note

  Cuando se genera texto como se muestra en esta — sección mediante un elemento HTML, el operador @: o el elemento — <text> ASP.net no codifica en HTML el resultado. (Como se indicó anteriormente, ASP.NET codifica la salida de las expresiones de código de servidor y los bloques de código de servidor precedidos por @, excepto en los casos especiales que se indican en esta sección).

Whitespace

Los espacios adicionales en una instrucción (y fuera de un literal de cadena) no afectan a la instrucción:

@{ var lastName =    "Smith"; }

Un salto de línea en una instrucción no tiene ningún efecto en la instrucción y puede ajustar las instrucciones para mejorar la legibilidad. Las siguientes instrucciones son iguales:

@{ var theName =
"Smith"; }

@{
    var
    personName
    =
    "Smith"
    ;
}

Sin embargo, no se puede ajustar una línea en medio de un literal de cadena. El ejemplo siguiente no funciona:

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

Para combinar una cadena larga que se ajusta a varias líneas como el código anterior, hay dos opciones. Puede usar el operador de concatenación (+), que verá más adelante en este artículo. También puede usar el carácter @ para crear un literal de cadena textual, como vimos anteriormente en este artículo. Puede romper los literales de cadena textual entre las líneas:

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

Comentarios de código (y marcado)

Los comentarios le permiten dejar notas por su cuenta o por otras personas. También le permiten deshabilitar (comentar) una sección de código o de marcado que no desea ejecutar, pero que desea mantener en la página por el momento.

Hay una sintaxis de comentario diferente para el código Razor y para el marcado HTML. Al igual que con todo el código Razor, los comentarios de Razor se procesan (y luego se quitan) en el servidor antes de que la página se envíe al explorador. Por lo tanto, la sintaxis de comentarios de Razor permite colocar comentarios en el código (o incluso en el marcado) que se pueden ver al editar el archivo, pero que los usuarios no ven, ni siquiera en el origen de la página.

En el caso de los comentarios de Razor ASP.NET, inicie el comentario con @* y termine con *@. El comentario puede estar en una o varias líneas:

@*  A one-line code comment. *@

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

Este es un comentario dentro de un bloque de código:

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

Este es el mismo bloque de código, con la línea de código comentada para que no se ejecute:

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

Dentro de un bloque de código, como alternativa al uso de la sintaxis de comentarios de Razor, puede usar la sintaxis de comentarios del lenguaje de programación que está C#usando, por ejemplo:

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

En C#, los comentarios de una línea van precedidos de los caracteres // y los comentarios de varias líneas comienzan con /* y terminan con */. (Al igual que con los C# comentarios de Razor, los comentarios no se representan en el explorador).

Para el marcado, como probablemente sepa, puede crear un Comentario HTML:

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

Los comentarios HTML comienzan con <!-- caracteres y terminan con -->. Puede usar comentarios HTML para rodear no solo texto, sino también cualquier código HTML que desee conservar en la página, pero que no quiera que se represente. Este comentario HTML ocultará todo el contenido de las etiquetas y el texto que contienen:

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

A diferencia de los comentarios de Razor, los comentarios HTML se representan en la página y el usuario puede verlos viendo el origen de la página.

Razor tiene limitaciones en los bloques anidados C#de. Para obtener más información , C# consulte las variables con nombre y los bloques anidados generar código roto

variables

Una variable es un objeto con nombre que se utiliza para almacenar los datos. Puede asignar cualquier valor a las variables, pero el nombre debe comenzar por un carácter alfabético y no puede contener espacios en blanco ni caracteres reservados.

Variables y tipos de datos

Una variable puede tener un tipo de datos específico, que indica qué tipo de datos se almacenan en la variable. Puede tener variables de cadena que almacenen valores de cadena (como "Hello World"), variables de entero que almacenan valores de número entero (como 3 o 79) y variables de fecha que almacenan valores de fecha en una variedad de formatos (como 4/12/2012 o marzo de 2009). Y hay muchos otros tipos de datos que puede usar.

Sin embargo, por lo general no es necesario especificar un tipo para una variable. La mayoría de las veces, ASP.NET puede averiguar el tipo en función de cómo se usan los datos de la variable. (En ocasiones, debe especificar un tipo; verá ejemplos donde esto es cierto).

Declare una variable mediante la palabra clave var (si no desea especificar un tipo) o con el nombre del tipo:

@{
    // 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);
}

En el ejemplo siguiente se muestran algunos usos típicos de las variables en una página web:

@{
    // 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>
}

Si combina los ejemplos anteriores en una página, verá que se muestra en un explorador:

Conversión y prueba de tipos de datos

Aunque ASP.NET normalmente puede determinar un tipo de datos de forma automática, a veces no es posible. Por lo tanto, es posible que necesite ayudar a ASP.NET a realizar una conversión explícita. Incluso si no tiene que convertir tipos, a veces resulta útil probar para ver el tipo de datos con el que puede trabajar.

El caso más común es que tenga que convertir una cadena en otro tipo, como un entero o una fecha. En el ejemplo siguiente se muestra un caso típico en el que debe convertir una cadena en un número.

@{
    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();
    }
}

Como regla, los datos proporcionados por el usuario se incluyen como cadenas. Incluso si ha solicitado que los usuarios escriban un número e incluso si han escrito un dígito, cuando se envía la entrada del usuario y lo lee en el código, los datos están en formato de cadena. Por lo tanto, debe convertir la cadena en un número. En el ejemplo, si intenta realizar operaciones aritméticas en los valores sin convertirlos, se producirá el siguiente error, porque ASP.NET no puede agregar dos cadenas:

No se puede convertir implícitamente el tipo ' String ' a ' int '.

Para convertir los valores en enteros, llame al método AsInt. Si la conversión se realiza correctamente, puede Agregar los números.

En la tabla siguiente se enumeran algunos métodos de conversión y prueba comunes para las variables.

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();

Operadores

Un operador es una palabra clave o un carácter que indica a ASP.NET qué tipo de comando se debe realizar en una expresión. El C# lenguaje (y el sintaxis Razor que se basa en él) admite muchos operadores, pero solo tiene que reconocer algunos para comenzar. En la tabla siguiente se resumen los operadores más comunes.

@(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.
}

Trabajar con rutas de acceso de archivos y carpetas en el código

A menudo, trabajará con rutas de acceso de archivos y carpetas en el código. A continuación se muestra un ejemplo de una estructura de carpetas físicas para un sitio Web tal y como podría aparecer en el equipo de desarrollo:

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

Estos son algunos detalles esenciales sobre las direcciones URL y las rutas de acceso:

• Una dirección URL comienza con un nombre de dominio (http://www.example.com) o un nombre de servidor (http://localhost, http://mycomputer).
• Una dirección URL corresponde a una ruta de acceso física en un equipo host. Por ejemplo, http://myserver podría corresponder a la carpeta C:\websites\mywebsite del servidor.
• Una ruta de acceso virtual es una forma abreviada de representar las rutas de acceso en el código sin tener que especificar la ruta de acceso completa. Incluye la parte de una dirección URL que sigue al nombre de dominio o de servidor. Al usar las rutas de acceso virtuales, puede trasladar el código a otro dominio o servidor sin tener que actualizar las rutas de acceso.

Este es un ejemplo para ayudarle a comprender las diferencias:

La raíz virtual es/, al igual que la raíz de la unidad C: . (Las rutas de acceso de carpeta virtual siempre usan barras diagonales). La ruta de acceso virtual de una carpeta no tiene que tener el mismo nombre que la carpeta física; puede ser un alias. (En servidores de producción, la ruta de acceso virtual rara vez coincide con una ruta de acceso física exacta).

Cuando se trabaja con archivos y carpetas en el código, a veces es necesario hacer referencia a la ruta de acceso física y, en ocasiones, a una ruta de acceso virtual, en función de los objetos con los que esté trabajando. ASP.NET proporciona estas herramientas para trabajar con rutas de acceso de archivos y carpetas en el código: el método Server.MapPath y el operador ~ y el método Href.

Conversión de rutas de acceso virtuales a físicas: el método Server. MapPath

El método Server.MapPath convierte una ruta de acceso virtual (como /default.cshtml) en una ruta de acceso física absoluta (como C:\WebSites\MyWebSiteFolder\default.cshtml). Utilice este método siempre que necesite una ruta de acceso física completa. Un ejemplo típico es al leer o escribir un archivo de texto o de imagen en el servidor Web.

Normalmente, no se conoce la ruta de acceso física absoluta del sitio en el servidor de un sitio de hospedaje, por lo que este método puede convertir la ruta de acceso que se conoce (la ruta de acceso virtual) en la ruta de acceso correspondiente en el servidor. Pasa la ruta de acceso virtual a un archivo o una carpeta al método y devuelve la ruta de acceso física:

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

Referencia a la raíz virtual: el operador ~ y el método href

En un archivo . cshtml o . vbhtml , puede hacer referencia a la ruta de acceso de la raíz virtual mediante el operador ~. Esto es muy útil porque puede mover páginas en un sitio y los vínculos que contienen a otras páginas no se romperán. También es útil en caso de que se mueva el sitio web a una ubicación diferente. A continuación se muestran algunos ejemplos:

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

Si el sitio web está http://myserver/myapp, aquí se muestra cómo ASP.NET tratará estas rutas de acceso cuando se ejecute la página:

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

(En realidad, no verá estas rutas de acceso como los valores de la variable, pero ASP.NET tratará las rutas de acceso como si eso fuera).

Puede usar el operador ~ en el código del servidor (como arriba) y en el marcado, como se indica a continuación:

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

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

En el marcado, se usa el operador ~ para crear rutas de acceso a recursos como archivos de imagen, otras páginas web y archivos CSS. Cuando se ejecuta la página, ASP.NET busca en la página (código y marcado) y resuelve todas las referencias de ~ a la ruta de acceso adecuada.

Lógica y bucles condicionales

El código de servidor ASP.NET permite realizar tareas basadas en condiciones y escribir código que repite instrucciones un número específico de veces (es decir, código que ejecuta un bucle).

Condiciones de prueba

Para probar una condición simple, use la instrucción if, que devuelve true o false en función de una prueba que especifique:

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

La palabra clave if inicia un bloque. La prueba real (condición) está entre paréntesis y devuelve true o false. Las instrucciones que se ejecutan si la prueba es true se incluyen entre llaves. Una instrucción if puede incluir un bloque de else que especifica las instrucciones que se ejecutarán si la condición es falsa:

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

Puede agregar varias condiciones mediante un bloque else if:

@{
    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>
    }
}

En este ejemplo, si la primera condición del bloque If no es true, se comprueba la condición else if. Si se cumple esta condición, se ejecutan las instrucciones del bloque else if. Si no se cumple ninguna de las condiciones, se ejecutan las instrucciones del bloque else. Puede agregar cualquier número de bloques else if y, a continuación, cerrar con un bloque else como el "todo lo demás" condición.

Para probar un gran número de condiciones, use un bloque switch:

@{
    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>
}

El valor que se va a probar se encuentra entre paréntesis (en el ejemplo, la variable weekday). Cada prueba individual utiliza una instrucción case que termina con dos puntos (:). Si el valor de una instrucción case coincide con el valor de prueba, se ejecuta el código de ese bloque de casos. Cierre cada instrucción case con una instrucción break. (Si olvida incluir break en cada bloque case, el código de la siguiente instrucción case se ejecutará también). Un bloque switch suele tener una instrucción default como el último caso para un "todo lo demás" opción que se ejecuta si no se cumple ninguno de los otros casos.

El resultado de los dos últimos bloques condicionales mostrados en un explorador:

Código de bucle

A menudo es necesario ejecutar las mismas instrucciones varias veces. Para ello, puede crear un bucle. Por ejemplo, a menudo se ejecutan las mismas instrucciones para cada elemento en una colección de datos. Si sabe exactamente cuántas veces desea crear un bucle, puede usar un bucle for. Este tipo de bucle es especialmente útil para la acumulación o el recuento:

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

El bucle comienza con la palabra clave for, seguido de tres instrucciones entre paréntesis, cada una termina con un punto y coma.

• Dentro de los paréntesis, la primera instrucción (var i=10;) crea un contador y lo inicializa en 10. No tiene que asignar un nombre al contador — i puede usar cualquier variable. Cuando se ejecuta el bucle for, el contador se incrementa automáticamente.
• La segunda instrucción (i < 21;) establece la condición de cuánto desea contar. En este caso, desea que pase a un máximo de 20 (es decir, continúe mientras el contador sea inferior a 21).
• La tercera instrucción (i++) utiliza un operador de incremento, que simplemente especifica que el contador debería tener 1 agregado cada vez que se ejecuta el bucle.

Dentro de las llaves está el código que se ejecutará para cada iteración del bucle. El marcado crea un nuevo párrafo (elemento<p>) cada vez y agrega una línea a la salida, mostrando el valor de i (el contador). Al ejecutar esta página, en el ejemplo se crean 11 líneas que muestran la salida, con el texto en cada línea que indica el número de elemento.

Si está trabajando con una colección o una matriz, a menudo utiliza un bucle foreach. Una colección es un grupo de objetos similares y el bucle foreach le permite llevar a cabo una tarea en cada elemento de la colección. Este tipo de bucle es práctico para las colecciones, porque a diferencia de un bucle for, no tiene que incrementar el contador o establecer un límite. En su lugar, el código de bucle foreach simplemente continúa a través de la colección hasta que termina.

Por ejemplo, el código siguiente devuelve los elementos de la colección Request.ServerVariables, que es un objeto que contiene información sobre el servidor Web. Usa un bucle foreac h para mostrar el nombre de cada elemento mediante la creación de un nuevo elemento <li> en una lista con viñetas HTML.

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

La palabra clave foreach va seguida de paréntesis en el que se declara una variable que representa un único elemento de la colección (en el ejemplo, var item), seguido de la palabra clave in, seguido de la colección a la que se desea crear un bucle. En el cuerpo del bucle foreach, puede tener acceso al elemento actual mediante la variable que declaró anteriormente.

Para crear un bucle de uso más general, use la instrucción while:

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

Un bucle while comienza con la palabra clave while, seguido de paréntesis en el que se especifica cuánto tiempo continúa el bucle (aquí, siempre y cuando countNum sea inferior a 50), después el bloque que se va a repetir. Los bucles suelen incrementar (agregar a) o disminuir (restar de) una variable o un objeto que se usa para el recuento. En el ejemplo, el operador += agrega 1 a countNum cada vez que se ejecuta el bucle. (Para reducir una variable en un bucle que se recuenta, se usaría el operador de decremento -=).

Objetos y colecciones

Casi todo en un sitio web de ASP.NET es un objeto, incluida la propia página web. En esta sección se describen algunos objetos importantes con los que trabajará con frecuencia en el código.

Objetos de página

El objeto más básico de ASP.NET es la página. Puede tener acceso directamente a las propiedades del objeto de página sin ningún objeto calificador. En el código siguiente se obtiene la ruta de acceso del archivo de la página mediante el Request objeto de la página:

@{
    var path = Request.FilePath;
}

Para aclarar que está haciendo referencia a las propiedades y los métodos del objeto de página actual, puede usar opcionalmente la palabra clave this para representar el objeto de página en el código. Este es el ejemplo de código anterior, con this agregados para representar la página:

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

Puede utilizar las propiedades del objeto Page para obtener una gran cantidad de información, como:

• RequestOperador Como ya ha visto, se trata de una colección de información sobre la solicitud actual, incluido el tipo de explorador que realizó la solicitud, la dirección URL de la página, la identidad del usuario, etc.

• ResponseOperador Se trata de una colección de información sobre la respuesta (página) que se enviará al explorador cuando el código del servidor haya terminado de ejecutarse. Por ejemplo, puede usar esta propiedad para escribir información en la respuesta.

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

Objetos de colección (matrices y diccionarios)

Una colección es un grupo de objetos del mismo tipo, como una colección de objetos Customer de una base de datos. ASP.NET contiene muchas colecciones integradas, como la Request.Files colección.

A menudo, trabajará con los datos de las colecciones. Dos tipos de colección comunes son la matriz y el Diccionario. Una matriz es útil cuando desea almacenar una colección de elementos similares pero no desea crear una variable independiente que contenga cada elemento:

@* 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>
    }
}

Con las matrices, se declara un tipo de datos específico, como string, into DateTime. Para indicar que la variable puede contener una matriz, agregue corchetes a la declaración (por ejemplo, string[] o int[]). Puede tener acceso a los elementos de una matriz mediante su posición (índice) o mediante la instrucción foreach. Los índices de matriz son de base — cero, es decir, el primer elemento está en la posición 0, el segundo elemento está en la posición 1, y así sucesivamente.

@{
    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>
    }
}

Puede determinar el número de elementos de una matriz obteniendo su Length propiedad. Para obtener la posición de un elemento específico en la matriz (para buscar en la matriz), use el método Array.IndexOf. También puede hacer cosas como invertir el contenido de una matriz (el método Array.Reverse) u ordenar el contenido (el método Array.Sort).

La salida del código de la matriz de cadenas que se muestra en un explorador:

Un diccionario es una colección de pares clave-valor, donde se proporciona la clave (o nombre) para establecer o recuperar el valor correspondiente:

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

Para crear un diccionario, use la palabra clave new para indicar que está creando un nuevo objeto de diccionario. Puede asignar un diccionario a una variable mediante la palabra clave var. Los tipos de datos de los elementos del diccionario se indican mediante corchetes angulares (< >). Al final de la declaración, debe agregar un par de paréntesis, porque en realidad es un método que crea un nuevo diccionario.

Para agregar elementos al diccionario, puede llamar al método Add de la variable Dictionary (myScores en este caso) y, a continuación, especificar una clave y un valor. Como alternativa, puede usar corchetes para indicar la clave y realizar una asignación simple, como en el ejemplo siguiente:

myScores["test4"] = 79;

Para obtener un valor del diccionario, especifique la clave entre corchetes:

var testScoreThree = myScores["test3"];

Llamar a métodos con parámetros

Tal como se ha leído anteriormente en este artículo, los objetos con los que programa pueden tener métodos. Por ejemplo, un objeto de Database podría tener un método Database.Connect. Muchos métodos también tienen uno o más parámetros. Un parámetro es un valor que se pasa a un método para que el método pueda completar su tarea. Por ejemplo, examine una declaración para el método Request.MapPath, que toma tres parámetros:

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

(La línea se ha ajustado para que sea más legible. Recuerde que puede colocar los saltos de línea prácticamente en cualquier lugar excepto en las cadenas entre comillas).

Este método devuelve la ruta de acceso física en el servidor que corresponde a una ruta de acceso virtual especificada. Los tres parámetros del método son virtualPath, baseVirtualDiry allowCrossAppMapping. (Observe que en la declaración, los parámetros se enumeran con los tipos de datos de los datos que aceptarán). Cuando llame a este método, debe proporcionar valores para los tres parámetros.

El sintaxis Razor proporciona dos opciones para pasar parámetros a un método: parámetros posicionales y parámetros con nombre. Para llamar a un método mediante parámetros posicionales, se pasan los parámetros en un orden estricto que se especifica en la declaración del método. (Normalmente se conoce este orden leyendo la documentación del método). Debe seguir el orden y no puede omitir ninguno de los parámetros — si es necesario, pasa una cadena vacía ("") o null para un parámetro posicional para el que no tiene un valor.

En el ejemplo siguiente se da por supuesto que tiene una carpeta denominada scripts en el sitio Web. El código llama al método Request.MapPath y pasa los valores de los tres parámetros en el orden correcto. A continuación, se muestra la ruta de acceso asignada resultante.

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

Cuando un método tiene muchos parámetros, puede mantener el código más legible mediante el uso de parámetros con nombre. Para llamar a un método con parámetros con nombre, especifique el nombre del parámetro seguido de un signo de dos puntos (:) y, a continuación, el valor. La ventaja de los parámetros con nombre es que puede pasarlos en cualquier orden que desee. (Una desventaja es que la llamada al método no es tan compacta).

En el ejemplo siguiente se llama al mismo método que el anterior, pero se usan parámetros con nombre para proporcionar los valores:

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

Como puede ver, los parámetros se pasan en un orden diferente. Sin embargo, si ejecuta el ejemplo anterior y este ejemplo, devolverán el mismo valor.

Control de errores

Instrucciones try-catch

A menudo tendrá instrucciones en el código que podrían producir errores por motivos ajenos al control. Por ejemplo:

• Si el código intenta crear o tener acceso a un archivo, puede producirse todo tipo de errores. Es posible que el archivo que desea no exista, que esté bloqueado, que el código no tenga permisos, etc.
• Del mismo modo, si el código intenta actualizar registros en una base de datos, puede haber problemas con los permisos, que la conexión a la base de datos se haya quitado, que los datos que se van a guardar no sean válidos, etc.

En términos de programación, estas situaciones se denominan excepciones. Si el código encuentra una excepción, genera (lanza) un mensaje de error que, en el mejor de los usuarios, le molesta:

En situaciones en las que el código pueda encontrar excepciones y para evitar los mensajes de error de este tipo, puede usar try/catch instrucciones. En la instrucción try, ejecute el código que está comprobando. En una o varias instrucciones de catch, puede buscar errores específicos (tipos específicos de excepciones) que puedan haberse producido. Puede incluir tantas instrucciones catch como necesite para buscar los errores que espera.

En el ejemplo siguiente se muestra una página que crea un archivo de texto en la primera solicitud y, a continuación, muestra un botón que permite al usuario abrir el archivo. En el ejemplo se usa deliberadamente un nombre de archivo incorrecto para que se produzca una excepción. El código incluye catch instrucciones para dos posibles excepciones: FileNotFoundException, que se produce si el nombre de archivo es incorrecto y DirectoryNotFoundException, que se produce si ASP.NET no puede incluso encontrar la carpeta. (Puede quitar el comentario de una instrucción en el ejemplo para ver cómo se ejecuta cuando todo funciona correctamente).

Si el código no controla la excepción, verá una página de error como la captura de pantalla anterior. Sin embargo, la sección try/catch ayuda a evitar que el usuario vea estos tipos de errores.

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

Recursos adicionales

Programar con Visual Basic

Apéndice: lenguaje de Visual Basic y sintaxis

Documentación de referencia

ASP.NET

C#Módulo