Capitolo 1: Modello di applicazione "Longhorn"

 

Introduzione

Capitolo 1: Modello di applicazione "Longhorn"

Brent Rettore
Wise Owl Consulting

Ottobre 2003

Contenuto

Caratteristiche del modello di applicazione "Longhorn"
Classe Application
Classe NavigationApplication
Extensible Application Markup Language (XAML)
Riepilogo

Perché è necessario un nuovo modello di applicazione? Uno dei motivi principali è colmare il divario tra lo sviluppo di un'applicazione per Microsoft® Windows® e lo sviluppo di un'applicazione per il Web.

Oggi, quando scrivi un'applicazione Windows, puoi sfruttare le funzionalità di Windows. L'applicazione può fornire un'interfaccia utente avanzata e reattiva. È possibile installare l'applicazione nel computer client, che consente all'applicazione di eseguire offline, senza una connessione di rete. Le applicazioni Windows possono sfruttare le funzionalità hardware del computer client.

Tuttavia, le applicazioni Windows tradizionali presentano anche alcuni svantaggi. In genere è necessario installare un'applicazione Windows. In questo modo l'applicazione e tutti gli aggiornamenti sono difficili da distribuire. Le applicazioni Windows non vengono eseguite nel browser. Pertanto, i paradigmi familiari dell'interfaccia utente Web, ad esempio le applicazioni orientate alle pagine, lo spostamento direttamente da una pagina a un'altra, la cronologia delle pagine e altro ancora non sono disponibili per l'applicazione, a meno che non vengano creati da zero. Le applicazioni Windows non supportano molto bene il testo, soprattutto quando si tenta di combinare testo e grafica nella stessa pagina. La creazione di un'applicazione Windows che scorre automaticamente il testo intorno alla grafica e che risponde alle modifiche avviate dall'utente nelle dimensioni della finestra e alle preferenze dell'utente per i tipi di carattere e la leggibilità è un'enorme quantità di lavoro.

Anche le applicazioni Web hanno i propri punti di forza distinti. Quando si passa a una pagina Web, il browser scarica solo tale pagina e i componenti necessari per la pagina. Quando si passa a una nuova pagina, il browser scarica quindi i requisiti della nuova pagina. In altre parole, il browser scarica progressivamente l'applicazione in base alle esigenze.

La distribuzione di un'applicazione Web è semplice. Quale distribuzione? Inserire i componenti dell'applicazione necessari in un server e il browser li scarica in base alle esigenze. Non è disponibile alcuna distribuzione.

Anche la creazione dell'interfaccia utente per un'applicazione Web è piuttosto semplice. Dichiari le tue intenzioni usando il markup. Si supponga, ad esempio, di volere una tabella in una posizione specifica. Voglio che un'immagine segua la tabella. Voglio un testo che scorre intorno all'immagine. La combinazione di testo, grafica e contenuti multimediali (audio e video) in un'applicazione Web è semplice.

Naturalmente, le applicazioni Web hanno anche i loro punti negativi. Non è possibile installare un'applicazione Web nel sistema desktop; pertanto, l'applicazione non può essere eseguita offline. È sempre necessario avere una connessione al server. Alcune operazioni dell'applicazione richiedono il round trip al server e ciò riduce le prestazioni. Una selezione di controlli applicazione Web è piuttosto primitiva rispetto ai controlli Windows disponibili. Un'applicazione Web ha quindi in genere scarsa interattività. È anche difficile sviluppare un'interfaccia utente interessante per un'applicazione Web perché è necessario esprimere qualsiasi layout non semplice usando tabelle.

Attualmente, gli sviluppatori che progettano nuove applicazioni devono prendere una decisione iniziale, enorme e irreversibile: l'applicazione deve essere un'applicazione in stile Web o una classica applicazione Microsoft Win32®? Sono necessari modelli di programmazione completamente separati (e competenze!) a seconda del modello di applicazione scelto.

"Longhorn" consente di sviluppare applicazioni usando il meglio di entrambi i mondi. Il modello di applicazione "Longhorn" accetta le migliori funzionalità delle applicazioni Web e le migliori funzionalità delle applicazioni Windows e le combina in un unico modello di programmazione unificato basato sul codice gestito.

Un secondo motivo principale per lo sviluppo di un nuovo modello di applicazione consiste nel fornire un singolo modello di programmazione in grado di creare la vasta gamma di "applicazioni" attualmente in uso. Guarda uno dei tuoi siti Web preferiti, ad esempio CNN o MSNBC. Il sito Web è un'applicazione tradizionale? Si tratta di un documento? È una presentazione multimediale? In molti casi, la risposta è sì a tutte e tre le domande.

Quando un sito Web include elementi dell'interfaccia utente, ad esempio caselle di riepilogo, controlli di modifica e pulsanti di opzione, sembra che un'applicazione presenti un'interfaccia utente. Tuttavia, quando visualizza immagini e testo che scorre intorno alle immagini, il sito Web è simile a un documento. Quando presenta contenuti Flash, grafica, audio, video e animazione, il sito Web sembra essere una presentazione multimediale.

Naturalmente, questi siti Web ricchi sono difficili da sviluppare. È necessario applicare patch insieme a una descrizione basata su markup HTML della pagina, con i controlli Microsoft ActiveX® per un'interfaccia utente avanzata, con animazioni Flash incorporate ed eventualmente usando il formato PDF (Portable Document Format) per il supporto dei documenti. Tutte queste tecnologie usano un'architettura diversa, forniscono caratteristiche di prestazioni diverse e richiedono modelli e strumenti di programmazione diversi.

Ciò significa in genere che è necessario assumere più sviluppatori con set di competenze diversi per sviluppare ogni parte dell'applicazione. Gli sviluppatori devono quindi unire i diversi modelli in una singola applicazione funzionante. Lo sviluppo dell'applicazione è abbastanza difficile. Il debug è spesso un incubo.

"Longhorn" offre un'architettura unificata che supporta questi tre livelli, ovvero documenti, applicazioni e supporti. Creare l'interfaccia utente in modo dichiarativo usando il markup? Vai per questo. È necessario usare controlli Windows avanzati? Allora farlo! Si vogliono scrivere gestori eventi in un linguaggio gestito fortemente tipizzato? Puoi farlo anche tu. Si desidera combinare testo, grafica e video in un documento con layout e presentazione intelligenti in base alle preferenze dell'utente e ottimizzate per la migliore visualizzazione e lettura nel sistema client? Sapete una cosa? Anche tu lo fai.

Il modello di applicazione "Longhorn" consente di scrivere un'applicazione usando un singolo modello di programmazione che supporta la funzionalità dell'interfaccia utente in stile applicazione, la presentazione in stile documento di testo e grafica e l'integrazione di vari supporti. È anche possibile creare l'interfaccia utente usando markup come un'applicazione Web. Si ottiene anche la facilità di distribuzione (o mancanza di distribuzione) di un'applicazione Web. Tuttavia, hai ancora le prestazioni e la possibilità di installare l'applicazione per l'uso offline come un'applicazione Windows. L'applicazione può essere eseguita come applicazione autonoma o ospitata in un Web browser semplicemente ricompilando una base di codice sorgente. In entrambi i casi, l'applicazione può essere basata su form, come molte applicazioni Windows tradizionali o basate su pagine, ad esempio applicazioni Web.

Caratteristiche del modello di applicazione "Longhorn"

Il modello di applicazione "Longhorn" definisce il significato di un'applicazione:

• Punti di ingresso
• Flusso di controllo: come spostarsi da una pagina a un'altra
• Stato condiviso e risorse
• Eventi a livello di applicazione
• Isolamento da altre applicazioni

Il modello di applicazione "Longhorn" definisce come distribuire e gestire un'applicazione:

• Distribuzione come singolo o più file
• Aggiornare, eseguire il rollback e l'amministrazione

Il modello di applicazione "Longhorn" definisce l'esperienza dell'utente con l'applicazione:

• Installazione a impatto zero
• Autonomo (stile Windows) o integrato nel browser
• Esegue online o offline
• Modello di spostamento

Applicazioni Web "Longhorn"

Il modello di applicazione "Longhorn" consente di scrivere un'applicazione avanzata in modo analogo al modo in cui si scrivono le applicazioni Web odierne. In questo modo viene fornito un percorso di migrazione semplice per gli sviluppatori Web, poiché il codice scritto è simile al codice per le pagine Web DHTML (Dynamic HTML). Possono (brividi) inserire markup e script nello stesso file. Possono distribuire i file per l'applicazione in un server Web. Le pagine dell'applicazione vengono eseguite nel Web browser.

Tuttavia, il modello a oggetti per un'applicazione in stile Web "Longhorn" è molto più semplice e molto più potente di DHTML. Il codice dell'applicazione può usare il livello di presentazione "Longhorn" completo. Pertanto, un'applicazione Web "Longhorn" può usare controlli client avanzati, supportare elementi multimediali e grafici nella pagina, gestire gli eventi in locale, fondamentalmente tutto ciò che può fare un'applicazione client normale. Infatti, un'applicazione Web "Longhorn" non è molto diversa da un'applicazione desktop "Longhorn" diversa da quella dei file in un server; un browser in genere, ma non necessariamente, ospita l'interfaccia utente; e l'applicazione viene eseguita con autorizzazioni limitate perché l'utente non l'ha installato nel sistema client.

Applicazioni desktop "Longhorn"

Il modello di applicazione "Longhorn" definisce anche come scrivere applicazioni desktop. Un'applicazione desktop "Longhorn"è un'applicazione installata localmente dall'utente. Tali applicazioni possono essere eseguite online o offline. Tali applicazioni possono registrarsi con la shell, posizionare le icone sul desktop, aggiungere collegamenti al menu Start e altro ancora.

Un'applicazione desktop può essere eseguita anche nella finestra del browser o in una finestra autonoma. Infatti, un'applicazione desktop può supportare molte funzionalità tradizionalmente associate a un'applicazione Web, tra cui quanto segue:

• Definire in modo esplicito i punti di ingresso esterni, ovvero può iniziare in qualsiasi pagina
• Condividere lo stato tra pagine
• Gestire vari eventi, inclusi gli eventi di spostamento pagina
• Controllare il flusso dell'applicazione
• Aggiungere/rimuovere voci da una cronologia pagina/log di spostamento di viaggio
• Avviare le finestre dell'applicazione

Creazione di un'applicazione "Longhorn"

Per creare un'applicazione "Longhorn", si definisce il modello a oggetti per l'applicazione. È possibile definire il modello a livello di codice scrivendo codice o dichiarativo scrivendo markup in un linguaggio denominato Extensible Application Markup Language (XAML). È possibile compilare il codice e/o il markup in uno o più assembly .NET, un file manifesto dell'applicazione e un file manifesto di distribuzione.

Facoltativamente, è possibile creare un pacchetto dell'applicazione in un nuovo formato di file, denominato contenitore. I file dell'applicazione in un contenitore possono essere compressi, crittografati e firmati digitalmente.

Viene illustrata la creazione di un'applicazione "Longhorn" in dettaglio nel capitolo 2, ma per ora l'idea principale è che la creazione di un'applicazione "Longhorn" fornisce il codice dell'applicazione, un manifesto dell'applicazione che descrive tutti i componenti usati dall'applicazione e un manifesto di distribuzione che indica al sistema come installare e gestire l'applicazione.

Distribuzione di un'applicazione "Longhorn"

Il modello di applicazione "Longhorn" offre una distribuzione semplice e conveniente dell'applicazione. Nel caso più semplice, è sufficiente copiare i file dell'applicazione in un server. Analogamente, l'installazione dell'applicazione è semplice e non interessata.

Un'opzione non consiste nell'installare l'applicazione. L'utente può passare al manifesto dell'applicazione in un server ed eseguirlo. "Longhorn" scarica in modo incrementale l'applicazione ed esegue questa operazione. Non si ottengono richieste di conferma, nessun requisito di riavvio e nessuna DLL. Infatti, non è necessario nemmeno diritti di amministratore per installare o eseguire l'applicazione.

In alternativa, l'utente può passare al manifesto della distribuzione dell'applicazione nel server ed eseguirlo. "Longhorn" scarica in modo incrementale l'applicazione, la installa e la esegue. Per impostazione predefinita, tutte le applicazioni "Longhorn" vengono eseguite in un ambiente di autorizzazione limitato denominato Secure Execution Environment (SEE).

Le applicazioni in esecuzione in SEE ricevono un set di autorizzazioni limitato che equivale approssimativamente alle autorizzazioni concesse alle applicazioni odierne associate all'area Internet. Per impostazione predefinita, un'applicazione che richiede autorizzazioni aggiuntive rispetto a "Longhorn" deve richiedere tali autorizzazioni aggiuntive nel manifesto dell'applicazione.

La prima volta che l'utente esegue un'applicazione di questo tipo, il Trust Manager "Longhorn" valuta la richiesta di autorizzazione con privilegi elevati, notifica all'utente di un livello di rischio suggerito associato alla concessione della richiesta di autorizzazione dell'applicazione e fornisce una risposta suggerita per tale livello di rischio. Quando l'utente consente a Trust Manager di concedere all'applicazione le autorizzazioni richieste, Trust Manager registra queste informazioni. Le esecuzioni successive dell'applicazione installata procedeno senza l'avviso di sicurezza.

Oggi, quando si installa un'applicazione in locale, riceve il set di autorizzazioni FullTrust semplicemente perché carica dalla zona LocalComputer. La sicurezza di accesso al codice funziona in modo diverso per le applicazioni "Longhorn". Un'applicazione locale (o installata) viene eseguita con i criteri di sicurezza del sito da cui l'utente l'ha scaricata invece di ricevere automaticamente FullTrust semplicemente perché è installata in locale.

Quando si carica un'applicazione, i relativi componenti e le relative risorse, "Longhorn" fornisce prove al sistema di sicurezza CLR (Common Language Runtime), ad esempio

• Zona Internet e sito di origine (dall'URI [Uniform Resource Identifier])
• Nome del server di pubblicazione e del modulo (dal manifesto della distribuzione)

Cas fornisce quindi l'imposizione basata sui criteri di sicurezza sui privilegi di accesso in base alle prove dell'applicazione.

Il manifesto di distribuzione per un'applicazione può specificare l'intervallo di aggiornamento che "Longhorn" deve usare quando si verifica una nuova versione dell'applicazione. Quando "Longhorn" rileva che è disponibile una nuova versione, scarica e installa la nuova versione in background. Al successivo esecuzione dell'applicazione, l'utente riceve la nuova versione.

Quando si installa un'applicazione, "Longhorn" mantiene la versione precedente, se presente. Se è necessario, è possibile eseguire il rollback senza dolore alla versione precedente o anche disinstallare completamente l'applicazione usando Componenti aggiuntivi/Rimuovi programmi. I reparti IT possono eseguire il push dell'installazione di un'applicazione in un sistema client per una distribuzione pratica.

Si specifica come distribuire l'applicazione quando si compila il progetto e è possibile modificare lo scenario di distribuzione ricompilazione, in genere con poche o nessuna modifica al codice sorgente.

Il programma di uno sviluppatore interagisce inizialmente con gran parte del supporto dell'applicazione "Longhorn" tramite un'istanza della classe MSAvalon.Windows.Application , quindi esaminiamo tale classe.

Classe application

Un programma "Longhorn" contiene sempre una singola istanza di un oggetto applicazione. Questo oggetto deriva direttamente o indirettamente dalla classe MSAvalon.Windows.Application ed esegue le funzioni seguenti:

• Fornisce un punto di ingresso, l'incapsulamento e l'ambito per l'applicazione
• Consente a un'applicazione di condividere codice e stato tra le pagine che costituiscono l'applicazione
• Fornisce eventi a livello di applicazione
• Gestisce una raccolta delle finestre dell'applicazione
• Fornisce un modello di sicurezza
• Definisce le risorse usate dall'applicazione

La classe MSAvalon.Windows.Application fornisce il supporto dell'applicazione di base per un'applicazione. In genere viene usato quando l'applicazione richiede un sovraccarico basso e non usa le funzionalità di spostamento di pagina. Tuttavia, la maggior parte delle applicazioni della piattaforma "Longhorn" usa la classe MSAvalon.Windows.NavigationApplication strettamente correlata, che eredita da MSAvalon.Windows.Application e aggiunge il supporto per la navigazione. Verrà descritta in dettaglio la classe NavigationApplication nella sezione seguente. In genere si definirà una classe che eredita la classe di base appropriata, esegue l'override dei metodi della classe di base in base in base e quindi esegue la registrazione per gli eventi per fornire procedure di avvio o arresto personalizzate.

L'elenco di file di origine SimpleApplication1.cs, illustrato qui, illustra l'uso dell'oggetto Application . Il metodo EntryClass.Main crea l'oggetto applicazione specializzato, MyApp e chiama il metodo Run per avviare l'applicazione. La classe MyApp esegue l'override del metodo OnStartingUp , che riceve il controllo quando l'applicazione viene avviata. Quando il sistema richiama il metodo OnStartingUp , chiama un metodo helper che crea la finestra principale dell'applicazione, aggiunge un testo alla finestra e visualizza la finestra.

SimpleApplication1.cs

using System;
using MSAvalon.Windows;
using MSAvalon.Windows.Controls;
using MSAvalon.Windows.Media;

namespace IntroLonghorn {
  public class MyApp : MSAvalon.Windows.Application {
    MSAvalon.Windows.Controls.SimpleText txtElement;
    MSAvalon.Windows.Window              mainWindow;

    protected override void OnStartingUp (StartingUpCancelEventArgs e) {
      base.OnStartingUp (e);
      CreateAndShowMainWindow ();
    }

    private void CreateAndShowMainWindow () {
      // Create the application's main window
      mainWindow = new MSAvalon.Windows.Window ();

      // Add a dark red, 14 point, "Hello World!" text element
      txtElement = new MSAvalon.Windows.Controls.SimpleText ();
      txtElement.Text = "Hello World!";
      txtElement.Foreground = new
       MSAvalon.Windows.Media.SolidColorBrush (Colors.DarkRed);
      txtElement.FontSize = new FontSize (14, 
                                          FontSizeType.Point);
      mainWindow.Children.Add (txtElement);
      mainWindow.Show ();
    }
  }

  internal sealed class EntryClass {
    [System.STAThread]
    private static void Main () {
      MyApp app = new MyApp ();

      app.Run ();
    }
  }
}

È stata usata la riga di comando seguente per compilare il codice sorgente SimpleApplication1.cs in un'applicazione eseguibile. Potrebbe essere necessario modificare i percorsi degli assembly a cui si fa riferimento.

csc /r:C:\WINDOWS\Microsoft.NET\Windows\v6.0.4030\PresentationCore.dll
    /r:C:\WINDOWS\Microsoft.NET\Windows\v6.0.4030\PresentationFramework.dll
    /r:C:\WINDOWS\Microsoft.NET\Windows\v6.0.4030\WindowsBase.dll
    SimpleApplication1.cs

La classe Application contiene una serie di altre proprietà, metodi ed eventi utili. Ad esempio, la classe applicazione può eseguire l'override del metodo virtuale OnShuttingDown per fornire un comportamento di arresto personalizzato. La classe applicazione fornisce anche gli eventi StartingUp e ShuttingDown in modo che altre classi possano registrarsi per le notifiche di avvio e arresto. Il metodo Shutdown consente di avviare l'arresto dell'applicazione a livello di codice.

È possibile fare riferimento all'oggetto applicazione da più posizioni nel codice sorgente. Pertanto, la classe Application fornisce la proprietà statica Current che restituisce un riferimento all'oggetto applicazione. Il frammento di codice seguente usa la proprietà Current per individuare l'oggetto applicazione e registrare per una notifica di evento di arresto:

MyApp app = (MyApp) MSAvalon.Windows.Application.Current;
  app.ShuttingDown += new
       Application.ShuttingDownEventHandler (ShutDownHandler);
§
private static void
 ShutDownHandler (object sender, MSAvalon.Windows.ShuttingDownEventArgs e) {
§
}

Classe NavigationApplication

Quando si vuole supportare la navigazione per l'applicazione, in genere si userà la classe MSAvalon.Windows.Navigation.NavigationApplication , che estende la classe MSAvalon.Windows.Application . Anche se è possibile creare un'applicazione basata su navigazione senza usare la classe NavigationApplication , usando la classe offre le funzionalità aggiuntive seguenti per l'applicazione:

• Semplifica la scrittura di applicazioni basate su navigazione; non in genere necessario per sottoclasse la classe
• Determina quando è disponibile una connessione
• Fornisce eventi di spostamento, ad esempio Navigazione, NavigationProcess, Navigated, NavigationError, LoadCompleted e Arresta, che viene generato quando si verifica l'evento appropriato in una delle finestre dell'applicazione
• Condivide lo stato tra le pagine
• Fornisce un contenitore per i valori delle proprietà condivisi tra pagine
• Implementa un criterio che apre una finestra iniziale per impostazione predefinita

Esternamente, l'utente di un'applicazione di spostamento può passare solo a punti di ingresso ben definiti dell'applicazione. Internamente, tuttavia, lo sviluppatore controlla lo spostamento tramite l'associazione di eventi. È possibile determinare quando una finestra o un frame tenta di passare a una nuova pagina e al termine della navigazione. È possibile annullare o reindirizzare qualsiasi navigazione. È possibile trovare l'identità della pagina di destinazione. È possibile gestire gli errori di spostamento.

Il modello di navigazione familiare semplifica l'uso di un'applicazione. Un'applicazione di navigazione fornisce un comportamento simile al Web. L'applicazione può usare collegamenti ipertestuali, fornire pulsanti Avanti e Indietro, visualizzare un elenco Preferiti e mantenere una pagina Cronologia. La classe NavigationApplication "Longhorn" e le classi correlate forniscono tutto il supporto per tali funzionalità.

Un'applicazione di navigazione funziona sia online che offline e funziona allo stesso modo se un browser ospita l'applicazione o l'applicazione viene eseguita come autonoma. Inoltre, si ha il controllo completo su questo comportamento weblike. È possibile personalizzare l'esperienza utente in base alle esigenze. È possibile inserire, rimuovere e modificare le voci Travelog per controllare dove vanno le operazioni Inoltra e Indietro. È possibile definire le pagine (punti di ingresso) registrate nella cronologia.

Un'applicazione di navigazione crea in genere una o più istanze della classe MSAvalon.Windows.Navigation.NavigationWindow . L'elenco SimpleApplication2.cs, illustrato di seguito, illustra l'uso di queste classi. Questo elenco è identico a SimpleApplication1.cs, ad eccezione del fatto che usa le classi NavigationApplication e NavigationWindow .

SimpleApplication2.cs

using System;
using MSAvalon.Windows;
using MSAvalon.Windows.Controls;
using MSAvalon.Windows.Media;
using MSAvalon.Windows.Navigation;

namespace IntroLonghorn {
  public class MyApp : MSAvalon.Windows.Navigation.NavigationApplication {

    protected override void OnStartingUp (StartingUpCancelEventArgs e) {
      base.OnStartingUp (e);
      CreateAndShowMainWindow ();
    }

    private void CreateAndShowMainWindow () {

      // Create the application's main window
      mainWindow = new MSAvalon.Windows.Navigation.NavigationWindow ();

      // Fill window with appropriate controls
      §
      // Show the window
      mainWindow.Show ();
    }
  }

  internal sealed class EntryClass {
    [System.STAThread]
    private static void Main () {
      MyApp app = new MyApp ();
      app.Run ();
    }
  }
}

Il codice che si è visto fino ad ora è solo un'altra variante dei modelli di programmazione tradizionali. L'unico nuovo aspetto è rappresentato dalle classi effettive usate. Nella maggior parte dei casi, tuttavia, non si scriverà gran parte di questo codice. Si esamini una leggera deviazione e si apprenderà un nuovo linguaggio di programmazione che consente di scrivere lo stesso codice in modo molto più compatto e, almeno, più comprensibile.

Extensible Application Markup Language (XAML)

In molte applicazioni gran parte del codice scritto riguarda la creazione e l'aggiornamento dell'interfaccia utente dell'applicazione. Negli esempi precedenti, infatti, non c'era codice diverso da quello necessario per creare l'interfaccia utente. Negli ultimi anni, molti sviluppatori hanno imparato a scrivere e anche a preferire la definizione dell'interfaccia utente di un'applicazione usando uno dei numerosi linguaggi di markup disponibili. La piattaforma "Longhorn" definisce un nuovo linguaggio di markup denominato Extensible Application Markup Language (XAML, pronunciato "Zamel", che fa rima con "camel").

L'uso di un linguaggio di markup per definire un'interfaccia utente presenta numerosi vantaggi rispetto all'uso di un linguaggio di programmazione procedurale. Questi vantaggi includono i seguenti:

• Gerarchie di controllo più evidenti
• Ereditarietà di proprietà più apparente
• Elaborazione e interpretazione semplificate del linguaggio di markup tramite strumenti
• Potenziale separazione dell'interfaccia utente e del codice procedurale

Mi piace XAML e preferisco usarlo per definire le mie interfacce utente invece di usare la codifica procedural-type che ti ho mostrato finora in questo capitolo. Tuttavia, non pensare che sarai in grado di eseguire tutte le operazioni che dovrai usare usando solo XAML.

Prendere in considerazione questa istruzione dalla documentazione: "I documenti possono spesso essere scritti interamente in XAML e visualizzati nel browser". Ho sottolineato con fretta che questa frase usa la parola documenti, non applicazioni, e qualifica l'istruzione con il termine spesso. Quando scrivi un documento che visualizza contenuto statico, puoi crearlo in XAML puro. Puoi anche scrivere un documento che usa il data binding per visualizzare e aggiornare il contenuto da un'origine dati usando solo XAML. Puoi definire animazioni ed effetti del mouse usando solo XAML. Puoi fare un sacco di cose usando nient'altro che XAML. (In effetti, cerco di fare il più possibile in XAML e il minor possibile nel codice. Le mie applicazioni sembrano essere meno buggy e lavorare più rapidamente meno codice che scrivo!) Tuttavia, per scrivere un'applicazione di produzione, in genere dovrai reagire agli eventi, fornire logica decisionale personalizzata o includere molte altre operazioni non dell'interfaccia utente, quindi dovrai combinare XAML e codice. Fortunatamente, questo è estremamente facile da fare.

Descriverò i file XAML in modo più approfondito nel capitolo 3; per il momento, esaminiamo una guida di base per XAML:

• Un nome di elemento XAML è un nome di classe .NET Framework. Quando definisci un elemento XAML, stai creando in modo efficace un'istanza della classe .NET Framework con lo stesso nome dell'elemento XAML.
• Un nome di attributo XAML esegue il mapping alla proprietà o al campo con lo stesso nome, in genere nell'istanza della classe.

Nel programma SimpleApplication1.cs creare una finestra e aggiungervi alcuni controlli usando il codice seguente:

// Create the application's main window
mainWindow = new MSAvalon.Windows.Window ();

// Add a dark red, 14 point, "Hello World!" text element
txtElement = new MSAvalon.Windows.Controls.SimpleText ();
txtElement.Text = "Hello World!";
txtElement.Foreground = new 
           MSAvalon.Windows.Media.SolidColorBrush (Colors.DarkRed);
txtElement.FontSize = new FontSize (14, FontSizeType.Point);
mainWindow.Children.Add (txtElement);
mainWindow.Show ();

Il documento XAML seguente produce esattamente questa stessa interfaccia utente.

HelloWorld.xaml

<Window xmlns="https://schemas.microsoft.com/2003/xaml" Visible="true">
    <SimpleText Foreground="DarkRed" FontSize="14">Hello World!</SimpleText>
</Window>

L'elemento root Window crea un'istanza di una classe denominata MSAvalon.Windows.Window. In qualche modo, il sistema di compilazione deve sapere che l'elemento XAML denominato Window fa riferimento a un'istanza della classe denominata MSAvalon.Windows.Window. Il valore dell'attributo xmlns fornisce questo mapping.

I parser XML interpretano i nomi di elementi non qualificati relativi allo spazio dei nomi specificato nell'ambito più recente, nell'ambito, attributo dello spazio dei nomi predefinito, xmlns. Quando si specifica un valore xmlns "https://schemas.microsoft.com/2003/xaml", il sistema di compilazione interpreta un nome di elemento non qualificato nell'elemento di definizione o uno dei relativi elementi subordinati, come nome di una classe in un set predefinito di spazi dei nomi.

Riformulare che in termini più concreti, usando C# come esempio. La dichiarazione xmlns aggiunge in modo efficace una serie di istruzioni using al codice. Il sistema di compilazione interpreta quindi ogni nome di elemento XAML non qualificato come nome di classe con le dichiarazioni using che forniscono il contesto per gli spazi dei nomi possibili. Anche se l'elenco potrebbe cambiare, al momento della stesura di questo articolo, specificare il valore standard per l'attributo dello spazio dei nomi predefinito causa l'inclusione delle istruzioni using seguenti:

using MSAvalon.Windows;
using MSAvalon.Windows.Controls;
using MSAvalon.Windows.Controls.Primitives;
using MSAvalon.Windows.Data;
using MSAvalon.Windows.Documents;
using MSAvalon.Windows.Shapes;
using MSAvalon.Windows.Media;
using MSAvalon.Windows.Media.Animation;
using MSAvalon.Windows.Navigation;

La dichiarazione dello spazio dei nomi predefinito standard fa anche in modo che il sistema di compilazione faccia riferimento agli assembly PresentationFramework e PresentationCore , che contengono classi negli spazi dei nomi elencati in precedenza.

Ho impostato l'attributo Visible dell'elemento Windowsu true. Corrisponde al codice originale che visualizza la finestra chiamando il relativo metodo Show .

Ho annidato un elemento SimpleText all'interno della definizione dell'elemento Window . Questo indica al sistema di creare un'istanza di un oggetto MSAvalon.Windows.Controls.SimpleText, impostarlo come elemento figlio dell'oggetto Window e impostare il valore dell'oggetto di testo semplice sulla stringa "Hello World!".

Salvare il codice XAML precedente in un file denominato HelloWorld.xaml ed eseguire il file. Il browser interpreterà il codice XAML nel file e visualizzerà l'interfaccia utente, come illustrato nella figura 1-1.

Figura 1-1. Il browser che visualizza la versione XAML di Hello World (fare clic sull'immagine per visualizzare un'immagine più grande)

È possibile usare una classe .NET non definita in uno degli spazi dei nomi predefiniti elencati in precedenza. Un esempio tipico consiste nell'usare una classe da un assembly creato. Il sistema di compilazione deve essere in grado di eseguire il mapping del nome dell'elemento specificato nel file di origine XAML alla classe .NET appropriata nell'assembly corretto. XAML definisce un'istruzione di elaborazione XML denominata ? Mapping usato per creare questa associazione.

Il ? Mapping PI consente di definire un prefisso dello spazio dei nomi XML mappato a uno spazio dei nomi CLR e a un assembly. Quando si qualifica un nome di elemento XAML con questo prefisso dello spazio dei nomi, si indica al sistema di compilazione, in effetti, di accettare il nome dell'elemento, aggiungere il prefisso CLR al nome e creare un'istanza della classe con il nome risultante. Il compilatore farà riferimento all'assembly specificato in modo che possa trovare la definizione della classe .

Nell'esempio seguente viene creata un'istanza della classe WiseOwl.Statistics.PoissonDeviate , la cui definizione risiede nell'assembly WiseOwl.Statistics.Library :

<?Mapping XmlNamespace="stat" ClrNamespace="WiseOwl.Statistics"
                              Assembly="WiseOwl.Statistics.Library" ?>
<Window xmlns="https://schemas.microsoft.com/2003/xaml" Visible="true">
    <SimpleText Foreground="DarkRed" FontSize="14">Hello World!</SimpleText>
    <stat:PoissonDeviate Mean="5.0" />
</Window>

Non posso sottolineare abbastanza che XAML è semplicemente un altro modo per produrre codice che usa le classi dell'interfaccia utente di .NET Framework. Infatti, potresti avere uno strumento che visualizza graficamente una specifica dell'interfaccia utente XAML usando una finestra di progettazione visiva. Un altro strumento potrebbe eseguire l'operazione inversa e consentire di progettare graficamente l'interfaccia utente e salvarla come file XAML. Un altro strumento potrebbe salvare la progettazione dell'interfaccia utente come codice procedurale, che è simile al funzionamento della finestra di progettazione di WinForms. Tutti questi approcci sono solo metodi diversi per specificare le stesse informazioni.

In precedenza in questo capitolo, ho detto che il browser potrebbe eseguire il rendering di un file XAML nella relativa finestra. Il browser può eseguire questa operazione solo quando il file XAML non contiene altro che markup, come l'esempio semplice appena illustrato. Man mano che l'interfaccia utente diventa più complessa, in genere dovrai usare i gestori eventi e altri codici sorgente non contrassegnati oltre al codice XAML che descrive l'interfaccia utente. Ogni volta che si dispone di una base di codice sorgente mista, ovvero il markup e il codice sorgente non contrassegnato, è necessario compilare il markup e il codice sorgente usando l'utilità MSBuild. Dopo la compilazione, è possibile eseguire l'applicazione come componente autonomo o fare in modo che il browser visualizzi l'interfaccia utente risultante.

Riepilogo

Bene. A questo punto si conoscono le nozioni di base del nuovo modello di applicazione. Si è appreso come usare il markup per creare un'interfaccia utente in modo dichiarativo, anche se un'interfaccia utente molto semplice. È possibile scrivere l'equivalente delle pagine Web usando i file XAML e distribuirli in un server per consentire a un utente di esplorare. Tuttavia, gli scenari più interessanti richiedono in genere di compilare l'applicazione prima di distribuirla. Si apprenderà quindi come compilare e distribuire un'applicazione "Longhorn".

Continuare con il capitolo 2: Creazione di un'applicazione "Longhorn".

© 2003 Microsoft Corporation. Tutti i diritti sono riservati.

IntelliSense, Microsoft, MSDN, MS-DOS, Visual Basic .NET e Visual Studio .NET sono marchi registrati o marchi di Microsoft Corporation nei Stati Uniti e/o in altri paesi. Altri nomi di prodotti e società menzionati nel presente documento possono essere i marchi dei rispettivi proprietari.