Статьи

Windows Phone 8: кратко: доступ к данным — сеть

Февраль 15, 2019

Проверка интернет-соединения

Все устройства Windows Phone имеют встроенное сетевое соединение, но по той же причине, по которой мы узнали, как локально хранить данные, мы должны быть готовы управлять тем, как пользователи используют наше приложение, когда соединение отсутствует.

Для этой цели платформа Windows Phone включает в себя класс, который можно использовать для обнаружения информации о подключении к Интернету, который называется DeviceNetworkInformation , который является частью пространства имен Microsoft.Phone.Net.NetworkInformation .

Наиболее важным из них является IsNetworkAvailable , который сообщает нам, доступно ли подключение к Интернету. Мы всегда должны использовать этот API перед выполнением операции, требующей подключения, как в следующем примере:

01
02
03
04
05
06
07
08
09
10
11
12
private void OnCheckConnectionClicked(object sender, RoutedEventArgs e)
{
    if (DeviceNetworkInformation.IsNetworkAvailable)
    {
        MessageBox.Show(«You are connected to Internet»);
        //Perform network operations.
    }
    else
    {
        MessageBox.Show(«You aren’t connected to Internet»);
    }
}

Класс также предлагает событие NetworkAvailabilityChanged которое запускается каждый раз, когда изменяется состояние соединения. Это полезно, если вы хотите быстро реагировать на изменения в сети, такие как включение или отключение определенных функций приложения.

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
public MainPage()
{
    InitializeComponent();
    DeviceNetworkInformation.NetworkAvailabilityChanged += DeviceNetworkInformation_NetworkAvailabilityChanged;
}
 
private void DeviceNetworkInformation_NetworkAvailabilityChanged(object sender, NetworkNotificationEventArgs e)
{
    if (e.NotificationType == NetworkNotificationType.InterfaceDisconnected)
    {
        MessageBox.Show(«Disconnected»);
    }
    else if (e.NotificationType == NetworkNotificationType.InterfaceConnected)
    {
        MessageBox.Show(«Connected»);
    }
}

Возвращаемые параметры содержат свойство с именем NotificationType типа NetworkNotificationType , которое сообщает нам текущее состояние сети.

Однако с помощью DeviceNetworkInformation вы также сможете получать другую информацию о текущем состоянии сети, например, о том, активировал ли пользователь сотовое соединение для передачи данных ( IsCellularDataEnabled ), соединение Wi-Fi ( IsWiFiEnabled ) или параметры роуминга ( IsCellularDataRoamingOptions ). ,

Фреймворк предлагает еще один полезный класс для работы с сетевыми подключениями, который называется NetworkInterface . Используя свойство NetworkInterfaceType , вы сможете определить, какой тип подключения используется в данный момент. Например, мы можем использовать это свойство, чтобы избежать загрузки больших файлов при использовании сотовой связи.

NetworkInterfaceType — это перечислитель, который может принимать много значений. Самые важные из них:

  • MobileBroadbandGsm и MobileBroadbandCdma когда телефон подключен к сотовой сети (GSM или CDMA, в зависимости от страны)
  • Wireless80211 , когда телефон подключен к сети Wi-Fi

В следующем примере мы выводим на экран сообщение с текущим типом соединения:

01
02
03
04
05
06
07
08
09
10
11
private void OnCheckConnectionTypeClicked(object sender, RoutedEventArgs e)
{
    if (NetworkInterface.NetworkInterfaceType == NetworkInterfaceType.MobileBroadbandGsm || NetworkInterface.NetworkInterfaceType == NetworkInterfaceType.MobileBroadbandCdma)
    {
        MessageBox.Show(«Mobile»);
    }
    else if (NetworkInterface.NetworkInterfaceType == NetworkInterfaceType.Wireless80211)
    {
        MessageBox.Show(«Wi-Fi»);
    }
}

Выполнение сетевых операций: HttpClient

Платформа Windows Phone имеет два встроенных класса для выполнения сетевых операций: WebClient и HttpWebRequest . К сожалению, ни один из них не идеален. WebClient очень прост в использовании, но он основан на старом подходе обратного вызова (если только вы не установите пакет Async for .NET, который мы обсуждали ранее в этой серии ). HttpWebRequest очень мощный, но он сложен в использовании и основан на старом асинхронном шаблоне, который трудно понять.

Среда выполнения Windows представила новый класс под названием HttpClient , который использует лучшее из обоих миров. Он мощный и предлагает отличную производительность, но он прост в использовании и предлагает методы, основанные на новом шаблоне асинхронности и ожидания. Этот класс доступен в полной версии Windows Runtime для приложений Магазина Windows, но он не включен в подмножество среды выполнения Windows Phone — его необходимо установить из NuGet .

Класс HttpClient , как мы увидим позже, отлично подходит не только для выполнения общих сетевых операций, таких как загрузка и выгрузка файлов, но и для взаимодействия с веб-службами. Фактически, он предоставляет асинхронные методы для каждой HTTP-команды, такие как GET, POST, PUT и т. Д.

Примечание. Чтобы иметь возможность взаимодействовать с сетью, вам нужно включить опцию ID_CAP_NETWORKING в файле манифеста. Он включен в каждом новом проекте Windows Phone по умолчанию.

Загрузка данных

Файлы обычно загружаются с помощью команды GET HTTP, поэтому HttpClient предлагает метод GetAsync() . Чтобы упростить жизнь разработчиков, в HttpClient есть несколько встроенных методов для загрузки наиболее распространенных типов файлов, таких как GetStringAsync() для загрузки текстовых файлов, таких как XML, RSS или ответы REST; или GetByteArrayAsync() и GetStreamAsync() для получения содержимого двоичного файла.

Загрузка строк действительно проста. Метод GetStringAsync() требует в качестве параметра URL-адрес файла и возвращает содержимое файла в виде строки. В следующем примере вы можете увидеть, как загрузить RSS-канал моего блога:

1
2
3
4
5
private async void OnDownloadStringClicked(object sender, RoutedEventArgs e)
{
    HttpClient client = new HttpClient();
    string result = await client.GetStringAsync(«http://feeds.feedburner.com/qmatteoq_eng»);
}

Когда у вас есть строка, вы можете выполнять необходимые операции в соответствии с вашим сценарием. Например, в предыдущем примере я мог бы проанализировать возвращенный XML с LINQ to XML, чтобы отобразить список новостей на экране.

Загрузка бинарных файлов может быть выполнена разными способами. Вы можете использовать GetByteArrayAsync() если вы предпочитаете работать с байтами, или GetStreamAsync() если вы предпочитаете манипулировать содержимым файла как потоком.

В следующем примере вы увидите, как загрузить изображение с помощью GetByteArrayAsync() . Он возвращает массив байтов, который можно легко сохранить в локальном хранилище с помощью API, о которых мы узнали ранее в этой серии.

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
private async void OnDownloadFileClicked(object sender, RoutedEventArgs e)
{
    HttpClient client = new 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);
 
    using (IOutputStream outputStream = accessStream.GetOutputStreamAt(0))
    {
        DataWriter writer = new DataWriter(outputStream);
        writer.WriteBytes(bytes);
        await writer.StoreAsync();
    }
}

Используя класс DataWriter , мы можем сохранить байтовый массив, возвращенный классом HttpClient в файл в локальном хранилище с именем picture.png.

Если вам нужен полный контроль над операцией загрузки, вы можете использовать универсальный GetAsync() , который возвращает объект HttpResponseMessage со всем содержимым ответа, таким как заголовки, код состояния и т. Д.

В следующем примере вы можете увидеть, как с помощью GetAsync() мы можем загрузить изображение в виде Stream и отобразить его в элементе управления Image размещенном на странице. В метод мы передаем второй параметр типа HttpCompletionOption , который сообщает классу, когда нужно пометить операцию как завершенную. Поскольку нам нужно полное содержимое ответа (то есть загруженного изображения), мы используем опцию ResponseContentRead .

01
02
03
04
05
06
07
08
09
10
11
private async void OnDownloadStreamClicked(object sender, RoutedEventArgs e)
{
    HttpClient client = new HttpClient();
    HttpResponseMessage httpResponseMessage = await 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 = image;
}

Обратите внимание, что конкретные методы, предлагаемые классом HttpClient являются просто ярлыком для методов, предлагаемых свойством Content класса HttpResponseMessage (в предыдущем примере мы использовали метод ReadAsStreamAsync() для возврата содержимого ответа в виде Stream ).

Загрузка данных

Загрузка данных выполняется аналогичным образом: операция обычно выполняется с помощью команды POST, поэтому класс HttpClient предоставляет для этого метод PostAsync() .

Контент для отправки подготовлен с использованием класса HttpContent , который предлагает множество реализаций: StreamContent для отправки потока файла, ByteArrayContent для отправки двоичного файла, StringContent для отправки строки или MultipartFormDataContent для отправки контента, закодированного с использованием MIME-типа multipart / form-data ,

В следующем примере вы можете увидеть, как загрузить поток файла в сервис:

1
2
3
4
5
6
7
8
9
private async void OnUploadFileClicked(object sender, RoutedEventArgs e)
{
    StorageFile storageFile = await ApplicationData.Current.LocalFolder.GetFileAsync(«picture.png»);
    IRandomAccessStream accessStream = await storageFile.OpenAsync(FileAccessMode.ReadWrite);
 
    HttpClient client = new HttpClient();
    HttpContent content = new StreamContent(accessStream.AsStreamForRead());
    await client.PostAsync(«http://wp8test.azurewebsites.net/api/values», content);
}

После того, как мы получили поток файла, хранящегося в локальном хранилище, мы передаем его новому экземпляру класса StreamContent . Затем мы вызываем метод PostAsync() , передавая URL-адрес службы и объект HttpContent качестве параметров.

Использование сервисов REST

REST (Transfer State State), без сомнения, является наиболее часто используемым подходом в настоящее время в разработке веб-сервисов, особенно в мобильном мире.

Услуги REST стали очень популярными по двум причинам:

  • Они основаны на протоколе HTTP и предоставляют операции с использованием стандартных команд HTTP (таких как GET, POST, PUT и т. Д.).
  • Они возвращают данные, используя стандартные языки, такие как XML и JSON.

Почти каждая платформа изначально поддерживает эти технологии, поэтому вам не нужно искать специальные библиотеки для взаимодействия с ними, как это требуется для веб-служб на основе WSDL.

Мы уже видели, как с классом HttpClient взаимодействовать с сетью, используя стандартные команды HTTP. В большинстве случаев для взаимодействия со службой REST вам просто нужно выполнить метод GetStringAsync() чтобы получить ответ XML или JSON.

Получив результат, большую часть времени вам придется преобразовывать его в объекты, которые будут использоваться внутри приложения. Ранее в этой серии мы обсудили самый простой способ решения этой задачи: десериализация, то есть перевод простого текста в сложные объекты. Для этого мы можем использовать классы DataContractSerializer или DataContractJsonSerializer . В этом случае вам просто нужно обратиться к процессу десериализации, поскольку процедура такая же.

01
02
03
04
05
06
07
08
09
10
11
private async void OnConsumeServiceClicked(object sender, RoutedEventArgs e)
{
    HttpClient client = new HttpClient();
    string result = await client.GetStringAsync(«http://wp8test.azurewebsites.net/api/values»);
 
    using (MemoryStream ms = new MemoryStream(Encoding.Unicode.GetBytes(result)))
    {
        DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(List<Person>));
        List<Person> people = serializer.ReadObject(ms) as List<Person>;
    }
}

Мы предполагаем, что сервис возвращает в формате JSON список лиц:

01
02
03
04
05
06
07
08
09
10
11
12
[
  {
    «id»:1,
    «name»:»Matteo»,
    «surname»:»Pagani»
  },
  {
    «id»:2,
    «name»:»John»,
    «surname»:»Doe»
  }
]

С помощью класса DataContractJsonSerializer мы можем преобразовать предыдущий JSON в список объектов Person , который является тем же классом, который мы использовали во многих других примерах в этой серии. Разница в этом примере заключается в том, что мы можем контролировать процесс сериализации, например, в случае, если имена свойств, возвращаемые из JSON, отличаются от тех, которые мы используем в наших классах. Это очень распространенный сценарий при работе с JSON, поскольку имена свойств обычно строчные, а в объектах C # они являются CamelCase. Этот результат достигается использованием атрибута [DataMember] , который можно применить к свойствам, которые мы хотим сериализовать. В следующем примере вы можете видеть, что атрибут предлагает свойство с именем Name , которое можно использовать для указания имени свойства, которое мы ожидаем найти в файле JSON.

01
02
03
04
05
06
07
08
09
10
11
public class Person
{
    [DataMember(Name = «id»)]
    public int Id { get;
 
    [DataMember(Name = «name»)]
    public string Name { get;
 
    [DataMember(Name = «surname»)]
    public string Surname { get;
}

У этого подхода есть недостаток: службы REST всегда возвращают простую строку, в то время как класс DataContractJsonSerializer требует Stream в качестве входного параметра метода ReadObject() , поэтому мы всегда вынуждены преобразовывать его с помощью объекта MemoryStream .

Есть еще один способ добиться того же результата. Позвольте мне представить JSON.NET, стороннюю библиотеку, которая предлагает некоторые дополнительные полезные функции для обработки данных JSON. Кроме того, он предлагает лучшую производительность и способен десериализовать сложные JSON-файлы быстрее.

Его можно легко установить с помощью NuGet , а его официальный сайт предлагает сравнение с другими библиотеками JSON и подробную документацию.

В следующем примере мы используем JSON.NET для достижения того же результата, что и код, который мы использовали ранее:

1
2
3
4
5
6
7
private async void OnGetDataClicked(object sender, RoutedEventArgs e)
{
    HttpClient client = new HttpClient();
    string result = await client.GetStringAsync(«http://wp8test.azurewebsites.net/api/values»);
 
    List<Person> people = JsonConvert.DeserializeObject<List<Person>>(result);
}

Класс JsonConvert (который является частью пространства имен Newtonsoft.Json ) предоставляет метод DeserializeObject<T>() , где T — это тип объекта, который мы ожидаем получить в ответ. В качестве входного параметра требуется только строка JSON, которую мы загрузили из сервиса.

Также возможно управлять процессом десериализации, используя атрибуты, как мы ранее делали с DataMember . В следующем примере вы можете увидеть, как мы можем вручную определить, как следует преобразовывать свойства JSON:

01
02
03
04
05
06
07
08
09
10
11
public class Person
{
    [JsonProperty(«id»)]
    public int Id { get;
 
    [JsonProperty(«name»)]
    public string Name { get;
 
    [JsonProperty(«surname»)]
    public string Surname { get;
}

Совет: вам часто придется использовать сторонние сервисы, поэтому вы не будете знать точное соответствие между сущностями и данными JSON. Существует сайт, который поможет вам в этом сценарии: http://json2csharp.com/ . Просто вставьте JSON, возвращенный вашим сервисом, и он сгенерирует для вас необходимые классы C # для сопоставления данных JSON.

LINQ to JSON

Еще одна интересная функция, представленная JSON.NET, — это LINQ to JSON, язык на основе LINQ, который, подобно LINQ to XML, может использоваться для манипулирования строкой JSON для извлечения только необходимой информации. Этот подход полезен, когда вам на самом деле не нужно использовать десериализацию, а просто нужно извлечь некоторые данные из ответа JSON, который вы получили от службы.

Отправной точкой для использования LINQ to JSON является класс JObject , который идентифицирует файл JSON. Чтобы начать работать с ним, вам просто нужно вызвать метод Parse() , передав в качестве параметра строку JSON, как показано в следующем примере:

1
2
3
4
5
6
7
private async void OnParseJson(object sender, RoutedEventArgs e)
{
    HttpClient client = new HttpClient();
    string result = await client.GetStringAsync(«http://wp8test.azurewebsites.net/api/values»);
 
    JObject json = JObject.Parse(result);
}

Теперь вы готовы выполнить некоторые операции. Давайте посмотрим на наиболее распространенные из них.

Простой JSON

Вот пример простого файла JSON:

1
2
3
4
5
{
  «Id»:1,
  «Name»:»Matteo»,
  «Surname»:»Pagani»
}

С помощью LINQ to JSON мы можем извлечь значение одного свойства следующим образом:

1
2
3
4
5
6
7
8
private async void OnParseJson(object sender, RoutedEventArgs e)
{
    HttpClient client = new HttpClient();
    string result = await client.GetStringAsync(«http://wp8test.azurewebsites.net/api/values/1»);
 
    JObject json = JObject.Parse(result);
    string value = json[«Name»].Value<string>();
}

Класс JObject рассматривается как коллекция, поэтому вы можете просто получить доступ к свойству, используя его имя в качестве ключа. В конце вы можете извлечь значение с помощью метода Value<T>() , где T — это тип данных, который мы ожидаем сохранить.

Комплекс JSON

Как и объекты C #, объекты JSON также могут иметь сложные свойства, как показано в следующем примере:

1
2
3
4
5
6
7
8
9
{
  «Id»:1,
  «Name»:»Matteo»,
  «Surname»:»Pagani»,
  «Address»: {
    «Street»:»Fake address»,
    «City»:»Milan»
  }
}

Address является сложным свойством, поскольку содержит другие вложенные свойства. Чтобы получить доступ к этим свойствам, нам нужно использовать метод SelectToken() , передавая полный путь JSON в качестве параметра:

1
2
3
4
5
6
7
8
private async void OnParseJson(object sender, RoutedEventArgs e)
{
    HttpClient client = new HttpClient();
    string result = await client.GetStringAsync(«http://wp8test.azurewebsites.net/api/values/1»);
 
    JObject json = JObject.Parse(result);
    string city = json.SelectToken(«Address.City»).Value<string>();
}

С помощью пути Address.City мы можем извлечь значение свойства City которое является частью узла Address .

Коллекции JSON

Когда вы обрабатываете коллекции JSON, вы можете использовать метод Children() чтобы получить доступ ко всем дочерним узлам определенного свойства. Давайте используем в качестве примера код JSON, который мы видели ранее:

01
02
03
04
05
06
07
08
09
10
11
12
[
  {
    «Id»:1,
    «Name»:»Matteo»,
    «Surname»:»Pagani»
  },
  {
    «Id»:2,
    «Name»:»John»,
    «Surname»:»Doe»
  }
]

В этом случае мы можем использовать класс JArray и метод Children() для извлечения всех элементов коллекции. В следующем примере вы можете увидеть, как мы используем его для получения вложенной коллекции только со значениями свойства Name .

1
2
3
4
5
6
7
8
private async void OnGetDataClicked(object sender, RoutedEventArgs e)
{
    HttpClient client = new HttpClient();
    string result = await client.GetStringAsync(«http://wp8test.azurewebsites.net/api/values»);
 
    JArray json = JArray.Parse(result);
    List<string> list = json.Children().Select(x => x[«Name»].Value<string>()).ToList();
}

Фоновые переводы

Класс HttpClient мы видели ранее, как и классы WebClient и HttpWebRequest , можно использовать только для операций переднего плана. Когда приложение приостановлено, сетевые переводы отменяются.

Когда нам приходится иметь дело с передачей больших данных, принуждение пользователя держать приложение открытым не создает наилучшего пользовательского опыта. Для этого сценария Windows Phone 7.5 представил API-интерфейсы фоновой передачи, которые можно использовать для запуска операции загрузки или выгрузки и ее продолжения, даже если приложение приостановлено.

Тем не менее, есть некоторые ограничения, которые были введены, чтобы избежать проблем с батареей и высоким расходом данных:

  • Если телефон подключен к сотовой сети, файлы размером более 20 МБ не могут быть загружены.
  • Если телефон подключен к сети Wi-Fi, файлы размером более 100 МБ не могут быть загружены.
  • Ограничение в 100 МБ может быть превышено только в том случае, если телефон подключен к сети Wi-Fi и аккумулятор заряжается.
  • Одно приложение может поставить в очередь до 25 операций фоновой передачи.
  • Глобальная очередь операционной системы может содержать до 500 операций фоновой передачи.
  • Телефон может выполнять максимум две операции передачи одновременно.

Фоновая передача определяется классом BackgroundTransferRequest , который является частью пространства имен Microsoft.Phone.BackgroundTransfer . Как разработчики, мы можем контролировать некоторые условия, которые должны быть выполнены для запуска фоновой передачи, созданной в нашем приложении, благодаря свойству TransferPreferences которое может принимать следующие значения:

  • None , значение по умолчанию: передача начинается только в том случае, если телефон подключен к сети Wi-Fi и батарея заряжается.
  • AllowBattery : передача начинается только в том случае, если телефон подключен к сети Wi-Fi, независимо от источника питания.
  • AllowCelullar : передача начинается только в том случае, если телефон заряжается, независимо от сетевого подключения.

AllowCellularAndBattery : всегда запускает передачу, независимо от состояния соединения и источника питания.

Класс BackgroundTransferRequest предоставляет два обработчика событий, которые можно использовать для управления передачей:

  • TransferStatusChanged срабатывает при изменении статуса перевода. Параметр, возвращаемый методом, содержит объект TransferStatus который уведомляет вас о текущем состоянии (например, Completed когда передача заканчивается, или Paused когда передача приостановлена). Существуют также определенные статусы, которые начинаются с префикса « Waiting который сообщает вам, когда передача приостановлена, поскольку условия, определенные в свойстве TransferPreferences , не выполнены. Например, WaitingForWiFi устанавливается, когда передача ожидает подключения телефона к сети Wi-Fi.
  • TransferProgressChanged запускается при изменении хода выполнения передачи, что означает, что новые данные были загружены или загружены. Обычно этот обработчик событий подключается к ProgressBar управления ProgressBar поскольку он предоставляет свойства для уведомления о том, сколько данных было передано и сколько данных еще необходимо загрузить или отправить.

После того, как вы определили фоновую передачу, вам нужно добавить ее в очередь операционной системы. Windows Phone позаботится о его запуске, когда указанные условия будут выполнены. Для выполнения этой задачи мы используем класс BackgroundTransferService , который является центральным диспетчером фоновой передачи. Вы можете добавлять, удалять или перечислять фоновые переводы, которые принадлежат приложению.

В следующем примере вы можете увидеть определение переноса фона:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
private BackgroundTransferRequest backgroundRequest;
 
private void OnStartBackgroundDownloadClicked(object sender, 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(object sender, BackgroundTransferEventArgs e)
{
    if (backgroundRequest.TransferStatus == TransferStatus.Completed)
    {
        //Manage the downloaded file.
        BackgroundTransferService.Remove(backgroundRequest);
    }
}

Мы регистрируем этот перевод для выполнения независимо от доступного сетевого подключения и источника питания. Предыдущий пример связан с операцией загрузки, поэтому нам нужно определить исходный URI (файл для загрузки) и целевой URI (локальный путь хранения, где будет сохранен файл). В отличие от того, что мы видели с HttpClient , нам не нужно заботиться о процессе сохранения; файл будет автоматически загружен и сохранен в локальном хранилище, поскольку загрузка также может быть завершена, когда приложение приостановлено. URI источника и назначения передаются как параметры конструктора BackgroundTransferRequest .

Примечание. Фоновые передачи, которые используются для выполнения операций загрузки, всегда должны сохранять файл в пути Shared / Transfers в локальном хранилище, которое создается автоматически при установке приложения, в противном случае вы получите исключение. После завершения загрузки вы можете переместить файл в другое место, если это необходимо, но вы не можете запланировать фоновую передачу, которая пытается загрузить файл в другую папку.

Далее мы подписываемся на событие TransferStatusChanged . Если загрузка завершена, когда приложение находится на переднем плане, мы можем управлять загруженным файлом — например, если это изображение, мы можем отобразить его. Обратите внимание на операцию Remove() которую мы выполняем в классе BackgroundTransferService . Это действительно важно всегда выполнять эту задачу, потому что операционная система не будет автоматически удалять завершенные передачи из очереди приложения, и это может привести к непредвиденным проблемам, так как приложение не может запланировать более 25 передач.

Вместо этого, если вам нужно загрузить файл, вам нужно будет создать объект BackgroundTransferRequest другим способом. Вам все еще нужно определить два URI: источник (файл для загрузки) и место назначения (служба, которая может получить файл с помощью команды HTTP, заданной в свойстве Method ). Целевой URI можно передать в конструкторе BackgroundTransferRequest (как мы это делали ранее), но исходный URI необходимо установить в свойстве UploadLocation , как в следующем примере:

01
02
03
04
05
06
07
08
09
10
private void OnUploadFile()
{
    Uri destinationUrl = new Uri(«http://wp8test.azurewebsites.com/api/values», UriKind.Relative);
    Uri sourceUri = new Uri(«/Shared/Transfers/image.png», UriKind.Relative);
 
    BackgroundTransferRequest request = new BackgroundTransferRequest(destinationUrl);
    request.UploadLocation = sourceUri;
    request.Method = «POST»;
    BackgroundTransferService.Add(request);
}

Вывод

В этой статье мы увидели, как работать с одной из наиболее часто используемых функций смартфона: подключением к Интернету. Подробно мы узнали:

  • Даже если подключение к Интернету является обязательным для каждого устройства, мы должны знать, что иногда пользователи могут не иметь доступного подключения. Важно правильно проверить, подключен ли телефон к Интернету, прежде чем выполнять какие-либо операции в сети.
  • HttpClient — это новый класс, представленный в среде выполнения Windows, который помогает выполнять сетевые операции. Мы видели, как использовать его для загрузки и выгрузки файлов и взаимодействия со службами.
  • Загрузка и выгрузка файлов — обычная задача, но в настоящее время все больше и больше приложений вынуждены взаимодействовать с веб-службами для получения необходимых данных. В этой статье мы узнали, как благодаря библиотеке JSON.NET легко работать со службами REST и преобразовывать данные JSON в объекты C #.
  • HttpClient — отличная помощь, но он работает, только если приложение находится на переднем плане. Когда он приостановлен, сетевые операции отменяются. Для этого платформа предлагает некоторые специальные API для выполнения операций загрузки и выгрузки даже в фоновом режиме, когда приложение не используется.

Это руководство представляет собой главу из Windows Phone 8 Succinctly , бесплатной электронной книги от команды Syncfusion.

33
Share: