How to: Implement a Route Calculator Using GIS Providers

• Jun 07, 2019
• 5 minutes to read

This example demonstrates how to create a calculating routes application using GIS services.

Follow the steps below.

• Add an ImageTilesLayer object to the MapControl.Layers collection and assign an instance of the BingMapDataProvider class to the ImageLayer.DataProvider property. Specify the valid Bing key using the BingMapDataProvider.BingKey property.
• Add a VectorLayer object to the MapControl.Layers collection and assign a MapItemStorage object to the VectorLayer.Data property.
• Add an InformationLayer object to the MapControl.Layers collection and assign an instance of the BingSearchDataProvider to the InformationLayer.DataProvider property. Create a handler of the BingSearchDataProvider.SearchCompleted event. Specify the valid Bing key using the BingMapDataProviderBase.BingKey property.
• Add an InformationLayer object to the MapControl.Layers collection and assign an instance of the BingGeocodeDataProvider to the InformationLayer.DataProvider property. Create a handler of the BingGeocodeDataProvider.LocationInformationReceived event. Specify the valid Bing key using the BingMapDataProviderBase.BingKey property.
• Add an InformationLayer object to the MapControl.Layers collection and assign an instance of the BingRouteDataProvider to the InformationLayer.DataProvider property. Create a handler of the BingRouteDataProvider.RouteCalculated event. Specify the valid Bing key using the BingMapDataProviderBase.BingKey property.

• For each information layer data provider set the InformationDataProviderBase.GenerateLayerItems property value to False.

  The following XAML demonstrates this in code.

  MainWindow.xaml

  <dxm:MapControl>
      <dxm:ImageTilesLayer>
          <dxm:ImageTilesLayer.DataProvider>
              <dxm:BingMapDataProvider BingKey="{Binding Source={StaticResource bingKey}}"/>
          </dxm:ImageTilesLayer.DataProvider>
      </dxm:ImageTilesLayer>
      <dxm:VectorLayer EnableSelection="False" EnableHighlighting="False">
          <dxm:MapItemStorage x:Name="storage"/>
      </dxm:VectorLayer>
      <dxm:InformationLayer>
          <dxm:InformationLayer.DataProvider>
              <dxm:BingSearchDataProvider BingKey="{Binding Source={StaticResource bingKey}}"
                                          GenerateLayerItems="False"
                                          SearchCompleted="SearchCompleted"/>
          </dxm:InformationLayer.DataProvider>
      </dxm:InformationLayer>
      <dxm:InformationLayer>
          <dxm:InformationLayer.DataProvider>
              <dxm:BingGeocodeDataProvider BingKey="{Binding Source={StaticResource bingKey}}"
                                           GenerateLayerItems="False"
                                           LocationInformationReceived="LocationInformationReceived"/>
          </dxm:InformationLayer.DataProvider>
      </dxm:InformationLayer>
      <dxm:InformationLayer>
          <dxm:InformationLayer.DataProvider>
              <dxm:BingRouteDataProvider x:Name="routeProvider" 
                                         BingKey="{Binding Source={StaticResource bingKey}}"
                                         GenerateLayerItems="False"
                                         RouteCalculated="RouteCalculated"/>
          </dxm:InformationLayer.DataProvider>
      </dxm:InformationLayer>
  </dxm:MapControl>
  

• Create a helper class, which allows you to convert MapPushpin objects to RouteWaypoint and store the route using a MapPolyline object. Create a private member of this class in the MainWindow class.

  MainWindow.xaml.cs

  class RoutingHelper {
      List<MapPushpin> pushpins = new List<MapPushpin>();
      MapPolyline route = new MapPolyline() {
          Stroke = new SolidColorBrush(Color.FromArgb(0xFF, 0x8A, 0xFB, 0xFF)),
          StrokeStyle = new StrokeStyle() { Thickness = 3 }
      };
      List<RouteWaypoint> waypoints = new List<RouteWaypoint>();
      char currentLatter = 'A';
  
      public List<MapPushpin> Pushpins { get { return pushpins; } }
      public List<RouteWaypoint> Waypoints { get { return waypoints; } }
      public MapPolyline Route { get { return route; } set { route = value; } }
      public int Count { get { return pushpins.Count; } }
  
      public void BuildRoute(IEnumerable<GeoPoint> points) {
          route.Points.Clear();
          foreach (GeoPoint point in points)
              route.Points.Add(point);
      }
  
      public void AddItem(MapPushpin pushpin) {
          pushpins.Add(pushpin);
          waypoints.Add(new RouteWaypoint(
              ((LocationInformation)pushpin.Information).DisplayName,
              (GeoPoint)pushpin.Location)
          );
          pushpin.Text = (currentLatter++).ToString();
      }
  
      public void Clear() {
          route.Points.Clear();
          pushpins.Clear();
          waypoints.Clear();
          currentLatter = 'A';
      }
  }
  

  MainWindow.xaml.vb

  Friend Class RoutingHelper
  
      Private pushpins_Renamed As New List(Of MapPushpin)()
  
      Private route_Renamed As New MapPolyline() With { _
          .Stroke = New SolidColorBrush(Color.FromArgb(&HFF, &H8A, &HFB, &HFF)), .StrokeStyle = New StrokeStyle() With {.Thickness = 3} _
      }
  
      Private waypoints_Renamed As New List(Of RouteWaypoint)()
      Private currentLatter As Char = "A"c
  
      Public ReadOnly Property Pushpins() As List(Of MapPushpin)
          Get
              Return pushpins_Renamed
          End Get
      End Property
      Public ReadOnly Property Waypoints() As List(Of RouteWaypoint)
          Get
              Return waypoints_Renamed
          End Get
      End Property
      Public Property Route() As MapPolyline
          Get
              Return route_Renamed
          End Get
          Set(ByVal value As MapPolyline)
              route_Renamed = value
          End Set
      End Property
      Public ReadOnly Property Count() As Integer
          Get
              Return pushpins_Renamed.Count
          End Get
      End Property
  
      Public Sub BuildRoute(ByVal points As IEnumerable(Of GeoPoint))
          route_Renamed.Points.Clear()
          For Each point As GeoPoint In points
              route_Renamed.Points.Add(point)
          Next point
      End Sub
  
      Public Sub AddItem(ByVal pushpin As MapPushpin)
          pushpins_Renamed.Add(pushpin)
          waypoints_Renamed.Add(New RouteWaypoint(CType(pushpin.Information, LocationInformation).DisplayName, CType(pushpin.Location, GeoPoint)))
          pushpin.Text = (currentLatter).ToString()
          currentLatter = ChrW(AscW(currentLatter) + 1)
      End Sub
  
      Public Sub Clear()
          route_Renamed.Points.Clear()
          pushpins_Renamed.Clear()
          waypoints_Renamed.Clear()
          currentLatter = "A"c
      End Sub
  End Class
  

• Handle BingSearchDataProvider.SearchCompleted, BingGeocodeDataProvider.LocationInformationReceived and BingRouteDataProvider.RouteCalculated events. Also handle the MapPushpin.MouseLeftButtonDown event to add a location to waypoints.

  MainWindow.xaml.cs

  private void LocationInformationReceived(object sender, LocationInformationReceivedEventArgs e) {
      if ((e.Cancelled) && (e.Result.ResultCode != RequestResultCode.Success)) return;
      GenerateItems(e.Result.Locations);
  }
  
  private void SearchCompleted(object sender, BingSearchCompletedEventArgs e) {
      if (e.Cancelled || (e.RequestResult.ResultCode != RequestResultCode.Success)) return;
  
      if (e.RequestResult.SearchResults.Count != 0)
          GenerateItems(e.RequestResult.SearchResults);
      else
          GenerateItems(new LocationInformation[] { e.RequestResult.SearchRegion });
  }
  
  private void RouteCalculated(object sender, BingRouteCalculatedEventArgs e) {
      if (e.Cancelled) return;
  
      if (e.CalculationResult.ResultCode != RequestResultCode.Success) return;
      helper.BuildRoute(e.CalculationResult.RouteResults[0].RoutePath);
      UpdateStorage();
  }
  
  void GenerateItems(IEnumerable<LocationInformation> locations) {
      UpdateStorage();
      foreach (var location in locations) {
          MapPushpin pushpin = new MapPushpin() {
              Location = location.Location,
              Information = location
          };
          pushpin.MouseLeftButtonDown += pushpin_MouseLeftButtonDown;
          storage.Items.Add(pushpin);
      }
  }
  
  void UpdateStorage() {
      storage.Items.Clear();
      storage.Items.Add(helper.Route);
      foreach (MapPushpin pushpin in helper.Pushpins)
          storage.Items.Add(pushpin);
  }
  
  void pushpin_MouseLeftButtonDown(object sender, MouseButtonEventArgs e) {
      MapPushpin pushpin = sender as MapPushpin;
      if (pushpin == null) return;
      e.Handled = true;
      helper.AddItem(pushpin);
      routeProvider.CalculateRoute(helper.Waypoints);
      pushpin.MouseLeftButtonDown -= pushpin_MouseLeftButtonDown;
  }
  

  MainWindow.xaml.vb

  Private Sub LocationInformationReceived(ByVal sender As Object, ByVal e As LocationInformationReceivedEventArgs)
      If (e.Cancelled) AndAlso (e.Result.ResultCode <> RequestResultCode.Success) Then
          Return
      End If
      GenerateItems(e.Result.Locations)
  End Sub
  
  Private Sub SearchCompleted(ByVal sender As Object, ByVal e As BingSearchCompletedEventArgs)
      If e.Cancelled OrElse (e.RequestResult.ResultCode <> RequestResultCode.Success) Then
          Return
      End If
  
      If e.RequestResult.SearchResults.Count <> 0 Then
          GenerateItems(e.RequestResult.SearchResults)
      Else
          GenerateItems(New LocationInformation() { e.RequestResult.SearchRegion })
      End If
  End Sub
  
  Private Sub RouteCalculated(ByVal sender As Object, ByVal e As BingRouteCalculatedEventArgs)
      If e.Cancelled Then
          Return
      End If
  
      If e.CalculationResult.ResultCode <> RequestResultCode.Success Then
          Return
      End If
      helper.BuildRoute(e.CalculationResult.RouteResults(0).RoutePath)
      UpdateStorage()
  End Sub
  
  Private Sub GenerateItems(ByVal locations As IEnumerable(Of LocationInformation))
      UpdateStorage()
      For Each location In locations
          Dim pushpin As New MapPushpin() With {.Location = location.Location, .Information = location}
          AddHandler pushpin.MouseLeftButtonDown, AddressOf pushpin_MouseLeftButtonDown
          storage.Items.Add(pushpin)
      Next location
  End Sub
  
  Private Sub UpdateStorage()
      storage.Items.Clear()
      storage.Items.Add(helper.Route)
      For Each pushpin As MapPushpin In helper.Pushpins
          storage.Items.Add(pushpin)
      Next pushpin
  End Sub
  
  Private Sub pushpin_MouseLeftButtonDown(ByVal sender As Object, ByVal e As MouseButtonEventArgs)
      Dim pushpin As MapPushpin = TryCast(sender, MapPushpin)
      If pushpin Is Nothing Then
          Return
      End If
      e.Handled = True
      helper.AddItem(pushpin)
      routeProvider.CalculateRoute(helper.Waypoints)
      RemoveHandler pushpin.MouseLeftButtonDown, AddressOf pushpin_MouseLeftButtonDown
  End Sub
  

Note

If you run the application, and see a window with the following error message: ”The specified Bing Maps key is invalid. To create a developer account, refer to https://www.microsoft.com/en-us/maps/create-a-bing-maps-key”, refer to the following tutorial: How to: Get a Bing Maps Key.