Workflow: Create an app using a web map (ahead of time)

Simple offline mapping app

In this workflow, you will learn how to prepare a web map for offline use, define areas in the map for offline use, then use it to create a partially offline app. This is also known as the ahead-of-time method because you are defining the offline areas in the map ahead of time.

Prerequisites

You need an account for ArcGIS Online or ArcGIS Enterprise to host data for offline use and get an access token. If you need an account, go to Get started.

Steps

1. Prepare the map and data

Create a web map

To create a web map with the Map Viewer, start by setting the basemap layer. Use the Streets vector tile basemap layer.

  1. Open the Map Viewer and sign into your ArcGIS account.

  2. In the left-panel, click Layers > Add.

    • Click the My content dropdown and select ArcGIS Online.
    • In the search box, type World Street Map (for Developers).
    • Click on the resulting Tile Layer from Esri Vector Maps, then click Use as basemap.
  3. In the left-panel, click Layers to close the window.

Set focus to an area of interest

To specify the viewpoint of the map to an area of interest, use the magnifier icon and set the map properties to preserve map scale.

  1. In the bottom right panel, click the magnifier icon.

  2. Type in Santa Monica in the search field and hit enter. This will set your map focus to an area of interest, which, in this case, is the city of Santa Monica, California.

  3. In the left panel, click Map properties.

  4. Under Map view, toggle on the Preserve map scale. This will ensure that the map focus stays on the city of Santa Monica, California, even after you close the web map.

Your web map should look something like this.

Save the web map

Now that you have a web map, you need to save it to your portal.

  1. In the left panel, click Save > Save as. At minimum, you need to provide a title and tags for your web map.

  2. In the left panel, click Share map.

  3. Select Everyone (public). Then, click Save.

Enable web map for offline use

  1. In your web browser, find the item ID at the end of the URL for the web map you just saved.

    • For example: 8ab76e9c5352400d87ca3315db9ba08e
  2. In a new browser tab, copy and paste the following URL and insert your item ID. This will return the item page for your web map, where you can configure it for offline use.

  3. Click Settings on the top bar of the item page. Settings

  4. Scroll down to the Offline menu. Offline section

  5. If you don't see the Offline enabled icon at the top right corner, click Check Compatibility and turn on Offline.

  6. Optionally, you can also manage advanced offline settings for your web map by clicking Options. These settings allow you to choose what data or updates mobile devices get and use a tile package for your offline basemap.

  7. Click Save. Your web map is enabled for offline use now.

Draw offline map areas

Now, you are going to define areas in your web map that you want to take offline, also known as offline map areas or preplanned map areas_.

  1. Under Offline Map Areas, click Manage Offline Areas.

  2. In the left panel, click Create offline area.

  3. Draw an offline area on the map. You have two options to do this:

    • To draw a box around the area to take offline, click the Sketch rectangular map area button and draw a box on the map.
    • To draw a polygon to define the area you need to take offline, click the Sketch polygon map area button and draw the polygon on the map.
    Create offline areas

Manage offline map area settings

After defining your offline map areas, you can configure settings such as name, level of detail, and packaging schedule. Then, you will save the offline map area and an offline map package will be generated.

  1. In the Name field in the left panel, type a descriptive name for the offline map area.

  2. Open the Level of detail setting to change the quality and resolution of the downloaded raster or vector tile layers. You can move the slider to the right for more detail or to the left for less detail. Make sure that the small triangle icon is included in the scope of your slider.

  3. Open the Packaging schedule section to set the interval and time that you want the offline map area packages to be refreshed to capture changes to feature layer data. If you don't want to set an automatic refresh schedule, select Never from the drop-down menu.

  4. Open the Optimizations section to create offline map area packages for read-only use. Then, switch on the Enable packaged updates toggle button. Read-only packages are created based on the schedule you set in the previous step.

  5. Click Save.

  6. To create more offline areas for this map, click Create offline area and repeat the previous steps starting from Draw offline map areas. You can create up to 16 offline map areas per web map.

2. Build the app

Setup offline app

  1. Install and setup the ArcGIS Maps SDK for .NET on your development machine. Make sure you fulfill the SDK's system requirements.

  2. Follow the Display a map tutorial or download the completed solution to get a starter code for this workflow.

  3. Open the .sln file in Visual Studio.

    The Visual Studio solution, project, and the namespace for all classes currently use the name DisplayAMap. Follow the steps below if you prefer the name to reflect the current tutorial. These steps are not required, your code will still work if you keep the original name.

  4. Update the name for the solution and the project.

    • In Visual Studio, in the Solution Explorer, right-click the solution name and choose Rename. Provide the new name for your solution.
    • In the Solution Explorer, right-click the project name and choose Rename. Provide the new name for your project.
  5. Rename the namespace used by classes in the project.

    • In the Solution Explorer, expand the project node.
    • Double-click MapViewModel.cs in the Solution Explorer to open the file.
    • In the MapViewModel class, double-click the namespace name (DisplayAMap) to select it, and then right-click and choose Rename....
    • Provide the new name for the namespace.
    • Click Apply in the Rename: DisplayAMap window that appears in the upper-right of the code window. This will rename the namespace throughout your project.
  6. Build the project.

    • Choose Build > Build solution (or press F6).

Download and display the offline map

  1. In the Visual Studio > Solution Explorer, double-click MapViewModel.cs to open the file.

  2. Add additional required using statements at the top of the class.

    MapViewModel.cs
    Use dark colors for code blocks
    2 3 4 5 6 7 8 9 10 11 12 13
    Add line.Add line.Add line.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    
    using System;
    using System.Collections.Generic;
    using Esri.ArcGISRuntime.Portal;
    using System.Text;
    using System.Threading.Tasks;
    using System.ComponentModel;
    using System.Runtime.CompilerServices;
    
    using System.Linq;
    using Esri.ArcGISRuntime.Mapping;
    using Esri.ArcGISRuntime.Tasks.Offline;
    
  3. Create an empty global variable _downloadLocation to store the path to the downloaded map area later.

    MapViewModel.cs
    Use dark colors for code blocks
    29 30 31 32 33 34 35 36 37 38 39 40
    Add line.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
            private string _downloadLocation;
    
            private Map? _map;
            public Map? Map
            {
                get { return _map; }
                set
                {
                    _map = value;
                    OnPropertyChanged();
                }
            }
    
  4. Modify the SetupMap function signature to private async returning a Task.

    MapViewModel.cs
    Use dark colors for code blocks
    42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
    Change lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange line
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
            private async Task GetOfflinePreplannedMap()
            {
                var portal = await ArcGISPortal.CreateAsync();
                var portalItem = await PortalItem.CreateAsync(portal, "YOUR_ITEM_ID"); // Replace with your web map ID
                var map = new Map(portalItem);
    
                OfflineMapTask offlineMapTask = await OfflineMapTask.CreateAsync(map);
                IReadOnlyList<PreplannedMapArea> availableAreas = await offlineMapTask.GetPreplannedMapAreasAsync();
    
                if (availableAreas?.FirstOrDefault() is PreplannedMapArea area)
                {
                    DownloadPreplannedOfflineMapParameters downloadParameters = await offlineMapTask.CreateDefaultDownloadPreplannedOfflineMapParametersAsync(area);
    
                    string documentsFolder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
                    _downloadLocation = System.IO.Path.Combine(documentsFolder, "OfflineMap");
    
                    DownloadPreplannedOfflineMapJob job = offlineMapTask.DownloadPreplannedOfflineMap(downloadParameters, _downloadLocation);
                    DownloadPreplannedOfflineMapResult result = await job.GetResultAsync();
    
                    if (result?.OfflineMap is Map offlineMap)
                    {
                        this.Map = offlineMap;
                    }
                }
            }
    
  5. Remove the Map initializer from the SetupMap function. Because the map area will be downloaded from the web map, this is no longer needed.

    MapViewModel.cs
    Use dark colors for code blocks
    42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
            private async Task GetOfflinePreplannedMap()
            {
                var portal = await ArcGISPortal.CreateAsync();
                var portalItem = await PortalItem.CreateAsync(portal, "YOUR_ITEM_ID"); // Replace with your web map ID
                var map = new Map(portalItem);
    
                OfflineMapTask offlineMapTask = await OfflineMapTask.CreateAsync(map);
                IReadOnlyList<PreplannedMapArea> availableAreas = await offlineMapTask.GetPreplannedMapAreasAsync();
    
                if (availableAreas?.FirstOrDefault() is PreplannedMapArea area)
                {
                    DownloadPreplannedOfflineMapParameters downloadParameters = await offlineMapTask.CreateDefaultDownloadPreplannedOfflineMapParametersAsync(area);
    
                    string documentsFolder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
                    _downloadLocation = System.IO.Path.Combine(documentsFolder, "OfflineMap");
    
                    DownloadPreplannedOfflineMapJob job = offlineMapTask.DownloadPreplannedOfflineMap(downloadParameters, _downloadLocation);
                    DownloadPreplannedOfflineMapResult result = await job.GetResultAsync();
    
                    if (result?.OfflineMap is Map offlineMap)
                    {
                        this.Map = offlineMap;
                    }
                }
            }
    
  6. Inside MainWindow.xaml.cs, remove the viewpoint configuration.

    MainWindow.xaml.cs
    Use dark colors for code blocks
    37 38 39 40 41 42 43 44
    Remove lineRemove line
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
            public MainWindow()
            {
                InitializeComponent();
    
                MapPoint mapCenterPoint = new MapPoint(-118.805, 34.027, SpatialReferences.Wgs84);
                MainMapView.SetViewpoint(new Viewpoint(mapCenterPoint, 100000));
    
            }
    
  7. Get the web map item ID from your portal, for example 8ab76e9c5352400d87ca3315db9ba08e.

  8. Create a Map from the web map using its item ID.

    MapViewModel.cs
    Use dark colors for code blocks
    42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
            private async Task GetOfflinePreplannedMap()
            {
                var portal = await ArcGISPortal.CreateAsync();
                var portalItem = await PortalItem.CreateAsync(portal, "YOUR_ITEM_ID"); // Replace with your web map ID
                var map = new Map(portalItem);
    
                OfflineMapTask offlineMapTask = await OfflineMapTask.CreateAsync(map);
                IReadOnlyList<PreplannedMapArea> availableAreas = await offlineMapTask.GetPreplannedMapAreasAsync();
    
                if (availableAreas?.FirstOrDefault() is PreplannedMapArea area)
                {
                    DownloadPreplannedOfflineMapParameters downloadParameters = await offlineMapTask.CreateDefaultDownloadPreplannedOfflineMapParametersAsync(area);
    
                    string documentsFolder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
                    _downloadLocation = System.IO.Path.Combine(documentsFolder, "OfflineMap");
    
                    DownloadPreplannedOfflineMapJob job = offlineMapTask.DownloadPreplannedOfflineMap(downloadParameters, _downloadLocation);
                    DownloadPreplannedOfflineMapResult result = await job.GetResultAsync();
    
                    if (result?.OfflineMap is Map offlineMap)
                    {
                        this.Map = offlineMap;
                    }
                }
            }
    
  9. Create an OfflineMapTask referencing the web map. This task object reads the offline properties of the web map and manages downloading an offline map from it.

    MapViewModel.cs
    Use dark colors for code blocks
    42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
            private async Task GetOfflinePreplannedMap()
            {
                var portal = await ArcGISPortal.CreateAsync();
                var portalItem = await PortalItem.CreateAsync(portal, "YOUR_ITEM_ID"); // Replace with your web map ID
                var map = new Map(portalItem);
    
                OfflineMapTask offlineMapTask = await OfflineMapTask.CreateAsync(map);
                IReadOnlyList<PreplannedMapArea> availableAreas = await offlineMapTask.GetPreplannedMapAreasAsync();
    
                if (availableAreas?.FirstOrDefault() is PreplannedMapArea area)
                {
                    DownloadPreplannedOfflineMapParameters downloadParameters = await offlineMapTask.CreateDefaultDownloadPreplannedOfflineMapParametersAsync(area);
    
                    string documentsFolder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
                    _downloadLocation = System.IO.Path.Combine(documentsFolder, "OfflineMap");
    
                    DownloadPreplannedOfflineMapJob job = offlineMapTask.DownloadPreplannedOfflineMap(downloadParameters, _downloadLocation);
                    DownloadPreplannedOfflineMapResult result = await job.GetResultAsync();
    
                    if (result?.OfflineMap is Map offlineMap)
                    {
                        this.Map = offlineMap;
                    }
                }
            }
    
  10. Use the OfflineMapTask to list any available ahead-of-time offline maps. In the ArcGIS Maps SDKs for Native Apps the ahead-of-time offline map areas are referred to as preplanned areas.

    MapViewModel.cs
    Use dark colors for code blocks
    42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
            private async Task GetOfflinePreplannedMap()
            {
                var portal = await ArcGISPortal.CreateAsync();
                var portalItem = await PortalItem.CreateAsync(portal, "YOUR_ITEM_ID"); // Replace with your web map ID
                var map = new Map(portalItem);
    
                OfflineMapTask offlineMapTask = await OfflineMapTask.CreateAsync(map);
                IReadOnlyList<PreplannedMapArea> availableAreas = await offlineMapTask.GetPreplannedMapAreasAsync();
    
                if (availableAreas?.FirstOrDefault() is PreplannedMapArea area)
                {
                    DownloadPreplannedOfflineMapParameters downloadParameters = await offlineMapTask.CreateDefaultDownloadPreplannedOfflineMapParametersAsync(area);
    
                    string documentsFolder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
                    _downloadLocation = System.IO.Path.Combine(documentsFolder, "OfflineMap");
    
                    DownloadPreplannedOfflineMapJob job = offlineMapTask.DownloadPreplannedOfflineMap(downloadParameters, _downloadLocation);
                    DownloadPreplannedOfflineMapResult result = await job.GetResultAsync();
    
                    if (result?.OfflineMap is Map offlineMap)
                    {
                        this.Map = offlineMap;
                    }
                }
            }
    
  11. Get a set of default DownloadPreplannedOfflineMapParameters. These parameters describe how the owner of the web map configured the offline map to be downloaded by default. You can modify the parameters to fine tune the downloaded offline map.

    MapViewModel.cs
    Use dark colors for code blocks
    42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
            private async Task GetOfflinePreplannedMap()
            {
                var portal = await ArcGISPortal.CreateAsync();
                var portalItem = await PortalItem.CreateAsync(portal, "YOUR_ITEM_ID"); // Replace with your web map ID
                var map = new Map(portalItem);
    
                OfflineMapTask offlineMapTask = await OfflineMapTask.CreateAsync(map);
                IReadOnlyList<PreplannedMapArea> availableAreas = await offlineMapTask.GetPreplannedMapAreasAsync();
    
                if (availableAreas?.FirstOrDefault() is PreplannedMapArea area)
                {
                    DownloadPreplannedOfflineMapParameters downloadParameters = await offlineMapTask.CreateDefaultDownloadPreplannedOfflineMapParametersAsync(area);
    
                    string documentsFolder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
                    _downloadLocation = System.IO.Path.Combine(documentsFolder, "OfflineMap");
    
                    DownloadPreplannedOfflineMapJob job = offlineMapTask.DownloadPreplannedOfflineMap(downloadParameters, _downloadLocation);
                    DownloadPreplannedOfflineMapResult result = await job.GetResultAsync();
    
                    if (result?.OfflineMap is Map offlineMap)
                    {
                        this.Map = offlineMap;
                    }
                }
            }
    
  12. Define a path to store the downloaded map area and store it in the global variable _downloadLocation.

    MapViewModel.cs
    Use dark colors for code blocks
    42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
            private async Task GetOfflinePreplannedMap()
            {
                var portal = await ArcGISPortal.CreateAsync();
                var portalItem = await PortalItem.CreateAsync(portal, "YOUR_ITEM_ID"); // Replace with your web map ID
                var map = new Map(portalItem);
    
                OfflineMapTask offlineMapTask = await OfflineMapTask.CreateAsync(map);
                IReadOnlyList<PreplannedMapArea> availableAreas = await offlineMapTask.GetPreplannedMapAreasAsync();
    
                if (availableAreas?.FirstOrDefault() is PreplannedMapArea area)
                {
                    DownloadPreplannedOfflineMapParameters downloadParameters = await offlineMapTask.CreateDefaultDownloadPreplannedOfflineMapParametersAsync(area);
    
                    string documentsFolder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
                    _downloadLocation = System.IO.Path.Combine(documentsFolder, "OfflineMap");
    
                    DownloadPreplannedOfflineMapJob job = offlineMapTask.DownloadPreplannedOfflineMap(downloadParameters, _downloadLocation);
                    DownloadPreplannedOfflineMapResult result = await job.GetResultAsync();
    
                    if (result?.OfflineMap is Map offlineMap)
                    {
                        this.Map = offlineMap;
                    }
                }
            }
    
  13. Use the parameters to create a DownloadPreplannedOfflineMapJob to download the offline map, specifying the download location.

    MapViewModel.cs
    Use dark colors for code blocks
    42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
            private async Task GetOfflinePreplannedMap()
            {
                var portal = await ArcGISPortal.CreateAsync();
                var portalItem = await PortalItem.CreateAsync(portal, "YOUR_ITEM_ID"); // Replace with your web map ID
                var map = new Map(portalItem);
    
                OfflineMapTask offlineMapTask = await OfflineMapTask.CreateAsync(map);
                IReadOnlyList<PreplannedMapArea> availableAreas = await offlineMapTask.GetPreplannedMapAreasAsync();
    
                if (availableAreas?.FirstOrDefault() is PreplannedMapArea area)
                {
                    DownloadPreplannedOfflineMapParameters downloadParameters = await offlineMapTask.CreateDefaultDownloadPreplannedOfflineMapParametersAsync(area);
    
                    string documentsFolder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
                    _downloadLocation = System.IO.Path.Combine(documentsFolder, "OfflineMap");
    
                    DownloadPreplannedOfflineMapJob job = offlineMapTask.DownloadPreplannedOfflineMap(downloadParameters, _downloadLocation);
                    DownloadPreplannedOfflineMapResult result = await job.GetResultAsync();
    
                    if (result?.OfflineMap is Map offlineMap)
                    {
                        this.Map = offlineMap;
                    }
                }
            }
    
  14. Start the job and wait for it to complete, returning a Map that is ready for use.

    MapViewModel.cs
    Expand
    Use dark colors for code blocks
    42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
            private async Task GetOfflinePreplannedMap()
            {
                var portal = await ArcGISPortal.CreateAsync();
                var portalItem = await PortalItem.CreateAsync(portal, "YOUR_ITEM_ID"); // Replace with your web map ID
                var map = new Map(portalItem);
    
                OfflineMapTask offlineMapTask = await OfflineMapTask.CreateAsync(map);
                IReadOnlyList<PreplannedMapArea> availableAreas = await offlineMapTask.GetPreplannedMapAreasAsync();
    
                if (availableAreas?.FirstOrDefault() is PreplannedMapArea area)
                {
                    DownloadPreplannedOfflineMapParameters downloadParameters = await offlineMapTask.CreateDefaultDownloadPreplannedOfflineMapParametersAsync(area);
    
                    string documentsFolder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
                    _downloadLocation = System.IO.Path.Combine(documentsFolder, "OfflineMap");
    
                    DownloadPreplannedOfflineMapJob job = offlineMapTask.DownloadPreplannedOfflineMap(downloadParameters, _downloadLocation);
                    DownloadPreplannedOfflineMapResult result = await job.GetResultAsync();
    
                    if (result?.OfflineMap is Map offlineMap)
                    {
                        this.Map = offlineMap;
                    }
                }
            }
    
    Expand
  15. Click Debug > Start Debugging (or press F5 on the keyboard) to run the app.

Access the offline map

  1. Inside MapViewModel.cs, create a private async function returning a Task called AccessMap().

    MapViewModel.cs
    Use dark colors for code blocksCopy
    68 69 70 71
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
            private async Task AccessMap()
            {
    
            }
    
  2. Inside the function, create a MobileMapPackage that references the path to the downloaded offline map area.

    MapViewModel.cs
    Use dark colors for code blocks
    68 69 70 71 72 73
    Add line.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
            private async Task AccessMap()
            {
    
                var mobileMapPackage = await MobileMapPackage.OpenAsync(_downloadLocation);
    
            }
    
  3. Load the mobile map package and read the Map from it.

    MapViewModel.cs
    Use dark colors for code blocks
    68 69 70 71 72 73 74 75 76 77
    Add line.Add line.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
            private async Task AccessMap()
            {
    
                var mobileMapPackage = await MobileMapPackage.OpenAsync(_downloadLocation);
    
                await mobileMapPackage.LoadAsync();
    
                this.Map = mobileMapPackage.Maps.First();
    
            }
    
  4. The function is now ready to be called to access a previously downloaded offline map area. You can trigger this function from a UI button click or by calling it directly from the constructor.

  5. Click Debug > Start Debugging (or press F5 on the keyboard) to run the app.

Your browser is no longer supported. Please upgrade your browser for the best experience. See our browser deprecation post for more details.