Recursos ocultos do ASP.NET [fechado]

Esta pergunta existe porque tem significado histórico, mas não é considerada uma boa pergunta específica para este site, portanto, não a use como evidência de que você pode fazer perguntas semelhantes aqui.

Mais informações: https://stackoverflow.com/faq

Sempre existem recursos que seriam úteis em cenários marginais, mas por esse motivo a maioria das pessoas não os conhece. Estou solicitando recursos que normalmente não são ensinados pelos livros didáticos.

Quais são os que você conhece?

Durante o teste, você pode enviar e-mails para uma pasta no seu computador em vez de para um servidor SMTP. Coloque isso no seu web.config:

<system.net>
    <mailSettings>
        <smtp deliveryMethod="SpecifiedPickupDirectory">
            <specifiedPickupDirectory pickupDirectoryLocation="c:\Temp\" />
        </smtp>
    </mailSettings>
</system.net>

Se você colocar um arquivo chamado app_offline.htm na raiz de um diretório de aplicativo Web, o ASP.NET 2.0+ encerrará o aplicativo e interromperá o processamento normal de novas solicitações de entrada para esse aplicativo, mostrando apenas o conteúdo do app_offline.htm arquivo para todos os novos pedidos .

Essa é a maneira mais rápida e fácil de exibir o aviso "Site temporariamente indisponível" enquanto reimplanta (ou reverte) alterações em um servidor de produção.

Além disso, conforme indicado pela marxidad , verifique se você possui pelo menos 512 bytes de conteúdo no arquivo para que o IE6 o processe corretamente.

throw new HttpException(404, "Article not found");

Isso será detectado pelo ASP.NET, que retornará a página customErrors. Aprendi sobre este em uma dica recente do .NET Tip of the Day

Aqui está o melhor. Adicione isso ao seu web.config para uma compilação MUITO mais rápida. Isto é pós 3.5SP1 através deste QFE .

<compilation optimizeCompilations="true">

Resumo rápido: estamos introduzindo uma nova opção optimizeCompilations no ASP.NET que pode melhorar bastante a velocidade de compilação em alguns cenários. Existem algumas capturas, então continue lendo para mais detalhes. Essa opção está atualmente disponível como QFE para 3.5SP1 e fará parte do VS 2010.

O sistema de compilação do ASP.NET adota uma abordagem muito conservadora, o que faz com que ele elimine qualquer trabalho anterior realizado sempre que um arquivo de 'nível superior' for alterado. Os arquivos de 'nível superior' incluem qualquer coisa no bin e App_Code, além de global.asax. Embora isso funcione bem para aplicativos pequenos, torna-se quase inutilizável para aplicativos muito grandes. Por exemplo, um cliente estava encontrando um caso em que demorava 10 minutos para atualizar uma página depois de fazer qualquer alteração em uma montagem de 'compartimento'.

Para aliviar a dor, adicionamos um modo de compilação "otimizado", que adota uma abordagem muito menos conservadora da recompilação.

Via aqui :

• HttpContext.Current sempre lhe dará acesso à Solicitação / Resposta / etc. Do contexto atual, mesmo quando você não tiver acesso às propriedades da Página (por exemplo, de uma classe auxiliar fracamente acoplada).

• Você pode continuar executando o código na mesma página após redirecionar o usuário para outro chamando Response.Redirect ( url , false )

• Você não precisa de arquivos .ASPX se tudo o que você deseja é uma página compilada (ou qualquer IHttpHandler ). Basta definir o caminho e os métodos HTTP para apontar para a classe no <httpHandlers>elemento no arquivo web.config.

• Um objeto Page pode ser recuperado de um arquivo .ASPX programaticamente chamando PageParser.GetCompiledPageInstance (virtualPath, aspxFileName, Context)

Modo de varejo no nível machine.config:

<configuration>
  <system.web>
    <deployment retail="true"/>
  </system.web>
</configuration>

Substitui as configurações web.config para forçar a depuração para false, ativa erros personalizados e desativa o rastreamento. Não é mais necessário mudar os atributos antes da publicação - basta deixá-los todos configurados para ambientes de desenvolvimento ou teste e atualizar a configuração de varejo de produção.

Ativando intellisense para MasterPages nas páginas de conteúdo
Tenho certeza de que este é um hack muito pouco conhecido

Na maioria das vezes, você precisa usar o método findcontrol e converter os controles na página mestre das páginas de conteúdo quando quiser usá-las, o MasterType diretiva permitirá o intellisense no visual studio assim que você fizer isso.

basta adicionar mais uma diretiva à página

<%@ MasterType VirtualPath="~/Masters/MyMainMasterPage.master" %>

Se você não quiser usar o Caminho Virtual e, em vez disso, usar o nome da classe,

<%@ MasterType TypeName="MyMainMasterPage" %>

Veja o artigo completo aqui

HttpContext.Items como uma ferramenta de cache no nível de solicitação

Duas coisas se destacam na minha cabeça:

1) Você pode ativar e desativar o Trace no código:

#ifdef DEBUG 
   if (Context.Request.QueryString["DoTrace"] == "true")
                {
                    Trace.IsEnabled = true;
                    Trace.Write("Application:TraceStarted");
                }
#endif

2) Você pode criar várias páginas .aspx usando apenas um arquivo "code-behind" compartilhado.

Crie um arquivo .cs de classe:

public class Class1:System.Web.UI.Page
    {
        public TextBox tbLogin;

        protected void Page_Load(object sender, EventArgs e)
        {

          if (tbLogin!=null)
            tbLogin.Text = "Hello World";
        }
    }

e, em seguida, você pode ter qualquer número de páginas .aspx (depois de excluir o código .designer.cs e .cs por trás do código gerado pelo VS):

  <%@ Page Language="C#"  AutoEventWireup="true"  Inherits="Namespace.Class1" %>
     <form id="form1" runat="server">
     <div>
     <asp:TextBox  ID="tbLogin" runat="server"></asp: TextBox  >
     </div>
     </form>

Você pode ter controles no ASPX que não aparecem na Classe1 e vice-versa, mas é necessário lembrar-se de verificar se há nulos nos seus controles.

Você pode usar:

 Request.Params[Control.UniqueId] 

Para obter o valor de um controle ANTES do viewstate ser inicializado (Control.Text etc estará vazio neste momento).

Isso é útil para o código no Init.

WebMethods.

Você pode usar retornos de chamada do ASP.NET AJAX para métodos da Web colocados em páginas ASPX. Você pode decorar um método estático com os atributos [WebMethod ()] e [ScriptMethod ()]. Por exemplo:

[System.Web.Services.WebMethod()] 
[System.Web.Script.Services.ScriptMethod()] 
public static List<string> GetFruitBeginingWith(string letter)
{
    List<string> products = new List<string>() 
    { 
        "Apple", "Banana", "Blackberry", "Blueberries", "Orange", "Mango", "Melon", "Peach"
    };

    return products.Where(p => p.StartsWith(letter)).ToList();
}

Agora, na sua página ASPX, você pode fazer isso:

<form id="form1" runat="server">
    <div>
        <asp:ScriptManager ID="ScriptManager1" runat="server" EnablePageMethods="true" />
        <input type="button" value="Get Fruit" onclick="GetFruit('B')" />
    </div>
</form>

E chame seu método do lado do servidor via JavaScript usando:

    <script type="text/javascript">
    function GetFruit(l)
    {
        PageMethods.GetFruitBeginingWith(l, OnGetFruitComplete);
    }

    function OnGetFruitComplete(result)
    {
        alert("You got fruit: " + result);
    }
</script>

Verifique se o cliente ainda está conectado, antes de iniciar uma tarefa de longa execução:

if (this.Response.IsClientConnected)
{
  // long-running task
}

Um recurso pouco conhecido e raramente usado do ASP.NET é:

Mapeamento de tags

Raramente é usado porque há apenas uma situação específica em que você precisa, mas quando precisa, é muito útil.

Alguns artigos sobre esse recurso pouco conhecido:

Mapeamento de tags no ASP.NET
usando o mapeamento de tags no ASP.NET 2.0

e desse último artigo:

O mapeamento de tags permite que você troque controles compatíveis em tempo de compilação em todas as páginas do seu aplicativo da web. Um exemplo útil é se você possui um controle ASP.NET padrão, como um DropDownList, e deseja substituí-lo por um controle personalizado derivado do DropDownList. Pode ser um controle personalizado para fornecer armazenamento em cache mais otimizado dos dados de pesquisa. Em vez de editar todos os formulários da Web e substituir as DropDownLists incorporadas por sua versão personalizada, você pode fazer com que o ASP.NET efetue isso modificando o web.config:

<pages>
 <tagMapping>
   <clear />
   <add tagType="System.Web.UI.WebControls.DropDownList"
        mappedTagType="SmartDropDown"/>
  </tagMapping>
</pages>

HttpModules . A arquitetura é louca e elegante. Talvez não seja um recurso oculto, mas interessante mesmo assim.

Você pode usar Comentários do ASP.NET em uma página .aspx para comentar partes completas de uma página, incluindo controles de servidor. E o conteúdo comentado nunca será enviado ao cliente.

<%--
    <div>
        <asp:Button runat="server" id="btnOne"/>
    </div>
--%>

O construtor de expressões de código

Exemplo de marcação:

Text = '<%$ Code: GetText() %>'
Text = '<%$ Code: MyStaticClass.MyStaticProperty %>'
Text = '<%$ Code: DateTime.Now.ToShortDateString() %>'
MaxLenth = '<%$ Code: 30 + 40 %>'

A verdadeira beleza do construtor de expressões de código é que você pode usar a ligação de dados como expressões em situações que não são de ligação de dados. Você também pode criar outros Construtores de Expressões que executam outras funções.

web.config:

<system.web>    
    <compilation debug="true">
        <expressionBuilders>
            <add expressionPrefix="Code" type="CodeExpressionBuilder" />

A classe cs que faz tudo acontecer:

[ExpressionPrefix("Code")]
public class CodeExpressionBuilder : ExpressionBuilder
{
    public override CodeExpression GetCodeExpression(
        BoundPropertyEntry entry,
        object parsedData,
        ExpressionBuilderContext context)
    {            
        return new CodeSnippetExpression(entry.Expression);
    }
} 

Uso do tipo de arquivo ASHX:
se você deseja apenas alguns html ou xml básicos sem passar pelos manipuladores de eventos da página, poderá implementar o HttpModule de uma maneira simples

Nomeie a página como SomeHandlerPage.ashx e apenas coloque o código abaixo (apenas uma linha) nela

<%@ webhandler language="C#" class="MyNamespace.MyHandler" %>

Então o arquivo de código

using System;
using System.IO;
using System.Web;

namespace MyNamespace
{
    public class MyHandler: IHttpHandler
    {
        public void ProcessRequest (HttpContext context)
        {   
            context.Response.ContentType = "text/xml";
            string myString = SomeLibrary.SomeClass.SomeMethod();
            context.Response.Write(myString);
        }

        public bool IsReusable
        {
            get { return true; }
        }
    }
}

Definindo propriedades de controle do servidor com base no navegador de destino e muito mais .

<asp:Label runat="server" ID="labelText" 
    ie:Text="This is IE text" 
    mozilla:Text="This is Firefox text" 
    Text="This is general text" 
/>

Aquele meio que me pegou de surpresa.

System.Web.VirtualPathUtility

Eu trabalhei em um aplicativo asp.net que passou por uma auditoria de segurança por uma empresa líder em segurança e aprendi esse truque fácil para evitar uma vulnerabilidade de segurança menos conhecida, mas importante.

A explicação abaixo é de: http://www.guidanceshare.com/wiki/ASP.NET_2.0_Security_Guidelines_-_Parameter_Manipulation#Consider_Using_Page.ViewStateUserKey_to_Counter_One-Click_Attacks

Considere usar o Page.ViewStateUserKey para combater ataques de um clique. Se você autenticar seus chamadores e usar o ViewState, defina a propriedade Page.ViewStateUserKey no manipulador de eventos Page_Init para impedir ataques com um clique.

void Page_Init (object sender, EventArgs e) {
  ViewStateUserKey = Session.SessionID;
}

Defina a propriedade com um valor que você sabe que é exclusivo para cada usuário, como um ID de sessão, nome de usuário ou identificador de usuário.

Um ataque com um clique ocorre quando um invasor cria uma página da Web (.htm ou .aspx) que contém um campo de formulário oculto chamado __VIEWSTATE que já está preenchido com os dados do ViewState. O ViewState pode ser gerado a partir de uma página criada anteriormente pelo invasor, como uma página de carrinho de compras com 100 itens. O invasor atrai um usuário desavisado para navegar até a página e, em seguida, o invasor faz com que a página seja enviada ao servidor em que o ViewState é válido. O servidor não tem como saber que o ViewState se originou do invasor. A validação do ViewState e os HMACs não contrariam esse ataque porque o ViewState é válido e a página é executada no contexto de segurança do usuário.

Ao definir a propriedade ViewStateUserKey, quando o invasor navega para uma página para criar o ViewState, a propriedade é inicializada com seu nome. Quando o usuário legítimo envia a página ao servidor, ela é inicializada com o nome do invasor. Como resultado, a verificação do ViewState HMAC falha e uma exceção é gerada.

HttpContext.Current.IsDebuggingEnabled

Isso é ótimo para determinar quais scripts serão exibidos (versões mínimas ou completas) ou qualquer outra coisa que você possa querer no dev, mas não ao vivo.

Incluído no ASP.NET 3.5 SP1:

• agora customErrors suporta o atributo "redirectMode" com o valor "ResponseRewrite". Mostra a página de erro sem alterar o URL.
• A tag do formulário agora reconhece o atributo action. Ótimo para quando você estiver usando a reescrita de URL

Propriedade DefaultButton nos painéis.

Ele define o botão padrão para um painel específico.

O ScottGu tem vários truques em http://weblogs.asp.net/scottgu/archive/2006/04/03/441787.aspx

Usando configSource para dividir arquivos de configuração.

Você pode usar o atributo configSource em um arquivo web.config para enviar elementos de configuração para outros arquivos .config, por exemplo, em vez de:

    <appSettings>
        <add key="webServiceURL" value="https://some/ws.url" />
        <!-- some more keys -->
    </appSettings>

... você pode ter toda a seção appSettings armazenada em outro arquivo de configuração. Aqui está o novo web.config:

    <appSettings configSource="myAppSettings.config" />

O myAppSettings.configarquivo:

    <appSettings>        
        <add key="webServiceURL" value="https://some/ws.url" />
        <!-- some more keys -->
    </appSettings>

Isso é bastante útil para cenários em que você implanta um aplicativo em um cliente e não deseja que ele interfira no próprio arquivo web.config e apenas deseja que eles possam alterar apenas algumas configurações.

ref: http://weblogs.asp.net/fmarguerie/archive/2007/04/26/using-configsource-to-split-configuration-files.aspx

Atributo MaintainScrollPositionOnPostback na diretiva Page. É usado para manter a posição de rolagem da página aspx entre as postagens.

HttpContext.IsCustomErrorEnabled é um recurso interessante. Eu achei útil mais de uma vez. Aqui está um pequeno post sobre isso.

Por padrão, qualquer conteúdo entre as tags para um controle personalizado é adicionado como um controle filho. Isso pode ser interceptado em uma substituição AddParsedSubObject () para filtragem ou análise adicional (por exemplo, do conteúdo de texto em LiteralControls):

    protected override void AddParsedSubObject(object obj)
     { var literal = obj as LiteralControl;
       if (literal != null) Controls.Add(parseControl(literal.Text));
       else base.AddParsedSubObject(obj);
     }

...

   <uc:MyControl runat='server'>
     ...this text is parsed as a LiteralControl...
  </uc:MyControl>

Se você tiver o ASP.NET gerando um feed RSS, ele às vezes colocará uma linha extra na parte superior da página. Isso não será validado com validadores comuns de RSS. Você pode contornar isso colocando a diretiva de página <@Page>na parte inferior da página.

Antes que o ASP.NET v3.5 adicionasse rotas, você poderia criar seus próprios URLs amigáveis ​​simplesmente escrevendo um HTTPModule e reescrevendo a solicitação no início do pipeline da página (como o evento BeginRequest).

URLs como http: // nome_do_servidor / página / Param1 / SomeParams1 / Param2 / SomeParams2 seriam mapeados para outra página como abaixo (geralmente usando expressões regulares).

HttpContext.RewritePath("PageHandler.aspx?Param1=SomeParms1&Param2=SomeParams2");

O DotNetNuke tem um HttpModule realmente bom que faz isso por seus URLs amigáveis. Ainda é útil para máquinas nas quais você não pode implantar o .NET v3.5.