Share
Tutti i dispositivi Windows Phone hanno una connessione di rete integrata ma, per lo stesso motivo per cui abbiamo imparato a memorizzare i dati a livello locale, dobbiamo essere pronti a gestire il modo in cui gli utenti utilizzano la nostra applicazione mentre manca una connessione.
A tale scopo, il framework Windows Phone include una classe che può essere utilizzata per scoprire informazioni sulla connessione Internet chiamata DeviceNetworkInformation, che fa parte del Microsoft.Phone.Net.NetworkInformation namespace.
Il più importante è IsNetworkAvailable, che ci dice se è disponibile una connessione Internet. Dovremmo sempre utilizzare questa API prima di eseguire un'operazione che richiede una connessione, come nell'esempio seguente:
Accentsconagua
private void OnCheckConnectionClicked (mittente dell'oggetto, RoutedEventArgs e) if (DeviceNetworkInformation.IsNetworkAvailable) MessageBox.Show ("Sei connesso a Internet"); // Esegue operazioni di rete. else MessageBox.Show ("Non sei connesso a Internet"); La classe offre anche un evento chiamato NetworkAvailabilityChanged che viene attivato ogni volta che cambia lo stato della connessione. È utile se vuoi reagire rapidamente alle modifiche della rete, come abilitare o disabilitare determinate funzionalità dell'applicazione.
public MainPage () InitializeComponent (); DeviceNetworkInformation.NetworkAvailabilityChanged + = DeviceNetworkInformation_NetworkAvailabilityChanged; private void DeviceNetworkInformation_NetworkAvailabilityChanged (mittente dell'oggetto, NetworkNotificationEventArgs e) if (e.NotificationType == NetworkNotificationType.InterfaceDisconnected) MessageBox.Show ("Disconnected"); else if (e.NotificationType == NetworkNotificationType.InterfaceConnected) MessageBox.Show ("Connected"); I parametri di ritorno contengono una proprietà chiamata NotificationType, del tipo NetworkNotificationType, che ci dice lo stato corrente della rete.
Tuttavia, con il DeviceNetworkInformation sarai in grado di ottenere anche altre informazioni sullo stato attuale della rete, ad esempio se l'utente ha abilitato la connessione dati cellulare (IsCellularDataEnabled), la connessione Wi-Fi (IsWiFiEnabled) o opzioni di roaming (IsCellularDataRoamingOptions).
Il framework offre un'altra classe utile per gestire le connessioni di rete chiamate Interfaccia di rete. Usando il NetworkInterfaceType proprietà, sarete in grado di identificare quale tipo di connessione è attualmente in uso. Ad esempio, possiamo utilizzare questa proprietà per evitare il download di file di grandi dimensioni durante l'utilizzo di una connessione cellulare.
NetworkInterfaceType è un enumeratore che può assumere molti valori. I più importanti sono:
MobileBroadbandGsm e MobileBroadbandCdma quando il telefono è collegato a una rete cellulare (GSM o CDMA, secondo il Paese)Wireless80211, quando il telefono è connesso a una rete Wi-FiNell'esempio seguente, viene visualizzato un messaggio sullo schermo con il tipo di connessione corrente:
private void OnCheckConnectionTypeClicked (mittente dell'oggetto, RoutedEventArgs e) if (NetworkInterface.NetworkInterfaceType == NetworkInterfaceType.MobileBroadbandGsm || NetworkInterface.NetworkInterfaceType == NetworkInterfaceType.MobileBroadbandCdma) MessageBox.Show ("Mobile"); else if (NetworkInterface.NetworkInterfaceType == NetworkInterfaceType.Wireless80211) MessageBox.Show ("Wi-Fi"); Il framework Windows Phone ha due classi integrate per l'esecuzione delle operazioni di rete: WebClient e HttpWebRequest. Sfortunatamente, nessuno dei due è perfetto. WebClient è molto facile da usare, ma si basa sul vecchio approccio callback (a meno che non si installi il Async per .NET pacchetto di cui abbiamo parlato in precedenza in questa serie). HttpWebRequest è molto potente, ma è complesso da usare e basato su un vecchio modello asincrono che è difficile da capire.
Windows Runtime ha introdotto una nuova classe chiamata HttpClient, che prende il meglio di entrambi i mondi. È potente e offre grandi prestazioni, ma è facile da usare e offre metodi basati sul nuovo modello asincrono e in attesa. Questa classe è disponibile nelle app complete di Windows Runtime per Windows Store, ma non è inclusa nel sottoinsieme di Windows Phone Runtime: dovrai installarlo da NuGet.
Il HttpClient la classe, come vedremo in seguito, è ottima non solo per l'esecuzione di operazioni di rete generiche come il download e il caricamento di file, ma anche per l'interazione con i servizi web. Infatti, espone metodi asincroni per ogni comando HTTP, come GET, POST, PUT, ecc.
Nota: per poter interagire con la rete è necessario abilitare l'opzione ID_CAP_NETWORKING nel file manifest. È abilitato in ogni nuovo progetto Windows Phone per impostazione predefinita.
I file vengono solitamente scaricati tramite il comando GET HTTP, quindi HttpClient offre il GetAsync () metodo. Per semplificare la vita degli sviluppatori, HttpClient ha alcuni metodi integrati per scaricare i tipi di file più comuni, come ad esempio GetStringAsync () per scaricare file di testo come le risposte XML, RSS o REST; o GetByteArrayAsync () e GetStreamAsync () per ottenere il contenuto del file binario.
Il download di stringhe è davvero facile. Il metodo GetStringAsync () richiede come parametro l'URL del file e restituisce il contenuto del file come una stringa. Nel seguente esempio, puoi vedere come scaricare il feed RSS del mio blog:
private async void OnDownloadStringClicked (mittente dell'oggetto, RoutedEventArgs e) Client HttpClient = new HttpClient (); string result = attende client.GetStringAsync ("http://feeds.feedburner.com/qmatteoq_eng"); Una volta ottenuta la stringa, è possibile eseguire le operazioni richieste in base al proprio scenario. Ad esempio, nell'esempio precedente avrei potuto analizzare il XML restituito con LINQ in XML per visualizzare l'elenco di notizie sullo schermo.
Il download di file binari può essere realizzato in molti modi. Puoi usare GetByteArrayAsync () se preferisci lavorare con i byte, o GetStreamAsync () se preferisci manipolare il contenuto del file come uno stream.
Nel seguente esempio, vedrai come scaricare un'immagine usando il GetByteArrayAsync () metodo. Restituisce l'array di un byte, che può essere facilmente salvato nella memoria locale utilizzando le API che abbiamo appreso in precedenza in questa serie.
private async void OnDownloadFileClicked (mittente dell'oggetto, RoutedEventArgs e) Client HttpClient = new HttpClient (); byte [] bytes = attendi client.GetByteArrayAsync ("http://www.syncfusion.com/Content/en-US/Home/Images/syncfusion-logo.png"); StorageFile storageFile = attendi ApplicationData.Current.LocalFolder.CreateFileAsync ("picture.png", CreationCollisionOption.ReplaceExisting); IRandomAccessStream accessStream = attende storageFile.OpenAsync (FileAccessMode.ReadWrite); using (IOutputStream outputStream = accessStream.GetOutputStreamAt (0)) DataWriter writer = new DataWriter (outputStream); writer.WriteBytes (bytes); attendi writer.StoreAsync (); Usando il DataWriter classe, siamo in grado di salvare l'array di byte restituito dal HttpClient class in un file nello storage locale chiamato picture.png.
Se è necessario il pieno controllo sull'operazione di download, è possibile utilizzare il generico GetAsync () metodo, che restituisce a HttpResponseMessage oggetto con il contenuto dell'intera risposta, come intestazioni, codice di stato, ecc.
Nel seguente esempio puoi vedere come, usando il GetAsync () metodo, siamo in grado di scaricare un'immagine come ruscello e mostrarlo in un Immagine controllo posizionato sulla pagina. Al metodo passiamo un secondo parametro di tipo HttpCompletionOption, che indica alla classe quando contrassegnare l'operazione come completata. Dal momento che vogliamo il contenuto completo della risposta (che è l'immagine scaricata), usiamo il ResponseContentRead opzione.
private async void OnDownloadStreamClicked (mittente dell'oggetto, RoutedEventArgs e) HttpClient client = new HttpClient (); HttpResponseMessage httpResponseMessage = attendi client.GetAsync ("http://www.syncfusion.com/Content/en-US/Home/Images/syncfusion-logo.png", HttpCompletionOption.ResponseContentRead); Stream stream = attendi httpResponseMessage.Content.ReadAsStreamAsync (); BitmapImage image = new BitmapImage (); image.SetSource (stream); Logo.Source = immagine; Si noti che i metodi specifici che abbiamo visto offerti dal HttpClient classe sono semplicemente una scorciatoia per i metodi offerti dal Soddisfare proprietà del HttpResponseMessage classe (nell'esempio precedente, usiamo il ReadAsStreamAsync () metodo per restituire il contenuto della risposta come ruscello).
Il caricamento dei dati avviene in modo simile: l'operazione viene solitamente eseguita utilizzando il comando POST, quindi HttpClient la classe espone il PostAsync () metodo per questo scopo.
Il contenuto da inviare è preparato usando il HttpContent classe, che offre molte implementazioni: StreamContent per inviare lo stream di un file, ByteArrayContent per inviare un file binario, StringContent per inviare una stringa, o MultipartFormDataContent per inviare contenuto codificato utilizzando il tipo MIME multipart / form-data.
Nell'esempio seguente, puoi vedere come caricare lo stream di un file su un servizio:
private async void OnUploadFileClicked (mittente dell'oggetto, RoutedEventArgs e) StorageFile storageFile = attende ApplicationData.Current.LocalFolder.GetFileAsync ("picture.png"); IRandomAccessStream accessStream = attende storageFile.OpenAsync (FileAccessMode.ReadWrite); Client HttpClient = new HttpClient (); HttpContent content = new StreamContent (accessStream.AsStreamForRead ()); attendere client.PostAsync ("http://wp8test.azurewebsites.net/api/values", contenuto); Dopo aver recuperato il flusso di un file archiviato nella memoria locale, lo passiamo a una nuova istanza di StreamContent classe. Quindi, chiamiamo il PostAsync () metodo, passando l'URL del servizio e il HttpContent oggetto come parametri.
REST (Representational State Transfer) è, senza dubbio, l'approccio più utilizzato al giorno d'oggi nello sviluppo di servizi web, in particolare nel mondo mobile.
I servizi REST sono diventati molto popolari per due motivi:
Quasi tutte le piattaforme supportano in modo nativo queste tecnologie, quindi non è necessario cercare librerie speciali per interagire con esse, come è necessario per i servizi Web basati su WSDL.
Abbiamo già visto come, con HttpClient classe, è semplice interagire con il web usando i comandi HTTP standard. La maggior parte delle volte, per interagire con un servizio REST, devi semplicemente eseguire il GetStringAsync () metodo per ottenere la risposta XML o JSON.
Una volta ottenuto il risultato, la maggior parte delle volte dovrai convertirlo in oggetti da utilizzare all'interno dell'applicazione. In precedenza in questa serie, abbiamo discusso il modo più semplice per eseguire questo compito: deserializzazione, che significa tradurre il testo semplice in oggetti complessi. Possiamo usare il DataContractSerializer o DataContractJsonSerializer classi per fare questo. In questo caso, è sufficiente fare riferimento al processo di deserializzazione poiché la procedura è la stessa.
private async void OnConsumeServiceClicked (mittente dell'oggetto, RoutedEventArgs e) HttpClient client = new HttpClient (); string result = attende client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values"); utilizzando (MemoryStream ms = new MemoryStream (Encoding.Unicode.GetBytes (result))) DataContractJsonSerializer serializer = new DataContractJsonSerializer (typeof (List)); Elenco people = serializer.ReadObject (ms) come elenco; Supponiamo che il servizio restituisca, in formato JSON, un elenco di persone:
["id": 1, "nome": "Matteo", "cognome": "Pagani", "id": 2, "nome": "Giovanni", "cognome": "Doe"]
Con l'aiuto di DataContractJsonSerializer classe, siamo in grado di convertire il precedente JSON in un elenco di Persona oggetti, che è la stessa classe che abbiamo usato in molti altri campioni di questa serie. La differenza in questo esempio è che siamo in grado di controllare il processo di serializzazione, nel caso in cui, ad esempio, i nomi di proprietà restituiti da JSON siano diversi da quelli che usiamo nelle nostre classi. Questo è uno scenario molto comune quando si ha a che fare con JSON poiché i nomi delle proprietà sono tipicamente in minuscolo, mentre negli oggetti C # sono CamelCase. Questo risultato si ottiene usando il [DataMember] attributo, che può essere applicato alle proprietà che vogliamo serializzare. Nell'esempio seguente, puoi vedere che l'attributo offre una proprietà chiamata Nome, che può essere usato per specificare quale nome di proprietà ci aspettiamo di trovare nel file JSON.
public class Person [DataMember (Name = "id")] public int Id get; impostato; [DataMember (Name = "name")] public string Nome get; impostato; [DataMember (Name = "cognome")] public string Cognome get; impostato;
Questo approccio ha uno svantaggio: i servizi REST restituiscono sempre una stringa semplice, mentre il DataContractJsonSerializer la classe richiede a ruscello come parametro di input del ReadObject () metodo, quindi siamo sempre costretti a convertirlo usando a MemoryStream oggetto.
C'è un altro modo per ottenere lo stesso risultato. Permettetemi di presentare JSON.NET, una libreria di terze parti che offre alcune funzioni utili aggiuntive per la gestione dei dati JSON. Inoltre, offre prestazioni migliori ed è in grado di deserializzare i file JSON complessi più velocemente.
Può essere facilmente installato utilizzando NuGet e il suo sito Web ufficiale offre confronti con altre librerie JSON e documentazione dettagliata.
Nell'esempio seguente, utilizziamo JSON.NET per ottenere lo stesso risultato del codice che abbiamo utilizzato in precedenza:
private async void OnGetDataClicked (mittente dell'oggetto, RoutedEventArgs e) HttpClient client = new HttpClient (); string result = attende client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values"); Elenco people = JsonConvert.DeserializeObject> (Risultato); Il JsonConvert classe (che fa parte del Newtonsoft.Json namespace) espone il DeserializeObject metodo, dove T è il tipo di oggetto che ci aspettiamo in cambio. Come parametro di input, richiede solo la stringa JSON che abbiamo scaricato dal servizio.
È anche possibile controllare il processo di deserializzazione utilizzando gli attributi, come abbiamo fatto precedentemente con DataMember attributo. Nell'esempio seguente, puoi vedere come possiamo definire manualmente come devono essere tradotte le proprietà JSON:
public class Person [JsonProperty ("id")] public int Id get; impostato; [JsonProperty ("name")] public string Nome get; impostato; [JsonProperty ("cognome")] public string Cognome get; impostato; Suggerimento: spesso dovrai utilizzare servizi di terze parti, quindi non conoscerai la mappatura esatta tra entità e dati JSON. C'è un sito web che ti aiuterà in questo scenario: http://json2csharp.com/. Basta incollare il JSON restituito dal servizio e genererà per te le classi C # necessarie per mappare i dati JSON.
Un'altra caratteristica interessante introdotta da JSON.NET è LINQ to JSON, che è un linguaggio basato su LINQ che, simile a LINQ to XML, può essere utilizzato per manipolare una stringa JSON per estrarre solo le informazioni necessarie. Questo approccio è utile quando non è necessario utilizzare la deserializzazione, ma è sufficiente estrarre alcuni dati dalla risposta JSON ricevuta dal servizio.
Il punto di partenza per usare LINQ to JSON è il jobject classe, che identifica un file JSON. Per iniziare a lavorare con esso, devi semplicemente chiamare il Parse () metodo, passando come parametro la stringa JSON, come mostrato nel seguente esempio:
private async void OnParseJson (mittente dell'oggetto, RoutedEventArgs e) HttpClient client = new HttpClient (); string result = attende client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values"); JObject json = JObject.Parse (risultato); Ora sei pronto per eseguire alcune operazioni. Diamo un'occhiata a quelli più comuni.
Semplice JSON
Ecco un esempio di un semplice file JSON:
"Id": 1, "Nome": "Matteo", "Cognome": "Pagani"
Con LINQ to JSON, siamo in grado di estrarre il valore di una singola proprietà nel modo seguente:
private async void OnParseJson (mittente dell'oggetto, RoutedEventArgs e) HttpClient client = new HttpClient (); string result = attende client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values/1"); JObject json = JObject.Parse (risultato); string value = json ["Name"]. Valore(); Il jobject la classe viene trattata come una raccolta, quindi puoi semplicemente accedere a una proprietà usando il suo nome come chiave. Alla fine, puoi estrarre il valore usando il Valore metodo, dove T è il tipo di dati che ci aspettiamo di essere memorizzati.
Complesso JSON
Come gli oggetti C #, anche gli oggetti JSON possono avere proprietà complesse, come mostrato nel seguente esempio:
"Id": 1, "Nome": "Matteo", "Cognome": "Pagani", "Indirizzo": "Via": "Indirizzo falso", "Città": "Milano"
Indirizzo è una proprietà complessa perché contiene altre proprietà nidificate. Per accedere a queste proprietà, è necessario utilizzare il SelectToken () metodo, passando il percorso JSON completo come parametro:
private async void OnParseJson (mittente dell'oggetto, RoutedEventArgs e) HttpClient client = new HttpClient (); string result = attende client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values/1"); JObject json = JObject.Parse (risultato); string city = json.SelectToken ("Address.City"). Valore(); Con il Address.City percorso, siamo in grado di estrarre il valore del Città proprietà che fa parte del Indirizzo nodo.
Collezioni JSON
Quando gestisci le raccolte JSON, puoi utilizzare Bambini() metodo per ottenere l'accesso a tutti i nodi figli di una proprietà specifica. Usiamo, ad esempio, un codice JSON che abbiamo visto in precedenza:
["Id": 1, "Nome": "Matteo", "Cognome": "Pagani", "Id": 2, "Nome": "Giovanni", "Cognome": "Doe"]
In questo caso, possiamo usare il JArray classe e il Bambini() metodo per estrarre tutti gli elementi della collezione. Nell'esempio seguente puoi vedere come lo usiamo per ottenere una sottoraccolta con solo il Nome i valori della proprietà.
private async void OnGetDataClicked (mittente dell'oggetto, RoutedEventArgs e) HttpClient client = new HttpClient (); string result = attende client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values"); JArray json = JArray.Parse (risultato); Elenco list = json.Children (). Seleziona (x => x ["Nome"]. Valore()).Elencare(); Il HttpClient classe che abbiamo visto in precedenza, come il WebClient e HttpWebRequest le classi, possono essere utilizzate solo per le operazioni in primo piano. Quando l'applicazione è sospesa, i trasferimenti di rete vengono annullati.
Quando dobbiamo gestire trasferimenti di dati di grandi dimensioni, costringere l'utente a mantenere l'app aperta non crea la migliore esperienza utente. In questo scenario, Windows Phone 7.5 ha introdotto API di trasferimento in background che possono essere utilizzate per avviare un'operazione di download o caricamento e per continuare anche se l'app è sospesa.
Tuttavia, sono state introdotte alcune limitazioni per evitare problemi di batteria e un consumo elevato di piani dati:
Un trasferimento in background è identificato dal BackgroundTransferRequest classe, che fa parte del Microsoft.Phone.BackgroundTransfer namespace. Come sviluppatori, abbiamo il controllo su alcune condizioni che devono essere soddisfatte per iniziare un trasferimento in background creato nella nostra applicazione, grazie a TransferPreferences proprietà che può ottenere i seguenti valori:
Nessuna, il valore predefinito: il trasferimento viene avviato solo se il telefono è connesso a una rete Wi-Fi e la batteria è in carica.AllowBattery: Il trasferimento viene avviato solo se il telefono è connesso a una rete Wi-Fi, indipendentemente dalla fonte di alimentazione.AllowCelullar: Il trasferimento viene avviato solo se il telefono è in carica, indipendentemente dalla connessione di rete.AllowCellularAndBattery: Avvia sempre il trasferimento, indipendentemente dalle condizioni di connessione e di alimentazione.
Il BackgroundTransferRequest class espone due gestori di eventi che possono essere utilizzati per controllare il trasferimento:
TransferStatusChanged viene attivato quando lo stato del trasferimento cambia. Il parametro restituito dal metodo contiene a TransferStatus oggetto che ti informa dello stato corrente (come Completato quando il trasferimento finisce, o In pausa quando il trasferimento è in pausa). Esistono anche stati specifici che iniziano con In attesa prefisso che ti dice quando un trasferimento è sospeso perché le condizioni definite nel file TransferPreferences la proprietà non è soddisfatta. Per esempio, WaitingForWiFi viene impostato quando il trasferimento è in attesa che il telefono sia connesso a una rete Wi-Fi per l'avvio.TransferProgressChanged viene attivato quando il progresso di un trasferimento cambia, il che significa che i nuovi dati sono stati scaricati o caricati. Di solito, questo gestore di eventi è connesso a a Barra di avanzamento controllo poiché espone proprietà per notificare quanti dati sono stati trasferiti e quanti dati devono ancora essere scaricati o inviati.Dopo aver definito un trasferimento in background, è necessario aggiungerlo alla coda del sistema operativo. Windows Phone si prenderà cura di avviarlo quando le condizioni specificate sono soddisfatte. Per realizzare questo compito, usiamo il BackgroundTransferService classe, che è il gestore di trasferimento in background centrale. È possibile aggiungere, rimuovere o elencare i trasferimenti in background che appartengono all'applicazione.
Nell'esempio seguente è possibile vedere una definizione di trasferimento in background:
private BackgroundTransferRequest backgroundRequest; private void OnStartBackgroundDownloadClicked (mittente dell'oggetto, RoutedEventArgs e) Uri sourceUrl = new Uri ("http://wpsauce.com/wp-content/uploads/2011/11/windows_phone_logo.jpg"); Uri destinationUrl = new Uri ("/ Shared / Transfers / windows_phone_logo.jpg", UriKind.RelativeOrAbsolute); backgroundRequest = new BackgroundTransferRequest (sourceUrl, destinationUrl); backgroundRequest.TransferStatusChanged + = backgroundRequest_TransferStatusChanged; backgroundRequest.TransferPreferences = TransferPreferences.AllowCellularAndBattery; BackgroundTransferService.Add (backgroundRequest); void backgroundRequest_TransferStatusChanged (mittente dell'oggetto, BackgroundTransferEventArgs e) if (backgroundRequest.TransferStatus == TransferStatus.Completed) // Gestisce il file scaricato. BackgroundTransferService.Remove (backgroundRequest); Registriamo questo trasferimento da eseguire indipendentemente dalla connessione di rete disponibile e dalla fonte di alimentazione. L'esempio precedente è correlato a un'operazione di download, quindi è necessario definire un URI di origine (il file da scaricare) e un URI di destinazione (il percorso di archiviazione locale in cui verrà salvato il file). A differenza di ciò che abbiamo visto con HttpClient, non dobbiamo prenderci cura del processo di salvataggio; il file verrà automaticamente scaricato e salvato nella memoria locale poiché il download può anche terminare quando l'app è sospesa. Sia gli URI di origine che di destinazione sono passati come parametri del BackgroundTransferRequest costruttore.
Nota: i trasferimenti in background utilizzati per eseguire le operazioni di download devono sempre salvare il file all'interno del percorso Shared / Transfers nella memoria locale, che viene automaticamente creata quando l'app è installata, altrimenti si otterrà un'eccezione. Al termine del download, sei libero di spostare il file in un'altra posizione se necessario, ma non puoi pianificare un trasferimento in background che tenta di scaricare un file in una cartella diversa.
Successivamente, ci iscriviamo al TransferStatusChanged evento. Se il download è completato mentre l'app è in primo piano, siamo in grado di gestire il file scaricato, ad esempio, se si tratta di un'immagine, possiamo visualizzarla. Notare il Rimuovere() operazione che eseguiamo sul BackgroundTransferService classe. È molto importante eseguire sempre questa attività perché il sistema operativo non rimuoverà automaticamente i trasferimenti completati dalla coda dell'applicazione e potrebbe causare problemi imprevisti poiché un'applicazione non può pianificare più di 25 trasferimenti.
Invece, se devi caricare un file, devi creare un file BackgroundTransferRequest oggetto in un modo diverso. È ancora necessario definire due URI: la sorgente (il file da caricare) e la destinazione (un servizio che è in grado di ricevere il file utilizzando il comando HTTP impostato nel Metodo proprietà). L'URI di destinazione può essere passato nel BackgroundTransferRequestil costruttore (come abbiamo fatto in precedenza), ma l'URI sorgente deve essere impostato nel file UploadLocation proprietà, come nel seguente esempio:
private void OnUploadFile () Uri destinationUrl = new Uri ("http://wp8test.azurewebsites.com/api/values", UriKind.Relative); Uri sourceUri = new Uri ("/ Shared / Transfers / image.png", UriKind.Relative); BackgroundTransferRequest request = new BackgroundTransferRequest (destinationUrl); request.UploadLocation = sourceUri; request.Method = "POST"; BackgroundTransferService.Add (richiesta); In questo articolo abbiamo visto come lavorare con una delle funzionalità più utilizzate di uno smartphone: una connessione Internet. In dettaglio, abbiamo imparato:
HttpClient è una nuova classe introdotta in Windows Runtime che consente di eseguire operazioni di rete. Abbiamo visto come usarlo per scaricare e caricare file e interagire con i servizi.HttpClient è di grande aiuto, ma funziona solo se l'applicazione è in primo piano. Quando viene sospeso, le operazioni di rete vengono annullate. A tale scopo, il framework offre alcune API specifiche per eseguire operazioni di download e caricamento anche in background quando l'app non è in uso.Questo tutorial rappresenta un capitolo di Windows Phone 8 in modo succinto, un eBook gratuito dal team di Syncfusion.
