Share
Alla Windows Phone-enheter har en inbyggd nätverksanslutning, men av samma anledning lärde vi oss hur vi lagrar data lokalt, vi måste vara redo att hantera hur användarna använder vår applikation när en anslutning saknas.
I detta syfte innehåller Windows Phone-ramen en klass som kan användas för att upptäcka information om den uppringda Internet-anslutningen DeviceNetworkInformation, som är en del av Microsoft.Phone.Net.NetworkInformation namespace.
Den viktigaste är IsNetworkAvailable, som berättar om en internetanslutning är tillgänglig. Vi bör alltid använda detta API innan du utför en operation som kräver en anslutning, som följande exempel:
Accentsconagua
privat tomt OnCheckConnectionClicked (objekt avsändare, RoutedEventArgs e) if (DeviceNetworkInformation.IsNetworkAvailable) MessageBox.Show ("Du är ansluten till Internet"); // Utför nätverksoperationer. else MessageBox.Show ("Du är inte ansluten till Internet"); Klassen erbjuder också en händelse som heter NetworkAvailabilityChanged som utlöses varje gång anslutningsstatus ändras. Det är användbart om du snabbt vill reagera på nätverksändringar, till exempel att aktivera eller inaktivera vissa programfunktioner.
public MainPage () InitializeComponent (); DeviceNetworkInformation.NetworkAvailabilityChanged + = DeviceNetworkInformation_NetworkAvailabilityChanged; privat tomt DeviceNetworkInformation_NetworkAvailabilityChanged (objekt avsändare, NetworkNotificationEventArgs e) if (e.NotificationType == NetworkNotificationType.InterfaceDisconnected) MessageBox.Show ("Disconnected"); annars om (e.NotificationType == NetworkNotificationType.InterfaceConnected) MessageBox.Show ("Connected"); Returparametrarna innehåller en egenskap som heter NotificationType, av typen NetworkNotificationType, vilket berättar om aktuell nätverksstatus.
Men med DeviceNetworkInformation Du kan även få annan information om den aktuella nätverksstatusen, som om användaren har aktiverat mobildataanslutningen (IsCellularDataEnabled), Wi-Fi-anslutningen (IsWiFiEnabled) eller roamingalternativ (IsCellularDataRoamingOptions).
Ramverket erbjuder en annan användbar klass för att hantera nätverksanslutningar som heter Network. Genom att använda NetworkInterfaceType egendom, kan du identifiera vilken anslutningstyp som används för närvarande. Till exempel kan vi använda den här egenskapen för att undvika att ladda ner stora filer när du använder en mobil anslutning.
NetworkInterfaceType är en talare som kan anta många värden. De viktigaste är:
MobileBroadbandGsm och MobileBroadbandCdma när telefonen är ansluten till ett mobilnät (GSM eller CDMA, beroende på land)Wireless80211, när telefonen är ansluten till ett Wi-Fi-nätverkI följande exempel visas ett meddelande på skärmen med aktuell anslutningstyp:
privat tomt OnCheckConnectionTypeClicked (objekt avsändare, RoutedEventArgs e) if (NetworkInterface.NetworkInterfaceType == NetworkInterfaceType.MobileBroadbandGsm || NetworkInterface.NetworkInterfaceType == NetworkInterfaceType.MobileBroadbandCdma) MessageBox.Show ("Mobile"); annars om (NetworkInterface.NetworkInterfaceType == NetworkInterfaceType.Wireless80211) MessageBox.Show ("Wi-Fi"); Windows Phone Framework har två inbyggda klasser för att utföra nätverksoperationer: WebClient och HttpWebRequest. Tyvärr är ingen av dem perfekta. WebClient är mycket lätt att använda, men det är baserat på den gamla återuppringningsmetoden (om du inte installerar Async för .NET paket som vi diskuterade tidigare i denna serie). HttpWebRequest är mycket kraftfull, men det är komplext att använda och bygger på ett gammalt asynkront mönster som är svårt att förstå.
Windows Runtime har introducerat en ny klass som heter Httpclient, som tar bäst av båda världarna. Den är kraftfull och erbjuder bra prestanda, men det är lätt att använda och erbjuder metoder som bygger på det nya asynk och väntar mönstret. Den här klassen är tillgänglig i hela Windows Runtime for Windows Store-appar, men den ingår inte i Windows Phone Runtime-underuppsättningen-du måste installera den från NuGet.
De Httpclient klass, som vi ser senare, är bra, inte bara för att utföra generiska nätverksoperationer som nedladdning och uppladdning av filer, men också för att interagera med webbtjänster. Faktum är att det exponerar asynkrona metoder för varje HTTP-kommando, som GET, POST, PUT, etc.
Obs! För att kunna interagera med nätverket måste du aktivera alternativet ID_CAP_NETWORKING i manifestfilen. Den är aktiverad i varje nytt Windows Phone-projekt som standard.
Filer laddas vanligtvis med hjälp av GET HTTP-kommandot, så Httpclient erbjuder GetAsync () metod. Att göra utvecklarens liv enklare, Httpclient har några inbyggda metoder för att hämta de vanligaste filtyperna, t.ex. GetStringAsync () för nedladdning av textfiler som XML, RSS eller REST-svar; eller GetByteArrayAsync () och GetStreamAsync () för att få binärt filinnehåll.
Att ladda ner strängar är väldigt enkelt. Metoden GetStringAsync () kräver som en parameter filens URL och returnerar filens innehåll som en sträng. I följande exempel kan du se hur du hämtar min blogg RSS-flöde:
privat async ogiltig OnDownloadStringClicked (objekt avsändare, RoutedEventArgs e) HttpClient client = new HttpClient (); strängresultat = väntar client.GetStringAsync ("http://feeds.feedburner.com/qmatteoq_eng"); När du har strängen kan du utföra de nödvändiga operationerna enligt ditt scenario. I det föregående provet kunde jag till exempel ha analyserat den returnerade XML med LINQ till XML för att visa nyhetslistan på skärmen.
Nedladdning av binära filer kan åstadkommas på många sätt. Du kan använda GetByteArrayAsync () om du föredrar att arbeta med byte eller GetStreamAsync () om du föredrar att manipulera filens innehåll som en ström.
I följande exempel ser du hur du laddar ner en bild med hjälp av GetByteArrayAsync () metod. Den returnerar en bytes array, som enkelt kan sparas i lokal lagring med hjälp av API-erna som vi lärde oss om tidigare i denna serie.
privat async ogiltig OnDownloadFileClicked (objekt avsändare, RoutedEventArgs e) HttpClient client = new HttpClient (); byte [] bytes = väntar client.GetByteArrayAsync ("http://www.syncfusion.com/Content/en-US/Home/Images/syncfusion-logo.png"); StorageFile storageFile = väntar ApplicationData.Current.LocalFolder.CreateFileAsync ("picture.png", CreationCollisionOption.ReplaceExisting); IRandomAccessStream accessStream = väntar storageFile.OpenAsync (FileAccessMode.ReadWrite); använder (IOutputStream outputStream = accessStream.GetOutputStreamAt (0)) DataWriter writer = new DataWriter (outputStream); writer.WriteBytes (byte); väntar på författare. StoraAsync (); Genom att använda DataWriter klass, vi kan spara byte array returneras av Httpclient klass i en fil i det lokala lagret kallas picture.png.
Om du behöver fullständig kontroll över nedladdningsoperationen kan du använda generiken GetAsync () metod som returnerar a HttpResponseMessage objekt med hela svarets innehåll, till exempel rubriker, statuskod etc..
I följande exempel kan du se hur, genom att använda GetAsync () metod, vi kan ladda ner en bild som en Strömma och visa den i en Bild kontroll placerad på sidan. Till metoden passerar vi en andra parameter av typen HttpCompletionOption, som berättar för klassen när man markerar operationen som färdigställd. Eftersom vi vill ha hela innehållet i svaret (vilket är den nedladdade bilden) använder vi ResponseContentRead alternativ.
privat async ogiltig OnDownloadStreamClicked (objekt avsändare, RoutedEventArgs e) HttpClient client = new HttpClient (); HttpResponseMessage httpResponseMessage = väntar client.GetAsync ("http://www.syncfusion.com/Content/en-US/Home/Images/syncfusion-logo.png", HttpCompletionOption.ResponseContentRead); Stream stream = väntar httpResponseMessage.Content.ReadAsStreamAsync (); BitmapImage image = nytt BitmapImage (); image.SetSource (stream); Logo.Source = image; Observera att de specifika metoder som vi har sett erbjuds av Httpclient klassen är helt enkelt en genväg till de metoder som erbjuds av Innehåll egenskapen hos HttpResponseMessage klass (i föregående prov använder vi ReadAsStreamAsync () Metod för att returnera svarets innehåll som en Strömma).
Uppladdning av data uppnås på ett liknande sätt: operationen utförs vanligen med POST-kommandot, så att Httpclient klassen avslöjar PostAsync () metod för detta ändamål.
Innehållet som ska skickas utarbetas med hjälp av HttpContent klass, som erbjuder många implementeringar: StreamContent att skicka en fils ström, ByteArrayContent att skicka en binär fil, StringContent att skicka en sträng, eller MultipartFormDataContent att skicka innehåll som kodas med hjälp av multipart / form-data MIME-typ.
I följande exempel kan du se hur du laddar upp en fils ström till en tjänst:
privat async ogiltig OnUploadFileClicked (objekt avsändare, RoutedEventArgs e) StorageFile storageFile = väntar ApplicationData.Current.LocalFolder.GetFileAsync ("picture.png"); IRandomAccessStream accessStream = väntar storageFile.OpenAsync (FileAccessMode.ReadWrite); HttpClient client = new HttpClient (); HttpContent content = new StreamContent (accessStream.AsStreamForRead ()); vänta klient.PostAsync ("http://wp8test.azurewebsites.net/api/values", innehåll); När vi har hämtat strömmen av en fil som lagrats i lokal lagring, skickar vi den till en ny instans av StreamContent klass. Då kallar vi PostAsync () metod, som skickar tjänstens webbadress och HttpContent objekt som parametrar.
REST (Representational State Transfer) är utan tvekan det mest använda tillvägagångssättet för närvarande inom webbtjänstutveckling, särskilt i mobilvärlden.
REST-tjänster har blivit mycket populära av två skäl:
Nästan alla plattformar stödjer nationellt dessa tekniker, så du behöver inte leta efter specialbibliotek att interagera med dem som behövs för WSDL-baserade webbtjänster.
Vi har redan sett hur, med Httpclient klass, är det enkelt att interagera med webben genom att använda standard HTTP-kommandon. För det mesta, för att interagera med en REST-tjänst, måste du helt enkelt utföra GetStringAsync () metod för att få XML eller JSON svaret.
När du har fått resultatet, måste du oftast konvertera det till objekt som ska användas inom applikationen. Tidigare i denna serie diskuterade vi det enklaste sättet att uppnå denna uppgift: deserialisering, vilket innebär att man översätter vanlig text till komplexa objekt. Vi kan använda DataContractSerializer eller DataContractJsonSerializer klasser för att göra detta. I det här fallet behöver du bara hänvisa till deserialiseringsprocessen eftersom proceduren är densamma.
privat async void OnConsumeServiceClicked (objekt avsändare, RoutedEventArgs e) HttpClient client = new HttpClient (); strängresultat = väntar client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values"); (MemoryStream ms = new MemoryStream (Encoding.Unicode.GetBytes (result))) DataContractJsonSerializer serializer = new DataContractJsonSerializer (typof (Listof)); Lista people = serializer.ReadObject (ms) som lista; Vi antar att tjänsten returnerar, i JSON-format, en lista över personer:
["id": 1, "namn": "Matteo", "efternamn": "Pagani", "id": 2, "namn": "John"
Med hjälp av DataContractJsonSerializer klass, kan vi konvertera tidigare JSON till en lista över Person objekt, som är samma klass som vi har använt i många andra prover i denna serie. Skillnaden i det här provet är att vi kan styra serialiseringsprocessen, om exempelvis de egendomsnamn som returneras från JSON är annorlunda än de vi använder i våra klasser. Detta är ett mycket vanligt scenario när det handlar om JSON eftersom egenskapsnamn är typiskt små bokstäver, medan i C # -objekt är de CamelCase. Detta resultat uppnås genom att använda [DataMember] attribut som kan tillämpas på de egenskaper vi vill serialisera. I följande exempel kan du se att attributet erbjuder en egendom som heter namn, som kan användas för att ange vilket egendomsnamn vi förväntar oss att hitta i JSON-filen.
offentlig klass Person [DataMember (Name = "id")] public int Id get; uppsättning; [DataMember (Name = "name")] public string Namn get; uppsättning; [DataMember (Namn = "Efternamn")] Offentlig sträng Efternamn get; uppsättning;
Denna inställning har en nackdel: REST-tjänster returnerar alltid en vanlig sträng, medan DataContractJsonSerializer klassen kräver a Strömma som en ingångsparameter för Readobject () metod, så vi är alltid tvungna att konvertera det med hjälp av a Memory objekt.
Det finns ett annat sätt att uppnå samma resultat. Låt mig presentera JSON.NET, ett tredje part bibliotek som erbjuder några ytterligare användbara funktioner för hantering av JSON data. Dessutom erbjuder den bättre prestanda och kan deserialisera komplexa JSON-filer snabbare.
Det kan enkelt installeras med NuGet, och dess officiella hemsida erbjuder jämförelser med andra JSON-bibliotek och detaljerad dokumentation.
I följande exempel använder vi JSON.NET för att uppnå samma resultat som den kod som vi tidigare använt:
privat asynk ogiltig OnGetDataClicked (objekt avsändare, RoutedEventArgs e) HttpClient client = new HttpClient (); strängresultat = väntar client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values"); Lista folk = JsonConvert.DeserializeObject> (Resultat); De JsonConvert klass (som ingår i Newtonsoft.Json namespace) exponerar DeserializeObject metod, var T är objektets typ som vi förväntar oss i gengäld. Som en ingångsparameter krävs det endast den JSON-sträng som vi har laddat ner från tjänsten.
Det är också möjligt att kontrollera deserialiseringsprocessen med attribut, som vi tidigare gjorde med DataMember attribut. I följande exempel kan du se hur vi manuellt kan definiera hur JSON-egenskaper ska översättas:
offentlig klass Person [JsonProperty ("id")] public int Id get; uppsättning; [JsonProperty ("name")] allmän sträng Namn get; uppsättning; [JsonProperty ("efternamn")] public string Efternamn get; uppsättning; Tips: Du måste ofta använda tjänster från tredje part, så du vet inte exakt kartläggningen mellan enheter och JSON-data. Det finns en webbplats som hjälper dig i det här scenariot: http://json2csharp.com/. Klistra enkelt in den JSON som returneras av din tjänst, och det kommer att generera för dig de erforderliga C # -klassen för att kartlägga JSON-data.
En annan intressant egenskap som introduceras av JSON.NET är LINQ till JSON, vilket är ett LINQ-baserat språk som, till skillnad från LINQ till XML, kan användas för att manipulera en JSON-sträng för att extrahera bara den information du behöver. Detta tillvägagångssätt är användbart när du verkligen inte behöver använda deserialisering, men behöver bara extrahera vissa data från det JSON-svar du fått från tjänsten.
Utgångspunkten för att använda LINQ till JSON är JObject klass, som identifierar en JSON-fil. För att börja jobba med det behöver du bara ringa Parse () metod som passerar som parameter JSON-strängen, som visas i följande prov:
privat async void OnParseJson (objekt avsändare, RoutedEventArgs e) HttpClient client = new HttpClient (); strängresultat = väntar client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values"); JObject json = JObject.Parse (resultat); Nu är du redo att utföra vissa operationer. Låt oss ta en titt på de vanligaste.
Enkel JSON
Här är ett exempel på en enkel JSON-fil:
"Id": 1, "Namn": "Matteo", "Efternamn": "Pagani"
Med LINQ till JSON kan vi extrahera en egen fastighets värde på följande sätt:
privat async void OnParseJson (objekt avsändare, RoutedEventArgs e) HttpClient client = new HttpClient (); strängresultat = väntar client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values/1"); JObject json = JObject.Parse (resultat); strängvärde = json ["Name"]. Värde(); De JObject klassen behandlas som en samling, så du kan helt enkelt komma åt en egendom med namnet som en nyckel. I slutändan kan du extrahera värdet genom att använda Värde metod, var T är den datatyp vi förväntar oss att lagras.
Komplex JSON
Liksom C # -objekt kan JSON-objekt också ha komplexa egenskaper, som visas i följande exempel:
"Id": 1, "Namn": "Matteo", "Efternamn": "Pagani", "Adress": "Street": "Fel adress", "Stad": "Milano"
Adress är en komplex egenskap eftersom den innehåller andra kapslade egenskaper. För att komma åt dessa egenskaper måste vi använda SelectToken () metod, som överför hela JSON-sökvägen som en parameter:
privat async void OnParseJson (objekt avsändare, RoutedEventArgs e) HttpClient client = new HttpClient (); strängresultat = väntar client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values/1"); JObject json = JObject.Parse (resultat); strängstad = json.SelectToken ("Address.City"). Värde(); Med Postort väg, vi kan extrahera värdet av Stad egendom som ingår i Adress nod.
JSON samlingar
När du hanterar JSON-samlingar kan du använda Barn() metod för att få tillgång till alla barnens noder av en viss egendom. Låt oss exempelvis använda en JSON-kod som vi tidigare sett:
["Id": 1, "Namn": "Matteo", "Efternamn": "Pagani", "Id": 2, "Namn": "John", "Efternamn": "Doe"]
I det här fallet kan vi använda JArray klass och Barn() metod för att extrahera alla samlingens element. I följande exempel kan du se hur vi använder det för att få en delkollektion med endast namn egenskapens värden.
privat asynk ogiltig OnGetDataClicked (objekt avsändare, RoutedEventArgs e) HttpClient client = new HttpClient (); strängresultat = väntar client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values"); JArray json = JArray.Parse (resultat); Lista list = json.Children (). Välj (x => x ["Name"]. Värde()).Att lista(); De Httpclient klass vi tidigare sett, som WebClient och HttpWebRequest klasser, kan endast användas för förgrundsoperationer. När applikationen är avstängd, avbryts nätverksöverföringar.
När vi måste hantera stora dataöverföringar, tvingar användaren att hålla appen öppen öppnar inte den bästa användarupplevelsen. I detta scenario har Windows Phone 7.5 introducerat API för bakgrundsöverföring som kan användas för att starta en nedladdning eller uppladdning och fortsätta det även om appen är avstängd.
Det finns emellertid några begränsningar som har införts för att undvika batteriproblem och hög data planförbrukning:
En bakgrundsöverföring identifieras av BackgroundTransferRequest klass, som är en del av Microsoft.Phone.BackgroundTransfer namnutrymmet. Som utvecklare har vi kontroll över vissa villkor som måste vara nöjda för en bakgrundsöverföring som skapats i vår ansökan för att starta, tack vare TransferPreferences egendom som kan få följande värden:
Ingen, standardvärdet: Överföringen startas endast om telefonen är ansluten till ett Wi-Fi-nätverk och batteriet laddas.AllowBattery: Överföringen startas endast om telefonen är ansluten till ett Wi-Fi-nätverk, oberoende av strömkällan.AllowCelullar: Överföringen startas endast om telefonen laddas, oberoende av nätverksanslutningen.AllowCellularAndBattery: Börjar alltid överföringen, oberoende av anslutningen och strömkällans villkor.
De BackgroundTransferRequest klassen avslöjar två händelsehanterare som kan användas för att styra överföringen:
TransferStatusChanged utlöses när överföringsstatus ändras. Parametern som returneras med metoden innehåller a TransferStatus objekt som meddelar dig om den aktuella statusen (som Avslutad när överföringen slutar, eller pausad när överföringen är pausad). Det finns också specifika statuser som börjar med Väntar prefix som berättar när en överföring är avstängd eftersom villkoren definieras i TransferPreferences egendom är inte nöjd. Till exempel, WaitingForWiFi är inställd när överföringen väntar på att telefonen ska anslutas till ett Wi-Fi-nätverk för att starta.TransferProgressChanged utlöses när en överförings framsteg ändras, vilket innebär att nya data har laddats ner eller laddats upp. Vanligtvis är denna händelsehanterare ansluten till a ProgressBar kontroll eftersom det avslöjar egenskaper för att meddela dig hur mycket data har överförts och hur mycket data som fortfarande behöver laddas ner eller skickas.När du har definierat en bakgrundsöverföring måste du lägga till den i operativsystemets kö. Windows Phone tar hand om att starta det när de angivna villkoren är uppfyllda. För att uppnå denna uppgift använder vi BackgroundTransferService klass, som är den centrala chefen för bakgrundsöverföring. Du kan lägga till, ta bort eller lista bakgrundsöverföringar som hör till programmet.
I följande exempel kan du se en definition för bakgrundsöverföring:
privat BackgroundTransferRequest backgroundRequest; privat tomt OnStartBackgroundDownloadClicked (objekt avsändare, RoutedEventArgs e) Uri sourceUrl = ny Uri ("http://wpsauce.com/wp-content/uploads/2011/11/windows_phone_logo.jpg"); Uri destinationUrl = ny Uri ("/ Shared / Transfers / windows_phone_logo.jpg", UriKind.RelativeOrAbsolute); backgroundRequest = ny BackgroundTransferRequest (sourceUrl, destinationUrl); backgroundRequest.TransferStatusChanged + = backgroundRequest_TransferStatusChanged; backgroundRequest.TransferPreferences = TransferPreferences.AllowCellularAndBattery; BackgroundTransferService.Add (backgroundRequest); tom bakgrundRequest_TransferStatusChanged (objekt avsändare, BackgroundTransferEventArgs e) if (backgroundRequest.TransferStatus == TransferStatus.Completed) // Hantera den nedladdade filen. BackgroundTransferService.Remove (backgroundRequest); Vi registrerar denna överföring som ska utföras oavsett den tillgängliga nätverksanslutningen och strömkällan. Det föregående provet är relaterat till en hämtningsoperation, så vi måste definiera en källkod URI (filen som ska hämtas) och en destinations-URI (den lokala lagringsbanan där filen kommer att sparas). Till skillnad från vad vi har sett med Httpclient, vi behöver inte ta hand om sparandet filen hämtas automatiskt och sparas i det lokala lagret eftersom nedladdningen också kan slutföras när appen är avstängd. Både käll- och destinations-URI-adresser överförs som parametrar för BackgroundTransferRequest konstruktör.
Obs! Bakgrundsöverföringar som används för att utföra nedladdningsoperationer måste alltid spara filen i rutan Delade / Överföringar i lokal lagring, som automatiskt skapas när appen är installerad, annars får du ett undantag. När nedladdningen är klar kan du flytta filen till en annan position om det behövs, men du kan inte schemalägga en bakgrundsöverföring som försöker ladda ner en fil i en annan mapp.
Därefter prenumererar vi på TransferStatusChanged händelse. Om nedladdningen är klar medan appen är i förgrunden kan vi hantera den nedladdade filen, till exempel om det är en bild kan vi visa den. Lägg märke till Ta bort() operation som vi utför på BackgroundTransferService klass. Det är väldigt viktigt att alltid utföra denna uppgift eftersom operativsystemet automatiskt inte tar bort färdiga överföringar från programmets kö och det kan leda till oväntade problem eftersom en applikation inte kan schemalägga mer än 25 överföringar.
Istället, om du behöver ladda upp en fil måste du skapa en BackgroundTransferRequest objekt på ett annat sätt. Du behöver fortfarande definiera två URI: källan (filen som ska laddas upp) och destinationen (en tjänst som kan ta emot filen med hjälp av HTTP-kommandosatsen i Metod fast egendom). Destination URI kan skickas i BackgroundTransferRequestkonstruktör (som vi gjorde tidigare), men källan URI måste ställas in i UploadLocation egendom, som i följande prov:
privat tomt OnUploadFile () Uri destinationUrl = new Uri ("http://wp8test.azurewebsites.com/api/values", UriKind.Relative); Uri sourceUri = ny Uri ("/ Shared / Transfers / image.png", UriKind.Relative); BackgroundTransferRequest request = ny BackgroundTransferRequest (destinationUrl); request.UploadLocation = sourceUri; request.Method = "POST"; BackgroundTransferService.Add (begäran); I den här artikeln har vi sett hur du arbetar med en av de mest använda funktionerna i en smartphone: en Internetanslutning. I detalj har vi lärt oss:
Httpclient är en ny klass introducerad i Windows Runtime som hjälper till att utföra nätverksoperationer. Vi har sett hur du använder den för att ladda ner och ladda upp filer och interagera med tjänster.Httpclient är en bra hjälp, men det fungerar bara om applikationen är i förgrunden. När den är avstängd, avbryts nätverksoperationerna. I detta syfte erbjuder ramverket vissa specifika API: er för att utföra nedladdning och uppladdning, även i bakgrunden när appen inte används.Denna handledning representerar ett kapitel från Windows Phone 8 Succinctly, en gratis eBook från laget vid Syncfusion.
