Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
Visual Studio offre ASP.NET sviluppatori due tipi di progetti: web application projects (WAP) e web site projects (WSP). Una delle differenze principali tra i due tipi di progetto è che i WAP devono avere il codice compilato in modo esplicito prima della distribuzione, mentre il codice in un WSP può essere compilato automaticamente nel server Web. Tuttavia, è possibile precompilare un provider di servizi WSP prima della distribuzione. Questa esercitazione illustra i vantaggi della precompilazione e illustra come precompilare un sito Web da Visual Studio e dalla riga di comando.
Introduzione
Visual Studio offre ASP.NET sviluppatori due tipi di progetto diversi: Progetti applicazione Web (WAP) e Progetti sito Web (WSP). Una delle differenze principali tra questi tipi di progetto è che i WAP richiedono la compilazione esplicita, mentre i WSP, per impostazione predefinita, usano la compilazione automatica. Con i wap si compila il codice dell'applicazione Web in un singolo assembly, creato nella cartella del Bin sito Web. La distribuzione comporta la copia del contenuto di markup (i .aspx.ascx e .master file) nel progetto, insieme all'assembly nella cartella Bin; non è necessario distribuire i file della classe code-behind Bin stessi. D'altra parte, si implementano WSP copiando sia le pagine di markup che le classi code-behind corrispondenti nell'ambiente di produzione. Le classi code-behind vengono compilate su richiesta nel server Web.
Annotazioni
Fare riferimento alla sezione "Compilazione esplicita e compilazione automatica" nell'esercitazione Determinazione dei file da distribuire per altre informazioni sulle differenze tra i modelli di progetto, la compilazione esplicita e automatica e il modo in cui il modello di compilazione influisce sulla distribuzione.
L'opzione di compilazione automatica è semplice da usare. Non esiste alcun passaggio di compilazione esplicito e devono essere distribuiti solo i file che sono stati modificati, mentre la compilazione esplicita richiede la distribuzione delle pagine di markup modificate e dell'assembly appena compilato. Tuttavia, la distribuzione automatica presenta due potenziali svantaggi:
- Poiché le pagine devono essere compilate automaticamente quando vengono visitate per la prima volta, può verificarsi un breve ma notevole ritardo quando viene richiesta una pagina ASP.NET per la prima volta dopo la distribuzione.
- La compilazione automatica richiede che sia il markup dichiarativo che il codice sorgente siano presenti nel server Web. Questa può essere un'opzione non interessante se si prevede di vendere l'applicazione Web ai clienti che lo installeranno nei server Web.
Se una delle due carenze precedenti rappresenta un ostacolo, è possibile passare al modello WAP o precompilare il progetto Web WSP prima della distribuzione. Questa esercitazione esamina le opzioni di precompilazione più adatte per un sito Web ospitato e illustra il processo di precompilazione e la distribuzione di un sito Web precompilato.
Panoramica della generazione e della compilazione di codice ASP.NET
Prima di esaminare le opzioni di precompilazione disponibili, si esaminerà prima di tutto la generazione e la compilazione del codice che si verifica quando viene richiesta una pagina ASP.NET per la prima volta dalla creazione o dall'ultimo aggiornamento. Come sapete, le pagine ASP.NET sono composte da due parti: markup dichiarativo nel file .aspx; e una parte di codice sorgente, in genere in un file di classe code-behind separato (.aspx.cs). I passaggi eseguiti dal runtime quando viene richiesta una pagina di ASP.NET dipendono dal modello di compilazione dell'applicazione.
Con i wap, il codice sorgente delle pagine deve essere compilato in modo esplicito in un singolo assembly prima di essere distribuito. Durante la distribuzione, questo assembly e le varie pagine di markup vengono copiati nell'ambiente di produzione. Quando una richiesta arriva al server Web per una pagina ASP.NET, il runtime crea un'istanza della classe code-behind della pagina e richiama il relativo ProcessRequest metodo, che avvia il ciclo di vita della pagina e, infine, genera il contenuto della pagina, restituito al richiedente. Il runtime può funzionare con la classe code-behind della pagina ASP.NET perché la classe code-behind è già stata compilata in un assembly prima della distribuzione.
Con WSP e compilazione automatica, non è previsto alcun passaggio di compilazione esplicito prima della distribuzione. La distribuzione comporta invece la copia sia del contenuto dichiarativo che del contenuto del codice sorgente nell'ambiente di produzione. Quando una richiesta arriva al server web per una pagina ASP.NET per la prima volta da quando la pagina è stata creata o è stata aggiornata l'ultima volta, il runtime deve prima compilare la classe sottostante in un assembly. Questo assembly compilato viene salvato nella cartella %WINDIR%\Microsoft.NET\Framework\v2.0.50727\Temporary ASP.NET Files, anche se il percorso di questa cartella può essere personalizzato tramite l'elemento <compilation tempDirectory="" /> di <system.web>, in genere in Web.config. Poiché l'assembly viene salvato su disco, non è necessario ricompilarlo alle richieste successive della stessa pagina.
Annotazioni
Come si prevede, si verifica un lieve ritardo quando si richiede una pagina per la prima volta (o per la prima volta dalla modifica) in un sito che usa la compilazione automatica perché il server deve compilare il codice della pagina e salvare l'assembly risultante su disco.
In breve, con la compilazione esplicita è necessario compilare il codice sorgente del sito Web prima della distribuzione, salvando il runtime dalla necessità di eseguire tale passaggio. Con la compilazione automatica, il runtime gestisce la compilazione del codice sorgente delle pagine, ma con un costo di inizializzazione leggero per la prima visita alla pagina dopo la creazione o l'ultimo aggiornamento.
Ma che ne dici della parte dichiarativa delle pagine ASP.NET (il .aspx file)? È ovvio che esiste una relazione tra i .aspx file e il codice nelle classi code-behind, perché i controlli Web definiti nel markup dichiarativo sono accessibili nel codice. È anche ovvio che il contenuto nei .aspx file influisce notevolmente sul markup sottoposto a rendering generato dalla pagina. In che modo il runtime funziona con le sintassi di testo, HTML e dei controlli Web definite nel file .aspx per generare il contenuto della pagina richiesta di cui è stato eseguito il rendering?
Non voglio perdermi troppo nei dettagli di implementazione di basso livello, che variano tra WAP e WSP, ma in poche parole il runtime genera automaticamente un file di classe che contiene i vari controlli web come membri e metodi protetti. Questo file generato viene implementato come classe parziale per la classe code-behind corrispondente.
Le classi parziali consentono di distribuire il contenuto di una singola classe tra più file. Pertanto, la classe code-behind viene definita in due posizioni: nel .aspx.cs file creato e in questa classe generata automaticamente dal runtime. Questa classe generata automaticamente viene archiviata nella %WINDIR%\Microsoft.NET\Framework\v2.0.50727\Temporary ASP.NET Files cartella .
L'importante è che per il rendering di una pagina ASP.NET dal runtime sia le parti dichiarative che di codice sorgente devono essere compilate in un assembly. Con i wap, il codice sorgente viene compilato in modo esplicito in un assembly prima della distribuzione, ma il markup dichiarativo deve comunque essere convertito in codice e compilato dal runtime nel server Web. Con WSP che usano la compilazione automatica, sia il codice sorgente che il markup dichiarativo devono essere compilati dal server Web.
È possibile usare la compilazione esplicita con il modello WSP. È possibile compilare in modo esplicito la parte del codice sorgente, ad esempio con il modello WAP. Inoltre, è anche possibile compilare il markup dichiarativo.
Opzioni di precompilazione
.NET Framework viene fornito con uno strumento di compilazione ASP.NET (aspnet_compiler.exe) che consente di compilare il codice sorgente (e anche il contenuto) di un'applicazione ASP.NET compilata usando il modello WSP. Questo strumento è stato rilasciato con .NET Framework versione 2.0 e si trova nella %WINDIR%\Microsoft.NET\Framework\v2.0.50727 cartella . Può essere usato dalla riga di comando o avviato da Visual Studio tramite l'opzione Pubblica sito Web del menu Compila.
Lo strumento di compilazione fornisce due forme generali di compilazione: precompilazione sul posto e precompilazione per la distribuzione. Con la precompilazione in loco si esegue lo aspnet_compiler.exe strumento dalla riga di comando e si specifica il percorso della directory virtuale o del percorso fisico di un sito Web che risiede nel tuo computer. Lo strumento di compilazione compila quindi ogni pagina ASP.NET nel progetto, archiviando la versione compilata nella %WINDIR%\Microsoft.NET\Framework\v2.0.50727\Temporary ASP.NET Files cartella esattamente come se le pagine fossero state visitate per la prima volta da un browser. La precompilazione sul posto può velocizzare la prima richiesta effettuata alle pagine di ASP.NET appena distribuite nel sito perché riduce il runtime dalla necessità di eseguire questo passaggio. Tuttavia, la precompilazione sul posto non è utile per la maggior parte dei siti Web ospitati perché richiede che sia possibile eseguire programmi dalla riga di comando del server Web. Negli ambienti di hosting condivisi questo livello di accesso non è consentito.
Annotazioni
Per ulteriori informazioni sulla precompilazione in loco, vedere Procedura: Precompilare siti Web ASP.NET e Precompilazione in ASP.NET 2.0.
Anziché compilare le pagine nel sito Web nella Temporary ASP.NET Files cartella , la precompilazione per la distribuzione compila le pagine in una directory di propria scelta e in un formato che può essere distribuito nell'ambiente di produzione.
Esistono due versioni di precompilazione per la distribuzione esaminate in questa esercitazione: precompilazione con un'interfaccia utente aggiornabile e precompilazione con un'interfaccia utente non aggiornabile. La precompilazione con un'interfaccia utente aggiornabile lascia il markup dichiarativo nei .aspxfile , .ascxe .master , consentendo così a uno sviluppatore di visualizzare e, se lo si desidera, modificare il markup dichiarativo nel server di produzione. La precompilazione con un'interfaccia utente non aggiornabile genera .aspx pagine void di qualsiasi contenuto e rimuove .ascx e .master file, nascondendo così il markup dichiarativo e vietando a uno sviluppatore di modificarlo dall'ambiente di produzione.
Precompilazione per la distribuzione con un'interfaccia utente aggiornabile
Il modo migliore per comprendere la precompilazione per la distribuzione consiste nel vedere un esempio in azione. Precompilare il WSP Book Reviews per la distribuzione usando un'interfaccia utente aggiornabile. Lo strumento di compilazione ASP.NET può essere richiamato dal menu Compila di Visual Studio o dalla riga di comando. Questa sezione esamina l'uso dello strumento da Visual Studio; La sezione "Precompilazione dalla riga di comando" esamina l'esecuzione dello strumento del compilatore dalla riga di comando.
Aprire Book Review WSP in Visual Studio , passare al menu Compila e selezionare l'opzione di menu Pubblica sito Web. Verrà avviata la finestra di dialogo Pubblica sito Web (vedere la figura 1), in cui è possibile specificare il percorso di destinazione, se l'interfaccia utente del sito precompilato è aggiornabile e altre opzioni dello strumento del compilatore. Il percorso di destinazione può essere un server Web remoto o un server FTP, ma per il momento scegliere una cartella sul disco rigido del computer. Poiché si vuole precompilare il sito con un'interfaccia utente aggiornabile, lasciare selezionata la casella di controllo "Consenti aggiornabile il sito precompilato" e fare clic su OK.
Figura 1: Lo strumento di compilazione ASP.NET precompila il sito Web nel percorso di destinazione specificato
(Fare clic per visualizzare l'immagine a dimensione intera)
Annotazioni
L'opzione Pubblica sito Web nel menu Compila non è disponibile in Visual Web Developer. Se si usa Visual Web Developer, è necessario usare la versione della riga di comando dello strumento di compilazione ASP.NET, descritta nella sezione "Precompilazione dalla riga di comando".
Dopo la precompilazione del sito Web, accedere al percorso di destinazione inserito nella finestra di dialogo Pubblica sito Web. Dedicare un attimo a confrontare il contenuto di questa cartella con il contenuto del sito Web.
La figura 2 mostra la cartella del sito Web Book Reviews. Si noti che contiene sia i file .aspx che i file .aspx.cs. Si noti anche che la Bin directory include un solo file, Elmah.dll, che è stato aggiunto nell'esercitazione precedente
Figura 2: La directory del progetto contiene i file .aspx e .aspx.cs; la cartella Bin contiene solo Elmah.dll
(Fare clic per visualizzare l'immagine a dimensione intera)
La figura 3 mostra la cartella del percorso di destinazione il cui contenuto è stato creato dallo strumento di compilazione ASP.NET. Questa cartella non contiene alcun file del codice associato. Inoltre, la directory di questa cartella Bin include diversi assembly e due file .compiled oltre all'assembly Elmah.dll.
Figura 3: La cartella Percorso di destinazione include i file per la distribuzione
(Fare clic per visualizzare l'immagine a dimensione intera)
A differenza della compilazione esplicita nei WAP, la precompilazione per il processo di distribuzione non crea un assembly per l'intero sito. Raggruppa in batch diverse pagine in ogni assembly. Compila anche il file Global.asax (se presente) nel proprio assembly, oltre a eventuali classi nella cartella App_Code. I file che contengono il markup dichiarativo per le pagine Web ASP.NET, i controlli utente e le pagine master (.aspx, .ascx e .master file, rispettivamente) vengono copiati così come sono nella directory di destinazione. Analogamente, il Web.config file viene copiato direttamente, insieme a qualsiasi file statico, ad esempio immagini, classi CSS e file PDF. Per una descrizione più formale del modo in cui lo strumento di compilazione gestisce vari tipi di file, vedere Gestione dei file durante ASP.NET precompilazione.
Annotazioni
È possibile indicare allo strumento di compilazione di creare un assembly per pagina ASP.NET, controllo utente o pagina master selezionando la casella di controllo "Usata la denominazione fissa e gli assembly a pagina singola" dalla finestra di dialogo Pubblica sito Web. La compilazione di ogni pagina ASP.NET nel proprio assembly consente un controllo più granulare sulla distribuzione. Ad esempio, se è stata aggiornata una singola pagina Web ASP.NET ed è necessario distribuire tale modifica, è necessario distribuire solo il file della .aspx pagina e l'assembly associato all'ambiente di produzione. Per altre informazioni, vedere Procedura: Generare nomi fissi con lo strumento di compilazione ASP.NET .
La directory della posizione di destinazione contiene anche un file che non faceva parte del progetto web precompilato, ossia PrecompiledApp.config. Questo file informa il runtime ASP.NET che l'applicazione è stata precompilata e se è stata precompilata con un'interfaccia utente aggiornabile o non aggiornabile.
Infine, aprire uno dei .aspx file nel percorso di destinazione usando Visual Studio o l'editor di testo preferito. Quando si esegue la precompilazione per la distribuzione con un'interfaccia utente aggiornabile, le pagine ASP.NET nella directory dei percorsi di destinazione contengono esattamente lo stesso markup dei file corrispondenti nel sito Web.
Precompilazione per la distribuzione con un'interfaccia utente non aggiornabile
Lo strumento del compilatore ASP.NET può essere usato anche per precompilare un sito per la distribuzione con un'interfaccia utente non aggiornabile. La precompilazione del sito con un'interfaccia utente non aggiornabile funziona molto come la precompilazione con un'interfaccia utente aggiornabile, la differenza principale è che le pagine ASP.NET, i controlli utente e le pagine master nella directory di destinazione vengono rimosse dal markup. Per precompilare un sito Web per la distribuzione con un'interfaccia utente non aggiornabile, scegliere l'opzione Pubblica sito Web dal menu Compila, ma deselezionare l'opzione "Consenti l'aggiornabilità di questo sito precompilato" (vedere la figura 4).
Figura 4: Deselezionare l'opzione "Consenti l'aggiornabilità di questo sito precompilato" per precompilare con un'interfaccia utente non aggiornabile
(Fare clic per visualizzare l'immagine a dimensione intera)
La figura 5 mostra la cartella del percorso di destinazione dopo la precompilazione con un'interfaccia utente non aggiornabile.
Figura 5: Cartella del percorso di destinazione per la distribuzione con un'interfaccia utente non aggiornabile
(Fare clic per visualizzare l'immagine a dimensione intera)
Confrontare la figura 3 con la figura 5. Sebbene le due cartelle siano identiche, si noti che la cartella dell'interfaccia utente non aggiornabile non dispone della pagina master, Site.master. Mentre nella figura 5 sono incluse le varie pagine ASP.NET, se si visualizza il contenuto di questi file si noterà che sono stati rimossi dal markup dichiarativo e sostituiti con il testo segnaposto: "Si tratta di un file marcatore generato dallo strumento di precompilazione e non deve essere eliminato!"
Screenshot dei file A S P . N E T spogliati del loro markup dichiarativo e sostituiti con il testo segnaposto.
Figura 5: Il markup dichiarativo è stato rimosso dalle pagine ASP.NET
Le Bin cartelle nelle figure 3 e 5 differiscono in modo più sostanziale. Oltre agli assembly, la Bin cartella nella figura 5 include un .compiled file per ogni pagina ASP.NET, controllo utente e pagina master.
La precompilazione di un sito con un'interfaccia utente non aggiornabile è utile nelle situazioni in cui non si desidera che il contenuto delle pagine ASP.NET venga modificato dalla persona o dall'azienda che installa o gestisce il sito Web nell'ambiente di produzione. Se create un'applicazione Web ASP.NET che vendete ai clienti per l'installazione sui loro server Web, dovreste assicurarvi che non modifichino l'aspetto del sito modificando direttamente le .aspx pagine che fornite loro. Compilando in anticipo il tuo sito web con un'interfaccia utente non aggiornabile, le pagine segnaposto .aspx vengono fornite come parte dell'installazione, impedendo ai clienti di esaminare o modificare il contenuto.
Precompilazione dalla riga di comando
Dietro le quinte, la finestra di dialogo Pubblica sito Web di Visual Studio richiama lo strumento di compilazione ASP.NET (aspnet_compiler.exe) per precompilare il sito Web. In alternativa, è possibile richiamare questo strumento dalla riga di comando. Infatti, se si usa Visual Web Developer, sarà necessario eseguire lo strumento del compilatore dalla riga di comando, poiché il menu Compilazione di Visual Web Developer non include l'opzione Pubblica sito Web.
Per utilizzare lo strumento del compilatore dalla riga di comando, inizia accedendo al prompt dei comandi e navigando nella directory del framework. %WINDIR%\Microsoft.NET\Framework\v2.0.50727 Immettere quindi l'istruzione seguente nella riga di comando:
aspnet_compiler -p "physical_path_to_app" -v / -f -u "target_location_folder"
Il comando precedente avvia lo strumento del compilatore ASP.NET (aspnet_compiler.exe) e, tramite l'opzione -p, indica di precompilare il sito Web radicato in physical_path_to_app; questo valore sarà simile a C:\MySites\BookReviews, e deve essere delimitato da virgolette.
L'opzione -v specifica la directory virtuale del sito. Se il sito è registrato come sito Web predefinito nella metabase IIS, è possibile omettere l'opzione -p e specificare solo la directory virtuale dell'applicazione. Se si usa l'opzione -p, il valore che segue l'opzione -v indica la radice del sito Web e viene usato per risolvere i riferimenti all'applicazione radice. Ad esempio, se si specifica un valore di -v /MySite , i riferimenti nell'applicazione a ~/path/file verranno risolti come ~/MySite/path/file. Poiché il sito Book Reviews si trova nella directory radice della mia società di hosting Web ho usato l'opzione -v /.
Se l'opzione -f è presente, indica allo strumento di compilazione di sovrascrivere la directory target_location_folder se già esistente. Se si omette l'opzione -f e la cartella di destinazione esiste già, lo strumento di compilazione si interromperà con l'errore: "errore ASPRUNTIME: La directory di destinazione non è vuota." Eliminarlo manualmente o scegliere una destinazione diversa."
L'opzione -u , se presente, informa lo strumento per creare un'interfaccia utente aggiornabile. Omettere questa opzione per precompilare il sito con un'interfaccia utente non aggiornabile.
Infine, il target_location_folder è il percorso fisico della directory di destinazione; questo valore sarà simile a C:\MySites\Output\BookReviews e deve essere racchiuso tra virgolette.
Distribuzione del sito Web precompilato
A questo punto abbiamo visto come usare lo strumento di compilazione ASP.NET per precompilare un sito Web usando sia le opzioni aggiornabili che non aggiornabili dell'interfaccia utente. Tuttavia, i nostri esempi finora hanno precompilato il sito Web in una cartella locale e non nell'ambiente di produzione. La buona notizia è che distribuire il sito precompilato è molto semplice e può essere eseguito tramite Visual Studio o attraverso un altro metodo di copia file, come un client FTP indipendente.
La finestra di dialogo Pubblica sito Web (illustrata nella figura 1) include un'opzione di percorso di destinazione, che indica dove vengono copiati i file del sito Web precompilato. Questa posizione può essere un server web remoto o un server FTP. L'immissione di un server remoto in questa casella di testo precompila e distribuisce il sito Web nel server specificato in un unico passaggio. In alternativa, è possibile precompilare il sito Web in una cartella locale e quindi copiare manualmente il contenuto di tale cartella nell'ambiente di produzione tramite FTP o un altro approccio.
La distribuzione automatica del sito Web precompilato tramite la finestra di dialogo Pubblica sito Web di Visual Studio è utile per i siti semplici in cui non esistono differenze di configurazione tra gli ambienti di sviluppo e di produzione. Tuttavia, come indicato nell'esercitazione sulle differenze di configurazione comuni tra sviluppo e produzione, non è raro che esistano tali differenze. Ad esempio, l'applicazione Web Book Reviews usa un database diverso nell'ambiente di produzione rispetto all'ambiente di sviluppo. Quando Visual Studio pubblica il sito Web in un server remoto, copia in modo cieco le informazioni sul file di configurazione nell'ambiente di sviluppo.
Per i siti con differenze di configurazione tra gli ambienti di sviluppo e di produzione, può essere preferibile precompilare il sito in una directory locale, copiare i file di configurazione specifici della produzione e quindi copiare il contenuto dell'output precompilato nell'ambiente di produzione.
Per un aggiornamento sulla copia di file dall'ambiente di sviluppo all'ambiente di produzione, vedere l'esercitazione Distribuzione del sito Web tramite un client FTP e distribuzione del sito Web tramite Visual Studio .
Sommario
ASP.NET supporta due modalità di compilazione: automatica ed esplicita. Come illustrato nelle esercitazioni precedenti, i progetti di applicazioni Web (WAP) usano la compilazione esplicita, mentre per impostazione predefinita i progetti di siti Web (WSP) usano la compilazione automatica. Tuttavia, è possibile compilare in modo esplicito un WSP prima della distribuzione usando lo strumento di compilazione ASP.NET.
Questa esercitazione è incentrata sulla precompilazione dello strumento di compilazione per il supporto della distribuzione. Durante la precompilazione per la distribuzione, lo strumento di compilazione crea una cartella del percorso di destinazione, compila il codice sorgente dell'applicazione Web specificata e copia questi assembly compilati e i file di contenuto nella cartella del percorso di destinazione. Lo strumento di compilazione può essere configurato per creare un'interfaccia utente aggiornabile o non aggiornabile. Quando si esegue la precompilazione con un'opzione di interfaccia utente non aggiornabile, il markup dichiarativo nei file di contenuto viene rimosso. In breve, la precompilazione consente di distribuire l'applicazione basata su Progetto sito Web senza includere file di codice sorgente e con il markup dichiarativo rimosso, se necessario.
Buon programmatori!
Altre informazioni
Per altre informazioni sugli argomenti illustrati in questa esercitazione, vedere le risorse seguenti: