Funzioni nascoste di ASP.NET [chiuso]

Questa domanda esiste perché ha un significato storico, ma non è considerata una buona domanda sull'argomento per questo sito, quindi per favore non usarla come prova che puoi fare domande simili qui.

Ulteriori informazioni: https://stackoverflow.com/faq

Ci sono sempre caratteristiche che sarebbero utili in scenari marginali, ma proprio per questo la maggior parte delle persone non le conosce. Chiedo funzioni che in genere non sono insegnate dai libri di testo.

Quali sono quelli che conosci?

Durante il test, è possibile inviare e-mail a una cartella sul computer anziché a un server SMTP. Inserisci questo nel tuo web.config:

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

Se si inserisce un file denominato app_offline.htm nella directory principale di una directory dell'applicazione Web, ASP.NET 2.0+ arresta l'applicazione e interrompe l'elaborazione normale di eventuali nuove richieste in arrivo per tale applicazione, mostrando solo il contenuto di app_offline.htm file per tutte le nuove richieste .

Questo è il modo più rapido e semplice per visualizzare l'avviso "Sito temporaneamente non disponibile" durante la ridistribuzione (o il rollback) delle modifiche su un server di produzione.

Inoltre, come sottolineato da Marxidad , assicurati di avere almeno 512 byte di contenuto all'interno del file in modo che IE6 lo visualizzi correttamente.

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

Questo verrà rilevato da ASP.NET che restituirà la pagina customErrors. Scopri questo in un recente post di .NET Tip of the Day

Ecco il migliore. Aggiungi questo al tuo web.config per una compilazione MOLTO più veloce. Questo è post 3.5SP1 tramite questo QFE .

<compilation optimizeCompilations="true">

Riepilogo rapido: stiamo introducendo un nuovo switch optimCompilations in ASP.NET che può migliorare notevolmente la velocità di compilazione in alcuni scenari. Ci sono alcune catture, quindi continua a leggere per maggiori dettagli. Questo switch è attualmente disponibile come QFE per 3.5SP1 e farà parte di VS 2010.

Il sistema di compilazione ASP.NET adotta un approccio molto conservativo che gli fa cancellare qualsiasi lavoro precedente che ha fatto ogni volta che cambia un file di "livello superiore". I file "di livello superiore" includono qualsiasi cosa nel bin e App_Code, così come global.asax. Mentre questo funziona bene per le piccole app, diventa quasi inutilizzabile per app molto grandi. Ad esempio, un cliente si è imbattuto in un caso in cui ci sono voluti 10 minuti per aggiornare una pagina dopo aver apportato modifiche a un assieme "bin".

Per alleviare il dolore, abbiamo aggiunto una modalità di compilazione "ottimizzata" che adotta un approccio molto meno conservativo alla ricompilazione.

Via qui :

• HttpContext.Current ti darà sempre accesso alla richiesta / risposta / ecc. Del contesto corrente, anche quando non hai accesso alle proprietà della Pagina (ad esempio, da una classe di supporto liberamente accoppiata).

• Puoi continuare a eseguire il codice sulla stessa pagina dopo aver reindirizzato l'utente a un altro chiamando Response.Redirect ( url , false )

• Non hai bisogno di file .ASPX se tutto ciò che desideri è una Pagina compilata (o qualsiasi IHttpHandler ). Basta impostare il percorso e i metodi HTTP in modo che puntino alla classe <httpHandlers>nell'elemento nel file web.config.

• Un oggetto Page può essere recuperato da un file .ASPX a livello di codice chiamando PageParser.GetCompiledPageInstance (virtualPath, aspxFileName, Context)

Modalità di vendita al dettaglio a livello di machine.config:

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

Sostituisce le impostazioni web.config per imporre il debug su false, attiva gli errori personalizzati e disabilita la traccia. Non dimenticare più di modificare gli attributi prima della pubblicazione: lasciali tutti configurati per ambienti di sviluppo o test e aggiorna le impostazioni di vendita al dettaglio di produzione.

Abilitare intellisense per MasterPages nelle pagine dei contenuti
Sono sicuro che si tratta di un hack poco conosciuto

Il più delle volte devi usare il metodo findcontrol e lanciare i controlli nella pagina principale dalle pagine di contenuto quando vuoi usarli, la direttiva MasterType abiliterà intellisense in Visual Studio una volta che hai fatto questo

basta aggiungere un'altra direttiva alla pagina

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

Se non si desidera utilizzare il percorso virtuale e utilizzare invece il nome della classe, allora

<%@ MasterType TypeName="MyMainMasterPage" %>

Ottieni l'articolo completo qui

HttpContext.Items come strumento di memorizzazione nella cache a livello di richiesta

Due cose spiccano nella mia testa:

1) È possibile attivare e disattivare la traccia dal codice:

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

2) È possibile creare più pagine aspx utilizzando un solo file "code-behind" condiviso.

Crea un file .cs di 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 quindi puoi avere un numero qualsiasi di pagine .aspx (dopo aver eliminato .designer.cs e .cs code-behind che VS ha generato):

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

È possibile avere controlli nell'ASPX che non compaiono in Class1 e viceversa, ma è necessario ricordarsi di controllare i controlli per null.

Puoi usare:

 Request.Params[Control.UniqueId] 

Per ottenere il valore di un controllo PRIMA di inizializzare viewstate (Control.Text ecc. Sarà vuoto a questo punto).

Questo è utile per il codice in Init.

WebMethods.

È possibile utilizzare i callback ASP.NET AJAX per i metodi Web inseriti nelle pagine ASPX. È possibile decorare un metodo statico con gli attributi [WebMethod ()] e [ScriptMethod ()]. Per esempio:

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

Ora, nella tua pagina ASPX puoi fare questo:

<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 chiama il tuo metodo lato server tramite JavaScript utilizzando:

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

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

Verifica se il client è ancora connesso, prima di avviare un'attività di lunga durata:

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

Una caratteristica poco conosciuta e usata raramente di ASP.NET è:

Mappatura tag

È usato raramente perché c'è solo una situazione specifica in cui ne avresti bisogno, ma quando ne hai bisogno, è così utile.

Alcuni articoli su questa funzione poco conosciuta:

Mappatura dei tag in ASP.NET
Uso della mappatura dei tag in ASP.NET 2.0

e da quell'ultimo articolo:

La mappatura dei tag consente di scambiare controlli compatibili in fase di compilazione su ogni pagina dell'applicazione Web. Un esempio utile è se si dispone di un controllo ASP.NET di riserva, come DropDownList, e si desidera sostituirlo con un controllo personalizzato derivato da DropDownList. Questo potrebbe essere un controllo che è stato personalizzato per fornire una cache più ottimizzata dei dati di ricerca. Invece di modificare ogni modulo Web e sostituire le DropDownLists integrate con la tua versione personalizzata, puoi fare in modo che ASP.NET lo faccia per te modificando web.config:

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

HttpModules . L'architettura è pazzesca ed elegante. Forse non è una funzione nascosta, ma comunque interessante.

È possibile utilizzare i commenti ASP.NET all'interno di una pagina aspx per commentare parti complete di una pagina, inclusi i controlli del server. E i contenuti commentati non verranno mai inviati al client.

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

Il generatore di espressioni di codice

Markup di esempio:

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

La vera bellezza del generatore di espressioni di codice è che è possibile utilizzare la databinding come espressioni in situazioni non di databinding. Puoi anche creare altri Expression Builder che svolgono altre funzioni.

web.config:

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

La classe cs che rende tutto ciò possibile:

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

Utilizzo del tipo di file ASHX:
se si desidera semplicemente generare alcuni html o xml di base senza passare attraverso i gestori di eventi di pagina, è possibile implementare HttpModule in modo semplice

Denominare la pagina come SomeHandlerPage.ashx e inserire semplicemente il codice seguente (solo una riga) in essa

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

Quindi il file di codice

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

Impostazione delle proprietà di controllo del server in base al browser di destinazione e altro .

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

Quello mi ha colto di sorpresa.

System.Web.VirtualPathUtility

Ho lavorato su un'applicazione asp.net che è stata sottoposta a un audit di sicurezza da una delle principali società di sicurezza e ho imparato questo semplice trucco per prevenire una vulnerabilità di sicurezza meno nota ma importante.

La spiegazione di seguito è tratta da: http://www.guidanceshare.com/wiki/ASP.NET_2.0_Security_Guidelines_-_Parameter_Manipulation#Consider_Using_Page.ViewStateUserKey_to_Counter_One-Click_Attacks

Prendi in considerazione l'utilizzo di Page.ViewStateUserKey per contrastare gli attacchi con un clic. Se si autenticano i chiamanti e si utilizza ViewState, impostare la proprietà Page.ViewStateUserKey nel gestore eventi Page_Init per impedire attacchi con un clic.

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

Impostare la proprietà su un valore che si conosce sia univoco per ciascun utente, ad esempio un ID sessione, un nome utente o un identificatore utente.

Un attacco con un clic si verifica quando un utente malintenzionato crea una pagina Web (.htm o .aspx) che contiene un campo modulo nascosto denominato __VIEWSTATE che è già pieno di dati ViewState. ViewState può essere generato da una pagina che l'attaccante aveva precedentemente creato, ad esempio una pagina del carrello con 100 articoli. L'attaccante attira un utente ignaro a navigare nella pagina, quindi l'attaccante fa in modo che la pagina venga inviata al server in cui ViewState è valido. Il server non ha modo di sapere che ViewState ha avuto origine dall'aggressore. La convalida di ViewState e gli HMAC non contrastano questo attacco perché ViewState è valido e la pagina viene eseguita nel contesto di sicurezza dell'utente.

Impostando la proprietà ViewStateUserKey, quando l'attaccante accede a una pagina per creare ViewState, la proprietà viene inizializzata con il suo nome. Quando l'utente legittimo invia la pagina al server, viene inizializzata con il nome dell'attaccante. Di conseguenza, il controllo HMAC ViewState non riesce e viene generata un'eccezione.

HttpContext.Current.IsDebuggingEnabled

Questo è ottimo per determinare quali script produrre (versioni min o complete) o qualsiasi altra cosa tu possa desiderare in sviluppo, ma non in diretta.

Incluso in ASP.NET 3.5 SP1:

• customErrors ora supporta l'attributo "redirectMode" con un valore di "ResponseRewrite". Mostra la pagina di errore senza modificare l'URL.
• Il tag del modulo ora riconosce l'attributo action. Ottimo per quando si utilizza la riscrittura degli URL

Proprietà DefaultButton nei pannelli.

Imposta il pulsante predefinito per un determinato pannello.

ScottGu ha un sacco di trucchi su http://weblogs.asp.net/scottgu/archive/2006/04/03/441787.aspx

Utilizzo di configSource per dividere i file di configurazione.

È possibile utilizzare l'attributo configSource in un file web.config per inviare elementi di configurazione ad altri file .config, ad esempio invece di:

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

... puoi avere l'intera sezione appSettings memorizzata in un altro file di configurazione. Ecco il nuovo web.config:

    <appSettings configSource="myAppSettings.config" />

Il myAppSettings.configfile:

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

Questo è abbastanza utile per gli scenari in cui si distribuisce un'applicazione a un cliente e non si desidera che interferiscano con il file web.config stesso e si desidera solo che siano in grado di modificare solo alcune impostazioni.

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

Attributo MaintainScrollPositionOnPostback nella direttiva Page. Viene utilizzato per mantenere la posizione di scorrimento della pagina aspx tra i postback.

HttpContext.IsCustomErrorEnabled è una funzionalità interessante, l'ho trovata utile più di una volta. Ecco un breve post a riguardo.

Per impostazione predefinita, qualsiasi contenuto tra i tag per un controllo personalizzato viene aggiunto come controllo figlio. Questo può essere intercettato in una sostituzione AddParsedSubObject () per il filtro o l'analisi aggiuntiva (ad esempio, del contenuto del testo in 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 ASP.NET genera un feed RSS, a volte inserirà una riga aggiuntiva nella parte superiore della pagina. Ciò non verrà convalidato con i validatori RSS comuni. Puoi aggirare il problema inserendo la direttiva page <@Page>nella parte inferiore della pagina.

Prima che ASP.NET v3.5 aggiungesse le route, è possibile creare i propri URL descrittivi semplicemente scrivendo un HTTPModule e riscrivendo la richiesta all'inizio della pipeline della pagina (come l'evento BeginRequest).

Gli URL come http: // servername / page / Param1 / SomeParams1 / Param2 / SomeParams2 verrebbero mappati su un'altra pagina come sotto (spesso usando espressioni regolari).

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

DotNetNuke ha un ottimo HttpModule che lo fa per i loro URL amichevoli. È ancora utile per i computer in cui non è possibile distribuire .NET v3.5.