Compartilhar via

Personalizando Site-Wide comportamento para sites de Páginas da Web do ASP.NET (Razor)

  • Artigo

por Tom FitzMacken

Este artigo explica como criar configurações do lado do site para páginas em um site do Páginas da Web do ASP.NET (Razor).

O que você aprenderá:

  • Como executar o código que permite definir valores (valores globais ou configurações auxiliares) para todas as páginas em um site.
  • Como executar o código que permite definir valores para todas as páginas em uma pasta.
  • Como executar o código antes e depois que uma página é carregada.
  • Como enviar erros para uma página de erro central.
  • Como adicionar autenticação a todas as páginas em uma pasta.

Versões de software usadas no tutorial

  • Páginas da Web do ASP.NET (Razor) 2
  • WebMatrix 3
  • Biblioteca de Auxiliares da Web ASP.NET (pacote NuGet)

Este tutorial também funciona com Páginas da Web do ASP.NET 3 e Visual Studio 2013 (ou Visual Studio Express 2013 para Web), exceto que você não pode usar a Biblioteca de Auxiliares da Web ASP.NET.

Adicionando código de inicialização de site para Páginas da Web do ASP.NET

Para grande parte do código que você escreve em Páginas da Web do ASP.NET, uma página individual pode conter todo o código necessário para essa página. Por exemplo, se uma página envia uma mensagem de email, é possível colocar todo o código dessa operação em uma única página. Isso pode incluir o código para inicializar as configurações de envio de email (ou seja, para o servidor SMTP) e para enviar a mensagem de email.

No entanto, em algumas situações, talvez você queira executar algum código antes que qualquer página no site seja executada. Isso é útil para definir valores que podem ser usados em qualquer lugar do site (conhecidos como valores globais).) Por exemplo, alguns auxiliares exigem que você forneça valores como configurações de email ou chaves de conta. Pode ser útil manter essas configurações em valores globais.

Você pode fazer isso criando uma página chamada _AppStart.cshtml na raiz do site. Se essa página existir, ela será executada na primeira vez que qualquer página no site for solicitada. Portanto, é um bom lugar para executar o código para definir valores globais. (Como _AppStart.cshtml tem um prefixo de sublinhado, ASP.NET não enviará a página para um navegador mesmo que os usuários a solicitem diretamente.)

O diagrama a seguir mostra como funciona a página _AppStart.cshtml . Quando uma solicitação chega para uma página e, se essa é a primeira solicitação para qualquer página no site, ASP.NET primeiro verifica se existe uma página _AppStart.cshtml . Nesse caso, qualquer código na página _AppStart.cshtml é executado e, em seguida, a página solicitada é executada.

[A imagem mostra como funciona o ponto do App Star CSHTML.]

Definindo valores globais para seu site

  1. Na pasta raiz de um site da WebMatrix, crie um arquivo chamado _AppStart.cshtml. O arquivo deve estar na raiz do site.

  2. Substitua o conteúdo existente pelo seguinte:

    @{
  AppState["customAppName"] = "Application Name";
}

    Esse código armazena um valor no AppState dicionário, que está disponível automaticamente para todas as páginas do site. Observe que o arquivo _AppStart.cshtml não tem nenhuma marcação nele. A página executará o código e, em seguida, redirecionará para a página que foi solicitada originalmente.

    Observação

    Tenha cuidado ao colocar o código no arquivo _AppStart.cshtml . Se ocorrerem erros no código no arquivo _AppStart.cshtml , o site não será iniciado.

  3. Na pasta raiz, crie uma nova página chamada AppName.cshtml.

  4. Substitua a marcação padrão e o código pelo seguinte:

    <!DOCTYPE html>
<html>
    <head>
        <title>Show Application Name</title>
    </head>
    <body>
        <h1>@AppState["customAppName"]</h1>
    </body>
</html>

    Esse código extrai o valor do AppState objeto que você definiu na página _AppStart.cshtml .

  5. Execute a página AppName.cshtml em um navegador. (Verifique se a página está selecionada no workspace Arquivos antes de executá-la.) A página exibe o valor global.

    [Captura de tela que mostra a página exibindo o valor global.]

Definindo valores para auxiliares

Um bom uso para o arquivo _AppStart.cshtml é definir valores para auxiliares que você usa em seu site e que precisam ser inicializados. Exemplos típicos são configurações de email para o WebMail auxiliar e as chaves privadas e públicas para o ReCaptcha auxiliar. Em casos como esses, você pode definir os valores uma vez no _AppStart.cshtml e, em seguida, eles já estão definidos para todas as páginas em seu site.

Este procedimento mostra como definir WebMail as configurações globalmente. (Para obter mais informações sobre como usar o WebMail auxiliar, consulte Adicionando Email a um site de Páginas da Web do ASP.NET.)

  1. Adicione o ASP.NET Biblioteca de Auxiliares da Web ao seu site, conforme descrito em Instalando auxiliares em um site de Páginas da Web do ASP.NET, se você ainda não o adicionou.

  2. Se você ainda não tiver um arquivo _AppStart.cshtml , na pasta raiz de um site, crie um arquivo chamado _AppStart.cshtml.

  3. Adicione as seguintes WebMail configurações ao arquivo _AppStart.cshtml :

    @{
     // Initialize WebMail helper
     WebMail.SmtpServer = "your-SMTP-host";
     WebMail.SmtpPort = 25;
     WebMail.UserName = "your-user-name-here";
     WebMail.Password = "your-account-password";
     WebMail.From = "your-email-address-here";
}

    Modifique as seguintes configurações relacionadas ao email no código:

  4. Salve o arquivo _AppStart.cshtml e feche-o.

  5. Na pasta raiz de um site, crie uma nova página chamada TestEmail.cshtml.

  6. Substitua o conteúdo existente pelo seguinte:

    @{
    var message = "";
    try{
        if(IsPost){
            WebMail.Send(
                to: Request.Form["emailAddress"],
                subject: Request.Form["emailSubject"],
                body:Request.Form["emailBody"]
           );
           message = "Email sent!";
        }
    }
    catch(Exception ex){
        message = "Email could not be sent!";
    }
}
<!DOCTYPE html>
<html lang="en">
  <head>
     <meta charset="utf-8" />
     <title>Test Email</title>
  </head>
  <body>
    <h1>Test Email</h1>
    <form method="post">
      <p>
        <label for="emailAddress">Email address:</label>
        <input type="text" name="emailAddress" />
      </p>
      <p>
        <label for="emailSubject">Subject:</label>
        <input type="text" name="emailSubject" />
      </p>
      <p>
        <label for="emailBody">Text to send:</label><br/>
        <textarea name="emailBody" rows="6"></textarea>
      </p>
    <p><input type="submit" value="Send!" /></p>
    @if(IsPost){
        <p>@message</p>
    }
    </form>
  </body>
</html>

  7. Execute a página TestEmail.cshtml em um navegador.

  8. Preencha os campos para enviar uma mensagem de email e clique em Enviar.

  9. Verifique seu email para ter certeza de que você recebeu a mensagem.

A parte importante deste exemplo é que as configurações que você normalmente não altera , como o nome do servidor SMTP e suas credenciais de email , são definidas no arquivo _AppStart.cshtml . Dessa forma, você não precisa defini-los novamente em cada página para onde enviar emails. (Embora, por algum motivo, você precise alterar essas configurações, poderá defini-las individualmente em uma página.) Na página, você só define os valores que normalmente mudam a cada vez, como o destinatário e o corpo da mensagem de email.

Executando o código antes e depois de arquivos em uma pasta

Assim como você pode usar _AppStart.cshtml para escrever código antes que as páginas no site sejam executadas, você pode escrever código executado antes (e depois) de qualquer página em uma determinada execução de pasta. Isso é útil para itens como definir a mesma página de layout para todas as páginas em uma pasta ou para verificar se um usuário está conectado antes de executar uma página na pasta.

Para páginas em pastas específicas, você pode criar código em um arquivo chamado _PageStart.cshtml. O diagrama a seguir mostra como funciona a página _PageStart.cshtml . Quando uma solicitação chega para uma página, ASP.NET primeiro verifica uma página _AppStart.cshtml e executa isso. Em seguida, ASP.NET verifica se há uma página _PageStart.cshtml e, nesse caso, executa isso. Em seguida, ele executa a página solicitada.

Dentro da página _PageStart.cshtml , você pode especificar onde durante o processamento deseja que a página solicitada seja executada incluindo um RunPage método . Isso permite que você execute o código antes que a página solicitada seja executada e, em seguida, novamente após ela. Se você não incluir RunPage, todo o código em _PageStart.cshtml será executado e, em seguida, a página solicitada será executada automaticamente.

[A imagem mostra como a página solicitada será executada automaticamente.]

ASP.NET permite criar uma hierarquia de arquivos _PageStart.cshtml . Você pode colocar um arquivo _PageStart.cshtml na raiz do site e em qualquer subpasta. Quando uma página é solicitada, o arquivo _PageStart.cshtml no nível mais alto (mais próximo da raiz do site) é executado, seguido pelo arquivo _PageStart.cshtml na próxima subpasta e assim por diante, na estrutura da subpasta até que a solicitação atinja a pasta que contém a página solicitada. Depois que todos os arquivos _PageStart.cshtml aplicáveis forem executados, a página solicitada será executada.

Por exemplo, você pode ter a seguinte combinação de arquivos _PageStart.cshtml e arquivo Default.cshtml :

@* ~/_PageStart.cshtml *@
@{
  PageData["Color1"] = "Red";
  PageData["Color2"] = "Blue";
}

@* ~/myfolder/_PageStart.cshtml *@
@{
  PageData["Color2"] = "Yellow";
  PageData["Color3"] = "Green";
}

@* ~/myfolder/default.cshtml *@
@PageData["Color1"]
<br/>
@PageData["Color2"]
<br/>
@PageData["Color3"]

Ao executar /myfolder/default.cshtml, você verá o seguinte:

Red

Yellow

Green

Executando o código de inicialização para todas as páginas em uma pasta

Um bom uso para arquivos _PageStart.cshtml é inicializar a mesma página de layout para todos os arquivos em uma única pasta.

  1. Na pasta raiz, crie uma nova pasta chamada InitPages.

  2. Na pasta InitPages do seu site, crie um arquivo chamado _PageStart.cshtml e substitua a marcação e o código padrão pelo seguinte:

    @{
    // Sets the layout page for all pages in the folder.
    Layout = "~/Shared/_Layout1.cshtml";

    // Sets a variable available to all pages in the folder.
    PageData["MyBackground"] = "Yellow";
}

  3. Na raiz do site, crie uma pasta chamada Compartilhado.

  4. Na pasta Compartilhado , crie um arquivo chamado _Layout1.cshtml e substitua a marcação e o código padrão pelo seguinte:

    @{
  var backgroundColor = PageData["MyBackground"];
}
<!DOCTYPE html>
<html>
<head>
  <title>Page Title</title>
  <link type="text/css" href="/Styles/Site.css" rel="stylesheet" />
</head>
<body>
  <div id="header">
    Using the _PageStart.cshtml file
  </div>
  <div id="main" style="background-color:@backgroundColor">
    @RenderBody()
  </div>
<div id="footer">
  &copy; 2012 Contoso. All rights reserved
</div>
</body>
</html>

  5. Na pasta InitPages , crie um arquivo chamado Content1.cshtml e substitua o conteúdo existente pelo seguinte:

    <p>This is content page 1.</p>

  6. Na pasta InitPages , crie outro arquivo chamado Content2.cshtml e substitua a marcação padrão pelo seguinte:

    <p>This is content page 2.</p>

  7. Execute Content1.cshtml em um navegador.

    [A imagem mostra a execução do CSHTML de ponto de Conteúdo 1 em um navegador.]

    Quando a página Content1.cshtml é executada, o arquivo _PageStart.cshtml define Layout e também define PageData["MyBackground"] como uma cor. Em Content1.cshtml, o layout e a cor são aplicados.

  8. Exibir Content2.cshtml em um navegador.

    O layout é o mesmo, pois ambas as páginas usam a mesma página de layout e cor inicializadas em _PageStart.cshtml.

Usando _PageStart.cshtml para lidar com erros

Outro bom uso para o arquivo _PageStart.cshtml é criar uma maneira de lidar com erros de programação (exceções) que podem ocorrer em qualquer página .cshtml em uma pasta. Este exemplo mostra uma maneira de fazer isso.

  1. Na pasta raiz, crie uma pasta chamada InitCatch.

  2. Na pasta InitCatch do seu site, crie um arquivo chamado _PageStart.cshtml e substitua a marcação e o código existentes pelo seguinte:

    @{
    try
    {
        RunPage();
    }
    catch (Exception ex)
    {
        Response.Redirect("~/Error.cshtml?source=" +
            HttpUtility.UrlEncode(Request.AppRelativeCurrentExecutionFilePath));
    }
}

    Nesse código, você tenta executar a página solicitada explicitamente chamando o RunPage método dentro de um try bloco. Se ocorrerem erros de programação na página solicitada, o código dentro do catch bloco será executado. Nesse caso, o código redireciona para uma página (Error.cshtml) e passa o nome do arquivo que experimentou o erro como parte da URL. (Você criará a página em breve.)

  3. Na pasta InitCatch do seu site, crie um arquivo chamado Exception.cshtml e substitua a marcação e o código existentes pelo seguinte:

    @{
    var db = Database.Open("invalidDatabaseFile");
}

    Para fins deste exemplo, o que você está fazendo nesta página é deliberadamente criar um erro tentando abrir um arquivo de banco de dados que não existe.

  4. Na pasta raiz, crie um arquivo chamado Error.cshtml e substitua a marcação e o código existentes pelo seguinte:

    <!DOCTYPE html>
<html>
    <head>
        <title>Error Page</title>
    </head>
    <body>
<h1>Error report</h1>
<p>An error occurred while running the following file: @Request["source"]</p>
    </body>
</html>

    Nesta página, a expressão @Request["source"] obtém o valor da URL e a exibe.

  5. Na barra de ferramentas, clique em Salvar.

  6. Execute Exception.cshtml em um navegador.

    [Captura de tela que mostra a execução do ponto de exceção CSHTML em um navegador.]

    Como ocorre um erro em Exception.cshtml, a página _PageStart.cshtml redireciona para o arquivo Error.cshtml , que exibe a mensagem.

    Para obter mais informações sobre exceções, consulte Introdução à programação de Páginas da Web do ASP.NET usando a sintaxe Razor.

Usando _PageStart.cshtml para restringir o acesso a pastas

Você também pode usar o arquivo _PageStart.cshtml para restringir o acesso a todos os arquivos em uma pasta.

  1. No WebMatrix, crie um novo site usando a opção Site From Template .

  2. Nos modelos disponíveis, selecione Site Inicial.

  3. Na pasta raiz, crie uma pasta chamada AuthenticatedContent.

  4. Na pasta AuthenticatedContent , crie um arquivo chamado _PageStart.cshtml e substitua a marcação e o código existentes pelo seguinte:

    @{
    Response.CacheControl = "no-cache";
    if (!WebSecurity.IsAuthenticated) {
        var returnUrl = "~/Account/Login?ReturnUrl=" + Request.Url.LocalPath;
        Response.Redirect(returnUrl);
    }
}

    O código começa impedindo que todos os arquivos na pasta sejam armazenados em cache. (Isso é necessário para cenários como computadores públicos, em que você não deseja que as páginas armazenadas em cache de um usuário estejam disponíveis para o próximo usuário.) Em seguida, o código determina se o usuário entrou no site antes de poder exibir qualquer uma das páginas na pasta. Se o usuário não estiver conectado, o código será redirecionado para a página de logon. A página de logon pode retornar o usuário à página que foi originalmente solicitada se você incluir um valor de cadeia de caracteres de consulta chamado ReturnUrl.

  5. Crie uma nova página na pasta AuthenticatedContent chamada Page.cshtml.

  6. Substitua a marcação padrão pelo seguinte:

    @{
    Layout = "~/_SiteLayout.cshtml";
    Page.Title = "Authenticated Content";
}
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8" />
  </head>
  <body>
    Thank you for authenticating!
  </body>
</html>

  7. Execute Page.cshtml em um navegador. O código redireciona você para uma página de logon. Você deve se registrar antes de fazer logon. Depois de registrar e fazer logon, navegue até a página e exiba seu conteúdo.

Recursos adicionais

Introdução à programação de Páginas da Web do ASP.NET usando a sintaxe Razor