Share
Tous les appareils Windows Phone ont une connexion réseau intégrée, mais pour la même raison, nous avons appris à stocker localement les données. Nous devons être prêts à gérer la manière dont les utilisateurs utilisent notre application lorsqu'une connexion est manquante..
À cette fin, la structure Windows Phone comprend une classe permettant de découvrir des informations sur la connexion Internet, appelées DeviceNetworkInformation, qui fait partie de la Microsoft.Phone.Net.NetworkInformation espace de noms.
Le plus important est IsNetworkAvailable, qui nous indique si une connexion Internet est disponible. Nous devrions toujours utiliser cette API avant d'effectuer une opération nécessitant une connexion, comme dans l'exemple suivant:
Accentsconagua
Void privé OnCheckConnectionClicked (expéditeur de l'objet, RoutedEventArgs e) if (DeviceNetworkInformation.IsNetworkAvailable) MessageBox.Show ("Vous êtes connecté à Internet"); // Effectuer des opérations sur le réseau. else MessageBox.Show ("Vous n'êtes pas connecté à Internet"); La classe propose également un événement appelé NetworkAvailabilityChanged qui est déclenché à chaque changement d'état de la connexion. C'est utile si vous souhaitez réagir rapidement aux modifications du réseau, telles que l'activation ou la désactivation de certaines fonctionnalités de l'application..
public MainPage () InitializeComponent (); DeviceNetworkInformation.NetworkAvailabilityChanged + = DeviceNetworkInformation_NetworkAvailabilityChanged; void privé DeviceNetworkInformation_NetworkAvailabilityChanged (expéditeur de l'objet, NetworkNotificationEventArgs e) if (e.NotificationType == NetworkNotificationType.InterfaceDisconnected) MessageBox.Show ("Disconnected"); else if (e.NotificationType == NetworkNotificationType.InterfaceConnected) MessageBox.Show ("Connected"); Les paramètres de retour contiennent une propriété appelée Type de notification, du type NetworkNotificationType, qui nous dit l'état actuel du réseau.
Cependant, avec le DeviceNetworkInformation vous pourrez également obtenir d'autres informations sur l'état actuel du réseau, par exemple si l'utilisateur a activé la connexion de données cellulaires (IsCellularDataEnabled), la connexion Wi-Fi (IsWiFiEnabled), ou des options d'itinérance (IsCellularDataRoamingOptions).
Le cadre offre une autre classe utile pour traiter les connexions réseau appelée Interface réseau. En utilisant le NetworkInterfaceType propriété, vous pourrez identifier le type de connexion actuellement utilisé. Par exemple, nous pouvons utiliser cette propriété pour éviter de télécharger de gros fichiers en utilisant une connexion cellulaire.
NetworkInterfaceType est un énumérateur qui peut assumer de nombreuses valeurs. Les plus importants sont:
MobileBroadbandGsm et MobileBroadbandCdma lorsque le téléphone est connecté à un réseau cellulaire (GSM ou CDMA, selon le pays)Sans fil80211, lorsque le téléphone est connecté à un réseau Wi-FiDans l'exemple suivant, nous affichons un message à l'écran avec le type de connexion actuel:
void privé OnCheckConnectionTypeClicked (expéditeur d'objet, RoutedEventArgs e) if (NetworkInterface.NetworkInterfaceType == NetworkInterfaceType.MobileBroadbandGsm || NetworkInterface.NetworkInterfaceType == NetworkInterfaceType.MobileBroadbandCdma) MessageBox.Amis else if (NetworkInterface.NetworkInterfaceType == NetworkInterfaceType.Wireless80211) MessageBox.Show ("Wi-Fi"); La structure Windows Phone comporte deux classes intégrées pour effectuer des opérations sur le réseau: WebClient et HttpWebRequest. Malheureusement, aucun d'eux n'est parfait. WebClient est très facile à utiliser, mais il est basé sur l’ancienne approche de rappel (à moins d’installer le Async pour .NET paquet dont nous avons discuté plus tôt dans cette série). HttpWebRequest est très puissant, mais complexe à utiliser et basé sur un vieux modèle asynchrone difficile à comprendre.
Windows Runtime a introduit une nouvelle classe appelée HttpClient, qui prend le meilleur des deux mondes. Il est puissant et offre d'excellentes performances, mais il est facile à utiliser et propose des méthodes basées sur le nouveau modèle asynchrone et en attente. Cette classe est disponible dans la totalité des applications Windows Runtime pour Windows Store, mais elle n'est pas incluse dans le sous-ensemble Windows Phone Runtime. Vous devrez l'installer à partir de NuGet..
le HttpClient Comme nous le verrons plus tard, class est idéal non seulement pour effectuer des opérations réseau génériques telles que le téléchargement et le téléchargement de fichiers, mais également pour interagir avec des services Web. En fait, il expose des méthodes asynchrones pour chaque commande HTTP, comme GET, POST, PUT, etc..
Remarque: pour pouvoir interagir avec le réseau, vous devez activer l'option ID_CAP_NETWORKING dans le fichier manifeste. Il est activé par défaut dans chaque nouveau projet Windows Phone.
Les fichiers sont généralement téléchargés à l’aide de la commande GET HTTP. HttpClient offre le GetAsync () méthode. Pour simplifier la vie des développeurs, HttpClient possède des méthodes intégrées pour télécharger les types de fichiers les plus courants, tels que GetStringAsync () pour télécharger des fichiers texte tels que des réponses XML, RSS ou REST; ou GetByteArrayAsync () et GetStreamAsync () obtenir le contenu d'un fichier binaire.
Télécharger des chaînes est vraiment facile. La méthode GetStringAsync () requiert comme paramètre l'URL du fichier et renvoie le contenu du fichier sous forme de chaîne. Dans l'exemple suivant, vous pouvez voir comment télécharger le flux RSS de mon blog:
void asynchrone privé OnDownloadStringClicked (expéditeur d'objet, RoutedEventArgs e) client HttpClient = new HttpClient (); string result = wait client.GetStringAsync ("http://feeds.feedburner.com/qmatteoq_eng"); Une fois que vous avez la chaîne, vous pouvez effectuer les opérations requises en fonction de votre scénario. Par exemple, dans l'exemple précédent, j'aurais pu analyser le XML renvoyé avec LINQ to XML pour afficher la liste des nouvelles à l'écran..
Le téléchargement de fichiers binaires peut être accompli de plusieurs manières. Vous pouvez utiliser GetByteArrayAsync () si vous préférez travailler avec des octets, ou GetStreamAsync () si vous préférez manipuler le contenu du fichier sous forme de flux.
Dans l'exemple suivant, vous verrez comment télécharger une image à l'aide de la GetByteArrayAsync () méthode. Il retourne un tableau d'octets, qui peut être facilement sauvegardé dans le stockage local à l'aide des API que nous avons apprises précédemment dans cette série..
void async privé OnDownloadFileClicked (expéditeur d'objet, RoutedEventArgs e) client HttpClient = new HttpClient (); byte [] bytes = wait client.GetByteArrayAsync ("http://www.syncfusion.com/Content/en-US/Home/Images/syncfusion-logo.png"); StorageFile storageFile = wait ApplicationData.Current.LocalFolder.CreateFileAsync ("picture.png", CreationCollisionOption.ReplaceExisting); IRandomAccessStream accessStream = wait storageFile.OpenAsync (FileAccessMode.ReadWrite); using (IOutputStream outputStream = accessStream.GetOutputStreamAt (0)) DataWriter writer = new DataWriter (outputStream); writer.WriteBytes (octets); attendez writer.StoreAsync (); En utilisant le DataWriter classe, nous sommes en mesure de sauvegarder le tableau d'octets renvoyé par le HttpClient class dans un fichier dans le stockage local appelé picture.png.
Si vous avez besoin d’un contrôle total sur l’opération de téléchargement, vous pouvez utiliser le programme générique. GetAsync () méthode, qui retourne un HttpResponseMessage objet avec le contenu entier de la réponse, comme les en-têtes, le code d'état, etc..
Dans l'exemple suivant, vous pouvez voir comment, en utilisant le GetAsync () méthode, nous sommes en mesure de télécharger une image en tant que Courant et l'afficher dans un Image contrôle placé sur la page. A la méthode on passe un second paramètre de type HttpCompletionOption, qui indique à la classe quand marquer l'opération comme terminée. Puisque nous voulons le contenu complet de la réponse (l’image téléchargée), nous utilisons le ResponseContentRead option.
void asynchrone privé OnDownloadStreamClicked (expéditeur d'objet, RoutedEventArgs e) client HttpClient = new HttpClient (); HttpResponseMessage httpResponseMessage = wait client.GetAsync ("http://www.syncfusion.com/Content/en-US/Home/Images/syncfusion-logo.png", HttpCompletionOption.ResponseContentContentRead); Stream stream = attendez httpResponseMessage.Content.ReadAsStreamAsync (); BitmapImage image = new BitmapImage (); image.SetSource (flux); Logo.Source = image; Notez que les méthodes spécifiques proposées par le HttpClient classe sont simplement un raccourci vers les méthodes offertes par le Contenu propriété du HttpResponseMessage classe (dans l'exemple précédent, nous utilisons le ReadAsStreamAsync () méthode pour retourner le contenu de la réponse en tant que Courant).
Le téléchargement des données s’effectue de la même manière: l’opération est généralement effectuée à l’aide de la commande POST, de sorte que la HttpClient la classe expose le PostAsync () méthode à cette fin.
Le contenu à envoyer est préparé à l'aide du HttpContent classe, qui offre de nombreuses implémentations: StreamContent envoyer le flux d'un fichier, ByteArrayContent envoyer un fichier binaire, StringContent envoyer une chaîne, ou MultipartFormDataContent envoyer du contenu codé en utilisant le type MIME multipart / form-data.
Dans l'exemple suivant, vous pouvez voir comment télécharger le flux d'un fichier vers un service:
async void privé OnUploadFileClicked (expéditeur d'objet, RoutedEventArgs e) StorageFile storageFile = wait ApplicationData.Current.LocalFolder.GetFileAsync ("picture.png"); IRandomAccessStream accessStream = wait storageFile.OpenAsync (FileAccessMode.ReadWrite); Client HttpClient = new HttpClient (); HttpContent content = new StreamContent (accessStream.AsStreamForRead ()); wait client.PostAsync ("http://wp8test.azurewebsites.net/api/values", contenu); Après avoir récupéré le flux d’un fichier stocké dans le stockage local, nous le transmettons à une nouvelle instance du fichier. StreamContent classe. Ensuite, nous appelons le PostAsync () méthode, en passant l'URL du service et le HttpContent objet comme paramètres.
REST (Representational State Transfer) est sans aucun doute l'approche la plus utilisée de nos jours dans le développement de services Web, en particulier dans le monde mobile..
Les services REST sont devenus très populaires pour deux raisons:
Presque toutes les plates-formes supportent nativement ces technologies, vous n’avez donc pas besoin de rechercher des bibliothèques spéciales pour interagir avec celles-ci, contrairement aux services Web WSDL..
Nous avons déjà vu comment, avec le HttpClient classe, c’est simple d’interagir avec le Web à l’aide des commandes HTTP standard. La plupart du temps, pour interagir avec un service REST, vous devez simplement exécuter le GetStringAsync () méthode pour obtenir la réponse XML ou JSON.
Une fois que vous avez obtenu le résultat, vous devrez la plupart du temps le convertir en objets à utiliser dans l'application. Plus tôt dans cette série, nous avons discuté de la manière la plus simple d'accomplir cette tâche: la désérialisation, ce qui signifie la traduction de texte brut en objets complexes. Nous pouvons utiliser le DataContractSerializer ou DataContractJsonSerializer classes pour le faire. Dans ce cas, il vous suffit de vous référer au processus de désérialisation car la procédure est la même..
async privé void OnConsumeServiceClicked (expéditeur d'objet, RoutedEventArgs e) client HttpClient = new HttpClient (); string result = wait client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values"); using (MemoryStream ms = new MemoryStream (Encoding.Unicode.GetBytes (result)))) DataContractJsonSerializer serializer = new DataContractJsonSerializer (typeof (List)); liste people = serializer.ReadObject (ms) en tant que liste; Nous supposons que le service renvoie, au format JSON, une liste de personnes:
["id": 1, "nom": "Matteo", "nom de famille": "Pagani", "id": 2, "nom": "Jean", "nom de famille:" Doe "]
Avec l'aide du DataContractJsonSerializer classe, nous sommes en mesure de convertir le JSON précédent en une liste de La personne objets, qui est la même classe que nous avons utilisée dans de nombreux autres échantillons de cette série. La différence dans cet exemple réside dans le fait que nous sommes en mesure de contrôler le processus de sérialisation, au cas où, par exemple, les noms de propriété renvoyés par le JSON seraient différents de ceux que nous utilisons dans nos classes. Il s'agit d'un scénario très courant lorsque vous utilisez JSON, car les noms de propriété sont généralement en minuscule, alors que dans les objets C #, ils sont CamelCase. Ce résultat est obtenu en utilisant le [DataMember] attribut, qui peut être appliqué aux propriétés que nous voulons sérialiser. Dans l'exemple suivant, vous pouvez voir que l'attribut offre une propriété appelée prénom, qui peut être utilisé pour spécifier quel nom de propriété nous nous attendons à trouver dans le fichier JSON.
Classe publique Person [DataMember (Name = "id")] public int Id get; ensemble; [DataMember (Name = "name")] chaîne publique Name get; ensemble; [DataMember (Name = "nom de famille")] chaîne publique Nom de famille get; ensemble;
Cette approche a un inconvénient: les services REST renvoient toujours une chaîne simple, tandis que le DataContractJsonSerializer la classe nécessite un Courant en tant que paramètre d'entrée du ReadObject () méthode, donc nous sommes toujours obligés de le convertir en utilisant un MemoryStream objet.
Il y a une autre façon d'atteindre le même résultat. Permettez-moi de vous présenter JSON.NET, une bibliothèque tierce qui offre des fonctionnalités supplémentaires utiles pour la gestion des données JSON. De plus, il offre de meilleures performances et est capable de désérialiser plus rapidement des fichiers JSON complexes..
Il peut être facilement installé à l’aide de NuGet. Son site Web officiel offre des comparaisons avec d’autres bibliothèques JSON et une documentation détaillée..
Dans l'exemple suivant, nous utilisons JSON.NET pour obtenir le même résultat que le code que nous avons précédemment utilisé:
void async privé OnGetDataClicked (expéditeur d'objet, RoutedEventArgs e) client HttpClient = new HttpClient (); string result = wait client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values"); liste people = JsonConvert.DeserializeObject> (résultat); le JsonConvert classe (qui fait partie de la Newtonsoft.Json espace de noms) expose le DeserializeObject méthode, où T est le type d'objet que nous attendons en retour. En tant que paramètre d'entrée, il ne nécessite que la chaîne JSON que nous avons téléchargée à partir du service..
Il est également possible de contrôler le processus de désérialisation en utilisant des attributs, comme nous l’avions déjà fait avec le DataMember attribut. Dans l'exemple suivant, vous pouvez voir comment nous pouvons définir manuellement la traduction des propriétés JSON:
Classe publique Person [JsonProperty ("id")] public int Id get; ensemble; [JsonProperty ("name")] chaîne publique Name get; ensemble; [JsonProperty ("nom de famille")] chaîne publique Nom de famille get; ensemble; Conseil: Vous devrez souvent utiliser des services tiers pour ne pas connaître le mappage exact entre les entités et les données JSON. Il existe un site Web qui vous aidera dans ce scénario: http://json2csharp.com/. Il vous suffit de coller le JSON renvoyé par votre service, qui générera pour vous les classes C # nécessaires pour mapper les données JSON..
Une autre fonctionnalité intéressante introduite par JSON.NET est LINQ to JSON, un langage basé sur LINQ qui, similaire à LINQ to XML, peut être utilisé pour manipuler une chaîne JSON afin d'extraire uniquement les informations dont vous avez besoin. Cette approche est utile lorsque vous n'avez pas vraiment besoin d'utiliser la désérialisation, mais que vous devez simplement extraire certaines données de la réponse JSON que vous avez reçue du service..
Le point de départ pour utiliser LINQ to JSON est le JObject classe, qui identifie un fichier JSON. Pour commencer à travailler avec, il vous suffit d'appeler le Parse () méthode, en transmettant en tant que paramètre la chaîne JSON, comme indiqué dans l'exemple suivant:
void asynchrone privé OnParseJson (expéditeur d'objet, RoutedEventArgs e) client HttpClient = new HttpClient (); string result = wait client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values"); JObject json = JObject.Parse (résultat); Vous êtes maintenant prêt à exécuter certaines opérations. Jetons un coup d'oeil aux plus communs.
JSON simple
Voici un exemple de fichier JSON simple:
"Id": 1, "Nom": "Matteo", "Nom de famille": "Pagani"
Avec LINQ to JSON, nous pouvons extraire la valeur d'une propriété unique de la manière suivante:
void asynchrone privé OnParseJson (expéditeur d'objet, RoutedEventArgs e) client HttpClient = new HttpClient (); string result = wait client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values/1"); JObject json = JObject.Parse (résultat); valeur de chaîne = json ["Nom"]. Valeur(); le JObject class est traité comme une collection, vous pouvez donc simplement accéder à une propriété en utilisant son nom en tant que clé. En fin de compte, vous pouvez extraire la valeur en utilisant le Valeur méthode, où T est le type de données que nous espérons stocker.
JSON complexe
Comme les objets C #, les objets JSON peuvent également avoir des propriétés complexes, comme illustré dans l'exemple suivant:
"Id": 1, "Nom": "Matteo", "Nom de famille": "Pagani", "Adresse": "Rue": "Fausse adresse", "Ville": "Milan"
Adresse est une propriété complexe car elle contient d'autres propriétés imbriquées. Pour accéder à ces propriétés, nous devons utiliser le SelectToken () méthode, en passant le chemin JSON complet en tant que paramètre:
void asynchrone privé OnParseJson (expéditeur d'objet, RoutedEventArgs e) client HttpClient = new HttpClient (); string result = wait client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values/1"); JObject json = JObject.Parse (résultat); string city = json.SelectToken ("Address.City"). Valeur(); Avec le L'addresse de la ville chemin, nous sommes en mesure d'extraire la valeur de la Ville propriété qui fait partie de la Adresse nœud.
Collections JSON
Lorsque vous manipulez des collections JSON, vous pouvez utiliser le Enfants () méthode pour accéder à tous les nœuds enfants d’une propriété spécifique. Prenons, à titre d'exemple, un code JSON que nous avons vu précédemment:
["Id": 1, "Nom": "Matteo", "Nom de famille": "Pagani", "Id": 2, "Nom": "Jean", "Nom de famille": "Doe"]
Dans ce cas, nous pouvons utiliser le JArray la classe et la Enfants () méthode pour extraire tous les éléments de la collection. Dans l'exemple suivant, vous pouvez voir comment nous l'utilisons pour obtenir une sous-collection avec uniquement le prénom valeurs de la propriété.
void async privé OnGetDataClicked (expéditeur d'objet, RoutedEventArgs e) client HttpClient = new HttpClient (); string result = wait client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values"); JArray json = JArray.Parse (result); liste list = json.Children (). Sélectionnez (x => x ["Nom"].) Valeur()).Lister(); le HttpClient classe que nous avons déjà vu, comme le WebClient et HttpWebRequest classes, ne peut être utilisé que pour les opérations de premier plan. Lorsque l'application est suspendue, les transferts réseau sont annulés.
Lorsque nous devons faire face à des transferts Big Data, obliger l'utilisateur à garder l'application ouverte ne crée pas la meilleure expérience utilisateur. Pour ce scénario, Windows Phone 7.5 a introduit des API de transfert en arrière-plan pouvant être utilisées pour démarrer une opération de téléchargement ou une opération de téléchargement et la poursuivre même si l'application est suspendue..
Toutefois, certaines limitations ont été introduites pour éviter les problèmes de batterie et une consommation de plan de données élevée:
Un transfert en arrière-plan est identifié par le BackgroundTransferRequest classe, qui fait partie de la Microsoft.Phone.BackgroundTransfer espace de noms. En tant que développeurs, nous contrôlons certaines conditions à remplir pour qu'un transfert en arrière-plan créé dans notre application puisse démarrer, grâce à la TransferPreferences propriété pouvant obtenir les valeurs suivantes:
Aucun, la valeur par défaut: le transfert ne commence que si le téléphone est connecté à un réseau Wi-Fi et que la batterie est en cours de chargement.AllowBattery: Le transfert ne commence que si le téléphone est connecté à un réseau Wi ‑ Fi, quelle que soit la source d'alimentation.AllowCelullar: Le transfert est démarré uniquement si le téléphone est en cours de chargement, quelle que soit la connexion réseau.AllowCellularAndBattery: Commence toujours le transfert, quelles que soient la connexion et les conditions de la source d'alimentation.
le BackgroundTransferRequest La classe expose deux gestionnaires d’événements pouvant être utilisés pour contrôler le transfert:
TransferStatusChanged est déclenché lorsque le statut du transfert change. Le paramètre renvoyé par la méthode contient un Statut de transfert objet qui vous informe de l'état actuel (comme Terminé quand le transfert se termine, ou En pause lorsque le transfert est en pause). Il existe également des statuts spécifiques qui commencent par le Attendre préfixe qui vous indique quand un transfert est suspendu parce que les conditions définies dans le TransferPreferences la propriété ne sont pas satisfaits. Par exemple, WaitingForWiFi est défini lorsque le transfert attend que le téléphone soit connecté à un réseau Wi-Fi pour démarrer.TransferProgressChanged est déclenché lorsque la progression d'un transfert change, ce qui signifie que de nouvelles données ont été téléchargées ou téléchargées. Généralement, ce gestionnaire d’événements est connecté à un Barre de progression contrôle car il expose des propriétés pour vous informer de la quantité de données transférée et de la quantité de données restant à télécharger ou à envoyer.Une fois que vous avez défini un transfert en arrière-plan, vous devez l'ajouter à la file d'attente du système d'exploitation. Windows Phone se chargera de le démarrer lorsque les conditions spécifiées seront remplies. Pour accomplir cette tâche, nous utilisons le BackgroundTransferService classe, qui est le gestionnaire de transfert en arrière-plan central. Vous pouvez ajouter, supprimer ou répertorier les transferts en arrière-plan appartenant à l'application..
Dans l'exemple suivant, vous pouvez voir une définition de transfert en arrière-plan:
private BackgroundTransferRequest backgroundRequest; void privé OnStartBackgroundDownloadClicked (expéditeur d'objet, RoutedEventArgs e) Uri sourceUrl = nouvel 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 (expéditeur d'objet, BackgroundTransferEventArgs e) if (backgroundRequest.TransferStatus == TransferStatus.Completed) // Gère le fichier téléchargé. BackgroundTransferService.Remove (backgroundRequest); Nous enregistrons ce transfert à exécuter indépendamment des connexions réseau disponibles et de la source d'alimentation. L'exemple précédent étant lié à une opération de téléchargement, il est donc nécessaire de définir un URI source (le fichier à télécharger) et un URI de destination (le chemin de stockage local dans lequel le fichier sera enregistré). Contrairement à ce que nous avons vu avec HttpClient, nous n'avons pas à prendre en charge le processus de sauvegarde; le fichier sera automatiquement téléchargé et enregistré dans la mémoire de stockage locale car le téléchargement peut également se terminer lorsque l'application est suspendue. Les adresses URI source et cible sont transmises en tant que paramètres du BackgroundTransferRequest constructeur.
Remarque: les transferts en arrière-plan utilisés pour effectuer des opérations de téléchargement doivent toujours enregistrer le fichier dans le chemin d'accès Partagé / Transfers du stockage local, qui est automatiquement créé lors de l'installation de l'application. Sinon, vous obtiendrez une exception. Une fois le téléchargement terminé, vous êtes libre de déplacer le fichier vers un autre emplacement si nécessaire, mais vous ne pouvez pas planifier un transfert en arrière-plan qui tente de télécharger un fichier dans un autre dossier..
Ensuite, nous nous abonnons à la TransferStatusChanged un événement. Si le téléchargement est terminé alors que l'application est au premier plan, nous pouvons gérer le fichier téléchargé. Par exemple, si c'est une image, nous pouvons l'afficher. Remarquez le Retirer() opération que nous effectuons sur le BackgroundTransferService classe. Il est très important de toujours effectuer cette tâche car le système d'exploitation ne supprimera pas automatiquement les transferts terminés de la file d'attente de l'application et cela peut entraîner des problèmes inattendus puisqu'un logiciel ne peut pas planifier plus de 25 transferts..
Au lieu de cela, si vous devez télécharger un fichier, vous devez créer un fichier. BackgroundTransferRequest objet d'une manière différente. Vous devez toujours définir deux URI: la source (le fichier à télécharger) et la destination (un service capable de recevoir le fichier à l'aide de la commande HTTP définie dans la commande Méthode propriété). L’URI de destination peut être passé dans le BackgroundTransferRequestLe constructeur de (comme nous l'avons fait précédemment), mais l'URI source doit être défini dans le UploadLocation propriété, comme dans l'exemple suivant:
void privé OnUploadFile () Uri destinationUrl = nouvel Uri ("http://wp8test.azurewebsites.com/api/values", UriKind.Relative); Uri sourceUri = new Uri ("/ Shared / Transfers / image.png", UriKind.Relative); Demande BackgroundTransferRequest = new BackgroundTransferRequest (destinationUrl); request.UploadLocation = sourceUri; request.Method = "POST"; BackgroundTransferService.Add (demande); Dans cet article, nous avons vu comment utiliser l'une des fonctionnalités les plus utilisées d'un smartphone: une connexion Internet. En détail, nous avons appris:
HttpClient est une nouvelle classe introduite dans Windows Runtime qui permet d'effectuer des opérations sur le réseau. Nous avons vu comment l'utiliser pour télécharger et télécharger des fichiers et pour interagir avec des services..HttpClient est une aide précieuse, mais elle ne fonctionne que si l’application est au premier plan. Lorsqu'il est suspendu, les opérations du réseau sont annulées. À cette fin, la structure offre des API spécifiques pour effectuer des opérations de téléchargement et de téléchargement même en arrière-plan lorsque l'application n'est pas utilisée..Ce tutoriel représente un chapitre de Windows Phone 8 Succinctly, un eBook gratuit de l’équipe de Syncfusion.
