Declarações "using" e nomes completamente qualificados (fully qualified names)

As vezes é necessário trabalhar com um componente (ou classe) que está disponível na biblioteca .NET Framework, mas que não está totalmente disponível para páginas utilizando Razor.

É possível fazer isso de duas maneiras:

- Fully qualified name

A primeira maneira é utilizar um nome totalmente qualificado para o componente. Esse nome não será apenas o nome da classe, mas também o namespace que contém a referida classe.

O namespace é uma coleção - como se fosse uma biblioteca - que contém classes relacionadas, tornando prática a tarefa de organizar milhares de classes no .NET Framework.

Ao fornecer um nome totalmente qualificado, é possível certificar-se que o ASP.NET poderá encontrar a classe que será utilizada quando a página for executada.

Por exemplo, a classe DataSet está no namespace System.Data. Esse namespace não está disponível automaticamente para páginas Razor ASP.NET. Portanto, para trabalhar com a classe DataSet utilizando seu fully qualified name, podemos utilizar o seguinte código:

var dataSet = new System.Data.DataSet();

- Using

Caso seja necessário utilizar a classe DataSet várias vezes no mesmo documento (ou quaisquer outras classes do namespace System.Data), essa pode não ser a melhor forma de declarar. Como alternativa, portanto, é possível importar um namespace.

Para fazer isso, é possível utilizar a instrução using. Dessa forma, não é necessário utilizar nomes totalmente qualificados para classes desse namespace:

@using System.Data; 
@{ 
     var dataSet = new DataSet(); 
     // etc. 
}

Observe que sempre que o namespace for importado, o ASP.NET saberá onde pesquisar para encontrar a classe que está sendo referenciada.

[Parte 2] Capítulo 6: Como exibir dados utilizando o helper WebGrid

Este procedimento mostrará como exibir dados em um helper WebGrid utilizando configurações simples.

1 - Abra o website "Padaria" criado nos posts anteriores. Se você não possui as páginas criadas anteriormente, não será necessário criá-las. Entretanto, será necessário o banco de dados "padaria.sdf", criado no post Como criar e configurar um banco de dados. Este arquivo deve estar na pasta App_Data do site que você estiver trabalhando.

2 - Na pasta raiz do site, crie um arquivo CSHTML chamado WebGridBasico.cshtml.

3 - Substitua a marcação pela marcação abaixo:

Em primeiro lugar, o código abrirá o banco de dados "padaria.sdf" e criará uma declaração SQL:

SELECT * FROM Produto ORDER BY Id

A variável chamada "dado" será populada com os dados retornados pela declaração SELECT. O helper WebGrid é utiolizado então para criar uma tabela a partir dos dados:

var dado = db.QUery(selectQueryString);
var grid = new WebGrid(dado);

O código cria um novo objeto do tipo WebGrid e o atribui à variável "grid". No corpo da página, os dados serão renderizados utilizando o helper WebGrid utilizando o seguinte código:

@grid.GetHtml()

4 - Execute a página. O WebGrid renderizará uma tabela HTML que contem os dados selecionados através da declaração SELECT.

[Parte 3] Capítulo 5: Como criar e configurar um banco de dados

Este procedimento mostra como criar um banco de dados chamado Padaria, utilizando a ferramenta SQL Server Compact Database, inclusa no WebMatrix. Os bancos de dados podem ser criados utilizando códigos, porém, é muito frequente a criação de bancos de dados utilizando ferramentas auxiliares como o WebMatrix.

1 - Inicie o WebMatrix e na página de boas-vindas, clique em "Site from template"
2 - Selecione "Empty site" e no campo "Site name" digite Padaria e clique em OK. O site será criado e disponibilizado no WebMatrix.
3 - No painel da esquerda, clique em Databases .
4 - Na guia superior, clique em "New database". Um banco de dados é criado com o mesmo nome que foi dado ao site.
5 - Após criar o banco de dados, no menu esquerdo expanda "Padaria.sdf" e clique em "Tables".
6 - Na guia superior, clique na opção "New Table". O WebMatrix abrirá o modo designer de tabelas.

7 - No espaço reservado como "Column Properties", há o campo (Name). Defina o valor desse campo como "ID". Ainda na coluna "ID", defina os campos "Is identity?" e "Is primary key?" como TRUE. O campo "Is primary key?" define se a coluna será ou não a coluna identificadora da tabela. Já o campo "Is identity?" faz com que sejam criados números de identificação sequenciais, começando a partir do número 1, para cada linha que será inserida.
8 - Na guia superior, clique em "New column". Em "Column Properties", defina o atributo (Name) como "Nome". Configure "Allow nulls" como false. O atributo false não permitirá que o campo fique em branco.
9 - Defina o "Data type" como "nvarchar". Esse tipo de dado indica que os dados serão strings cujo comprimento poderá variar de um registro para outro.
10 - Repetindo os procedimentos acima, crie uma coluna chamada "Descrição" e configure "Allow nulls" como false e "Data type" como "nvarchar".
11 - Crie também uma coluna chamada "Preço". Configure "Allow nulls" como false e "Data type" como "money".
12 - Aperte CTRL+S (ou salve a tabela clicando no icone) com o nome de "Produto".
13 - Pronto! O banco criado deve terminar com a seguinte aparência:

Bancos de dados relacionais

Retirado de http://www.culturamix.com/tecnologia/banco-de-dados-relacionais 

Podemos armazenar dados de várias maneiras, inclusive em arquivos de texto e planilhas. Na maioria das vezes, entretanto, os dados são armazenados em um banco de dados relacional.

Em um banco de dados relacional, a informação é dividida de forma lógica em tabelas separadas. Por exemplo, um banco de dados para uma escola deve conter tabelas separadas para alunos e cursos ofercidos.

O software de banco de dados (como o SQL Server) suporta comandos poderosos que podem estabelecer relações entre as tabelas de forma dinâmica.

Um exemplo disso é que em um banco de dados relacional podemos estabelecer a relação lógica entre estudandes e cursos com o intuito de criar um cronograma para os alunos em seus respectivos cursos.

Armazenar dados em tabelas separadas reduz a complexidade estrutural da tabela, reduzindo também a quantidade de dados redundantes nas mesmas.

[Parte 1] Capítulo 5: Trabalhando com informações e bancos de dados

No decorrer da programação de sites e páginas Web, surge a necessidade de armazenar dados que serão exibidos aos usuários ou dados fornecidos pelos usuários.

Este capítulo mostrará como armazenar os dados do site em um banco de dados e, posteriormente, como exibir estas informações nas páginas ASP.NET.

Nos próximos posts veremos:
- Como criar um banco de dados
- Como conectar a um banco de dados
- Como exibir dados em uma página Web
- Como inserir, atualizar e excluir registros de um banco de dados

As características ASP.NET apresentadas no capítulo 5 são:
- Trabalhar com um banco de dados Microsoft SQL Server
- Trabalhar com consultas SQL
- A classe de banco de dados

[Parte 4] Capítulo 4: Como validar entradas de usuário em um formulário

Algumas vezes os usuários são solicitados a preencher um campo e esquecem, ou então digitam letras em campos que deveriam aceitar somente números. Para certificar que um formulário foi preenchido corretamente, devemos validar as entradas de usuário.

Este procedimento mostra como validar os campos do formulário para se certificar que o usuário não tenha deixado nenhum em branco. Também será verificado se o campo de telefone contém apenas números. Se houver erros, uma mensagem será exibida informando que o formulário não está correto.

1 - No formulário criado nos posts anteriores (Criando um formulário básico em HTML e Como ler entradas de usuário a partir de um formulário), adicione o seguinte código:

No código acima, é inicializada uma variável chamada erros com o valor false. Essa variável só será true caso alguma das condições não forem satisfeitas.

Cada vez que o código lê o valor de um campo, ele executa um teste de validação. Para os campos txtNome e txtEmail, a validação será feita chamando a função IsEmpty. Se o teste falha, a variavel erros recebe true e a mensagem de erro apropriada é apresentada.

O proximo passo é certificar-se que o usuário digitou um valor numerico para o campo txtTelefone. Para isso, chamamos a função IsInt. A função retornará true caso a string possa ser convertida em inteiro. Devemos lembrar sempre que os objetos Request são sempre strings.

2 - Depois de executar todos os testes, o código verifica se a variável erros ainda possui o valor false. Se sim, o código mostra o bloco que exibe os valores digitados. Se não, as mensagens de erro serão exibidas.

3 - Digite os valores corretos e a página será executada normalmente.

Codificação HTML - Aparência e segurança

O HTML faz uso especial de caracteres como <, > e &. Se esses caracteres especiais aparecem onde não são esperados, podem arruinar a aparência e a funcionalidade de  uma página web inteira.

Por exemplo: o navegador interpreta o caractere < como o início de um elemento HTML (a menos que o caractere seja seguido de um espaço).

Se o navegador não reconhece o elemento, ele simplesmente descarta a cadeia que começa com < até atingir algo que ele reconhece novamente. Obviamente, isto pode resultar em uma página renderizada de modo estranho.

A codificação HTML substitui esses caracteres reservados por um código que fará os navegadores interpretarem corretamente o simbolo.

Os caracteres são substituidos da seguinte forma:

< é substituído por &lt
> é substituido por &gt

O navegador processa esses códigos e exibe então o símbolo, sem causar danos à estrutura da página.

É uma ótima ideia utilizar a codificação HTML sempre que for exibir strings de entrada de usuário. Se isso não for feito, um usuário pode tentar fazer a página executar um script malicioso ou qualquer outra coisa que comprometa a segurança do site.

Essa dica é particularmente importante se desejamos pegar a entrada do usuário, armazená-la em algum lugar e então exibir posteriormente, por exemplo, como um comentário em um blog.

[Parte 3] Capítulo 4: Como ler entradas de usuário a partir de um formulário

Para processar um formulário, adicionamos o código capaz de ler os valores que foram submetidos nos campos e processamos as informações;

Esse procedimento mostra como ler os campos e mostrar as informações digitadas na página.

1 - No topo do arquivo Formulario.cshmt que criamos no post anterior (Criando um formulário básico em HTML), adicione o seguinte código:

Essa página funciona da seguinte forma: quando o usuario faz a solicitação da página pela primeira vez, é exibido apenas o formulário em branco. O usuário preenche o formulário e clica em "Gravar".

A página executa um post enviando os dados do usuário ao servidor. A requisição feita vai para a mesma página, pois a propriedade action do elemento form foi deixada em branco.

Para fins explicativos, quando a página é submetida, os dados são exibidos acima do formulário.

No código da página, primeiro é utilizado o método IsPost para determinar se a página está sendo publicada - isto é, se um usuário clicar no botão "Gravar". Se o comando for um post, retorna true. Essa é uma maneira padrão em ASP.NET para determinar se estamos trabalhando com um pedido inicial (uma requisição GET) ou um postback (um pedido POST). Para saber mais, visite o post Métodos GET e POST (e a propriedade IsPost).

Em seguida, obtemos através do Request os valores que o usuário preencheu e os coloca em variáveis para serem utilizados depois. O objeto Request tem todos os valores apresentados na página, identificados com uma chave.

A chave é equivale ao atributo name do campo que desejamos ler. Por exemplo, para ler o campo txtNome, devemos utilizar Request["txtNome"].

Valores de formulário são armazenados no objeto Request como strings. Portanto quando temos que trabalhar como número, data ou outro tipo, devemos convertê-lo primeiro. Para saber mais sobre conversão de valores, visite o post Variáveis.

2 - Execute a página no navegador, preencha os campos e clique em "Gravar". A página irá exibir os valores digitados.

[Parte 7] Capítulo 3: Criando e utilizando um Helper

Uma outra opção para criar uma aparência consistente em seu site é criar um helper personalizado. Como vimos no post Instalando helpers com package manager. Um helper é um componente que permite realizar uma tarefa utilizando uma única linha de código.

O ASP.NET inclui muitos helpers e utilizaremos muitos deles. O helper pode auxiliar na criação de uma aparência consistente permitindo que utilizemos um bloco comum de código em várias páginas do site.

Suponhamos que será necessário criar um item de nota que ficará separado dos parágrafos, o qual será criado utilizando um elemento <div> e seu estilo será definido como um box com uma borda.

Para não adicionar a mesma marcação em todas as páginas, podemos criar um helper e ele irá inserir a nota com apenas uma linha de código, onde for necessário. A utilização desse recurso fará com que o código das páginas seja simples e mais fácil de ler.

Outro ganho com a criação de helpers é a facilidade para dar manutenção no site, uma vez que se for necessário alterar a aparência das notas, será possível alterar em apenas um local.

Esse procedimento exemplifica como criar um helper responsável por criar notas, como foi descrito acima. Este é um exemplo simples, mas um helper personalizado pode ter incluso qualquer marcação e código ASP.NET.

1 - No diretório principal, crie uma pasta chamada "App_Code", caso ela ainda não exista.
2 - Na pasta App_code, crie um novo arquivo chamado MeuHelper.cshtml
3 - Substitua o código gerado pelo código abaixo:

Esse código utiliza a sintaxe @helper para declarar um novo helper chamado InserirNota. Esse helper específico permite passar um parâmetro chamado content que pode conter a combinação de texto e marcação. O helper insere uma string no corpo da nota utilizando a variável @conteudo.

4 - Salve e feche o arquivo.

O próximo procedimento mostra como utilizar um helper personalizado para inserir uma nota em uma página web.

1 - No diretório principal, crie um arquivo chamado TesteHelper.cshtml
2 - Adicione o seguinte código no arquivo:

Para chamar o helper que acabou de ser criado, utilize @ seguido pelo nome do arquivo onde o helper está, seguido por um ponto e em seguida o nome do helper. O texto entre aspas passado entre parênteses será o texto exibido na nota.

3 - Salve as alterações e execute a página. O helper irá inserir a nota no exato local onde foi chamado.

[Parte 6] Capítulo 3: Passando dados para páginas de layout com PageData

Algumas vezes, podemos ter dados definidos na página de conteúdo que serão necessários na página de layout. Para isso, devemos passar os dados de uma página para outra.

Podemos por exemplo, querer exibir o status de login de um usuário, ou podemos tambem querer mostrar ou ocultar áreas de conteúdo com base na entrada de um usuário.

Para passar dados de uma página de conteúdo para uma página de layout, os valores podem ser colocados na propriedade PageData de uma página de conteúdo.

A propriedade PageData é uma coleção de pares de nome/valor que contém os dados que serão passados através das páginas. Na página de layout os valores podem ser lidos fora da propriedade PageData.

Este diagrama mostra como o ASP.NET pode utilizar a propriedade PageData para passar valores de uma página de conteúdo para uma de layout. Quando o ASP.NET começa a criar a página, é criada também a coleção PageData.

Valores da coleção PageData também podem ser acessados por outras seções da página de conteúdo ou por outros blocos de conteúdo.

O procedimento a seguir mostra como é feita a passagem de dados. QUando a página é executada, exibe um botão que permite ao usuário ocultar ou exibir uma lista que é definida na página de layout. Quando os usuários clicam no botão, ele define o valor true/false na propriedade PageData. O layout da página lê o valor, e se for falso, oculta a lista. O valor também é utilizado na página de conteúdo para determinar se deve exibir o botão "Ocultar lista" ou "Exibir lista".

1 - No diretório principal, crie um arquivo chamado Content3.cshtml e substitua seu conteúdo pelo conteúdo abaixo:

Esse código armazena doias coisas na propriedade PageData: o título da página web e verdadeiro/falso para especificar se deseja exibir uma lista. Pode-se observar que o ASP.NET permite que seja colocada uma marcação HTML para a página utilizar o bloco ou não. Por exemplo, o if/else no corpo da página determina se será exibido o formulário, dependendo se PageData["MostrarLista"] for definido como verdadeiro.

2 - Na pasta shared, crie um arquivo chamado _layout3.cshtml e substitua seu conteúdo pelo conteúdo abaixo:

O layout da página inclui a expressão no elemento <title> que pega o valor na propriedade PageData. Também é utilizado o valor de MostrarLista em PageData para determinar quando exibir o conteúdo do bloco de lista.

3 - Ainda na pasta shared, crie um arquivo chamado _List.cshtml e substitua o seu conteúdo pelo conteúdo a seguir:

4 - Execute o arquivo Content3.cshtml no navegador. A página exibirá a lista visível na parte esquerda da página e o botão de ocultar no fundo da página.

[Parte 5] Capítulo 3: Criando seções de conteúdo opcionais

Normalmente, as secções de conteúdo que criamos tem que coincidir com as seções definidas na página de layout. Alguns erros podem surgir em algumas dessas situações:
- A página de conteúdo contém uma seção que nao tem seção correspondente na página de layout
- O layout da página contém uma seção para a qual não existe conteúdo
- O layout de página inclui chamadas de métodos que tentam chamar a seção mais de uma vez

No entanto, podemos evitar o surgimento desses erros declarando uma seção como opcional na página de layout.

Dessa forma, podemos definir múltiplas páginas de conteúdo que compartilhem a mesma página de layout, mas que podem ou não possuir conteúdo para uma seção específica.

Para exemplifcarmos essa situação, utilizaremos o exemplo criado no post anterior. (Para ir direto ao post, clique aqui).

1 - Abra o arquivo Content2.cshtml e apague a seguinte seção:

2 - Salve a página e execute no browser. Uma mensagem de erro será exibida, pois o conteúdo da página não fornece conteúdo para uma seção definida na página de layout, ou seja, a seção de cabeçalho.

3 - Na pasta shared, abra o arquivo _layout2.cshtml e substitua a linha:

por

4 - Execute a página Content2.cshtml novamente (se a página já estiver aberta no navegador, atualize a página). A página será executada sem erro, mesmo que não tenha cabeçalho.

[Parte 4] Capítulo 3: Projetando páginas de layout com múltiplas seções de conteúdo

Uma página de conteúdo pode ter várias seções. Na página de conteúdo, damos a cada seção um nome exclusivo. Uma seção default é sempre deixada sem nome. Na página de layout, é adicionado um método RenderBody para especificar onde a seção (default) deve aparecer. Em seguida, os métodos RenderSection são inseridos para separar as seções nomeadas individualmente.

O diagrama a seguit mostra como o ASP.NET trata de conteúdo que é dividido em várias seções. Cada seção chamada está contida em um bloco de seção na página de conteúdo (no exemplo são chamados de cabeçalho e lista). A seção de conteúdo é inserida na página no ponto onde p método RenderSection é chamado.

O procedimento abaixo mostra como criar uma página com múltiplas seções de conteúdo e como utilizar uma página de layout que suporta seções de conteúdo.

1 - Na pasta shared, crie um arquivo chamado _Layout2.cshtml
2 - substitua o conteúdo do arquivo criado pelo conteúdo a seguir:

3 - No diretório principal, crie um arquivo chamado Content2.cshtml e substitua o conteúdo da página pelo conteúdo a seguir:

4 - Execute a página no navegador e teremos o resultado abaixo. Há um bloco de conteúdo no topo da página, uma lista de ítens à esquerda e um bloco de conteúdo a direita.

[Parte 3] Capítulo 3: Criando um visual consistente com páginas de layout

Uma abordagem mais estruturada para criar uma aparência consistente em um site é a utilização de páginas de layout. Uma página de layout define a estrutura de uma página web, mas não contém nenhum conteúdo. Você pode criar páginas que possuam conteúdo, e em seguida, ligá-las à página de layout.

Quando as páginas forem exibidas, serão formatadas de acordo com a página de layout. Podemos dizer que a página de layout funciona como uma espécie de modelo para o conteúdo que é definido em outras páginas.

O layout da página é igual a qualquer página HTML, exceto pelo fato de que a página contém uma chamada para o método RenderBody. A posição do método RenderBody no layout determina onde as informações de conteúdo serão incluídas.

O diagrama a seguir mostra como páginas de conteúdo e páginas de layout são mescladas em tempo de execução para produzir a página da web completa. O navegador solicita uma página de conteúdo. A página de conteúdo possui o código que especifica qual layout será utilizado em sua estrutura. Na página de layout, o conteúdo é inserido no ponto onde o método RenderBody é chamado. Blocos de conteúdo também podem ser inseridos, chamando o método RenderPage, como fizemos no post anterior. Quando a página está completa, é enviada ao navegador.

O procedimento a seguir mostra como criar uma página de layour e páginas de conteúdo ligadas a ela.

1 - Na pasta raiz do seu site, crie um arquivo chamado _Layout1.cshtml
2 - Ediste seu conteúdo, para o conteúdo a seguir:

Utilizamos o método RenderPage em uma página de layout para inserir blocos de conteúdo. Uma página de layout pode conter apenas uma chamada para o método RenderBody.

3 - Na pasta Shared, crie um arquivo chamado _cabecalho2.cshtml e substitua o conteúdo pelo seguinte?

4 - Na pasta raiz, crie uma nova pasta com o nome de Styles
5 - Dentro da pasta Styles, crie um arquivo chamado Site.css e adicione as definições de estilo a seguir:

Estas definições de estilo apenas mostram como as folhas de estilo podem ser utilizadas em páginas de layout. Cada um pode definir seus próprios estilos para esses elementos.

6 - Na pasta raiz, crie um arquivo chamado Content1.cshtml e substitua seu conteúdo pelo seguinte:

7 - Execute a página Content1.cshtml em um navegador. A página processada utiliza o formato e as folhas de estilo definidas no arquivo _Layout1.cshtml e o conteúdo definido em Content1.cshtml.

[Parte 2] Capítulo 3: Criando blocos reutilizáveis de conteúdo

A maioria dos sitespossuem conteúdos que são exibidos em todas as páginas, como cabeçalho e rodapé, ou uma caixa que informa aos usuários onde estão e se estão logados. O ASP.NET permite que seja criado um arquivo separado com bloco de conteúdo que pode conter texto, marcação e código, assim como uma página web normal.

Pode-se então inserir o bloco de conteúdo em outras páginas no local onde queremos que as informações apareçam. Dessa forma, não teremos que copiar e colar o conteúdo em cada uma das páginas.

Essa estratégia é bastante comum e torna mais fácil a atualização do site. Se alguma mudança for necessária, basta alterar apenas um arquivo e essa mudança refletirá em todas as páginas que possuirem aquele bloco.

O diagrama a seguir mostra como blocs de conteúdo trabalham. Quando um navegador solicita uma página do servidor, o ASP.NET insere o bloco de conteúdo no ponto que o método RenderPage é chamado na página principal. A página com o bloco de conteúdo incorporado é então enviada ao navegador.

Neste procedimento, será criada uma ágina que faz referência a dois blocos de conteúdo (um cabeçalho e um rodapé) que estão localizados em arquivos separados. Poderemos utilizar esses blocos de conteúdo em quaisquer página do site. Quando estiver pronto, teremos uma página como esta:

1 - No diretório principal do seu site, crie um arquivo chamado index.cshtml
2 - Insira o código abaixo no lugar da marcação já existente

3 - Crie uma pasta chamada Shared. (É comum armazenar arquivos compartilhados entre páginas em uma pasta chamada "shared"). Para criar uma pasta, clique em "New", em seguida "New Folder".
4 - Dentro da pasta "shared", crie um arquivo chamado _cabecalho.cshtml
5 - Substitua o conteúdo da página pelo conteúdo a seguir:

Observe que o nome do arquivo possui um "_" como prefixo. As páginas prefixadas com underscore (_) não são enviadas ao navegador. Essa regra evita que as pessoas solicitem estas páginas, intencionalmente ou não. Normalmente utilizamos esse prefixo em páginas de blocos de conteúdo pois estas são páginas criadas para serem inseridas em outras páginas.

6 - Na pasta "shared", crie um arquivo chamado _rodape.cshtml e substitua o conteúdo pelo conteúdo a seguir:

7 - No arquivo index.cshtml, adicione o código abaixo, que faz duas chamadas ao método RenderPage:

O código acima exempliifca como inserir um bloco de código em uma página Web. Chamamos o método RenderPage e passamos por parâmetro o nome do arquivo que contém o conteúdo que desejamos inserir naquele ponto. Aqui, estamos inserindo o conteúdo de _cabecalho.cshtml e _rodape.cshtml no arquivo index.cshtml.

8 - Rode a página index.cshtml. Se abrirmos o código-fonte direto do navegador, poderemos observar que é exibida a marcação da página inteira, ocultando o fato de que os códigos vem de arquivos diferentes.

[Parte 12] Capítulo 2: Tratamento de erros

Blocos try-catch

É comum termos em nossos projetos blocos de código que podem falhar por razões que estão fora de nosso controle, como por exemplo:

- Se o código tenta abrir, criar, ler ou escrever um arquivo, todos tipos de erros podem ocorrer. O arquivo pode não existir, pode estar bloqueado, o código pode não possuir as permissões necessárias, etc.
- Se o código tenta atualizar registros em um banco de dados, pode haver problemas de permissões, a conexão com o banco de dados pode ser perdida, os dados a serem salvos podem ser invãlidos, etc.

Na programação, esse tipo de situação é chamado de exceção. Se o código encontra uma exceção, ele gera (lança) uma mensagem de erro que, na melhor das hipóteses, é irritante ao usuário.

Em situações onde podem haver exceções, para evitar mensagens de erro desse tipo, pode-se utilizar try/catch. Na instrução try, é executado o bloco de código para verificar se ocorre a exceção. Em instruções catch, é verificado se erros específicos ocorreram. Cada bloco try pode possuir vários blocos catch. A quantidade de blocos catch será proporcional à quantidade de erros que estamos tentando evitar que ocorram.

O exemplo a seguir mostra uma página que cria um arquivo de texto na primeira solicitação e, em seguida, exibe um botão que permite ao usuário abrir o arquivo. O exemplo utiliza de propósito um diretório errado para o aquivo, com o intuito de gerar uma exceção.

O código inclui catch para duas possíveis exceções: FileNotFoundException, que ocorre se o nome do arquivo for ruim, e DirectoryNotFoundException, que ocorre se o ASP.NET não pode encontrar a pasta onde o arquivo está. (Você pode descomentar uma declaração no exemplo, para ver como é executado quando tudo funciona perfeitamente.)

Se o código não trata a excessão, você veria uma página de erro, como a captura de tela anterior. No entanto, a seção de try/catch ajuda a prevenir o usuário de ver esses tipos de erros.

[Parte 11] Capítulo 2: Chamada de métodos com parâmetros

Como já vimos anteriormente, os objetos que trabalhamos podem ter métodos. Muitos métodos podem ter um ou mais parâmetros. Um parâmetro é um valor passado para o método que permite ao mesmo executar a sua tarefa.

A sintaxe Razor possui duas possibilidades para a passagem de parâmetros para um método:
- Parâmetros posicionais
- Parâmetros nomeados

Para chamar um método com parâmetros posicionais, devemos passar os parâmetros exatamente na mesma ordem que foi especificada na declaração do método. Essa ordem pode ser descoberta através da documentação do método. Além de seguir a ordem, nenhum parâmetro pode ser omitido. Caso não exista o parâmetro no contexto trabalhado, ele deve ser substituído por algum valor nulo ou uma string vazia (" ").

O exemplo a seguir supõe que tenhamos uma pasta chamada scripts no nosso site. O código chama o método Request.MapPath e passa o valor de tres parametros, na ordem correta, depois exibe o diretório mapeado.

Quando um método possui muitos parâmetros, podemos manter o código mais legível utilizando parâmetros nomeados. Para chamar um método utilizando parâmetros nomeados, onde é especificado o nome do parâmetro seguido por dois pontos e o valor. A vantagem dos parâmetros nomeados é que podem ser passados em qualquer ordem. Uma desvantagem é que a chamada do método não fica compacta. O exemplo a seguir mostra a mesma chamada de método do exemplo anterior, porém utilizando parâmetros nomeados.

[Parte 10] Capítulo 2: Objetos e Coleções

Praticamente tudo em um site ASP.NET é um objeto, incluindo a página em si. Existem alguns objetos importantes que trabalharemos frequentemente em nosso código.

Objetos de página
O objeto mais básico em ASP.NET é a própria página. pode-se acessar as propriedades do objeto página de forma direta. O código a seguir obtem o caminho do arquivo da página, utilizando o Request:

Para deixar claro que estamos referenciando propriedades e métodos do objeto da página atual, pode-se utilizar opicionalmente a palavra-chave this.

Podemos utilizar as propriedades do objeto página para obter várias informações, como por exemplo:
- Request: Como já foi visto, o Request é uma coleção de informações ssobre a solicitação atual, incluindo o tipo de navegador que fez a solicitação, a URL da página, a identidade do usuário, etc.
- Response: Esta é uma coleção de informações sobre a resposta (página) que será enviada para o navegador quando o código do servidor terminar a execução. Pode-se usar essa propriedade para gravar as informações para a resposta.

Coleções de objetos (Arrays e Dicionários)
Uma coleção é um grupo de objetos do mesmo tipo. Muitas vezes é necessário trabalhar com dados em coleções. Dois tipos de coleções comuns são o array e o dicionário.

Um array é util quando desejamos armazenar uma coleção de itens semelhantes sem criar uma variável separada para cada um deles:

Com arrays, declaramos um tipo de dados específico, como string, int ou DateTime. Para indicar que a variável é um array, adicionamos colchetes após a declaração de seu tipo (string[], int[], DateTime[]). Podemos acessar itens em uma matriz utilizando sua posição (index) ou utilizando a instrução foreach.

Em C#, os índices dos arrays sempre começam em zero.

É possível determinar quantos itens um array possui utilizando sua propriedade Length. Para obter a posição de um item específico no array (pesquisar item), utilizamos o método Array.IndexOf. É possível também inverter o conteúdo de um array com o método Array.Reverse ou classificar o conteúdo com o método Array.Sort.

Os códigos acima serão exibidos no navegador da seguinte forma:

Um dicionário é uma coleção de pares de palavras e valores, onde fornecemos a chave (ou nome) para definir ou recuperar o valor correspondente:

Para criar um dicionário utilizamos a palavra-chave new para indicar que estamos criando um novo objeto do tipo dicionário. Podemos declarar um dicionário para uma variável utilizando a palavra var. Para indicar os tipos de dados dos ítens do dicionário, utilizamos os caracteres < >. No final da declaração devemos inserir um par de parênteses pois esse é o método que cria o novo dicionário.

Para adiconar itens ao dicionário, a variável do dicionário deve chamar o método Add e especificar a chave e o valor.