Windows Phone 8 Succinctly: Data Access-Network
16
Del
Del
Del
Denne Cyber Monday Envato Tuts + kurs vil bli redusert til bare $ 3. Ikke gå glipp av
Dette innlegget er en del av en serie som heter Windows Phone 8 Succinctly.Windows Phone 8 Succinctly. Data Access-StorageWindows Phone 8 Succinctly: Integrering med maskinvaren
Kontroll av Internet Connection
< p> Alle Windows Phone-enheter har en innebygd nettverkstilkobling, men av samme grunn vi lærte å lokalt lagre data, må vi være klar til å styre hvordan brukerne bruker vår søknad mens forbindelsen mangler.
< p> For dette formålet, Windows Phone rammeverket inneholder en klasse som kan brukes til å finne informasjon om Internett-tilkobling kalt DeviceNetworkInformation, som er en del av Microsoft.Phone.Net.NetworkInformation navnerom.
Det viktigste en er IsNetworkAvailable, som forteller oss om en Internett-tilkobling er tilgjengelig. Vi bør alltid bruke denne API før du utfører en operasjon som krever tilkobling, slik ut:
private void OnCheckConnectionClicked (objekt avsenderen, RoutedEventArgs e) {if (DeviceNetworkInformation.IsNetworkAvailable) {MessageBox.Show ("Du er koblet til Internet "); //Utfør nettvirksomheten. } Else {MessageBox.Show ("Du er ikke koblet til Internett"); }}
Klassen har også et arrangement som heter NetworkAvailabilityChanged som utløses hver gang tilkoblingsstatus endres. Det er nyttig hvis du vil raskt reagere på endringer nettverk, for eksempel aktivere eller deaktivere enkelte programfunksjoner
offentlig Mainpage () {InitializeComponent (.); DeviceNetworkInformation.NetworkAvailabilityChanged + = DeviceNetworkInformation_NetworkAvailabilityChanged;} private void DeviceNetworkInformation_NetworkAvailabilityChanged (objekt avsenderen, NetworkNotificationEventArgs e) {if (e.NotificationType == NetworkNotificationType.InterfaceDisconnected) {MessageBox.Show ("Disconnected"); } Else if (e.NotificationType == NetworkNotificationType.InterfaceConnected) {MessageBox.Show ("Connected"); }}
Retur parametere inneholde en egenskap kalt NotificationType, av den typen NetworkNotificationType, som forteller oss den aktuelle nettverksstatus.
Men med DeviceNetworkInformation du vil kunne også få annen informasjon om gjeldende nettverksstatus, som om brukeren har aktivert mobildatatilkobling (IsCellularDataEnabled), Wi-Fi-tilkobling (IsWiFiEnabled), eller roaming-innstillinger (IsCellularDataRoamingOptions).
Rammeverket tilbyr en annen nyttig klasse å forholde seg til nettverk forbindelser kalt NetworkInterface. Som bruker NetworkInterfaceType eiendommen, vil du være i stand til å identifisere hvilken tilkoblingstype som er i bruk. For eksempel kan vi bruke denne eiendommen for å unngå å laste ned store filer mens du bruker en mobilforbindelse.
NetworkInterfaceType er en enumeratoren som kan anta mange verdier. De viktigste er:
MobileBroadbandGsm og MobileBroadbandCdma når telefonen er koblet til et mobilnett (GSM eller CDMA, i henhold til land)
Wireless80211, når telefonen er koblet til et Wi-Fi-nettverk
I følgende eksempel viser vi en melding på skjermen med den aktuelle tilkoblingstype:
private void OnCheckConnectionTypeClicked (objekt avsenderen, RoutedEventArgs e) { if (NetworkInterface.NetworkInterfaceType == NetworkInterfaceType.MobileBroadbandGsm || NetworkInterface.NetworkInterfaceType == NetworkInterfaceType.MobileBroadbandCdma) {MessageBox.Show ("Mobile"); } Else if (NetworkInterface.NetworkInterfaceType == NetworkInterfaceType.Wireless80211) {MessageBox.Show ("Wi-Fi"); }}
utøvende Network Operations: HttpClient
Windows Phone rammeverket har to innebygde klasser for å utføre nettverksoperasjoner: WebClient og HttpWebRequest. Dessverre er ingen av dem er perfekt. WebClient er svært enkel å bruke, men det er basert på den gamle tilbakeringing tilnærming (med mindre du installerer Async for .NET pakken vi diskutert tidligere i denne serien). HttpWebRequest er veldig kraftig, men det er komplisert å bruke og er basert på en gammel asynkron mønster som er vanskelig å forstå.
Windows Runtime har innført en ny klasse kalt HttpClient, som tar det beste fra begge verdener. Det er kraftig og gir god ytelse, men det er lett å bruke og gir metoder som er basert på den nye async og venter mønster. Denne klassen er tilgjengelig i hele Windows Runtime for Windows Store apps, men det er ikke inkludert i Windows Phone Runtime undergruppe-du må installere det fra nuget.
HttpClient klasse, så vi får se senere, er stor ikke bare for å utføre generiske nettvirksomheten som nedlasting og opplasting fil, men også for å kommunisere med webtjenester. Faktisk, eksponerer den asynkrone metoder for hver HTTP-kommandoen, som GET, POST, PUT, etc.
Merk: For å være i stand til å samhandle med nettverket må du aktivere ID_CAP_NETWORKING alternativet i manifestfilen. Det er aktivert i alle nye Windows Phone-prosjektet som standard.
laste ned data
filer er vanligvis ned ved hjelp av GET HTTP-kommandoen, så HttpClient tilbyr GetAsync () metoden . For å gjøre utviklernes liv enklere, HttpClient har noen innebygde metoder for å laste ned de mest vanlige filtyper, for eksempel GetStringAsync () for å laste ned tekstfiler som XML, RSS, eller hvile svar; eller GetByteArrayAsync () og GetStreamAsync () for å få binærfil innhold.
Nedlasting av strenger er virkelig enkelt. Metoden GetStringAsync () krever som et parameter filens URL og returnerer innholdet i filen som en streng. I følgende eksempel, kan du se hvordan du laster ned bloggen min RSS-feed:
privat async void OnDownloadStringClicked (objekt avsenderen, RoutedEventArgs e) {HttpClient klient = new HttpClient (); string resultat = avvente client.GetStringAsync ("http://feeds.feedburner.com/qmatteoq_eng");}
Når du har strengen, kan du utføre de nødvendige operasjonene i henhold til ditt scenario. For eksempel i den forrige prøven jeg kunne ha analysert den returnerte XML med LINQ til XML for å vise nyhetslisten på skjermen.
Nedlasting av binære filer kan gjøres på mange måter. Du kan bruke GetByteArrayAsync () hvis du foretrekker å jobbe med byte, eller GetStreamAsync () hvis du foretrekker å manipulere innholdet i filen som en bekk.
I følgende eksempel, vil du se hvordan du laster ned et bilde bruker GetByteArrayAsync () -metoden. Den returnerer en byte fylking, som lett kan lagres i lokal lagring ved hjelp av APIer vi lært om tidligere i denne serien.
Privat async void OnDownloadFileClicked (objekt avsenderen, RoutedEventArgs e) {HttpClient klient = new HttpClient ( ); byte [] bytes = avvente client.GetByteArrayAsync ("http://www.syncfusion.com/Content/en-US/Home/Images/syncfusion-logo.png"); StorageFile storageFile = avvente ApplicationData.Current.LocalFolder.CreateFileAsync ("picture.png", CreationCollisionOption.ReplaceExisting); IRandomAccessStream accessStream = avvente storageFile.OpenAsync (FileAccessMode.ReadWrite); bruker (IOutputStream outputStream = accessStream.GetOutputStreamAt (0)) {DataWriter forfatter = ny DataWriter (outputStream); writer.WriteBytes (bytes); avvente writer.StoreAsync (); }}
Ved hjelp av DataWriter klassen, er vi i stand til å lagre byte array returneres av HttpClient klassen i en fil i lokal lagring kalles picture.png.
Hvis du trenger full kontroll over nedlasting drift, kan du bruke den generiske GetAsync () metoden, som returnerer en HttpResponseMessage objekt med hele svaret innhold, som overskrifter, statuskode, etc.
I følgende eksempel kan du se hvordan, ved å bruke GetAsync () metoden, er vi i stand til å laste ned et bilde som Stream og vise det i en bildekontroll plasseres på siden. Den metode som passerer vi en andre parameter av type HttpCompletionOption, som forteller klassen når å merke operasjonen som fullført. Siden vi ønsker at alt innholdet i svaret (som er lastet ned bildet), bruker vi ResponseContentRead alternativet
privat async void OnDownloadStreamClicked (objekt avsenderen, RoutedEventArgs e) {HttpClient klient = new HttpClient (.); HttpResponseMessage httpResponseMessage = avvente client.GetAsync ("http://www.syncfusion.com/Content/en-US/Home/Images/syncfusion-logo.png", HttpCompletionOption.ResponseContentRead); Stream stream = avvente httpResponseMessage.Content.ReadAsStreamAsync (); BitmapImage image = ny BitmapImage (); image.SetSource (stream); Logo.Source = image;}
Legg merke til at de spesifikke metodene vi har sett som tilbys av HttpClient klassen er bare en snarvei til metodene som tilbys av innhold eiendommen av HttpResponseMessage klasse (i forrige prøven, bruker vi ReadAsStreamAsync () metode for å returnere svar innhold som Stream)
Opplasting av data
Laster opp data gjøres på en lignende måte. operasjonen utføres vanligvis bruker POST-kommandoen, så HttpClient klasse eksponerer PostAsync () metode for dette formålet
Innholdet sende, er utarbeidet etter den HttpContent klassen, som tilbyr mange implementeringer. StreamContent å sende en fil stream, ByteArrayContent å sende en binær fil, StringContent å sende en . streng, eller MultipartFormDataContent å sende innhold som er kodet i multipart /skjema-data MIME-type
I det følgende prøve, kan du se hvordan du laster opp en fil stream til en tjeneste:
privat async void OnUploadFileClicked (objekt avsender, RoutedEventArgs e) {StorageFile storageFile = avvente ApplicationData.Current.LocalFolder.GetFileAsync ("picture.png"); IRandomAccessStream accessStream = avvente storageFile.OpenAsync (FileAccessMode.ReadWrite); HttpClient klient = new HttpClient (); HttpContent content = ny StreamContent (accessStream.AsStreamForRead ()); avvente client.PostAsync ("http://wp8test.azurewebsites.net/api/values", innhold);}
Etter at vi har hentet strømmen av en fil som er lagret i lokal lagring, passerer vi den til en ny forekomst av StreamContent klassen. Så, vi kaller den PostAsync () -metoden, passerer tjenestens URL og HttpContent objekt som parametre.
Bruke REST Services
REST (Representational State Transfer) er, uten tvil, den mest . brukt tilnærming i dag i web-tjeneste utvikling, spesielt i den mobile verden
REST-tjenester har blitt svært populært for to grunner:
De er basert på HTTP-protokollen og de utsetter operasjoner bruke standard HTTP-kommandoer (som GET, POST, PUT, etc.).
De kommer tilbake data ved hjelp av standardspråk som XML og JSON.
Nesten hver plattform støtter opprinnelig disse teknologiene , så du slipper å lete etter spesielle biblioteker for å samhandle med dem som er nødvendig for WSDL-baserte webtjenester.
Vi har allerede sett hvordan, med HttpClient klassen, er det enkelt å samhandle med nettet ved hjelp av standard HTTP-kommandoer. Mesteparten av tiden, til å samhandle med en REST tjeneste, vil du rett og slett nødt til å utføre GetStringAsync () metode for å få XML eller JSON respons.
Når du har resultatet, mesteparten av tiden du ' ll nødt til å konvertere den til objekter som skal brukes inne i applikasjonen. Tidligere i denne serien, diskuterte vi den enkleste måten å utføre denne oppgaven: deserialization, noe som betyr sette ren tekst til komplekse objekter. Vi kan bruke DataContractSerializer eller DataContractJsonSerializer klasser for å gjøre dette. I dette tilfellet, er det bare å slå opp i deserialization prosessen siden prosedyren er den samme
private async void OnConsumeServiceClicked (objekt avsenderen, RoutedEventArgs e) {HttpClient klient = new HttpClient (.); string resultat = avvente client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values"); bruker (Memory ms = new Memory (Encoding.Unicode.GetBytes (resultat))) {DataContractJsonSerializer serialisering = new DataContractJsonSerializer (typeof (List < Person >)); List < Person > folk = serializer.ReadObject (ms) som List < Person >; }}
Vi antar at tjeneste avkastning, i JSON-format, en liste over personer: product: [{"id": 1, "name": "Matteo", "etternavn": "Pagani" }, {"id": 2, "name": "John", "etternavnet": "Nordmann"}]
Med hjelp av DataContractJsonSerializer klasse, er vi i stand til å konvertere den forrige JSON inn en liste over Person gjenstander, som er i samme klasse som vi har brukt i mange andre prøver i denne serien. Forskjellen i dette utvalget er at vi er i stand til å kontrollere serialisering prosessen, i tilfelle, for eksempel egenskapsnavnene returnert fra JSON er annerledes enn de vi bruker i våre klasser. Dette er en svært vanlig scenario når du arbeider med JSON siden egenskapsnavnene er vanligvis små, mens i C # objekter er de Camelcase. Dette resultatet er oppnådd ved hjelp av [DataMember] egenskap, som kan brukes til de egenskapene vi ønsker å serial. I følgende eksempel, kan du se at attributtet tilbyr en egenskap kalt navn, som kan brukes til å angi hvilke objektnavn vi forventer å finne i JSON-fil.
Public class Person {[DataMember (Name = "id")] public int Id {får; sett; } [DataMember (Name = "navn")] offentlig string Name {får; sett; } [DataMember (Name = "etternavn")] public String etternavn {får; sett; }}
Denne tilnærmingen har en ulempe: REST tjenester alltid returnere en vanlig streng, mens DataContractJsonSerializer klassen krever en Stream som inngangsparameter for ReadObject () -metoden, så vi er alltid tvunget til å konvertere den ved hjelp av en Memory objekt .
Det er en annen måte å oppnå det samme resultat. La meg presentere JSON.NET, en tredjeparts bibliotek som har noen flere nyttige funksjoner for håndtering av JSON data. I tillegg tilbyr bedre ytelse og er i stand til å deserialize komplekse JSON-filer raskere.
Det kan enkelt installeres ved hjelp nuget, og dens offisielle nettsiden tilbyr sammenligninger med andre JSON biblioteker og detaljert dokumentasjon.
I følgende eksempel, bruker vi JSON.NET å oppnå samme resultat som den koden som vi tidligere har brukt:
privat async void OnGetDataClicked (objekt avsenderen, RoutedEventArgs e) {HttpClient klient = new HttpClient ( ); string resultat = avvente client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values"); List < Person > folk = JsonConvert.DeserializeObject < List < Person > > (resultat);}
JsonConvert klasse (som er en del av Newtonsoft.Json navne) utsetter DeserializeObject < T > () -metoden, hvor T er objektet type vi forventer i retur. Som inngangsparameter, det krever bare JSON streng som vi har lastet ned fra tjenesten.
Det er også mulig å styre deserialization prosessen ved hjelp av attributter, som vi tidligere gjorde med DataMember attributt. I følgende eksempel, kan du se hvordan vi kan manuelt definere hvordan JSON egenskaper skal oversettes:
public class Person {[JsonProperty ("id")] public int Id {får; sett; } [JsonProperty ("navn")] offentlig string Name {får; sett; } [JsonProperty («etternavnet»)] public String etternavn {får; sett; }}
Tips: Du vil ofte nødt til å bruke tredjeparts tjenester, slik at du ikke vil vite nøyaktig kartlegging mellom enheter og JSON data. Det er et nettsted som vil hjelpe deg i dette scenariet:
http://json2csharp.com/
. Bare lim inn JSON returnert av tjenesteleverandøren, og det vil generere for deg de nødvendige C # klasser for å kartlegge JSON data.
LINQ til JSON
En annen interessant funksjon introdusert av JSON.NET er LINQ til JSON, som er et LINQ-basert språk som, i likhet med LINQ til XML, kan brukes til å manipulere en JSON streng å trekke ut akkurat den informasjonen du trenger. Denne tilnærmingen er nyttig når du egentlig ikke trenger å bruke deserialization, men trenger bare å trekke ut noen data fra JSON svaret du fikk fra tjenesten.
Utgangspunktet for å bruke LINQ til JSON er JObject klasse, som identifiserer en JSON-fil. For å begynne å jobbe med det, du bare må ringe Parse () -metoden, passerer som parameter JSON streng, som vist i følgende eksempel:
privat async void OnParseJson (objekt avsenderen, RoutedEventArgs e) {HttpClient klient = new HttpClient (); string resultat = avvente client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values"); JObject json = JObject.Parse (resultat);}
Nå er du klar til å utføre enkelte operasjoner. La oss ta en titt på de vanligste
Enkelt JSON
Her er et eksempel på en enkel JSON-fil. Product: {"id": 1, "Name" : "Matteo", "etternavn": "Pagani"}
Med LINQ til JSON, er vi i stand til å trekke ut en enkelt eiendommens verdi på følgende måte:
privat async void OnParseJson (objekt avsenderen, RoutedEventArgs e) {HttpClient klient = new HttpClient (); string resultat = avvente client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values/1"); JObject json = JObject.Parse (resultat); string value = json ["navn"] Verdi. < streng > ();}
JObject klassen er behandlet som en samling, så du kan bare få tilgang til en eiendom ved hjelp av sitt navn som en nøkkel. Til slutt kan du trekke verdien ved hjelp av Value < T >. () -metoden, Hvor T er datatypen vi forventer å bli lagret
Complex JSON
som C # objekter, JSON objekter kan også ha komplekse egenskaper, som vist i følgende eksempel: product: {"id": 1, "Name": "Matteo", "etternavn": "Pagani", "Adresse": {" street ":" Fake adresse "," By: Milan "}}
Adresse en kompleks egenskap fordi den inneholder andre nestede egenskaper" ". For tilgang til disse egenskapene, må vi bruke SelectToken () -metoden, passerer full JSON banen som en parameter:
privat async void OnParseJson (objekt avsenderen, RoutedEventArgs e) {HttpClient klient = new HttpClient (); string resultat = avvente client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values/1"); JObject json = JObject.Parse (resultat); . string by = json.SelectToken ("Address.City") Value < streng > ();}
Med Address.City banen, er vi i stand til å trekke ut verdien av City-hotellet som er en del av adresse node .
JSON samlinger
Når du håndterer JSON samlinger, kan du bruke Children () metode for å få tilgang til alle barn noder av en bestemt eiendom. La oss bruke, som et eksempel, en JSON kode som vi tidligere har sett: product: [{"id": 1, "Name": "Matteo", "etternavn": "Pagani"}, {" id ": 2," Name ":" John "," etternavn ":" Nordmann "}]
I dette tilfellet kan vi bruke JArray klasse og barn () metode for å utvinne alle samlingens elementer. I følgende eksempel kan du se hvordan vi bruker den til å få en delsamling med bare navn eiendommens verdier
privat async void OnGetDataClicked (objekt avsenderen, RoutedEventArgs e) {HttpClient klient = new HttpClient (.); string resultat = avvente client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values"); JArray json = JArray.Parse (resultat); List < streng > list = json.Children () Velg (x = > x ["navn"] Verdi. < streng > ()). tolist ();.}
Bakgrunns Overganger
HttpClient klasse Vi tidligere har sett, som WebClient og HttpWebRequest klasser, kan bare brukes for forgrunnen operasjoner. Når programmet er suspendert, er nettverksoverføring kansellert.
Når vi har for å håndtere store dataoverføringer, tvinger brukeren til å holde app åpnet skaper ikke den beste brukeropplevelsen. For dette scenariet har Windows Phone 7.5 introdusert bakgrunn overførings APIer som kan brukes til å starte en nedlasting eller opplasting drift og for å fortsette det selv om programmet er suspendert.
Det er imidlertid noen begrensninger som har blitt introdusert å unngå batteriproblemer og høy dataabonnement forbruk:
Hvis telefonen er koblet til et mobilnettverk, filer som er større enn 20 MB kan ikke lastes ned
Hvis telefonen er koblet til. en Wi-Fi-nettverk, filer som er større enn 100 MB kan ikke lastes ned.
100 MB grensen kan overskrides bare hvis telefonen er koblet til et Wi-Fi-nettverk, og batteriet lades.
Et enkelt program kan kø opptil 25 bakgrunnsoverføringsoperasjoner.
Den globale operativsystemets kø kan inneholde opptil 500 bakgrunnen overføringsoperasjoner.
Telefonen kan utføre et maksimum to overføringsoperasjoner på en gang.
En bakgrunn overføring er identifisert av BackgroundTransferRequest klassen, som er en del av Microsoft.Phone.BackgroundTransfer navnerom. Som utviklere, har vi kontroll over noen betingelser som må være oppfylt for en bakgrunn overføring opprettet i vår søknad til å starte, takket være TransferPreferences eiendommen som kan få følgende verdier:
Ingen, standard verdi. Overføringen starter bare hvis telefonen er koblet til et Wi-Fi-nettverk, og batteriet lades
AllowBattery: Overføringen starter bare hvis telefonen er koblet til et Wi-Fi-nettverk, uavhengig . av strømkilden
AllowCelullar. Overføringen starter bare hvis telefonen lades, uavhengig av nettverkstilkoblingen
AllowCellularAndBattery: starter alltid overføringen, uavhengig av sammenhengen og strømkilde forhold
BackgroundTransferRequest klasse eksponerer to hendelsesbehandlinger som kan brukes til å kontrollere overføring:.
TransferStatusChanged utløses når overføringen status endres. Parameteren returnert av metoden inneholder en TransferStatus objekt som varsler deg om gjeldende status (som fullført når overføringen er ferdig, eller stoppet når overføringen er satt på pause). Det finnes også spesielle statuser som starter med Waiting prefikset som forteller deg når en overføring er suspendert fordi forholdene er definert i TransferPreferences eiendommen ikke er fornøyd. For eksempel er WaitingForWiFi satt når overføringen venter på at telefonen skal være koblet til et Wi-Fi-nettverk for å starte.
Etter at du har definert bakgrunn overføring, må du legge det til operativsystemets kø. Windows Phone vil ta vare på starter det når de spesifiserte vilkår er oppfylt. For å oppnå denne oppgaven bruker vi BackgroundTransferService klassen, som er den sentrale bakgrunnen overføring manager. Du kan legge til, fjerne eller liste bakgrunn overføringer som hører til programmet
I følgende eksempel kan du se en bakgrunn overføring definisjon.
Privat BackgroundTransferRequest backgroundRequest; private void OnStartBackgroundDownloadClicked (objekt avsenderen , RoutedEventArgs e) {Uri sourceUrl = new Uri ("http://wpsauce.com/wp-content/uploads/2011/11/windows_phone_logo.jpg"); Uri destinationUrl = new Uri ("/Shared /Overganger /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 (objekt avsenderen, BackgroundTransferEventArgs e) {if (backgroundRequest.TransferStatus == TransferStatus.Completed) {//Administrer den nedlastede filen. BackgroundTransferService.Remove (backgroundRequest); }}
Vi registrerer denne overføringen skal gjennomføres uavhengig av den tilgjengelige nettverkstilkobling og strømkilden. Den forrige prøven er knyttet til en nedlasting drift, så vi trenger å definere en kilde URI (filen å laste ned) og et mål URI (lokal lagring banen der filen skal lagres). I motsetning til hva vi har sett med HttpClient, trenger vi ikke å ta vare på lagringsprosessen; filen vil automatisk bli lastet ned og lagret i lokal lagring siden nedlastingen kan også avslutte når programmet er suspendert. Både kilden og målet URI sendes som parametere i BackgroundTransferRequest konstruktør
. Merk: Bakgrunns overføringer som brukes til å utføre nedlasting operasjoner alltid må lagre filen inne i Shared /Overganger banen i lokal lagring, som opprettes automatisk når programmet er installert-ellers vil du få et unntak. Når nedlastingen er fullført, er du fri til å flytte filen til en annen stilling hvis det er nødvendig, men du kan ikke planlegge en bakgrunn overføring som prøver å laste ned en fil i en annen mappe.
Deretter abonnere vi til TransferStatusChanged hendelsen. Hvis nedlastingen er fullført, mens programmet er i forgrunnen, er vi i stand til å håndtere den nedlastede filen, for eksempel hvis det er et bilde, kan vi vise den. Legg merke til Slett () operasjon som vi utfører på BackgroundTransferService klasse. Det er veldig viktig å alltid utføre denne oppgaven fordi operativsystemet ikke vil automatisk fjerne gjennomført overføringer fra programmets kø, og det kan føre til uventede problemer siden en søknad ikke kan planlegge mer enn 25 overføringer.
I stedet Hvis du trenger å laste opp en fil, må du opprette en BackgroundTransferRequest objekt på en annen måte. Du trenger fortsatt å definere to URI: kilde (filen til å laste opp) og målet (en tjeneste som er i stand til å motta filen ved hjelp av HTTP-kommandoen satt i Method eiendom). Destinasjonen URI kan sendes i BackgroundTransferRequest konstruktør (som vi gjorde tidligere), men kilden URI må settes i UploadLocation eiendom, som i følgende eksempel:
private void OnUploadFile () {Uri destinationUrl = new Uri ("http://wp8test.azurewebsites.com/api/values", UriKind.Relative); Uri sourceUri = new Uri ("/Shared /Overganger /image.png", UriKind.Relative); BackgroundTransferRequest forespørsel = new BackgroundTransferRequest (destinationUrl); request.UploadLocation = sourceUri; request.Method = "POST"; BackgroundTransferService.Add (forespørsel);}
Konklusjon
I denne artikkelen har vi sett hvordan jobbe med en av de mest brukte funksjonene i en smarttelefon: en Internett-tilkobling. I detalj, har vi lært:
Selv om en Internett-tilkobling er en må-ha for hver enhet, bør vi være klar over at noen ganger brukerne ikke kan ha en tilgjengelig tilkobling. Det er viktig å sjekke ordentlig om telefonen er koblet til Internett før du gjør noen nettverksdrift.
Denne opplæringen representerer et kapittel fra Windows Phone 8 Succinctly, gratis eBook fra teamet på Syncfusion.