Programming MapPoint

How to find a place/address using MapPoint?

2010-12-27T12:34:00.000-08:00

When you think of mapping in general, the first thing that comes to mind is finding a location and their associated latitude/longitude - whether it is a place (as in a point of interest) or an address. A place is a general location that is referred by its commonly known name; on the other hand the address is a more detailed specification of a location. For example, one of the most known places in Seattle around the world is “Space Needle”, but the actual address of the Space Needle is 498 Broad St, Seattle, WA 98109.

Using MapPoint you can find both places and addresses among other things.

The code snippet below shows how to find a place:

//Create an instance of ApplicationClass
MapPoint.ApplicationClass app = new MapPoint.ApplicationClass();
//Get a reference to the Map instance via the ActiveMap property
MapPoint.Map map = app.ActiveMap;

The MapClass exposes a method, FindPlaceResults, which returns all places that matches the input query. This method takes place name as string as an input and returns FindResults, which is a collection of locations found. The following code shows the FindPlaceResults method call:

//Call FindPlaceResults on the MapClass instance
MapPoint.FindResults findResults = map.FindPlaceResults(“Space Needle”);

Similarly, you can find addresses using the FindAddressResults method, as shown below:

//Create an instance of the MapPoint application class
MapPoint.ApplicationClass app = new MapPoint.ApplicationClass();
//Get the Map object from the application object
MapPoint.Map map = app.ActiveMap;
//Call the FindAddressResults method
MapPoint.FindResults findResults = map.FindAddressResults(
"498 Broad St",
"Seattle",
string.Empty,
"WA",
"98109",
MapPoint.GeoCountry.geoCountryUnitedStates);

Finally, if you don’t know if an input is a place (POI) or an address, use FindResults method, as shown below:

//Works with finding addresses
MapPoint.FindResults findAddressResults
= map.FindResults("498 Broad St, Seattle, WA, 98109");
//Works with finding places
MapPoint.FindResults findPlaceResults
= map.FindResults("Space Needle");

Now you just have to iterate through find results to get the location information in each case.

How to access FindResult collection members from a Find call?

2010-12-27T12:33:00.000-08:00

Find method calls (both FindPlaceResults and FindAddressResults) in MapPoint returns the FindResults instance that contains all the locations that matched the input query. Each location that matched the input place is represented as an instance of MapPoint.Location class in the FindResults object. Even though the FindResults class is essentially a collection of Location objects, its behavior is quite different (blame the COM legacy) from any .NET collection in that you can’t really access the members of the collection with their index as you would in a generic .NET collection.

Having said that you can still access the collection members in the following ways:

Using the Get accessor method

Collections are implemented using two special accessor methods called get_Item and set_Item. These special methods are generated by the .NET compiler for every publicly exposed property. In case of FindResults instance, even though the Items read-only property is not exposed in the interoperable assembly, get_Item method is still implemented internally. The only differences from the conventional .NET get_Item method are that this method takes the index value as an object passed by reference (for COM marshalling purposes) and the index starts from 1 instead of 0.
The following code shows how to use the get_Item accessor method to iterate through the list of Location objects in the FindResults collection:

//Create an object to hold index value
object index = null;
//Start with index 1 instead of 0
for(int i=1; i<=findResults.Count; i++){ //Box the integer value as an object index = i; //Pass the index as a reference to the get_Item accessor method MapPoint.Location loc = findResults.get_Item(ref index) as MapPoint.Location; if(loc != null) //do something intersting}

Using an enumerator

You can also access the list of Locations from FindResults instance using the enumeration. The FindResults instance exposes a method, GetEnumerator, to get an enumerated list of locations. Using this enumerator instance, you can loop through the list of locations as shown below:

//Get an enumerator using the GetEnumerator method
IEnumerator locationEnumerator = findResults.GetEnumerator();
//Loop through the location instances to get the names
while(locationEnumerator.MoveNext())
{
MapPoint.Location loc = locationEnumerator.Current as MapPoint.Location;
//do something interesting
}

How to find nearby points of interest (POI) using MapPoint?

2010-12-27T12:32:00.001-08:00

Location class from MapPoint object model exposes the FindNearby method to find POI around a location. The only parameter that the FindNearby method takes is distance as type System.Double.

The distance must be greater than zero and less than or equal to 50 miles. The default unit of measurement for distance is in Miles. Code snippet shown below is a good example of how to use that method:

//Call the find nearby on the current location
MapPoint.FindResults poiResults = location.FindNearby(distance);

As you can see the result is again a FindResults class that encapsulates a collection of locations. You can get the details of the location including the POI category (such as a restaurant or a gas station etc) using the PlaceCategory.

The PlaceCategory class encapsulates a category name and is exposed as PlaceCategory property from the Location class.

How to parse an address using MapPoint?

2010-12-27T12:31:00.001-08:00

Map class has a method, ParseStreetAddress that parses a string into a valid street address represented as the StreetAddress class. The StreetAddress class has the Street, City, OtherCity, PostalCode, Region and Country properties that represent various parts of an address. The Value property of the StreetAddress class gives the full address as one string.

The following code shows how to parse a string into a valid address:

//Create an instance of the MapPoint application class
MapPoint.ApplicationClass app = new MapPoint.ApplicationClass();
//Get the Map object from the application object
MapPoint.Map map = app.ActiveMap;
//Parse the address
MapPoint.StreetAddress address =
map.ParseStreetAddress("498 Broad St, Seattle, WA, 98109");

//Now get the values from the
//StreetAddress properties
string streetName = address.Street;
string city = address.City;

How to calculate distance between two locations using MapPoint?

2010-12-27T12:30:00.002-08:00

The Location class has the DistanceTo method that calculates the distance to a given location. Keep in mind that the distance calculated using this method is not the same as the driving distance; this method only gives you an along-the-straight-line-distance (or “as the crow flies”) between the two locations.

The DistanceTo method takes another location as an argument; the following code shows how to calculate distance between two locations:

//Get the from location
MapPoint.Location fromLocation
= this.findResults.get_Item(ref fromIndex) as MapPoint.Location;
//Get the to location
MapPoint.Location toLocation
= poiResults.get_Item(ref poiIndex) as MapPoint.Location;
//Calculate the distance between the from location and
//to location using the DistanceTo method
double distance = fromLocation.DistanceTo(toLocation);

Another way of calculating the distance between two locations is to call the Distance method on active Map object as shown below:

double distance = app.ActiveMap.Distance(startLocation, endLocation);

Both startLocation and endLocation are of MapPoint.Location type objects.

How to display a map using MapPoint?

2010-12-27T12:30:00.000-08:00

You can build visual Map based applications in Windows environment using MapPoint ActiveX Control. When you drag and drop the MapPoint control on to your Windows form, the reference to the MapPoint interoperable assembly is automatically added to your project along with the control.

The drag and drop operation also creates and adds an instance of MapPoint control to your code file, as shown below:

private AxMapPoint.AxMappointControl axMappointControl1;

Before you use the AxMappointControl, you need to initialize the control by creating new map coverage. You do this by calling the NewMap method on the AxMappointControl class. This method takes the map region of type GeoMapRegion enumeration as an argument. There are two valid region values for the map region in MapPoint: GeoMapRegion.geoMapNorthAmerica for North American maps and GeoMapRegion.geoMapEurope for European maps.

The following code shows initializing the control to show the North American map:

axMappointControl1.NewMap(MapPoint.GeoMapRegion.geoMapNorthAmerica);

After initializing the map control, you can access the map object via the ActiveMap property, as shown below:

MapPoint.Map map = axMappointControl1.ActiveMap;

Once you have the map object, you can find and navigate to a specific location as shown below:

//Define a location instance
MapPoint.Location currentLocation = null;
//Get the current location from FindResults method
...
currentLocation = findResults.get_Item(ref index);

//Go to the current location on the map
currentLocation.GoTo();

Calling the GoTo method zooms in to the location with best possible view on the map and centers the map on that location.

How to add a pushpin (or a map marker) to the map using MapPoint?

2010-12-27T12:29:00.000-08:00

A pushpin in MapPoint is represented by the Pushpin class. The Name property of a Pushpin object can be used to annotate the Pushpin. You can also add notes to the Pushpin using the Pushpin.Notes property.

A Pushpin is essentially symbol (icon) on the map; MapPoint provides a number of symbols to be used with Pushpins. These symbols are indexed and their number should be used to indicate the symbol of a given Pushpin; For example the default symbol is black pushpin represented by the number 0. The valid range for the standard symbols is 0-255.

To add a pushpin to a location, you just have to call the Map.AddPushpin method, as shown below:

//Get map center location
MapPoint.Location location = axMappointControl1.ActiveMap.Location;
//Add a pushpin at this location
MapPoint.Pushpin pushpin = axMappointControl1.ActiveMap.AddPushpin(
location, "Center");
//Assign a symbol
pushpin.Symbol = 64;
//Select and highlight the location
pushpin.Select();
pushpin.Highlight = true;
//Write annotation
pushpin.Note = "This is my favorite place!";

Now if you want to open the “info window” for the pushpin, you can use the Pushpin.BallonState enumeration.

How to pan a MapPoint Map?

2010-12-27T12:28:00.000-08:00

The MapPoint ActiveX Control provides you with a fully interactive map to perform actions such as panning, zooming and tracking mouse clicks and so on.

To pan a map you would use Map.Pan method. This method takes two arguments:
1. PanDirection: Indicates the direction of the pan operation; this property is of type MapPoint.GeoPanCmd enumeration. This enumeration contains values that represent directional values such as east, west, north, south, north-east and so on.
2. PanFactor: Indicates amount of pan. Even though there are no limits to the pan factor, you have to keep in mind that this value is dependent on the altitude of your map. To give you an idea of what I mean, at 1 mile (lower altitudes), a pan factor of 1 pans the map by 0.2 miles, but the same pan factor at 50 miles (a higher altitude) pans the map by 10 miles!

The following code shows how to call the Pan method:

axMappointControl1.ActiveMap.Pan(MapPoint.GeoPanCmd.geoWest, 1);

How to zoom in and zoom out a MapPoint Map?

2010-12-27T12:27:00.001-08:00

MapPoint ActiveX Control offers two methods to perform zoom operations on the maps.

1.ZoomIn method – This method zooms the map view closer by reducing the map altitude
2.ZoomOut method – This methods zooms the map view farther by increasing the map altitude

These two methods zoom in/out in steps. There are ten levels of zoom effect that you can achieve using these two methods. The levels are defined based on the map altitude and each time when you call zoom methods, map’s altitude is modified accordingly and re-rendered to show the map at that altitude.
The following code shows how to call a ZoomIn method:

axMappointControl1.ActiveMap.ZoomIn();

Now, if you want to zoom into a particular level from your current view, say, you want to zoom to street level directly without calling ZoomIn method multiple times, you can do that by modifying the map altitude, as shown below:

//Zoom directly into Street Level by setting 3 mile altitude
axMappointControl1.ActiveMap.Altitude = 3;

How to convert a location/point to X/Y coordinates using MapPoint?

2010-12-27T12:26:00.001-08:00

If you want to process user’s interaction with maps in MapPoint ActiveX Control, you need to know when and where a mouse is clicked to obtain the location corresponding to a mouse click.
The Map object provides a way to convert a location on the map to a point on the screen. By using Map object’s LocationToX and LocationToY methods, you can obtain X and Y coordinates for any given location.

You need to make separate calls for each X and Y coordinate for any given location, as shown below:

//Get the center of the map
MapPoint.Location location = axMappointControl1.ActiveMap.Location;
//Get x and y coordinates
int x = axMappointControl1.ActiveMap.LocationToX(location);
int y = axMappointControl1.ActiveMap.LocationToY(location);
//Display the center coordinates
MessageBox.Show(String.Format("Map is centered at ({0}, {1})",
x.ToString(), y.ToString()));

Keep in mind that the LocationToX and LocationToY methods assume that a particular location is on the current map screen limits; if the location is not present in the ActiveX Control map screen limits, these methods fail. To avoid errors in a case like this, it’s always a good idea to use Location.GoTo() method before getting the coordinates.

How to obtain location for the X/Y coordinates using MapPoint?

2010-12-27T12:25:00.001-08:00

If you want to process user’s interaction with maps in MapPoint ActiveX Control, you need to know when and where a mouse is clicked to obtain the location corresponding to a mouse click.
Map object exposes the XYToLocation method to obtain a location at a given point on the map view on the screen. This method takes X and Y screen coordinates and returns the location corresponding to that point. So, in order to use this method you need to trap the mouse click and capture the X and Y coordinates.

You can do that using the Map object’s BeforeClick event. This event occurs when a user clicks on the map but before MapPoint ActiveX Control actually processes that mouse click. You would have to wire-up this event in the InitializeComponent method of your application, as shown below:

axMappointControl1.BeforeClick +=
new AxMapPoint._IMappointCtrlEvents_BeforeClickEventHandler(
axMappointControl1_BeforeClick);

Once you have wired up the event, the axMapPointControl1_BeforeClick method should be implemented so that you capture the mouse click coordinates, as shown below:

private void axMappointControl1_BeforeClick(object sender,
AxMapPoint._IMappointCtrlEvents_BeforeClickEvent e)
{
int XCoord = e.x;
int YCoord = e.y;
MapPoint.Location location =
axMappointControl1.ActiveMap.XYToLocation(XCoord, YCoord);
if(location != null)
{
//Do some processing with location
. . .
}
}

This event captures only single clicks from the mouse; if you want to capture double clicks from your mouse, you have to wire-up BeforeDblClick event. BeforeDlbClick event occurs when a user double-clicks on the map but before MapPoint ActiveX Control actually processes that double click.

How to disable Map interaction in MapPoint?

2010-12-27T12:24:00.001-08:00

Let’s say that you wanted a “static” map for your application – then you need to disable the map for user interaction; unfortunately, there is no straight forward way of doing it rather than disabling all events by overriding them.

Here are all the events that you need to take care of:

1. Turn-off the edge panning by setting the AllowEdgePan to false, as shown below:

2. Mouse down event – Need to capture any mouse down event and display a message saying this is a read only Map.

3. Pan and Zoom via Mouse wheel and Arrow keys – You can take care of this action by overriding the AfterViewChange event by restoring the original center of the map and altitude.
The AfterViewChange event handler restores both map center and altitude; this method takes care of both pan clicks and zoom (via the mouse wheel scroll); but keep in mind that performance may be affected by the mouse wheel scroll events.

How to avoid Memory Leaks in MapPoint Programming?

2010-12-27T12:23:00.001-08:00

MapPoint object model is originally designed and implemented using COM technologies. So, even if you write your code in managed using the COM Interoperable assemblies, the MapPoint Application instance will not be collected by the .NET runtime garbage collector.

So, in order to avoid memory leaks, before quitting your application, you have to manually make sure to quit the MapPoint Application by calling the Quit method on the MapPoint.Application object, as shown below:

//Define MapPoint Application instance
MapPoint.Application app = null;
//Obtain app references either via MapPoint.ApplicationClass or
//MapPoint.AxMapPointControl.ActiveMap.Application
. . .

//Clean up the MapPoint Application before you exit
if(app != null)
{
app.Quit();
app = null;
}

The Quit method discards the current map and unloads all other items such as add-ins etc before exiting the application. However, calling this method prompts the user whether they want to save the map before discarding it. If you don’t want this behavior you can set the Saved property to true on the application’s active Map object, as shown below:

app.ActiveMap.Saved = true;

Setting this value does not prompt the user to make a decision to save or discard the current map.

How to get Location from latitude/longitude in MapPoint?

2010-12-27T12:22:00.001-08:00

Using the Map class GetLocation method, you can easily find a location that corresponds to a given latitude and longitude. This method takes latitude and longitude as System.Double values and returns a Location instance that represents the input latitude and longitude. This method also takes the altitude as an argument, but it is mainly used at the time when the location is displayed on a map, so, you can freely pass 1 mile for the time being.

The following code shows how to find a location using latitude and longitude:

//Get the reference to the active map instance
MapPoint.Map map = app.ActiveMap;
//Call the GetLocation method to find location
//using the latitude and longitude
MapPoint.Location location =
m.GetLocation(41.33896, -122.43433, 1);

Hit-Detection in MapPoint

2010-12-27T12:21:00.001-08:00

Hit-Detection is one of the coolest features of MapPoint API. The Map object in MapPoint has the method, ObjectsFromPoint, which allows you to perform a hit-detenction around any given point (x and y coordinates) on the screen. What it means is that this method returns an array of “objects” wrapped in a FindResults instance. For example, if you call this method at lower altitudes, it returns locations with street addresses, if you go to higher altitudes and call this method, it returns larger geographic areas such as postal code, county, time-zone of the point and so on.
The following snippet shows how to call the ObjectsFromPoint method for any given Location:

//Get Location from latitude and longitude
MapPoint.Location location =
app.ActiveMap.GetLocation(mylatitude, mylongitude, altitude);

/Now use the Map.ObjectsFromPoint method to get points from the
//above location
MapPoint.FindResults findresults =
app.ActiveMap.ObjectsFromPoint(
app.ActiveMap.LocationToX(location),
app.ActiveMap.LocationToY(location));

The ObjectsFromPoint method, or hit-detection, is very versatile and can be used for many purposes such as querying for address of a given location, determining time-zone, querying a territory and so on.

How to determine a time-zone for a given location using MapPoint?

2010-12-27T12:20:00.000-08:00

Determining time-zone for any given location can be done using the ObjectsFromPoint (or so called Hit-Detection) method. When this method is called at lower altitudes (usually around 2-3 miles), it returns the time-zone as one of the FindResults objects. Using this technique you can check if the FindResults contains a time-zone or not by looking for the string “GMT” in the name of the each found result, as shown below:

string place = "San Francisco, CA";
//Find the locatoin first
MapPoint.FindResults findResults
= axMappointControl1.ActiveMap.FindResults(place);
if(findResults != null && findResults.Count > 0)
{
object index = 1;
MapPoint.Location location =
findResults.get_Item(ref index) as MapPoint.Location;
//Zoom into it
location.GoTo();
//Set low altitudes
axMappointControl1.ActiveMap.Altitude = 2;
//Now get points from the location
MapPoint.FindResults points
= axMappointControl1.ActiveMap.ObjectsFromPoint(
axMappointControl1.ActiveMap.LocationToX(location),
axMappointControl1.ActiveMap.LocationToY(location));
if(points != null && points.Count > 0)
{
for(int i=1;i<=points.Count;i++) { object index2 = i; //Get location MapPoint.Location loc = points.get_Item(ref index2) as MapPoint.Location; //Look for GMT in the name of the location if(loc.Name.IndexOf("GMT") > 0)
{
MessageBox.Show(loc.Name);
break;
}
}
}

That’s it!

How to determine street address for a given latitude/longitude using MapPoint?

2010-12-27T12:19:00.000-08:00

One of the limitations of the GetLocation method is that you cannot always get the address of a given set of latitude and longitude. The work-around for this limitation is to use the hit-detection technique around the given latitude and longitude.

There are a couple of ways to do the hit-detection:

1.Panning around at the same altitude to see if we find a street addresses
2.Zooming in and out trying find locations with street addresses
3.Route to a known place (such as a POI or Point of Interest or Address) and the found location automatically snaps to a nearest street.

In my book I have discussed a very efficient way in detail to detect street-address that minimizes the accuracy errors as well as optimizes for the performance.

Routing using MapPoint

2010-12-27T12:15:00.000-08:00

MapPoint provides a simple but extensive API to calculate routes using locations. Route in MapPoint is represented as a MapPoint.Route object. You can access a Route object via the ActuveRoute property of a Map object as shown below:

MapPoint.Route route = axMappointControl1.ActiveMap.ActiveRoute;

After obtaining valid route object, you can perform actions such as calculating routes, optimizing routes and personalizing routes and so on. Under the hood, a route is essentially a collection of locations that are connected via some kind of a street or ferry or a highway. These locations in a route are known as waypoints and represented using the MapPoint.Waypoint class. A valid route always contains two or more waypoints. Waypoints in a route are represented as the Route.Waypoints collection. So you use the Waypoints collection to add new waypoints as shown below:

//Get hold of route object
MapPoint.Route route = axMappointControl1.ActiveMap.ActiveRoute;
//Add the location to the ActiveRoute
route.Waypoints.Add(loc, loc.Name);

You can use the MapPoint.Waypoint object in many ways to specify a route or even modify an existing route. If you want to change the location that is represented by a Waypoint object, you need to use the Waypoint.Anchor property. This property is of type object due to the reason that it can be a Location or Pushpin. So, if you are assigning a new location to a waypoint, you can do it as shown below:

//Obtain a waypoint from a given route
object index = 1;
MapPoint.Waypoint waypoint = route.Waypoints.get_Item(ref index);
//Assign a new location
waypoint.Anchor = newlocation;

You may also have noticed that a Waypoint object also exposes the Location property, which returns the Location object that it corresponds to; however, keep in mind that this property is a read-only property and you cannot change the location using this property.
Using the Waypoint object’s SegmentPreferences property, you can set the segment preference indicating if you prefer a shorter route or a quicker route and so on.

This is really useful if you have preferences for a segment in a route. This property is of type MapPoint.GeoSegmentPreferences enumeration which has the following values:

1.geoSegmentQuickest – This option let’s you calculate a route based on the quickest route available between two locations.
2.geoSegmentShortest – This option lets you calculate a route based on shortest distance between two locations
3.geoSegmentPreferred – This option lets you calculate a route based on the route preferences set using the DriverProfile object at the Route object level (which we will discuss shortly).

The default value is always geoSegmentQuickest and you can set a different value as shown below:

object index = 2;
MapPoint.Waypoint waypoint = route.Waypoints.get_Item(ref index);
waypoint.SegmentPreferences = MapPoint.GeoSegmentPreferences.geoSegmentQuickest;

Actually, there is one last thing that you need to understand about waypoints and SegementPreferences; a waypoint represents only one location; but a route segment represents two locations. So what happens if you set two different segment preferences for each location in a single segment? The answer is that the waypoint (location) that is at the beginning of the segment always decides the segment’s route preference.
Waypoints are categorized into three types:

1.Start point
2.End point
3.Intermediate stop

You can access this information for a given Waypoint object using the Type property. This property is of MapPoint.GeoWayPointType enumeration. This property is useful in determining the type of a waypoint in analyzing a route or processing the driving directions.

You can set a Waypoint’s preferred arrival and departure times using the PreferredArrival and PreferredDeparture properties respectively; MapPoint uses this information while calculating the driving directions to adjust the itinerary. Finally you can specify stop time using the StopTime property. This property is of type double and takes value expressed in hours as a fraction of day (24 hours).

How to optimize a route using MapPoint

2010-12-27T12:12:00.001-08:00

You can optimize a route if it has more than one way points as intermediate stops. Optimization of a route is useful if you want to order waypoints (of type intermediate stops) so that the total distance you drive in a route is minimized. You can optimize a route by calling the Optimize method on the waypoints collection, as shown below:

//Optimize the route
route.Waypoints.Optimize();

Note that Optimize method does not alter the start and end points; it only re-orders the intermediate stops. If you do not have more than two waypoints, calling this method does not have effect on the waypoint order.

You can find out if a waypoints collection is optimized or not by using WayPoints.IsOptimized property. When the Optimize method is called and a route is successfully optimized, the RouteAfterOptimize event is fired; the following code shows how to wire-up this event:

this.axMappointControl1.RouteAfterOptimize
+=new AxMapPoint._IMappointCtrlEvents_RouteAfterOptimizeEventHandler(
axMappointControl1_RouteAfterOptimize);

The following code shows how a simple implementation of this event handler:

private void axMappointControl1_RouteAfterOptimize(object sender,
AxMapPoint._IMappointCtrlEvents_RouteAfterOptimizeEvent e)
{
//Now display the waypoints in correct order
DisplayCorrectRouteOrder(e.pRoute);
}

You can use this event to record the new order of the waypoints or display the new order of the waypoints.

Remember though, that calling the Optimize method does not calculate driving directions, it only re-orders the intermediate stop waypoints. So in order to get the driving directions, you need to calculate the route as a separate step.

How to calculate driving directions using MapPoint?

2010-12-27T12:10:00.000-08:00

You can calculate a route for a given set of waypoints using the Route object’s Calculate method, as shown below:

//Calculate the route
route.Calculate();

When you call this method you need to make sure you have at least two waypoints added to the route object; otherwise an exception is thrown. It is also important to note that this method also throws an exception when two waypoints are not connected by any routable means. When this method is successfully completed, the RouteAfterCalculate event is fired; you can use this event in several ways such as displaying driving directions and storing route cost into a database and so on. The following code shows how to wire up the RouteAfterCalculate event:

this.axMappointControl1.RouteAfterCalculate+=
new AxMapPoint._IMappointCtrlEvents_RouteAfterCalculateEventHandler(
axMappointControl1_RouteAfterCalculate);

And the following code snippet shows a sample implementation of the event handler method:

private void axMappointControl1_RouteAfterCalculate(object sender,
AxMapPoint._IMappointCtrlEvents_RouteAfterCalculateEvent e)
{
//Display diriving directions
DisplayDrivingDirections(e.pRoute);
}

Now, after calculating driving directions, you can get the detailed instructions from the directions using the route object’s Directions property, as shown below:

foreach(MapPoint.Direction direction in route.Directions)
{
. . .
}

The Directions property is a collection of Direction objects. The Direction class several properties such as driving instructions, starting time, distance and so on. Along with all these properties, the Direction object also provides the FindNearby method to find nearby points of interests; since a direction object connects two locations, this FindNearby works as a “find along route” instead of a FindNearby around a specific point. This method is useful in route planning tasks such as “where to stop for gas & food along a route” scenarios.