Il presente articolo è stato tradotto automaticamente.

Windows Phone 7

La prima applicazione per Windows Phone

Jesse Liberty

Il trucco per iscritto una prima applicazione di Windows Phone è quello di costruire qualcosa di abbastanza interessante per essere significativo, ancora abbastanza semplice per ottenere effettivamente in corso.Verso quel fine, vado a piedi si attraverso la creazione di una semplice utility che io uso ogni giorno: NoteToMe.L'idea è che potete inserire un messaggio e inviarlo a voi stessi da premendo un pulsante, come mostrato nella Figura 1.

Figura 1 l'interfaccia NoteToMe

Si noti che questo articolo toccherà su un numero di argomenti, ognuno dei quali sarà ampliata su alcuni articoli successivi, lunghezza.Sono descritti i seguenti argomenti:

• Creare il layout dell'applicazione
• Memorizzazione e recupero dati dall'archiviazione isolata
• Eventi e gestione degli eventi
• Creazione ed esecuzione di attività (lanciatori e le selezioni)

Prima di poter iniziare, è necessario scaricare gli strumenti da http://xbox.create.msdn.com.Se hai già sbloccato il telefono ma non ancora aggiornato a Windows Phone 7.5 ("Mango"), ora è il momento di farlo; Mango porta centinaia di nuove funzionalità al sistema operativo Windows Phone.

 Guida introduttiva

Come molti sviluppatori di Windows Phone, sono venuto a credere che il miglior strumento per la creazione di applicazioni di Windows Phone è una combinazione di Visual Studio (per codice) ed Expression Blend (per tutto il resto).Così, potremo iniziare aprendo Expression Blend e la creazione di una nuova applicazione denominata NoteToMe, basato sulla Windows Phone SDK 7.1.

Iniziamo modificando il titolo di applicazione.Clicca sul titolo e nella finestra Proprietà trovare la proprietà Text per tale controllo.Linee guida di progettazione per la Metro (gli orientamenti di progettazione per Windows Phone) chiamano per il titolo di essere in tutte le protezioni, quindi modificare il titolo a nota a me.

Clicca sul titolo della pagina e premete CANC per rimuoverlo.

Per creare il layout, avrete bisogno di una piccola riga nella parte superiore della pagina.Fare clic sul margine per far apparire una linea guida che ti aiuta a visivamente selezionare dove collocare la riga, come illustrato nella Figura 2.

Figura 2 la riga superiore del Layout di immissione

Naturalmente, è possibile impostare la dimensione di riga a mano direttamente in XAML:

<Grid.RowDefinitions>
  <RowDefinition Height="1*"/>
  <RowDefinition Height="9*"/>
</Grid.RowDefinitions>

L'asterisco dopo il valore indica il relativo ridimensionamento — in questo caso 1:9. Cioè, la prima riga sarà un nono della dimensione della seconda fila.

Aggiunta di tre controlli a StackPanel

La riga superiore avrà tre controlli in essa, fianco a fianco:

• Un oggetto TextBlock che agisce come un'etichetta
• Un oggetto TextBlock per contenere l'indirizzo di posta elettronica
• Un pulsante per inviare il messaggio

Questo design è mostrato Figura 3.

Figura 3 tre controlli nella riga superiore

Senza metterli dentro qualche sorta di organizzatore contenitore non si possono mettere tre controlli in un'unica colonna di una riga. Io uso un oggetto StackPanel cui orientamento è stato impostato a orizzontale — StackPanel impilare sulla parte superiore di ogni altro o accanto a vicenda.

Per creare un oggetto StackPanel, clicca sulla piccola freccia bianca accanto al controllo di Layout della barra degli strumenti come mostrato Figura 4.

Figura 4 aggiungendo un oggetto StackPanel

Fare clic su StackPanel per selezionare il controllo. Adesso trascinare un oggetto StackPanel nella riga e impostare il suo allineamento verticale e orizzontale di tratto e i suoi margini a zero nella finestra di Layout, come mostrato nella Figura 5.

Figura 5 immissione StackPanel

Aggiungere l'oggetto TextBlock, impostando la dimensione del carattere a 32 e il testo su A. Ora trascinare un controllo TextBox in StackPanel. (Si noti la sottile ma importante differenza tra un oggetto TextBlock, per la visualizzazione di testo e una casella di testo per l'input di testo). Denominare questo indirizzo TextBox. Infine, aggiungere un pulsante a StackPanel, denominarlo Send e impostare il suo contenuto per l'invio.

Questo produce XAML è mostrato in Figura 6.

Figura 6 progettazione StackPanel con XAML

<StackPanel
  Margin="0"
  Orientation="Horizontal">
  <TextBlock
    Margin="0,8"
    TextWrapping="Wrap"
    Text="To"
    Width="42"
    HorizontalAlignment="Left"
    VerticalAlignment="Center"
    FontSize="32" />
  <TextBox
    x:Name="Address"
    Margin="0,0,0,-7"
    TextWrapping="Wrap"
    Text="foo@bar.com"
    Width="293" />
  <Button
    x:Name="Send"
    Content="Send"
    Margin="0,4,0,0"
    Width="124"
    Click="Send_Click" />
</StackPanel>

Avviso il pulsante Invia ha un Click = "Send_Click" property. Si crea questo facendo clic sul pulsante, quindi nella finestra Proprietà si fa clic sul pulsante eventi, come illustrato nella Figura 7.

Figura 7 pulsante eventi

Questo apre tutti gli eventi per il pulsante. L'evento click di trovare e fare doppio clic. Il pulsante viene aggiornato con l'evento, e stai collocato nell'editor di codice (sia in Blend o in Visual Studio, a seconda di come avete Blend istituito) per tale gestore eventi. Per ora, è possibile lasciare questo gestore eventi come è:

private void Send_Click( object sender, RoutedEventArgs e )
{
}

Aggiungendo il controllo del messaggio

Fare clic su controllo TextBox nella barra degli strumenti e quindi trascinare un controllo TextBox per riempire la metà della pagina resto (stiamo lasciando l'altra metà per la tastiera, che apparirà quando è il momento di entrare qualcosa nella casella di testo). Impostare la proprietà HorizontalAlignment Stretch, VerticalAlignment verso l'alto, i margini a 0. Impostare la larghezza su automatico e l'altezza di 244. Si può fare tutto questo dall'occhio, come si ridimensiona la casella di testo, o è possibile disegnare l'oggetto TextBox all'incirca in luogo e impostare le proprietà nella finestra Proprietà, come illustrato nella Figura 8.

Figura 8 aggiungendo l'oggetto TextBox

Scrittura del codice

Con i controlli sul posto, si è pronti a lavorare sulla logica del programma. Si dovrebbe vedere una scheda denominata progetti nell'angolo superiore sinistro. Dopo aver salvato tutte le modifiche, fare clic sulla scheda progetti, quindi fare clic destro su MainPage.xaml.cs e selezionare Edit In Visual Studio, come mostrato nella Figura 9.

Figura 9 sempre pronto a scrivere il codice

La specifica

Mia specifica (autoimposta) dice che non dovreste avere riempire in campo a ogni volta che si utilizza il programma; campo a deve essere prepopolato con qualunque cosa era nel campo all'uso precedente.

Inoltre, quando si fa clic su Invia un nuovo messaggio di posta elettronica deve essere preparato a un programma di posta elettronica, con tutti i campi inseriti automaticamente il modo che basta premere invio o, se lo si desidera, modificare il messaggio e quindi premere INVIO.

Utilizzo di spazio di memorizzazione isolato

Per conservare il contenuto del campo a attraverso gli utilizzi dell'applicazione, è necessario archiviare i contenuti da qualche parte sul telefono cellulare. Questo è ciò che è di spazio di memorizzazione isolato per: dati persistenti quando l'applicazione viene chiusa. Come suggerisce il nome, archiviazione isolata permette l'applicazione memorizzare dati isolato e protetto da dati archiviati da altre applicazioni. Utilizzo di spazio di memorizzazione isolato è abbastanza semplice.

Innanzitutto, aggiungere il mediante dichiarazione:

using System.IO.IsolatedStorage;

Dichiarare una variabile membro di tipo IsolatedStorageSettings e una costante stringa di agire come una chiave nel dizionario archiviazione isolata, così è possibile memorizzare e recuperare l'indirizzo di posta elettronica:

private IsolatedStorageSettings _isoSettings;
const string IsoKey = "EmailAddress";

Initialize the _isoSettings member in the constructor:

_isoSettings = IsolatedStorageSettings.ApplicationSettings;

Memorizzazione e recupero l'indirizzo di posta elettronica

Le due attività correlate all'archiviazione isolata sono la stringa l'archiviazione e recupero. Memorizzandolo è fatto meglio come si lascia la pagina. Quando si lascia qualsiasi pagina di Windows Phone, il metodo OnNavigatedFrom viene chiamato. Sei libero di eseguirne l'override e una buona ragione per farlo è quello di memorizzare i dati in archiviazione isolata, come questo:

protected override void OnNavigatedFrom( 
  System.Windows.Navigation.NavigationEventArgs e )
{
  _isoSettings[IsoKey] = Address.Text;
  base.OnNavigatedFrom( e );
}

Ora avete l'indirizzo di posta elettronica archiviato nel dizionario _isoSettings sotto la chiave IsoKey. Quando si torna alla pagina, è possibile ripristinare questa impostazione. Faccio questo chiamando il metodo di supporto privato RestoreEmailAddress dal costruttore:

private void RestoreEmailAddress()
  {
    if (_isoSettings.Contains( IsoKey ))
      Address.Text = _isoSettings[IsoKey].ToString();
  }

Si noti che prova l'esistenza della chiave nell'archiviazione isolata prima di tentare di ripristinarla — questo evita un tempo di eccezione la prima KeyNotFound ho eseguito il programma. Ricordate, la prima volta si esegue il programma che non hanno ancora nulla memorizzati nell'archiviazione isolata.

Quando il programma è iniziato, non c'è nulla nel campo dell'indirizzo. Una volta che l'utente inserisce un indirizzo di posta elettronica nel campo dell'indirizzo, quell'indirizzo è memorizzato nell'archiviazione isolata e restaurato la prossima volta che il programma viene eseguito. Se l'utente cambia l'indirizzo, quell'indirizzo è quello restaurato.

Attività

Windows Phone 7.5 supporta una serie di compiti per l'interazione con le applicazioni di telefono incorporato (posta, elenco di contatti, la macchina fotografica e così via). Ci sono due tipi di attività: Lanciatori e le selezioni. Le selezioni sono utilizzate per selezionare informazioni e restituirlo al vostro programma (per ottenere un indirizzo e-mail dalla lista contatti, ad esempio). Lanciatori vengono utilizzati per avviare un programma che non restituisce dati.

In questo caso, avete tutto che è necessario inviare il messaggio, quindi è possibile chiamare il lanciatore di e-mail e fornire i campi richiesti. Quando si chiama Visualizza sul lanciatore di posta elettronica, sarà lanciato l'applicazione e-mail con i tuoi dati, ma non sarà possibile ottenere qualsiasi dati indietro (che sono bene; non è necessario qualsiasi).

Dopo la posta elettronica viene inviata, sei tornato al programma nel caso in cui si desidera inviare un altro messaggio.

Tutto il lavoro di creazione del lanciatore è incapsulata all'interno del gestore eventi click per il pulsante Invia. Iniziamo creando un'istanza di EmailComposeTask (il Launcher). Compila i campi e chiamare Show. Questo è tutto là è ad esso:

private void Send_Click( object sender, RoutedEventArgs e )
{
  EmailComposeTask emailComposeTask = new EmailComposeTask();
  emailComposeTask.Subject = "Send To Me";
  emailComposeTask.To = Address.Text;
  emailComposeTask.Body = Message.Text;
  Message.Text = String.Empty;
  emailComposeTask.Show();
}

Quando si chiama Show, l'oggetto, indirizzo e il corpo del messaggio vengono passati all'applicazione di posta elettronica. Se si dispone di più di un'applicazione di posta elettronica, ti viene chiesto che uno si desidera utilizzare. Un messaggio di posta elettronica indirizzati e formattato correttamente è creato, pronto per voi per inviare.

Ciclo di vita dell'applicazione

Se gli utenti potrebbero essere invocati mai interrompere il loro uso dell'applicazione fino a quando non hanno inviato il messaggio, sarebbe fatto. In realtà, però, gli utenti saranno fermare proprio nel mezzo di composizione di un messaggio e lanciare un'applicazione diversa. Quando ritornano, non sarà felice se il lavoro che hanno fatto è andato.

Per sapere come proteggere contro questo, è necessario capire un po ' circa il ciclo di vita di un'applicazione e come è possibile conservare stato supportando ancora una delle caratteristiche più potenti di Mango: Veloce applicazione di commutazione.

Quando l'applicazione viene lanciato (dire dal menu Start), viene generato l'evento di lancio di applicazione. Una volta che l'applicazione viene avviata, e ogni volta che l'utente si sposta alla tua pagina, viene chiamato il metodo OnNavigatedTo, dopo che la pagina sarà nello stato Running. Se l'utente avvia una nuova applicazione, l'applicazione riceve l'evento applicazione disattivato e viene messo in stato dormiente. Se il telefono viene eseguita in basso sulla memoria, l'applicazione potrebbe essere eliminati definitivamente.

Da eliminati definitivamente o dormiente, l'applicazione può essere terminato o può essere restituito. Che cosa ci preoccupiamo per adesso è ciò che accade quando l'applicazione viene ripristinata.

Se l'applicazione è sospeso, non solo non dovete prendere qualsiasi azione quando viene ripristinato, ma non volete anche di intraprendere qualsiasi azione; lo stato fu conservato quando l'applicazione è stato sospeso, ed è pronto ad andare.

Se l'applicazione è stato definitivamente, però, quindi si desidera ripristinare dello stato della pagina quando l'applicazione restituisce in modo che venga visualizzato all'utente che l'applicazione è in esecuzione (o almeno dormiente) mentre era commutazione di distanza.

Dovete quindi affrontare due compiti:

1. Salvare lo stato quando viene chiamato il metodo OnNavigatedFrom della pagina.
2. Potenzialmente ripristinare lo stato quando viene chiamato il metodo OnNavigatedTo della pagina — ripristino dello stato se l'applicazione è stato definitivamente ma non se è stato sospeso.

Salvataggio dello stato, quando la pagina sta andando via

Perché non può sapere, quando la pagina riceve OnNavigatedFrom, quale stato sarà in quando viene ripristinato, è necessario archiviare lo stato nel caso in cui è necessario. Questo è molto facile da fare: si utilizza un dizionario di stato che è molto simile al dizionario di archiviazione isolata nella sua sintassi, anche se si desidera ricordare che il dizionario di stato non è scritto archivio permanente e in realtà è distrutto quando uscire dal programma o spegnere il telefono.

Cominciamo con la creazione di una costante stringa StateKey, che userete come l'offset nel dizionario dello stato:

const string StateKey = "MessageState";

Nel metodo OnNavigatedFrom, si verrà memorizzare lo stato (in questo caso, il contenuto del MessageBox) nel dizionario dello stato:

protected override void OnNavigatedFrom( 
  System.Windows.Navigation.NavigationEventArgs e )
{
  _isoSettings[IsoKey] = Address.Text;
  State[StateKey] = Message.Text;
  base.OnNavigatedFrom( e );
}

Ripristino dello stato quando la pagina viene creata

Quando viene chiamato il metodo OnNavigatedTo, non volete intraprendere qualsiasi azione per ripristinare lo stato, se l'applicazione è stato sospeso, ma si desidera intervenire se fosse definitivamente.

È possibile distinguere tra lo stato dormiente o eliminati definitivamente impostando una bandiera su false e quindi impostando su true nel costruttore. Se l'applicazione è assopito, il costruttore non verrà chiamato; Se è stato rimosso definitivamente, sarà chiamato il costruttore (perché sarà la prima volta è costruito), in questo modo:

bool isNew = false;
  public MainPage()
  {
    InitializeComponent();
    isNew = true;

È possibile controllare quel tricolore in OnNavigatedTo:

protected override void OnNavigatedTo(
  System.Windows.Navigation.NavigationEventArgs e )
{
  if (isNew)
  {
    if (State.ContainsKey( StateKey ))
    {
      Message.Text = State[StateKey].ToString();
    }
  }
  isNew = false;
  base.OnNavigatedTo( e );
}

Questo test consente di risparmiare il tempo che altrimenti ci sarebbe voluto per ripristinare il valore dal dizionario di stato. È possibile verificare prima eseguendo il programma normalmente (nel qual caso quando si passa a un'altra applicazione il programma andrà dormiente) e poi costringendo il programma per essere eliminati definitivamente. È possibile forzare il tuo programma per essere eliminati definitivamente dal pulsante destro del mouse sul progetto, scegliendo Proprietà, scegliere la scheda Debug e controllando la lapide di checkbox su disattivazione durante il debug.

Quando si esegue con questo controllato, vedrai una pausa evidente quando si torna alla pagina perché lo stato deve essere ripristinato.

Panoramica finale

In questo breve articolo, ho mostrato come scrivere la vostra prima applicazione Windows Phone banale. Ho iniziato con la creazione dell'applicazione in Expression Blend, dove ho creato una riga e utilizzato un oggetto StackPanel per stendere i controlli.

Poi sono passato a Visual Studio per scrivere la logica per il gestore eventi del pulsante e utilizzata di spazio di memorizzazione isolato per rendere persistente l'indirizzo di posta elettronica. Ho usato la memoria allo stato per garantire che l'applicazione sarebbe riavviare correttamente dopo essere stati eliminati definitivamente.

Come osservato, non c'è molto di più da dire su ciascuno di questi argomenti, e sarò rientrare in dettaglio in futuri articoli.

Jesse Liberty è una community di sviluppatori senior evangelist sulla squadra Windows Phone. Liberty ospita popolare ancora un altro Podcast (jesseliberty.com/podcast) e il suo blog (jesseliberty.com/) è una lettura obbligatoria. Egli è l'autore di numerosi libri di best-seller, tra cui "Programmazione reattiva estensioni e LINQ" (Apress, 2011) e "Migrazione a Windows Phone," (Apress, 2011). È possibile seguire Liberty su Twitter a twitter.com/JesseLiberty.

Grazie ai seguenti esperti tecnici per la revisione di questo articolo: Drew Batchelor e Cheryl Simmons