Just as layers in your app can use data sourced from online services, such as ArcGIS Online, WFS, or WMS services, layers can also use data from data files stored locally on your user's device. Local data files support scenarios where your users never have a network connection.
This page describes what you can do with data files and lists supported data file formats. It also provides details on how to use a data file in your app, which are summarized in the following steps:
- Create, sideload, or download the data file onto your user's device.
- Access the data file with ArcGIS Runtime.
- Create a layer referencing the data file.
- Apply a renderer to define symbols for features in the layer (Optional).
- Add the layer to a map or scene.
For information on mobile map packages and mobile scene packages, which are also stand-alone files, see Offline maps, scenes, and data or the ArcGIS Pro topics Share a mobile map package and Share a mobile scene package. For details on working with data from services while offline, see Work with offline data.
What you can do with data files
You can do the following types of things in your app using local data files:
- Display maps or scenes without a network connection.
- Access, display, and analyze geospatial data.
- Include data with the installation of your app.
- Collect data on devices that never have access to a network connection.
- Create new mobile geodatabases, tables, and domains.
- Share datasets between applications using peer-to-peer technology.
Supported data file formats
ArcGIS Runtime supports the data files listed in the following table:
Data file type | Data access API | Layer API | Can query? | Can edit? | License level |
---|---|---|---|---|---|
Vector tile package |
VectorTileCache
|
ArcGISVectorTiledLayer
| No | No | Lite |
Image tile package |
TileCache
|
ArcGISTiledLayer
,
ArcGISTiledElevationSource
| No | No | Lite |
Mobile geodatabase. You can create a geodatabase file (SQLite database) with ArcGIS Runtime, using ArcGIS Pro or ArcMap, or by downloading offline data from a feature service. |
Geodatabase
|
FeatureLayer
| Yes | Yes | Lite |
Scene layer package. For display in scenes only. | N/A. Access a Scene Layer Package (.slpk) file directly from the ArcGIS Scene Layer. |
ArcGISSceneLayer
| No | No | Lite |
Shapefile |
ShapefileFeatureTable
|
FeatureLayer
| Yes | Yes | Standard |
Local raster file. The following raster formats are supported: ASRP/USRP, CIB, CADRG/ECRG, DTED, GeoPackage Raster, GeoTIFF/TIFF, HFA, HRE, IMG, JPEG, JPEG2000, Mosaic Dataset in SQLite, NITF, PNG, RPF, SRTM, CRF, and MrSID. |
Raster
|
RasterLayer
| No | No | Standard |
OGC GeoPackage (feature data) |
GeoPackageFeatureTable
|
FeatureLayer
| Yes | Yes | Standard |
OGC GeoPackage (raster data) |
GeoPackageRaster
|
RasterLayer
| No | No | Standard |
OGC KML file (.kml file or compressed .kmz file) |
KmlDataset
|
KmlLayer
| No | Yes | Standard |
Electronic Nautical Chart (S-57). For display in maps only. Not supported in scenes. |
EncCell
|
EncLayer
| No | No | Standard |
Other (e.g. GeoJSON) |
FeatureCollection
|
FeatureCollectionLayer
| Yes | Yes | Lite |
Vector tile package
Vector tiled layers contain vector representations of data across a range of scales. Unlike raster tiles, they can adapt to the resolution of their display device as you zoom in and out.
When you create a vector tile package, it must be in the same spatial reference as the map in which it will be displayed.
To create a vector tiled layer from the vector tile package (.vtpk) instantiate an
ArcGISVectorTiledLayer
object with the vector tile package's file URL. The default style will be loaded directly from the vector tile package.
// Path to the local vector tile package (.vtpk file).
string myDocumentsFolder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
string tileCachePath = System.IO.Path.Combine(myDocumentsFolder, "PencilMapTiles.vtpk");
// Create a vector tile cache from the local data.
VectorTileCache cache = new VectorTileCache(tileCachePath);
// Use the tile cache to create an ArcGISVectorTiledLayer.
ArcGISVectorTiledLayer tiledLayer = new ArcGISVectorTiledLayer(cache);
// Display the vector tiled layer as a basemap.
MyMapView.Map = new Map(new Basemap(tiledLayer));
Image tile package
Image tiled layers are typically used to display pregenerated tiled data as basemaps. A tile cache can also be used to provide offline elevation data for visualizing 3D terrain in a scene. You can take a portion of tiled data and store it within a single tile package (.tpk or .tpkx) file for completely disconnected scenarios. To store a portion of tile data as a tile package, you must specify area of interest, the tiling scheme, the levels of detail, and the tile format using one of the following approaches:
- Run the ArcGIS Pro python tool, Create Map Tile Package, to create a tile package file.
- In ArcMap, choose File > Share As > Tile Package to create a tile package file, as described in the ArcMap topic, How to create a tile package.
- In ArcMap, choose Share as > ArcGIS Runtime Content to export the map's basemap layer to a tile package file (.tpk) that is output within the ArcGIS Runtime Content folder. For details, see the ArcMap topic Creating ArcGIS Runtime content, which is available with ArcGIS 10.2.1 for Desktop or later. Also see ArcMap's tile packages.
When you create a tile package, it must have the same spatial reference as the map in which it will be displayed.
To create a tiled layer from a tile package file, instantiate an
ArcGISTiledLayer
object with the path to the tile package file on the device.
// Path to the local package (.tpk or .tpkx file).
string myDocumentsFolder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
string tileCachePath = Path.Combine(myDocumentsFolder, "StreetMapTiles.tpkx");
// Create a tile cache from the local data.
TileCache cache = new TileCache(tileCachePath);
// Use the tile cache to create an ArcGISTiledLayer.
ArcGISTiledLayer tiledLayer = new ArcGISTiledLayer(cache);
// Display the tiled layer as a basemap.
MyMapView.Map = new Map(new Basemap(tiledLayer));
To create an elevation source from a tile package file, instantiate an
ArcGISTiledElevationSource
object with the path to the tile package file on the device.
// Path to the local package (.tpkx or .tpkx file).
string myDocumentsFolder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
string tileCachePath = Path.Combine(myDocumentsFolder, "WorldElevation3DTiles.tpkx");
// Create a tile cache from the local data.
TileCache cache = new TileCache(tileCachePath);
// Use the tile cache to create an ArcGISTiledElevationSource.
ArcGISTiledElevationSource localElevationSource = new ArcGISTiledElevationSource(cache);
// Create a surface with the elevation source.
Surface elevationSurface = new Surface();
elevationSurface.ElevationSources.Add(localElevationSource);
// Set the elevation source into your scene as its base surface.
Scene scene = new Scene();
scene.BaseSurface = elevationSurface;
MySceneView.Scene = scene;
Feature layer
Feature layers allow you to display, select, edit, and query individual features and their attributes. You can work with features offline using features stored in a data file, such as a mobile geodatabase file (.geodatabase
), a GeoPackage file (.gpkg
), or a shapefile (.shp
). You can edit feature geometry and attributes, and, when using a mobile geodatabase, can also edit attachments and related records.
Mobile geodatabase
Mobile geodatabases (.geodatabase) can be created with ArcGIS Pro (2.7 or later) or ArcMap (10.2.1 or later). At version 100.14, they can also be created in your ArcGIS Runtime app.
To create a mobile geodatabase that you can sideload for use in your app:
-
In ArcGIS Pro, follow the instructions in the ArcGIS Pro help topic Create a mobile geodatabase.
-
In ArcMap, follow the instructions in the ArcMap help topic Creating ArcGIS Runtime content.
To create a mobile geodatabase using ArcGIS Runtime:
- Use the static method
Geodatabase.CreateAsync()
to create a new geodatabase at the provided path.
To display tables from a mobile geodatabase:
- Instantiate the
Geodatabase
object by opening an existing geodatabase or creating a new one. In either case, you need to specify a path to the.geodatabase
file. - Instantiate a
FeatureTable
from one of the mobile geodatabase's tables or create a new one using aTableDescription
and associatedFieldDescription
objects and callingGeodatabase.CreateTableAsync()
. - Create a new
FeatureLayer
from the feature table and add it to the map. Optionally, create a newRenderer
to symbolize features in the layer. If the layer is based on a new geodatabase table, nothing will appear in the layer until features are created.
The following code opens a geodatabase at the given path. If it doesn't exist, a new geodatabase is created at that location and a new table and domain are added. Finally, the table is displayed as a feature layer in the map.
public async void LayerFromMobileGeodatabase(string mobileGeodatabaseFilePath)
{
Geodatabase localGdb;
GeodatabaseFeatureTable trailheadsTable;
// Open the geodatabase if the file exists at the specified path.
if (File.Exists(mobileGeodatabaseFilePath))
{
// Get the geodatabase using the path.
localGdb = await Geodatabase.OpenAsync(mobileGeodatabaseFilePath);
// Access the "Trailheads" feature table in the geodatabase using its name.
trailheadsTable = localGdb.GetGeodatabaseFeatureTable("Trailheads");
}
else // If the geodatabase doesn't exist, create it.
{
localGdb = await Geodatabase.CreateAsync(mobileGeodatabaseFilePath);
// Create a new domain in the geodatabase for rating values from 1-10.
var domainDef = new RangeDomainDescription("RatingDomain", FieldType.Int16, (Int16)1, (Int16)10);
await localGdb.CreateDomainAsync(domainDef);
// Create a table description for a "Trailheads" table that will store points.
var tableDef = new TableDescription("Trailheads", SpatialReferences.Wgs84, GeometryType.Point);
// Add field descriptions to define "Name" and "Difficulty" fields
tableDef.FieldDescriptions.Add(new FieldDescription("Name", FieldType.Text));
tableDef.FieldDescriptions.Add(
new FieldDescription("Difficulty", FieldType.Int16)
{
// Apply the new range domain to the Difficulty field.
DomainName = "RatingDomain"
});
// Create a new trailheads table in the geodatabase using the table description.
trailheadsTable = await localGdb.CreateTableAsync(tableDef);
}
// Create a feature layer from the table and add it to the map.
var trailheadsLayer = new FeatureLayer(trailheadsTable);
MyMapView.Map.OperationalLayers.Add(trailheadsLayer);
}
GeoPackage
GeoPackage is an open, standards-based, platform-independent, portable, self-describing, compact format for transferring geospatial information. It uses a single SQLite file (.gpkg
) that conforms to the OGC GeoPackage standard. You can create a GeoPackage file from your own data using the Create SQLite Database tool in ArcGIS Pro.
To display features stored in a GeoPackage file, you must do the following:
- Instantiate the
GeoPackage
with the .gpkg file path. - Load the
GeoPackage
and then examine its list ofGeoPackageFeatureTable
s. - Create a
FeatureLayer
from one of theGeoPackageFeatureTable
s and add it as an operational layer to the map.
// Get the path to a local geopackage.
string geopackagePath = Path.Combine(Environment.ExpandEnvironmentVariables("%TEMP%"), "trails.gpkg");
// Open the geopackage by providing the path.
GeoPackage trailsGpkg = await GeoPackage.OpenAsync(geopackagePath);
// Iterate feature tables in the package to find one by name.
foreach (GeoPackageFeatureTable table in trailsGpkg.GeoPackageFeatureTables)
{
if (table.TableName.ToLower() == "trailheads")
{
// Create a feature layer from the table and add it to the map's operational layers.
FeatureLayer trailheadsLayer = new FeatureLayer(table);
MyMapView.Map.OperationalLayers.Add(trailheadsLayer);
}
}
Shapefile
A shapefile is a vector data storage format that contains geometry and attribute data for geographic features. Despite the name, a shapefile dataset is composed of at least three physical files: .shp
, .dbf
, and .shx
. A shapefile may include several other files, such as projection information, spatial indices, attribute indices, and so on.
To create a feature layer from a shapefile (.shp), do the following:
- Instantiate the
ShapefileFeatureTable
with the path to the shapefile. This path must point to the.shp
file. The.shp
file's associated files (.shx
,.dbf
, and so on) must be present at the same location. - Create a
FeatureLayer
from theShapefileFeatureTable
and add it to the map.
// Get the path to a local shapefile.
string shapefilePath = Path.Combine(Environment.ExpandEnvironmentVariables("%TEMP%"), "trails.shp");
// Create a shapefile feature table using the path.
ShapefileFeatureTable trailsFeatureTable = await ShapefileFeatureTable.OpenAsync(shapefilePath);
// Create a feature layer from the table and add it to the map's operational layers.
FeatureLayer trailsLayer = new FeatureLayer(trailsFeatureTable);
MyMapView.Map.OperationalLayers.Add(trailsLayer);
Raster layer
Raster data consists of a matrix of cells in which each individual cell contains a value representing information. For example, satellite or aerial images and photographs for visualizing an area. You can define renderers to display the raster data. ArcGIS Runtime supports several raster formats. To work offline, copy the raster data onto your device and add the raster dataset to your app using the
Raster
class. For more information and a list of supported raster formats, See Add raster data.