Windows Phone 8 : Services - The Network Stack

The network stack on the phone enables you to access network (for example, Internet) resources. The phone dictates that all network calls must be performed asynchronously. This is to ensure that an errant network call does not tie up the user interface (or more importantly, make the phone think your application has locked up or crashed). If you are new to asynchronous programming, this will be a good place to start learning.

One class that follows this pattern is the WebClient class. It is a simple way to make a basic web request on the phone, as shown here:

public partial class MainPage : PhoneApplicationPage
{
  // Constructor
  public MainPage()
  {
    InitializeComponent();

    // Create the client
    WebClient client = new WebClient();

    // Handle the event
    client.DownloadStringCompleted += client_DownloadStringCompleted;

    // Start the execution
    client.DownloadStringAsync(new Uri("http://wildermuth.com/rss"));
  }
}

In this example the WebClient class is created, the DownloadStringCompleted event is wired up, and the DownloadStringAsync method is called to start the download. When the download is complete, the event is fired like so:

void client_DownloadStringCompleted(object sender,
                                    DownloadStringCompletedEventArgs
e)
{
  // Make sure the process completed successfully
  if (e.Error == null)
  {
    // Use the result
    string rssFeed = e.Result;
  }
}

In the event argument, you are passed any exception that is thrown when the download is being attempted. This is returned to you as the Error property. In the preceding code, the error is null, which means no error occurred and the Result property will be filled with the result of the network call. Because of this pattern, you have to get used to the process of performing these types of operations asynchronously. Although still asynchronous, you can simplify the pattern a little by using a lambda for the event handler:

// Create the client
WebClient client = new WebClient();

// Handle the event
client.DownloadStringCompleted += (s, e) =>
  {
    // Make sure the process completed successfully
    if (e.Error == null)
    {
      // Use the result
      string rssFeed = e.Result;
    }
  };

// Start the execution
client.DownloadStringAsync(new Uri("http://wildermuth.com/rss"));

In this case, you’re writing the handling of the completed event as an inline block of code, which makes the process feel more linear.

The WebClient class is the starting point for most simple network calls. The class matches up an “Async” method and a “Completed” event for several types of operations, including the following:

• DownloadString: This downloads a text result and returns a string.

• OpenRead: This downloads a binary stream and returns a Stream object.

• UploadString: This writes text to a server.

• OpenWrite: This writes a binary stream to a server.

The code for using these other types of calls looks surprisingly similar. To download a binary stream (for example, any nontext object, such as an image), use this code:

// Create the client
WebClient client = new WebClient();

// Handle the event
client.OpenReadCompleted += (s, e) =>
  {
    // Make sure the process completed successfully
    if (e.Error == null)
    {
      // Use the result
      Stream image = e.Result;
    }
  };

// Start the execution
client.OpenReadAsync(new
Uri("http://wildermuth.com/images/headshot.jpg"));

Although the pattern is the same, the event and method names have changed and the result is now a stream instead of a string.

The DeviceNetworkInformation class supports a number of static properties that will give you information about the phone’s network, including

• IsNetworkAvailable: This is a Boolean value that indicates whether any network is currently available.

• IsCellularDataEnabled: This is a Boolean value that indicates whether the phone has enabled cellular data (as opposed to Wi-Fi data).

• IsCellularDataRoamingEnabled: This is a Boolean value that indicates whether the phone has enabled data roaming.

• IsWifiEnabled: This is a Boolean value that indicates whether the phone has enabled Wi-Fi on the device.

• CellularMobileOperator: This returns a string that contains the name of the mobile operator.

You can use this class to determine whether an active network connection is available:

if (DeviceNetworkInformation.IsNetworkAvailable)
{
  status.Text = "Network Found";
}
else
{
  status.Text = "Network not Found";
}

You can also access an event that indicates that the network information has changed:

public partial class MainPage : PhoneApplicationPage
{
  // Constructor
  public MainPage()
  {
    InitializeComponent();

    DeviceNetworkInformation.NetworkAvailabilityChanged +=
      DeviceNetworkInformation_NetworkAvailabilityChanged;
  }

  void DeviceNetworkInformation_NetworkAvailabilityChanged(
    object sender, NetworkNotificationEventArgs e)
  {
    switch (e.NotificationType)
    {
      case NetworkNotificationType.InterfaceConnected:
        status.Text = "Network Available";
        break;
      case NetworkNotificationType.InterfaceDisconnected:
        status.Text = "Network Not Available";
        break;
      case NetworkNotificationType.CharacteristicUpdate:
        status.Text = "Network Configuration Changed";
        break;
    }
  }
  // ...
}

The DeviceNetworkInformation class’s NetworkAvailabilityChanged event fires whenever the network changes. This example shows that you can access the NotificationType from the NetworkNotificationEventArgs class to see whether a network connection was just connected, disconnected, or just changed its configuration. In addition, this event passes in the network type:

public partial class MainPage : PhoneApplicationPage
{
  // Constructor
  public MainPage()
  {
    InitializeComponent();

    DeviceNetworkInformation.NetworkAvailabilityChanged +=
      DeviceNetworkInformation_NetworkAvailabilityChanged;
  }

  void DeviceNetworkInformation_NetworkAvailabilityChanged(
    object sender, NetworkNotificationEventArgs e)
  {
    switch (e.NetworkInterface.InterfaceSubtype)
    {
      case NetworkInterfaceSubType.Cellular_1XRTT:
      case NetworkInterfaceSubType.Cellular_EDGE:
      case NetworkInterfaceSubType.Cellular_GPRS:
        status.Text = "Cellular (2.5G)";
        break;
      case NetworkInterfaceSubType.Cellular_3G:
      case NetworkInterfaceSubType.Cellular_EVDO:
      case NetworkInterfaceSubType.Cellular_EVDV:
        status.Text = "Cellular (3G)";
        break;
      case NetworkInterfaceSubType.Cellular_HSPA:
        status.Text = "Cellular (3.5G)";
        break;
      case NetworkInterfaceSubType.WiFi:
        status.Text = "WiFi";
        break;
      case NetworkInterfaceSubType.LTE:
        status.Text = "LTE";
        break;
      case NetworkInterfaceSubType.Desktop_PassThru:
        status.Text = "Desktop Connection";
        break;
    }
  }
  // ...
}

By using the NetworkInterfaceInfo class’s NetworkInterfaceSubType enumeration, you can determine the exact type of network connection on the phone. The NetworkInterfaceInfo class also gives you access to several other useful properties, including the following:

• Bandwidth: This is an integer that specifies the speed of the network interface.

• Characteristics: This is an enumeration that specifies whether the phone is currently roaming.

• Description: This is a description of the network interface.

• InterfaceName: This is the name of the network interface.

• InterfaceState: This states whether the network interface is connected or disconnected.

By using this DeviceNetworkInformation class, you can have access to much of the network information you will need for your application.