Share
Todos los dispositivos con Windows Phone tienen una conexión de red incorporada pero, por la misma razón que aprendimos cómo almacenar datos localmente, debemos estar preparados para administrar cómo los usuarios usan nuestra aplicación mientras falta una conexión..
Para este propósito, el marco de Windows Phone incluye una clase que puede usarse para descubrir información sobre la conexión a Internet llamada DeviceNetworkInformation, que es parte de la Microsoft.Phone.Net.NetworkInformation espacio de nombres.
El mas importante es IsNetworkAvailable, lo que nos dice si una conexión a Internet está disponible. Siempre debemos usar esta API antes de realizar una operación que requiera una conexión, como la siguiente muestra:
Accentsconagua
void privado OnCheckConnectionClicked (emisor de objeto, RoutedEventArgs e) if (DeviceNetworkInformation.IsNetworkAvailable) MessageBox.Show ("Estás conectado a Internet"); // Realizar operaciones de red. else MessageBox.Show ("No estás conectado a Internet"); La clase también ofrece un evento llamado RedDisponibilidad Cambiado que se activa cada vez que cambia el estado de la conexión. Es útil si desea reaccionar rápidamente a los cambios de red, como habilitar o deshabilitar ciertas funciones de la aplicación.
mainPage () InitializeComponent () pública; DeviceNetworkInformation.NetworkASaludDeCualificadoCambiado + = DeviceNetworkInformation_NetworkA AutodesignidadCambiada; privada nula DeviceNetworkInformation_NetworkAeguibilityChanged (emisor de objeto, NetworkNotificationEventArgs e) if (e.NotificationType == NetworkNotificationType.InterfaceDisconnected) MessageBox.Show ("Disconnected"); else if (e.NotificationType == NetworkNotificationType.InterfaceConnected) MessageBox.Show ("Connected"); Los parámetros de retorno contienen una propiedad llamada Tipo de notificación, del tipo NetworkNotificationType, lo que nos dice el estado actual de la red.
Sin embargo, con el DeviceNetworkInformation También podrá obtener otra información sobre el estado actual de la red, como si el usuario ha habilitado la conexión de datos móviles (IsCellularDataEnabled), la conexión wifi (Está habilitado), u opciones de itinerancia (IsCellularDataRoamingOptions).
El marco ofrece otra clase útil para tratar con las conexiones de red llamadas Interfaz de red. Utilizando el NetworkInterfaceType propiedad, podrá identificar qué tipo de conexión está actualmente en uso. Por ejemplo, podemos usar esta propiedad para evitar descargar archivos grandes mientras usamos una conexión celular.
NetworkInterfaceType Es un enumerador que puede asumir muchos valores. Los más importantes son:
MobileBroadbandGsm y MobileBroadbandCdma cuando el teléfono está conectado a una red celular (GSM o CDMA, según el país)Wireless80211, cuando el teléfono está conectado a una red Wi-FiEn el siguiente ejemplo, mostramos un mensaje en la pantalla con el tipo de conexión actual:
private void OnCheckConnectionTypeClicked (emisor de objeto, RoutedEventArgs e) if (NetworkInterface.NetworkInterfaceType == NetworkInterfaceType.MobileBroadbandGsm || NetworkInterface.P.) else if (NetworkInterface.NetworkInterfaceType == NetworkInterfaceType.Wireless80211) MessageBox.Show ("Wi-Fi"); El marco de Windows Phone tiene dos clases integradas para realizar operaciones de red: WebClient y HttpWebRequest. Lamentablemente, ninguno de ellos es perfecto.. WebClient es muy fácil de usar, pero se basa en el antiguo enfoque de devolución de llamada (a menos que instale el Async para .NET paquete que discutimos anteriormente en esta serie). HttpWebRequest es muy poderoso, pero es complejo de usar y se basa en un patrón asíncrono antiguo que es difícil de entender.
El Windows Runtime ha introducido una nueva clase llamada HttpClient, Lo que se lleva lo mejor de ambos mundos. Es potente y ofrece un gran rendimiento, pero es fácil de usar y ofrece métodos que se basan en el nuevo patrón async y espera. Esta clase está disponible en las aplicaciones completas de Windows Runtime para Windows Store, pero no está incluida en el subconjunto de Windows Phone Runtime. Tendrá que instalarlo desde NuGet..
los HttpClient La clase, como veremos más adelante, es excelente no solo para realizar operaciones de red genéricas como descargar y cargar archivos, sino también para interactuar con servicios web. De hecho, expone métodos asíncronos para cada comando HTTP, como GET, POST, PUT, etc..
Nota: Para poder interactuar con la red, deberá habilitar la opción ID_CAP_NETWORKING en el archivo de manifiesto. Está habilitado en cada nuevo proyecto de Windows Phone por defecto.
Los archivos generalmente se descargan utilizando el comando GET HTTP, por lo que HttpClient ofrece el GetAsync () método. Para simplificar la vida de los desarrolladores., HttpClient tiene algunos métodos incorporados para descargar los tipos de archivos más comunes, como GetStringAsync () para descargar archivos de texto como XML, RSS o respuestas REST; o GetByteArrayAsync () y GetStreamAsync () para obtener el contenido del archivo binario.
Descargar cadenas es realmente fácil. El método GetStringAsync () requiere como parámetro la URL del archivo y devuelve el contenido del archivo como una cadena. En el siguiente ejemplo, puedes ver cómo descargar la fuente RSS de mi blog:
privado async void OnDownloadStringClicked (objeto remitente, RoutedEventArgs e) cliente HttpClient = nuevo HttpClient (); string result = await client.GetStringAsync ("http://feeds.feedburner.com/qmatteoq_eng"); Una vez que tenga la cadena, puede realizar las operaciones requeridas de acuerdo con su escenario. Por ejemplo, en el ejemplo anterior podría haber analizado el XML devuelto con LINQ to XML para mostrar la lista de noticias en la pantalla.
La descarga de archivos binarios se puede lograr de muchas maneras. Puedes usar GetByteArrayAsync () Si prefieres trabajar con bytes, o GetStreamAsync () Si prefieres manipular el contenido del archivo como un flujo.
En el siguiente ejemplo, verá cómo descargar una imagen usando el GetByteArrayAsync () método. Devuelve la matriz de un byte, que se puede guardar fácilmente en el almacenamiento local utilizando las API que aprendimos anteriormente en esta serie..
privado async void OnDownloadFileClicked (objeto remitente, RoutedEventArgs e) cliente HttpClient = nuevo HttpClient (); byte [] bytes = await client.GetByteArrayAsync ("http://www.syncfusion.com/Content/en-US/Home/Images/syncfusion-logo.png"); StorageFile storageFile = await ApplicationData.Current.LocalFolder.CreateFileAsync ("picture.png", CreationCollisionOption.ReplaceExisting); IRandomAccessStream accessStream = await storageFile.OpenAsync (FileAccessMode.ReadWrite); utilizando (IOutputStream outputStream = accessStream.GetOutputStreamAt (0)) DataWriter writer = new DataWriter (outputStream); writer.WriteBytes (bytes); aguarda writer.StoreAsync (); Utilizando el Escritor de datos clase, podemos guardar la matriz de bytes devuelta por el HttpClient clase en un archivo en el almacenamiento local llamado picture.png.
Si necesita un control total sobre la operación de descarga, puede utilizar el código genérico GetAsync () método, que devuelve un HttpResponseMessage Objeto con el contenido de toda la respuesta, como encabezados, código de estado, etc..
En la siguiente muestra puede ver cómo, usando el GetAsync () Método, podemos descargar una imagen como un Corriente y mostrarlo en una Imagen Control colocado en la página. Al método le pasamos un segundo parámetro de tipo HttpCompletionOption, que le dice a la clase cuándo marcar la operación como completada. Como queremos el contenido completo de la respuesta (que es la imagen descargada), usamos el RespuestaContenidoLeer opción.
privado async void OnDownloadStreamClicked (objeto remitente, RoutedEventArgs e) cliente HttpClient = nuevo HttpClient (); HttpResponseMessage httpResponseMessage = aguarda client.GetAsync ("http://www.syncfusion.com/Content/en-US/Home/Images/syncfusion-logo.png", HttpCompletionOption.ResponseContentRead); Stream stream = await httpResponseMessage.Content.ReadAsStreamAsync (); BitmapImage image = new BitmapImage (); image.SetSource (stream); Logo.Source = imagen; Tenga en cuenta que los métodos específicos que hemos visto ofrecidos por el HttpClient clase son simplemente un atajo a los métodos ofrecidos por el Contenido propiedad de la HttpResponseMessage clase (en la muestra anterior, usamos el ReadAsStreamAsync () método para devolver el contenido de la respuesta como una Corriente).
La carga de datos se realiza de manera similar: la operación generalmente se realiza mediante el comando POST, por lo que HttpClient clase expone la PostAsync () método para este propósito.
El contenido a enviar se prepara utilizando el HttpContent clase, que ofrece muchas implementaciones: Contenido continuo enviar el flujo de un archivo, ByteArrayContent enviar un archivo binario, StringContent para enviar una cadena, o MultipartFormDataContent para enviar contenido codificado usando multipart / form-data MIME type.
En el siguiente ejemplo, puede ver cómo cargar el flujo de un archivo a un servicio:
privado async void OnUploadFileClicked (emisor de objetos, RoutedEventArgs e) StorageFile storageFile = await ApplicationData.Current.LocalFolder.GetFileAsync ("picture.png"); IRandomAccessStream accessStream = await storageFile.OpenAsync (FileAccessMode.ReadWrite); Cliente HttpClient = nuevo HttpClient (); Contenido de HttpContent = new StreamContent (accessStream.AsStreamForRead ()); aguarda client.PostAsync ("http://wp8test.azurewebsites.net/api/values", contenido); Una vez que hemos recuperado la secuencia de un archivo almacenado en el almacenamiento local, lo pasamos a una nueva instancia de Contenido continuo clase. Entonces, llamamos al PostAsync () método, pasando la URL del servicio y la HttpContent objeto como parámetros.
REST (Representational State Transfer) es, sin lugar a dudas, el enfoque más utilizado en la actualidad en el desarrollo de servicios web, especialmente en el mundo móvil..
Los servicios REST se han vuelto muy populares por dos razones:
Casi todas las plataformas soportan estas tecnologías de forma nativa, por lo que no tiene que buscar bibliotecas especiales para interactuar con ellas, ya que es necesario para los servicios web basados en WSDL..
Ya hemos visto como, con el HttpClient clase, es simple interactuar con la web usando los comandos HTTP estándar. La mayoría de las veces, para interactuar con un servicio REST, simplemente deberá ejecutar el GetStringAsync () Método para obtener la respuesta XML o JSON.
Una vez que tenga el resultado, la mayoría del tiempo tendrá que convertirlo en objetos para usar dentro de la aplicación. Anteriormente en esta serie, analizamos la forma más sencilla de realizar esta tarea: la deserialización, que significa traducir texto sin formato en objetos complejos. Podemos usar el DataContractSerializer o DataContractJsonSerializer Clases para hacer esto. En este caso, solo tiene que referirse al proceso de deserialización ya que el procedimiento es el mismo.
onConsumeServiceClicked privado async void (objeto remitente, RoutedEventArgs e) cliente HttpClient = nuevo HttpClient (); string result = await client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values"); utilizando (MemoryStream ms = new MemoryStream (Encoding.Unicode.GetBytes (resultado))) DataContractJsonSerializer serializer = new DataContractJsonSerializer (typeof (List)); Lista people = serializer.ReadObject (ms) as List; Suponemos que el servicio devuelve, en formato JSON, una lista de personas:
["id": 1, "name": "Matteo", "apellido": "Pagani", "id": 2, "nombre": "John", "apellido": "Doe"]
Con la ayuda del DataContractJsonSerializer clase, somos capaces de convertir el JSON anterior en una lista de Persona Objetos, que es la misma clase que hemos usado en muchas otras muestras en esta serie. La diferencia en esta muestra es que podemos controlar el proceso de serialización, en caso de que, por ejemplo, los nombres de propiedades devueltos desde el JSON sean diferentes a los que usamos en nuestras clases. Este es un escenario muy común cuando se trata de JSON, ya que los nombres de las propiedades suelen estar en minúsculas, mientras que en los objetos C # son CamelCase. Este resultado se logra utilizando el [DataMember] atributo, que se puede aplicar a las propiedades que queremos serializar. En el siguiente ejemplo, puede ver que el atributo ofrece una propiedad llamada Nombre, que se puede usar para especificar qué nombre de propiedad esperamos encontrar en el archivo JSON.
public class Person [DataMember (Name = "id")] public int Id get; conjunto; [DataMember (Name = "name")] string público Nombre get; conjunto; [DataMember (Name = "surname")] public string Apellido obtener; conjunto;
Este enfoque tiene un inconveniente: los servicios REST siempre devuelven una cadena simple, mientras que DataContractJsonSerializer clase requiere un Corriente como un parámetro de entrada de la ReadObject () método, por lo que siempre estamos obligados a convertirlo utilizando un MemoryStream objeto.
Hay otra forma de lograr el mismo resultado. Permítame presentarle JSON.NET, una biblioteca de terceros que ofrece algunas funciones adicionales útiles para manejar los datos JSON. Además, ofrece un mejor rendimiento y es capaz de deserializar archivos JSON complejos más rápido.
Se puede instalar fácilmente usando NuGet, y su sitio web oficial ofrece comparaciones con otras bibliotecas JSON y documentación detallada.
En el siguiente ejemplo, usamos JSON.NET para lograr el mismo resultado que el código que hemos usado anteriormente:
privado async void OnGetDataClicked (objeto remitente, RoutedEventArgs e) cliente HttpClient = nuevo HttpClient (); string result = await client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values"); Lista people = JsonConvert.DeserializeObject> (resultado); los JsonConvert clase (que es parte de la Newtonsoft.Json espacio de nombres) expone el DeserializeObject método, donde T es el tipo de objeto que esperamos a cambio. Como parámetro de entrada, solo requiere la cadena JSON que hemos descargado del servicio.
También es posible controlar el proceso de deserialización utilizando atributos, como hicimos anteriormente con el DataMember atributo. En el siguiente ejemplo, puede ver cómo podemos definir manualmente cómo deben traducirse las propiedades JSON:
public class Person [JsonProperty ("id")] public int Id get; conjunto; [JsonProperty ("name")] public string Name get; conjunto; [JsonProperty ("apellido")] cadena pública Apellido obtener; conjunto; Sugerencia: a menudo tendrá que usar servicios de terceros, por lo que no sabrá la asignación exacta entre las entidades y los datos JSON. Hay un sitio web que te ayudará en este escenario: http://json2csharp.com/. Simplemente pegue el JSON devuelto por su servicio, y generará para usted las clases C # necesarias para asignar los datos JSON.
Otra característica interesante introducida por JSON.NET es LINQ to JSON, que es un lenguaje basado en LINQ que, similar a LINQ to XML, puede usarse para manipular una cadena JSON para extraer solo la información que necesita. Este enfoque es útil cuando realmente no necesita usar la deserialización, pero solo necesita extraer algunos datos de la respuesta JSON que recibió del servicio.
El punto de partida para usar LINQ to JSON es el Objeto clase, que identifica un archivo JSON. Para empezar a trabajar con él, simplemente tienes que llamar al Analizar gramaticalmente() Método, pasando como parámetro la cadena JSON, como se muestra en el siguiente ejemplo:
privado async void OnParseJson (emisor de objetos, RoutedEventArgs e) cliente HttpClient = nuevo HttpClient (); string result = await client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values"); JObject json = JObject.Parse (resultado); Ahora estás listo para ejecutar algunas operaciones. Echemos un vistazo a los más comunes..
Simple json
Aquí hay un ejemplo de un simple archivo JSON:
"Id": 1, "Nombre": "Matteo", "Apellidos": "Pagani"
Con LINQ to JSON, podemos extraer el valor de una sola propiedad de la siguiente manera:
privado async void OnParseJson (emisor de objetos, RoutedEventArgs e) cliente HttpClient = nuevo HttpClient (); string result = await client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values/1"); JObject json = JObject.Parse (resultado); valor de cadena = json ["Nombre"]. Valor(); los Objeto La clase se trata como una colección, por lo que simplemente puede acceder a una propiedad utilizando su nombre como clave. Al final, puede extraer el valor utilizando el Valor método, donde T Es el tipo de datos que esperamos almacenar..
Complejo json
Al igual que los objetos C #, los objetos JSON también pueden tener propiedades complejas, como se muestra en el siguiente ejemplo:
"Id": 1, "Nombre": "Matteo", "Apellidos": "Pagani", "Dirección": "Calle": "Dirección falsa", "Ciudad": "Milán"
Dirección es una propiedad compleja porque contiene otras propiedades anidadas. Para acceder a estas propiedades, necesitamos usar el SelectToken () Método, pasando la ruta JSON completa como parámetro:
privado async void OnParseJson (emisor de objetos, RoutedEventArgs e) cliente HttpClient = nuevo HttpClient (); string result = await client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values/1"); JObject json = JObject.Parse (resultado); string city = json.SelectToken ("Address.City"). Value(); Con el Dirección.ciudad camino, somos capaces de extraer el valor de la Ciudad propiedad que es parte de la Dirección nodo.
Colecciones JSON
Cuando maneja colecciones JSON, puede usar el Niños() Método para obtener acceso a todos los nodos secundarios de una propiedad específica. Usemos, como ejemplo, un código JSON que hemos visto anteriormente:
["Id": 1, "Nombre": "Matteo", "Apellidos": "Pagani", "Id": 2, "Nombre": "Juan", "Apellidos": "Doe"]
En este caso, podemos utilizar el JArray clase y la Niños() Método para extraer todos los elementos de la colección. En el siguiente ejemplo puede ver cómo lo usamos para obtener una subcolección con solo el Nombre valores de la propiedad.
privado async void OnGetDataClicked (objeto remitente, RoutedEventArgs e) cliente HttpClient = nuevo HttpClient (); string result = await client.GetStringAsync ("http://wp8test.azurewebsites.net/api/values"); JArray json = JArray.Parse (resultado); Lista list = json.Children (). Seleccione (x => x ["Nombre"]. Valor()).Listar(); los HttpClient clase que hemos visto anteriormente, como la WebClient y HttpWebRequest Clases, solo se pueden utilizar para operaciones de primer plano. Cuando se suspende la aplicación, se cancelan las transferencias de red..
Cuando tenemos que lidiar con las grandes transferencias de datos, obligar al usuario a mantener la aplicación abierta no crea la mejor experiencia de usuario. Para este escenario, Windows Phone 7.5 ha introducido API de transferencia en segundo plano que se pueden usar para iniciar una operación de descarga o carga y para continuar incluso si la aplicación está suspendida.
Sin embargo, se han introducido algunas limitaciones para evitar problemas con la batería y un alto consumo del plan de datos:
Una transferencia de fondo se identifica por la BackgroundTransferRequest clase, que es parte de la Microsoft.Phone.BackgroundTransfer espacio de nombres. Como desarrolladores, tenemos control sobre algunas condiciones que deben satisfacerse para que comience una transferencia en segundo plano creada en nuestra aplicación, gracias a Transferirpreferencias Propiedad que puede obtener los siguientes valores:
Ninguna, el valor predeterminado: la transferencia se inicia solo si el teléfono está conectado a una red Wi-Fi y la batería se está cargando.AllowBattery: La transferencia se inicia solo si el teléfono está conectado a una red Wi-Fi, independientemente de la fuente de alimentación.AllowCelullar: La transferencia se inicia solo si el teléfono se está cargando, independientemente de la conexión de red.AllowCellularAndBattery: Siempre se inicia la transferencia, independientemente de las condiciones de conexión y fuente de alimentación.
los BackgroundTransferRequest La clase expone dos controladores de eventos que se pueden usar para controlar la transferencia:
TransferStatusChanged se activa cuando cambia el estado de la transferencia. El parámetro devuelto por el método contiene un Estado de transferencia objeto que le notifica el estado actual (como Terminado cuando finaliza la transferencia, o En pausa cuando la transferencia está en pausa). También hay estados específicos que comienzan con el Esperando Prefijo que le indica cuándo se suspende una transferencia debido a que las condiciones definidas en el Transferirpreferencias La propiedad no está satisfecha. Por ejemplo, EsperandoFiFi se configura cuando la transferencia está a la espera de que el teléfono se conecte a una red Wi-Fi para iniciarse.TransferProgressChanged se activa cuando cambia el progreso de una transferencia, lo que significa que se han descargado o cargado nuevos datos. Por lo general, este controlador de eventos está conectado a un Barra de progreso control, ya que expone las propiedades para notificarle la cantidad de datos transferidos y la cantidad de datos que aún deben descargarse o enviarse.Una vez que haya definido una transferencia en segundo plano, debe agregarla a la cola del sistema operativo. Windows Phone se encargará de iniciarlo cuando se cumplan las condiciones especificadas. Para llevar a cabo esta tarea, utilizamos el BackgroundTransferService clase, que es el gestor de transferencia de fondo central. Puede agregar, eliminar o enumerar transferencias en segundo plano que pertenecen a la aplicación.
En el siguiente ejemplo puede ver una definición de transferencia de fondo:
Private BackgroundTransferRequest backgroundRequest; private void OnStartBackgroundDownloadClicked (objeto emisor, 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 (remitente del objeto, BackgroundTransferEventArgs e) if (backgroundRequest.TransferStatus == TransferStatus.Completed) // Administrar el archivo descargado. BackgroundTransferService.Remove (backgroundRequest); Registramos esta transferencia para que se ejecute independientemente de la conexión de red disponible y la fuente de alimentación. La muestra anterior está relacionada con una operación de descarga, por lo que necesitamos definir un URI de origen (el archivo a descargar) y un URI de destino (la ruta de almacenamiento local donde se guardará el archivo). A diferencia de lo que hemos visto con HttpClient, no tenemos que cuidar el proceso de ahorro; El archivo se descargará automáticamente y se guardará en el almacenamiento local, ya que la descarga también puede finalizar cuando se suspende la aplicación. Tanto los URI de origen como los de destino se pasan como parámetros de BackgroundTransferRequest constructor.
Nota: las transferencias en segundo plano que se utilizan para realizar operaciones de descarga siempre tienen que guardar el archivo dentro de la ruta de Shared / Transfers en el almacenamiento local, que se crea automáticamente cuando se instala la aplicación; de lo contrario, obtendrá una excepción. Cuando se completa la descarga, puede mover el archivo a otra posición si es necesario, pero no puede programar una transferencia en segundo plano que intente descargar un archivo en una carpeta diferente.
A continuación, nos suscribimos a la TransferStatusChanged evento. Si la descarga se completa mientras la aplicación está en primer plano, podemos administrar el archivo descargado, por ejemplo, si es una imagen, podemos mostrarlo. Observe la Retirar() operación que realizamos en el BackgroundTransferService clase. Es realmente importante realizar siempre esta tarea porque el sistema operativo no eliminará automáticamente las transferencias completadas de la cola de la aplicación y puede generar problemas inesperados ya que una aplicación no puede programar más de 25 transferencias.
En cambio, si necesita cargar un archivo, deberá crear un BackgroundTransferRequest Objeto de una manera diferente. Aún necesita definir dos URI: el origen (el archivo a cargar) y el destino (un servicio que puede recibir el archivo usando el comando HTTP establecido en el Método propiedad). El URI de destino se puede pasar en el BackgroundTransferRequestEl constructor (como hicimos anteriormente), pero el URI de origen debe establecerse en el UploadLocation Propiedad, como en la siguiente muestra:
void privado OnUploadFile () Uri destinationUrl = new Uri ("http://wp8test.azurewebsites.com/api/values", UriKind.Relative); Uri sourceUri = new Uri ("/ Shared / Transfers / image.png", UriKind.Relative); Solicitud BackgroundTransferRequest = nuevo BackgroundTransferRequest (destinationUrl); request.UploadLocation = sourceUri; request.Method = "POST"; BackgroundTransferService.Add (solicitud); En este artículo hemos visto cómo trabajar con una de las funciones más utilizadas de un teléfono inteligente: una conexión a Internet. En detalle, hemos aprendido:
HttpClient es una nueva clase introducida en Windows Runtime que ayuda a realizar operaciones de red. Hemos visto cómo usarlo para descargar y cargar archivos, e interactuar con los servicios..HttpClient es una gran ayuda, pero solo funciona si la aplicación está en primer plano. Cuando se suspende, las operaciones de red se cancelan. Para este propósito, el marco ofrece algunas API específicas para realizar operaciones de descarga y carga incluso en segundo plano cuando la aplicación no está en uso.Este tutorial representa un capítulo de Windows Phone 8 sucintamente, un libro electrónico gratuito del equipo de Syncfusion.
