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

por Tom FitzMacken

En este artículo se proporciona una visión general de la programación con ASP.NET Web Pages, utilizando la 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 uso del lenguaje de programación de C#.

Aprenderá lo siguiente:

Las 8 mejores sugerencias de programación para empezar a programar ASP.NET Web Pages mediante la sintaxis de Razor.

Conceptos básicos de programación que necesitará.

De qué se trata el código del servidor ASP.NET y la sintaxis de 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 absolutamente necesita saber a medida que empieza a escribir código de servidor ASP.NET mediante la sintaxis de Razor.

Nota:

La sintaxis de Razor se basa en el lenguaje de programación de C# y es el lenguaje que se usa con más frecuencia con ASP.NET Web Pages. Sin embargo, la sintaxis de Razor también admite el lenguaje Visual Basic, y todo lo que puede ver también puede hacerse en Visual Basic. Para obtener más información, consulte el apéndice Lenguaje y sintaxis de Visual Basic.

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

1. Agregar código a una página con el carácter @

El @ carácter inicia expresiones insertadas, bloques de instrucción única y 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:

Razor-Img1

Sugerencia

Codificación HTML

Al mostrar contenido en una página con el @ carácter , como en los ejemplos anteriores, ASP.NET codifica la salida en HTML. Esto reemplaza los caracteres HTML reservados (como < y y >&) por códigos que permiten que los caracteres se muestren como caracteres en una página web en lugar de interpretarse como etiquetas HTML o entidades. Sin codificación HTML, es posible que la salida del código del servidor no se muestre correctamente y podría exponer una página a riesgos de seguridad.

Si el objetivo es generar marcado HTML que represente etiquetas como marcado (por ejemplo  , para un párrafo o  para resaltar texto), consulte la sección Combinación de texto, marcado y código en bloques de código más adelante en este artículo.

Puede obtener más información sobre la codificación HTML en Trabajar con formularios.

2. Encierras bloques de código entre llaves

Un bloque de código incluye una o varias instrucciones de código y se incluye 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 que se muestra en un explorador:

Razor-Img2

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 completa debe terminar con un punto y coma. Las expresiones en línea no terminan 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. Las variables se usan para almacenar valores

Puede almacenar valores en una variable, incluidas cadenas, números y fechas, etc. Cree una variable con la var palabra clave . Puede insertar valores de variable 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 que se muestra en un explorador:

Razor-Img3

5. Incluya valores de cadena literal entre comillas dobles

Una cadena es una secuencia de caracteres que se tratan como texto. Para especificar una cadena, debe incluirla 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 una cadena de texto literal que tenga el operador @ como prefijo. (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 del uso de ambos ejemplos en una página:

Razor-Img4

Nota:

Tenga en cuenta que el carácter @ se usa tanto para marcar literales de cadena en C# como para marcar el código en las páginas de ASP.NET.

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

En C#, las palabras clave (como var, true, y if) y los nombres de las variables son sensibles a mayúsculas y minúsculas. Las siguientes líneas de código crean dos variables diferentes y lastNameLastName.

@{
    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á el valor "Jones" en lugar de "Smith".

Nota:

En Visual Basic, palabras clave y variables no distinguen mayúsculas de minúsculas.

7. Gran parte de la codificación implica objetos

Un objeto representa un elemento con el que puede programar: 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 se pueden leer o cambiar: un objeto de cuadro de texto tiene una Text propiedad (entre otros), un objeto de solicitud tiene una Url propiedad, un mensaje de correo electrónico tiene una From propiedad y un objeto customer tiene una FirstName propiedad . Los objetos también tienen métodos, que son los "verbos" que pueden ejecutar. Algunos ejemplos incluyen el método de un objeto de archivo Save, el método de un objeto de imagen Rotate, y el método de un objeto de correo electrónico Send.

A menudo trabajará con el Request objeto , que proporciona información como los valores de cuadros de texto (campos de formulario) en la página, qué tipo de explorador 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 Request objeto y cómo llamar al MapPath método del Request objeto , 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 que se muestra en un explorador:

Razor-Img5

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 manera más común de hacerlo es con la if instrucción (y la instrucción opcional else ).

@{
   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 if las instrucciones , hay varias maneras de probar condiciones, repetir bloques de código, etc., que se describen más adelante en este artículo.

Resultado que se muestra en un explorador (después de hacer clic en Enviar):

Razor-Img6

Sugerencia

Métodos HTTP GET y POST y la propiedad IsPost

El protocolo usado para páginas web (HTTP) admite un número muy limitado de métodos (verbos) que se usan para realizar solicitudes al servidor. Los dos más comunes son GET, que se usa para leer una página y POST, que se usa para enviar una página. En general, la primera vez que un usuario solicita una página, la página se solicita mediante GET. Si el usuario rellena un formulario y, a continuación, hace clic en un botón enviar, el explorador realiza una solicitud POST al servidor.

En la programación web, a menudo resulta útil saber si se solicita una página como GET o como POST para que sepa cómo procesar la página. En ASP.NET Páginas web, puede usar la IsPost propiedad para ver si una solicitud es GET o POST. Si la solicitud es POST, la IsPost propiedad devolverá "true", y podrá, por ejemplo, leer los valores de los cuadros de texto de un formulario. Muchos ejemplos que verá muestran cómo procesar la página de forma diferente en función del valor de IsPost.

Un ejemplo de código sencillo

Este procedimiento muestra cómo crear una página que muestre técnicas de programación básicas. En el ejemplo, se crea una página que permite a los usuarios escribir dos números y, a continuación, se agregan y se muestra el resultado.

En el editor, cree un nuevo archivo y asígnele el nombre AddNumbers.cshtml.
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>
 Enter two whole numbers and then click Add.
 <form action="" method="post">
 <label for="text1">First Number:</label>
 <input type="text" name="text1" />
 
 <label for="text2">Second Number:</label>
 <input type="text" name="text2" />
 
 <input type="submit" value="Add" />
 </form>

 @totalMessage

</body>
</html>
```
Estas son 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 totalMessage variable incrustada cerca de la parte inferior de la página.
- El bloque situado en la parte superior de la página está 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 totalMessage variable está entre comillas dobles.
- Dado que el código distingue mayúsculas de minúsculas, cuando la totalMessage variable se usa cerca de la parte inferior de la página, su nombre debe coincidir exactamente con la variable de la parte superior.
- La expresión num1.AsInt() + num2.AsInt() muestra cómo trabajar con objetos y métodos. El AsInt método de cada variable convierte la cadena especificada por un usuario en un número (un entero) para que pueda realizar la aritmética en ella.
- La <form> etiqueta incluye un method="post" atributo . Esto especifica que cuando el usuario hace clic en Agregar, la página se enviará al servidor mediante el método HTTP POST. Cuando se envía la página, la if(IsPost) prueba se evalúa como true y el código condicional se ejecuta, mostrando el resultado de agregar los números.
Guarde la página y ejecútelo 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 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 recorrido rápido por los conceptos de programación que usará con más frecuencia. Incluso así, cubre casi todo lo que necesitará para comenzar con ASP.NET Web Pages.

Pero primero, un poco de experiencia técnica.

Sintaxis de Razor, código de servidor y ASP.NET

La sintaxis de 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 usa la sintaxis de Razor, hay dos tipos de contenido: contenido de cliente y código de servidor. El contenido del cliente es el contenido que se usa en 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.

La sintaxis de 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 ese código primero, antes de enviar la página al explorador. Al ejecutarse en el servidor, el código puede realizar tareas que pueden ser mucho más complejas mediante el uso de contenido de cliente solo, como el acceso a bases de datos basadas en servidor. Lo más importante es que el código de servidor puede crear dinámicamente contenido de cliente; puede generar marcado HTML u otro contenido sobre la marcha y, a continuación, enviarlo al explorador junto con cualquier HTML estático que pueda contener la página. Desde la perspectiva del explorador, el contenido de cliente generado por el código de servidor no es diferente de ningún otro contenido de cliente. Como ya ha visto, el código de servidor necesario es bastante sencillo.

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

¿Dónde encaja ASP.NET?

La sintaxis de Razor se basa en una tecnología de Microsoft denominada ASP.NET, que a su vez se basa en Microsoft .NET Framework. The.NET Framework es un marco de programación grande y completo de Microsoft para desarrollar prácticamente cualquier tipo de aplicación informática. ASP.NET es la parte de .NET Framework diseñada específicamente para crear aplicaciones web. Los desarrolladores han usado ASP.NET para crear muchos de los sitios web más grandes y con mayor tráfico del mundo. (Cada vez que vea la extensión de nombre de archivo .aspx como parte de la dirección URL en un sitio, sabrá que el sitio se escribió mediante ASP.NET).

La sintaxis de Razor le ofrece toda la eficacia de ASP.NET, pero con una sintaxis simplificada que es más fácil de aprender si es principiante y que le hace más productivo si es un experto. Aunque esta sintaxis es sencilla de usar, su relación familiar con ASP.NET y .NET Framework significa que a medida que los sitios web se vuelven más sofisticados, tiene la potencia de los frameworks más grandes a su disposición.

Razor-Img8

Sugerencia

Clases e instancias

ASP.NET código de servidor usa objetos, que a su vez se basan en la idea de las clases. La clase es la definición o plantilla de un objeto . Por ejemplo, una aplicación podría contener una Customer clase que define las propiedades y los métodos que necesita cualquier objeto de cliente.

Cuando la aplicación necesita trabajar con información real del cliente, crea una instancia de (o instancia) un objeto de cliente. Cada cliente individual es una instancia independiente de la Customer clase . Cada instancia admite las mismas propiedades y métodos, pero los valores de propiedad de cada instancia suelen ser diferentes, ya que cada objeto de cliente es único. En un objeto de cliente, la LastName propiedad podría ser "Smith"; en otro objeto de cliente, la LastName propiedad podría ser "Jones".

Del mismo modo, cualquier página web individual del sitio es un Page objeto que es una instancia de la Page clase . Un botón de la página es un Button objeto que es una instancia de la Button clase, etc. Cada instancia tiene sus propias características, pero todas se basan en lo que se especifica en la definición de clase del objeto.

Sintaxis básica

Anteriormente usted vio un ejemplo básico de cómo crear una página de ASP.NET Web Pages y cómo puede agregar código del servidor al código HTML. Aquí aprenderá los conceptos básicos de escribir código de servidor ASP.NET mediante la sintaxis de 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 ha leído aquí será familiar. Probablemente deba familiarizarse únicamente con cómo se agrega el código de servidor al marcado en archivos .cshtml.

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

En los bloques de código del servidor, a menudo se desea generar 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, debe representarse tal como está, ASP.NET debe poder distinguir ese texto del código. Hay varias maneras de hacerlo.

Incluya el texto en un elemento HTML como  o :
```
@if(IsPost) {
 // This line has all content between matched tags.
 Hello, the time is @DateTime.Now and this page is a postback!
} else {
 // All content between matched tags, followed by server code.
 Hello stranger, today is: @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, ), representa todo lo que incluye el elemento y su contenido como está en el explorador, resolviendo expresiones de código de servidor a medida que va.
Use el @: operador o el <text> elemento . El @: genera una sola línea de contenido que contiene texto sin formato o etiquetas HTML no coincidentes; el elemento <text> abarca 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: @DateTime.Now
 
 // Server code and then plain text, matched tags, and more text.
 @DateTime.Now @:is the current time.
}
```
Si desea generar varias líneas de texto o etiquetas HTML no coincidentes, puede preceder a cada línea con @:o puede incluir la línea en un <text> elemento . Al igual que el operador @:, ASP.NET usa etiquetas <text> para identificar el contenido de texto y nunca se representan en la salida de la página.
```
@if(IsPost) {
 // Repeat the previous example, but use <text> tags.
 <text>
 The time is: @DateTime.Now
 
 @DateTime.Now is the current time.
 </text>
}

@{
 var minTemp = 75;
 <text>It is the month of @DateTime.Now.ToString("MMMM"), and
 it's a great day! You can go swimming if it's at
 least @minTemp degrees. </text>
}
```
En el primer ejemplo se repite el ejemplo anterior, pero se usa un único par de <text> etiquetas para incluir el texto que se va a representar. En el segundo ejemplo, las etiquetas <text> y </text> encierran tres líneas, todas las cuales tienen texto no contenido y etiquetas HTML incompatibles ( ), junto con el código de servidor y las etiquetas HTML coincidentes. De nuevo, también podría preceder cada línea individualmente con el @: operador; en cualquier caso, funciona.

Nota:

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

Espacio en blanco

Los espacios adicionales en una instrucción (y fuera de una cadena literal) 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 encapsular instrucciones para mejorar la legibilidad. Las siguientes declaraciones son iguales:

@{ var theName =
"Smith"; }

@{
    var
    personName
    =
    "Smith"
    ;
}

Sin embargo, no se puede encapsular 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 de texto, como vio anteriormente en este artículo. Puede dividir literales de cadena de texto entre líneas:

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

Comentarios de código (y marcado)

Los comentarios le permiten dejar notas para usted o para otros. También le permiten deshabilitar (comentar) una sección de código o marcado que no desea ejecutar, sino que quiere mantener en la página por el momento.

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

Para ASP.NET comentarios de Razor, inicie el comentario con @* y termine con *@. El comentario puede estar en una línea 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á usando, como C#:

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

En C#, los comentarios de una sola línea van precedidos de los caracteres //, y los comentarios de varias líneas comienzan por /* y terminan con */. (Al igual que con los comentarios de Razor, los comentarios de C# 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 . Puede usar comentarios HTML para rodear no solo el texto, sino también cualquier marcado HTML que quiera mantener en la página, pero no desea representar. 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 de C#. Para obtener más información, vea Variables de C# con nombre y bloques anidados generan código defectuoso.

Variables

Una variable es un objeto con nombre que se usa para almacenar datos. Puede asignar un nombre a las variables cualquier cosa, pero el nombre debe comenzar con 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 almacena en la variable. Puede tener variables de cadena que almacenen valores de cadena (como "Hola mundo"), variables enteras que almacenen valores enteros (como 3 o 79) y variables de fecha que almacenen valores de fecha en diversos 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 pueden averiguar el tipo en función de cómo se usan los datos de la variable. (En ocasiones, debes especificar un tipo; verás ejemplos en los que esto es cierto).

Declara una variable mediante la var palabra clave (si no desea especificar un tipo) o mediante 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 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:

Razor-Img9

Conversión y prueba de tipos de datos

Aunque ASP.NET normalmente pueden determinar automáticamente un tipo de datos, a veces no puede hacerlo. Por lo tanto, es posible que tenga que ayudar a ASP.NET realizando una conversión explícita. Incluso si no tienes que convertir tipos, a veces resulta útil comprobar qué tipo de datos podrías estar manejando.

El caso más común es que tiene que convertir una cadena a 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();
    }
}

Por regla general, la entrada del usuario se recibe como cadenas. Incluso si has solicitado a los usuarios que escriban un número e incluso si han escrito un dígito, cuando se envía la entrada del usuario y se 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 la aritmética en los valores sin convertirlos, se produce el siguiente error, ya que ASP.NET no puede agregar dos cadenas:

No se puede convertir implícitamente el tipo 'string' en '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 comunes de conversión y prueba para variables.

Método

Descripción

Ejemplo

AsInt(), IsInt()

Convierte una cadena que representa un número entero (como "593") en un entero.

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

AsBool(), IsBool()

Convierte una cadena como "true" o "false" en un tipo booleano.

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

AsFloat(), IsFloat()

Convierte una cadena que tiene un valor decimal como "1,3" o "7,439" en un número de punto flotante.

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

AsDecimal(), IsDecimal()

Convierte una cadena que tiene un valor decimal como "1,3" o "7,439" en un número decimal. (En ASP.NET, un número decimal es más preciso que un número de punto flotante).

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

AsDateTime(), IsDateTime()

Convierte una cadena que representa un valor de fecha y hora en el tipo ASP.NET DateTime .

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

ToString()

Convierte cualquier otro tipo de datos en una cadena.

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 ASP.NET qué tipo de comando realizar en una expresión. El lenguaje C# (y la sintaxis de Razor que se basa en él) admite muchos operadores, pero solo tiene que reconocer algunos para empezar. En la tabla siguiente se resumen los operadores más comunes.

Operador

Descripción

Ejemplos

+ - * /

Operadores matemáticos usados en expresiones numéricas.

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

=

Asignación. Asigna el valor del lado derecho de una expresión al objeto del lado izquierdo.

var age = 17;

==

Igualdad. Devuelve true si los valores son iguales. (Observe la distinción entre el = operador y el == operador).

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

!=

Desigualdad. Devuelve true si los valores no son iguales.

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

< > <= >=

Menor que, mayor que, menor o igual que y mayor o igual que.

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

+

Concatenación, que se usa para combinar cadenas. ASP.NET conoce la diferencia entre este operador y el operador de suma en función del tipo de datos de la expresión.

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

+= -=

Los operadores de incremento y decremento, que agregan y restan 1 (respectivamente) de una variable.

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

.

Punto. Se usa para distinguir objetos y sus propiedades y métodos.

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

()

Paréntesis. Se usa para agrupar expresiones y para pasar parámetros a métodos.

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

[]

Corchetes. Se usa para acceder a valores en matrices o colecciones.

var income = Request["AnnualIncome"];

!

No. Invierte un true valor en false y viceversa. Normalmente se usa como una manera abreviada de probar false (es decir, para no true).

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

&& ||

Operadores lógicos Y y O, que se usan para enlazar condiciones.

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

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

A menudo trabajarás con rutas de acceso de archivos y carpetas en tu código. Este es un ejemplo de estructura de carpetas físicas para un sitio web tal 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 en el servidor.
Una ruta virtual es una forma abreviada de representar rutas en el código sin tener que especificar la ruta completa. Incluye la parte de una dirección URL que sigue al nombre de dominio o servidor. Al usar rutas de acceso virtuales, puede mover 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:

Dirección URL completa	`http://mycompanyserver/humanresources/CompanyPolicy.htm`
Nombre del servidor	mycompanyserver
Ruta de acceso virtual	/humanresources/CompanyPolicy.htm
Ruta de acceso física	C:\mywebsites\humanresources\CompanyPolicy.htm

La raíz virtual es /, al igual que la raíz de la unidad C: es . (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 los 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, a veces, una ruta de acceso virtual, en función de los objetos con los que se trabaja. ASP.NET proporciona estas herramientas para trabajar con rutas de acceso de archivos y carpetas en código: el método Server.MapPath, el operador ~ y el método Href.

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

El Server.MapPath método convierte una ruta de acceso virtual (como /default.cshtml) en una ruta de acceso física absoluta (como C:\WebSites\MyWebSiteFolder\default.cshtml). Use este método cada vez que necesite una ruta de acceso física completa. Un ejemplo típico es cuando está leyendo o escribiendo un archivo de texto o un archivo de imagen en el servidor web.

Normalmente no conoce la ruta de acceso física absoluta de su sitio en el servidor de un sitio de hospedaje, por lo que este método puede convertir la ruta de acceso que conoce ( la ruta de acceso virtual) a la ruta de acceso correspondiente en el servidor automáticamente. Se pasa la ruta de acceso virtual de un archivo o carpeta al método, y este 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>

Hacer 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 raíz virtual mediante el ~ operador . Esto es muy útil porque puede mover páginas alrededor de un sitio, y los vínculos que contienen a otras páginas no se romperán. También es útil en caso de que alguna vez mueva su sitio web a una ubicación diferente. Estos son algunos ejemplos:

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

Si el sitio web es http://myserver/myapp, este es el modo en que 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 fuera lo que eran).

Puede usar el ~ operador en el código de servidor (como se indicó anteriormente) y en el marcado, de la siguiente manera:

<!-- 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 examina la página (código y marcado) y resuelve todas las ~ referencias a la ruta de acceso adecuada.

Lógica condicional y bucles

ASP.NET código de servidor 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 sencilla, use la if instrucción , que devuelve true o false en función de una prueba que especifique:

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

La if palabra clave inicia un bloque. La prueba actual (condición) está entre paréntesis y devuelve verdadero o falso. Las instrucciones que se ejecutan si la prueba es verdadera están entre llaves. Una if instrucción puede incluir un else bloque que especifica instrucciones que se van a ejecutar si la condición es false:

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

Puede agregar varias condiciones mediante un else if bloque :

@{
    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 else if condición. Si se cumple esa condición, se ejecutan las instrucciones del else if bloque . Si no se cumple ninguna de las condiciones, se ejecutan las instrucciones del else bloque . Puede agregar cualquier número de bloques else if y luego cerrar con un bloque else como la condición "todo sobre los demás".

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

@{
    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 está entre paréntesis (en el ejemplo, la weekday variable ). Cada prueba individual usa una case instrucción que termina con dos puntos (:). Si el valor de una expresión de case instrucción coincide con el valor de prueba, se ejecutará el código en ese bloque de caso. Cierra cada instrucción case con una instrucción break. (Si olvida incluir el break en cada bloque case, también se ejecutará el código de la instrucción del siguiente case). Un bloque switch suele tener una instrucción default como último caso para una opción de "cualquier otro caso" que se ejecuta si ninguno de los otros casos es true.

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

Razor-Img10

Código en bucle

A menudo, debe ejecutar las mismas instrucciones repetidamente. Para ello, se repite un bucle. Por ejemplo, a menudo se ejecutan las mismas instrucciones para cada elemento de una colección de datos. Si sabe exactamente cuántas veces desea repetir el bucle, puede usar un for bucle. Este tipo de bucle es especialmente útil para contar hacia arriba o hacia abajo.

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

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

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

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

Razor-Img11

Si está trabajando con una colección o matriz, a menudo usa un foreach bucle. Una colección es un grupo de objetos similares y el foreach bucle le permite realizar una tarea en cada elemento de la colección. Este tipo de bucle es conveniente para las colecciones, ya que, a diferencia de un for bucle, no es necesario incrementar el contador ni establecer un límite. En su lugar, el código del bucle foreach simplemente avanza a través de la colección hasta que ésta se completa.

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

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

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

Razor-Img12

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

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

Un while bucle comienza con la while palabra clave , seguido de paréntesis donde se especifica cuánto tiempo continúa el bucle (aquí, siempre que countNum sea menor que 50) y, a continuación, el bloque que se repetirá. Los bucles suelen incrementar o disminuir una variable u objeto que se usa para contar. En el ejemplo, el += operador agrega 1 a countNum cada vez que se ejecuta el bucle. (Para disminuir una variable en un bucle que cuenta hacia atrás, 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 a las propiedades del objeto de página directamente sin ningún objeto calificador. El código siguiente 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 hace referencia a propiedades y métodos en el 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 agregado para representar la página:

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

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

Request. 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.
Response. 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 de una base de Customer datos. ASP.NET contiene muchas colecciones integradas, como la Request.Files colección .

A menudo, usted trabajará con datos en colecciones. Dos tipos de colección comunes son el array y el diccionario. Una matriz es útil cuando desea almacenar una colección de elementos similares, pero no desea crear una variable independiente para contener 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 (como string[] o int[]). Puede acceder a los elementos de una matriz mediante su posición (índice) o mediante la foreach instrucción . Los índices de matriz se basan en cero, es decir, el primer elemento está en la posición 0, el segundo elemento está en la posición 1, etc.

@{
    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 Array.IndexOf método . También puede hacer cosas como invertir el contenido de una matriz (el Array.Reverse método) o ordenar el contenido (el Array.Sort método).

Salida del código de matriz de cadenas que se muestra en un explorador:

Razor-Img13

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 new palabra clave para indicar que va a crear un nuevo objeto de diccionario. Puede asignar un diccionario a una variable mediante la var palabra clave . 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, ya que en realidad es un método que crea un nuevo diccionario.

Para agregar elementos al diccionario, puede llamar al Add método 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 sencilla, 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

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

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

(La línea se ha dividido para que sea más legible. Recuerde que puede colocar saltos de línea en casi cualquier lugar excepto dentro de 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). Al llamar a este método, debe proporcionar valores para los tres parámetros.

La sintaxis de 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 especificado en la declaración de método. (Normalmente, conocería 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, pasar una cadena vacía ("") o null un parámetro posicional para el que no tenga ningún valor.

En el ejemplo siguiente se supone que tiene una carpeta denominada scripts en el sitio web. El código llama al Request.MapPath método y pasa valores para los tres parámetros en el orden correcto. A continuación, muestra la ruta de acceso mapeada 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 parámetros con nombre. Para llamar a un método mediante parámetros con nombre, especifique el nombre del parámetro seguido 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 concisa).

En el ejemplo siguiente se llama al mismo método que antes, 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á el mismo valor.

Manejo de errores

Declaraciones Try-Catch

A menudo, tendrá declaraciones en su código que podrían fallar por motivos fuera de su control. Por ejemplo:

Si el código intenta crear o acceder a un archivo, puede producirse todo tipo de errores. Es posible que el archivo que desee no exista, podría estar bloqueado, es posible que el código no tenga permisos, etc.
Del mismo modo, si el código intenta actualizar los registros de una base de datos, puede haber problemas de permisos, es posible que se quite la conexión a la base de datos, los datos que se guardarán podrían no ser válidos, etc.

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

Razor-Img14

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

Nota:

Se recomienda evitar el uso del método Response.Redirect en declaraciones try/catch, ya que puede provocar una excepción en tu página.

En el ejemplo siguiente se muestra una página que crea un archivo de texto en la primera solicitud y, a continuación, se muestra un botón que permite al usuario abrir el archivo. En el ejemplo se usa deliberadamente un nombre de archivo incorrecto para que cause 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 ocurre si ASP.NET ni siquiera puede encontrar la carpeta. (Puede descomentar una línea en el ejemplo para ver cómo se ejecuta cuando todo funciona correctamente).

Si el código no controló la excepción, verá una página de error como la captura de pantalla anterior. Sin embargo, la try/catch sección 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

Programación con Visual Basic

Apéndice: Lenguaje y sintaxis de Visual Basic

Documentación de referencia

ASP.NET

Lenguaje C#

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2026-03-27