ArcGIS Runtime SDK for .NET (WPF)

Release notes for 100.0

This major release of ArcGIS Runtime SDK for .NET introduces new and changed APIs from previous releases. The SDK provides an enhanced Windows Presentation Foundation (WPF) API for building desktop applications for Windows and a new Universal Windows Platform (UWP) API for building apps for Windows 10 desktops and devices. It also includes APIs for developing native iOS and Android apps as well as cross-platform Xamarin Forms apps using Visual Studio and C#.


In the previous (beta) release, the Xamarin APIs were in a separate SDK called ArcGIS Runtime SDK for Xamarin. This SDK no longer exists as a separate product, but all of its functionality has been incorporated into ArcGIS Runtime SDK for .NET.

The 100.0 release is the first release in the 100.0.0 family. The 100.0.0 code name reflects the next generation of ArcGIS Runtime, built from the ground up using a new architecture. This has enabled new capabilities and performance optimizations and provides API and functional consistency across all of the Runtime SDKs. The entire API was re-imagined to incorporate these new capabilities and best-of-breed ideas from all of the ArcGIS Runtime SDKs.

This topic describes what's new, what's changed, and known limitations in this release.

What's new

This release of the ArcGIS Runtime puts the map and the scene at the heart of the API to allow developers to quickly leverage the ArcGIS platforms Web GIS capabilities. The following additions highlight the benefits of the new ArcGIS Runtime release.

Maps and scenes

The Map and the Scene objects have been split out from the views that display them, to represent model components from a Model-View-Controller architecture. These important objects at the heart of the ArcGIS Runtime have an API that follows the ArcGIS Web GIS information model. They contain operational layers, basemaps, bookmarks, popups and other ArcGIS specific data to enable these to be leveraged in your apps. They also include convenient APIs to instantiate them from URLs, portal items or default basemaps so you can get great maps working quickly.


Version 2.0 of web maps and higher are supported (web maps from Portal for ArcGIS 10.3 and above); pre-2.0 versions are no longer supported.


GeoViews (MapView and SceneView) are solely responsible for display and interaction, separating concerns from the model objects and allowing the APIs to be simplified and harmonized between the 2D and 3D worlds. The Views contain Graphic Overlays, as well as operations to easily identify features and graphics without having to write any layer type specific code.

Go offline

To make things easy for you, the APIs for common operations such as editing, searching, geocoding or routing are the same whether you are online or offline.

  • Mobile map packages — Offline maps with great symbology, place search and directions can be packaged with ArcGIS Pro, side loaded onto your device and used in the Runtime through Mobile Map Packages. A mobile map package is a set of items bundled together for transport, often for use in offline workflows. The items are one or more maps, their associated layers and data, and optionally networks and locators. A mobile map package also includes metadata about the package.
  • Offline services — You can also take your connected ArcGIS based feature and tiled layers offline line on demand with dedicated Tasks and associated Jobs. The GeodatabaseSyncTask works with ArcGIS feature services to take features offline in a mobile geodatabase (.geodatabase file) and allow them to be edited and synced. The ExportTileCacheTask extracts tiles from a tiled ArcGIS map service as a tile package (.tpk file) and allows them to be viewed offline.

For more information, see the "Create an offline map" topic in this guide.


On desktop platforms, 3D has been brought to the ArcGIS Runtime for native app development. Build 3D scenes with raster, tiled and vector data sets including 3D specific symbology for great "better than flat" visualizations. This capability is Beta on mobile platforms.

For more information, see the "Display a scene" topic in this guide.

Vector tiled layers

You can use vector tiled layers in your ArcGIS Runtime app. These layers are similar to raster-based tiled layers but they are faster, smaller, and look better on high resolution devices. They also differ in the way cartography is delivered. Instead of raster pixels, vector tiled layers deliver cartography using vectors so cartography is rendered at runtime leveraging all the available pixels on the device. The file format is binary and conforms to the Mapbox vector tile specification. Vector tiled layers don't contain any feature data and they don't support identify or search operations. For details, see the API reference for ArcGISVectorTiledLayer or see the "Tiled layers" section in the "Layers" topic in this guide.

Graphics as overlays

Graphics have always been used to display temporary application data on top of a map. To formalize this usage, graphics are now added to GeoViews (MapView or SceneView) as overlays. This ensures that graphics are always displayed on top, even when map layers are reordered. This also makes it convenient to switch out maps while still keeping the graphics in place. For more information, see the "Add graphics overlays to your app" topic in this guide. It is now also possible to identify graphics overlays in a map view via a single convenient method.


This capability is Beta for deploying on mobile platforms.

You can now add raster data on desktop devices from many popular raster file formats such as DTED (Digital Terrain Elevation Data), GeoTIFF, RPF (Raster Product Format), NITF (National Imagery Transmission Format), HRE (High Resolution Elevation), Erdas Imagine, etc.

World files are no longer required to display GeoTiff and NITF formats.

Change the visualization of raster data by computing hillshades, applying colormaps, or stretching the statistical distribution of pixel values.

Local Server

The power of Local Server is still available in this release, but it's now an optional installation component. It contains the same capabilities as in the 10.2.7 release. For information on setting it up and using it, see the "Local Server" topic in this guide.

This release also introduces additional tools supported by Local Server at the Standard, Advanced, and Analysis levels, opening up new workflows for data management, analysis, and ArcGIS Runtime content packaging. For a list of supported tools, see the topic "Local Server geoprocessing tools support" in this guide.

Since the ArcGIS Runtime 100.0.0 release, a new version (minor) of Local Server has been released, version 100.0.1. This new version includes minor bug fixes.

New layer names

Other changes have been made to layer names: Use ArcGIS map image layers for adding ArcGIS Server map services. Use ArcGIS tiled layers for adding ArcGIS Server tiled map services and tile packages. Use a Feature layer with associated Feature Tables for adding layers or tables from ArcGIS feature services and geodatabases (including non-spatial tables). See the "Layers" topic in this guide for information on the supported layer types.

Web map pop-ups

Web map pop-ups allow you to customize how the data in your layers are presented to users. A new full popup API has been added to allow you to tap into the their configuration and build great user experiences for your users which include feature editing. Those layers which allow popup definitions implement the new PopupSource interface. The map view also provides coarse-grained methods to identify pop-ups taking into consideration different types of layers, their visibility, scale range, and pop-up configuration, and so on, and returns a list of pop-ups for features at a given location.


Version 2.0 of web maps and higher are supported (web maps from Portal for ArcGIS 10.3 and above); pre-2.0 versions are no longer supported.

Portal integration

The mapping API seamlessly integrates with the portal API, allowing you to access portal content and use them as maps. You can also edit existing maps or author completely new maps and save them back to the portal, which can then be used elsewhere in the ArcGIS system. For details see the "Access portal content" topic in this guide.

Military symbology

On desktop platforms, the API and workflow for using Military symbology has been greatly simplified in this release. You can now use military dictionary style files as the basis for a Dictionary Renderer which can be applied to graphics overlays OR feature layers. This capability is Beta on mobile platforms.

Loadable pattern

Resources, such as maps, layers, tasks etc, that load metadata asynchronously to initialize their state adopt the loadable pattern. This pattern makes the behavior of loading state more consistent and uniform, and also makes its asynchronous nature more explicit. Loadable resources do not automatically load their state. They load lazily, when asked either by the developer, or by other objects that depend on it. The status of a loadable resource can be easily monitored to determine if it is loading, loaded successfully, or failed to load, and you can retry loading it if it failed to load. For more information, refer to the loadable pattern topic in this guide.

Loadable features

Features retrieved from ArcGISFeatureTable have been optimized to contain only a minimum set of attributes which are required to render them on a map. To get the full list of attributes, the feature has to be explicitly loaded. This optimization reduces latency and bandwidth consumption while displaying features, but still allows you get the feature's complete data if you want to edit or display feature details. When editing features, they must be loaded first.

Centralized handling of authentication

All security and authentication related aspects are managed by a newAuthenticationManager class which helps to unify and centralize how authentication is performed regardless of the security mechanism being used or the operation being performed. The authentication manager issues an authentication challenge whenever security related events are encountered. Developers can monitor these challenges and respond with credentials to get access to secured resources, or allow the authentication manager to prompt the end user for credentials. For more information, refer to the API reference documentation for AuthenticationManager

Geometries and geometry builders

The fundamental geometry objects remain the same - point, multipoint, polyline, and polygon but they are immutable and cannot be modified once they are created. The constructors on geometry objects allow them to be created easily in one shot if their coordinates are known, but you can also use geometry builders to progressively construct new geometries, either from scratch or by using an existing geometry as the starting point and then manipulating its coordinates. For more information see the "Edit geometries" topic in this guide.

Error handling

It's now easier to determine where errors occur in the stack so you can provide better error messages to your users. A new standardized error domain property is available, which indicates if the error occurred client-side within the ArcGIS Runtime or server-side from an ArcGIS Server service or web service. A consistent error code property can be used to further diagnose what the error was and what error message should be displayed to the user. A listing of error code descriptions is provided in the "Platform error codes" topic in this guide.

Changes since the .NET and Xamarin betas

If you participated in beta testing for ArcGIS Runtime SDK for .NET or ArcGIS Runtime SDK for Xamarin, you will notice the following changes.

  • ArcGIS Runtime SDK for .NET includes APIs for WPF and UWP plus the APIs previously released as ArcGIS Runtime SDK for Xamarin.
  • The API reference for Xamarin.Forms is no longer a separate reference. In this release, it is included with Xamarin.Android, Xamairn.iOS, and UWP API Reference.
  • KML Layer has been removed and will be reintroduced in a future update.
  • ArcGIS Runtime SDK for .NET is now installed using Visual Studio Installer (.vsix) technology (as opposed to the previous Windows Installer (.msi) setup).
  • APIs for WPF and UWP are now delivered as NuGet pakages instead of assembly and extension SDK references.
  • Some system requirements have been updated. See the System requirements topic for details.
  • Deployment and licensing support has been added.

Known limitations

The following list describes known limitations or issues with the 100.0 release. Where one is available, a workaround is described.

  • MapView.ExportMapImage doesn't work when executed in a Virtualized environment.
  • When iterating a FeatureQueryResult (using foreach, e.g.), asynchronous calls throw an exception.
    • Workaround: iterate results using FeatureQueryResult.ToList(), FeatureQueryResult.ToArray(), or FeatureQueryResult.ElementAt(index).
  • In a Universal Windows Platform (UWP) app, properties that require a URI (Layer.Source, e.g.) cannot be set in XAML if running on Windows 10 Build 10240.
    • Workaround: Upgrade to Windows 10 Version 1511 Build 10586 or later.
  • In a Universal Windows Platform (UWP) project using NetCore 5.2.2 an exception is raised ("No parameterless constructor defined for this object") when calling ArcGISPortal.CreateAsync.
    • Workaround: Use the previous release of the NetCore serialization packages by adding the appropriate dependencies in the project.json file. See more details in this GitHub issue.
  • When using LocalGeoprocessingService in a Local Server with GeoprocessingServiceType.AsynchronousSubmitWithMapServiceResult mode, GeoprocessingResult.MapImageLayer isn't populated correctly.
    • Workaround: build a URL that references the map image result and use it to create a new ArcGISMapImageLayer.
      // ** Workaround for local server when using result map server to render results as an image
      // Note: the 'job' variable represents a GeoprocessingJob that has completed
      // Get URL of the local geoprocessing service from LocalGeoprocessingService
      var serviceUrl = localGeoprocessingService.Url.ToString();
      // Construct URL to the map server result
      var mapServerUrl = serviceUrl.Replace("GPServer", $"MapServer/jobs/{job.ServerJobId}");
      // Create new ArcGISMapImageLayer from the constructed URL
      var mapImageLayer = new ArcGISMapImageLayer(new Uri(mapServerUrl));
      // ** Workaround end
  • Navigation can appear slow when a debugger is attached and the map has the accelerated display mode enabled. The display can appear to "stutter" when zooming in, especially on tile layers.
    • Workaround: The issue is due to the performance impact of the debugger interacting with .Net exception handling. The exceptions are within the .Net framework and are caused by cancelling in-progress web requests for tiles that are not needed for display. It is therefore recommended to verify application performance in release mode (without a debugger attached).
  • SceneView.ElevationExaggeration has no effect on Xamarin APIs.
  • In an iOS app, touch events do not propagate to a child control added as a sub-view of a MapView control. This may happen without your knowledge when you drop a view on top of the map in the designer, in which case it gets added as a sub-view of the map view. There are a few ways to avoid or workaround the issue.
    • Workaround: Move a view that has already been added in this way up the visual hierarchy so that it's not a child of the map view.
    • Workaround: When dragging the view to the design surface, drop it somewhere that does not overlap the map view. This will avoid it being created as a child.
    • Workaround: Add the view programmatically.
  • Types that derive from Esri.ArcGISRuntime.RuntimeObservableCollection<T> have the following limitations.
    • An instance of an object cannot be added to the same collection twice.
    • An instance of an object cannot be added to multiple collections.
    • Null object instances cannot be added to the collection.
    • Existing instances in the collection cannot be set to null.
  • Esri.ArcGISRuntime.Xamarin.Android and Esri.ArcGISRuntime.Xamarin.Forms do not currently support arm64-v8a as a target CPU architecture for Android apps. Apps configured to support armeabi-v7a can run on 64-bit ARM devices. Support for Xamarin.Android on arm64-v8a is on the roadmap for a future release.


  • Deadlocks may occur if a map is destructed while it has outgoing requests.
  • In some cases, wrap-around does not stay enabled.
  • Map zooms in and out (5-10%) when dragged between monitors with different DPI
  • Some specialized layers are not supported in this release: KML, WMS, WMTS, OpenStreetMap, Bing, CSV by reference and GeoRSS.
  • Maps do not open consistently at exactly the same initial extent.
  • Map view grid lines close to the date line and poles may not display.
  • MapView doesn't zoom to geometry if the supplied geometry's envelope has zero height or width.
  • Cloning/copying an unloaded map does not render in a map view.
  • Quickly opening a mobilemap and then destroying the mapview may cause a crash

Web maps

  • A web map won't open when a feature layer's type ID is not an integer.
  • Pop-up title does not use name when its defined with a coded value domain field.
  • There's an inconsistency in handling null values in JsonSerializable UnknownJson.
  • Map does not display any features for FeatureLayer with date-based definition expression using the timestamp keyword.


  • Vector tiled layers (ArcGISVectorTiledLayer)
    • DrawStatus does not complete when zoomed out to lowest level of detail (LOD) and no labels are displayed
    • Vector tile symbols don't scale consistently with DPI
    • Vector tiled layers created from a URL don't have attribution
    • Crash may occur on Android when zooming and panning with vector tiled layers.
    • A vector tiled layer may crash if you interact with it before it has begun drawing.
  • ArcGISTiledLayer fails to load with cached image service as portal item
  • If the URL property under basemap doesn't exist in a layer type unsupported by ArcGIS Runtime, the layer will not get serialized.
  • Overrides to definition expressions on sublayers in a map image layer from a portal item are not respected.

Symbols, renderers and graphics

  • Points are not drawn on a graphics overlay if they're on the dateline.
  • If min/max scale is changed on graphics overlay before the map is loaded, min/max scale on the map view is locked.
  • The LocationDisplay symbol may sometimes behave strangely in navigation mode.
  • ClassBreaksRenderer with one class break and no minimum value symbolizes features incorrectly
  • Popup.Symbol returns null for features from a map service.
  • For GraphicsOverlay, the selection doesn't show for fully transparent symbols.
  • When creating a feature collection from an array of graphics, the graphics symbols are not honored.
  • For graphics overlays in dynamic mode, a renderer's rotation is used even if the graphic's symbol is overridden.
  • Symbol rotation type (arithmetic/geographic) is ignored by graphics.
  • Extrusion is applied to symbol in graphics when it should only be applied on symbol in renderer
  • Feature layers from federated 10.3 and 10.3.1 ArcGIS Servers cannot use the default advanced symbology setting.
  • Features with uncompressed BMP symbols may not display.
  • Static graphic overlays render fill symbols with an outline even if it is set to Null. Use a transparent outline instead.

Feature layers

  • Large amounts of local feature data delays tiles
  • When syncing a large geodatabase, offline features disappear intermittently during map interaction
  • Synchronizing large geodatabases with many features and no local edits may take longer than expected.
  • ArcGIS Online doesn't support requesting features from feature services in a different spatial reference using the latest WKID value stored in a map
  • TextSymbol doesn't honor the screen alignment property.
  • Creating a feature with an invalid field name throws an incorrect error (an ownership-based access error)
  • Sometimes, when changing zoom levels, there's a drawing delay for symbols for features in a FeatureLayer.


  • Vector tile layers are not supported on 3D scene views. These are only for 2D viewing in this release.
  • SceneView doesn't render on Galaxy s3
  • Graphics overlays in scene views
    • Graphics overlays drawn in static mode do not render correctly. Use graphics overlays in dynamic mode.
    • 3D Symbols are not supported on Graphics or in GraphicsOverlay Renderers when the GraphicsOverlay.RenderingMode property is set to GraphicsRenderingMode.Static.
    • Setting min scale on a graphics overlay is not accurate
    • Selection halo thickness for graphicsare not consistently sized.
    • Extruded graphics in a scene view may disappear while navigating the map.
    • Military lines and polygons don't render correctly in dynamic mode in 3D.
    • Symbol sizes for graphics in static mode differ in size between 2d and 3d
  • toJson doesn't work with scene symbols.
  • 3D feature symbol size is not always consistent with 2D.
  • Creating a swatch returns a null image for scene symbols.
  • Elevation sources added to a scene at runtime are not applied to the scene view.
  • Elevation sources from local raster files may crash on Android.
  • Callouts and attribution are not visible in a scene view on macOS.

    SceneView.ScreenToLocation returns innacurate Z values

  • The Identify operation:
    • On GraphicsOverlay does not return results for text symbols when using a 3D scene view.
    • On the GraphicsOverlay method ignores the search tolerance.
    • Returns empty results for ArcGISSceneLayer.
    • On macOS sometimes does not return results from map image layer sublayers
  • The sun's position doesn't change with different values for the sunDateTime variable on a scene view.
  • Scene layer transparent pixels are not rendering correctly on Android platforms.
  • Transparent simple marker graphics on a 3D scene view do not correctly display all symbols that are directly behind them.
  • SceneView screenToLocationAsync may provide inaccurate elevation results at small scales.
  • Feature layers displayed on 3D scene views do not render in the ON_INTERACTION_CACHE mode. When using scene views, the feature layers should be used in MANUAL_CACHE mode.
  • Updating graphics with ModelSceneSymbol and scene views in the map at the same time causes flickering.
  • Converting screen coordinates to location asynchronously for 3D scene views can generate inaccurate results when the elevation is not fully loaded. This can occur when the camera is very far from the surface.
  • Changing the opacity of a graphics overlay on a 3D scene view does not automatically take effect. It only updates following a pan or zoom interaction.
  • SimpleMarkerSceneSymbol, DistanceCompositeSymbol, and ModelMarkerSymbol each returns an empty string when you try to get its JSON representation.
  • When calling SetViewpointCameraAsync on a timer with high animation speeds a crash may be encountered.
  • Some 3D models do not respect their color, they appear black, on iPhone 5
  • The selection halo for a newly added feature is not visible at all scales in SceneView
  • Scene layer packages are sometimes visible through the terrain.
  • Changing the height of a 3D Scene Symbol changes the anchor position

Raster data

  • Raster renderer produces different results between MapView and SceneView
  • RasterLayer doesn't free a used raster before the application is shut down.


  • To return m and z values from the Submit geoprocessing tasks, you must include the returnZ=true and return=true parameters to the call that fetches the output value of the GeoprocessingFeature.


  • Suggestion results from local street address locators cannot be used to retrieve results if they don't contain a house number
  • Geodatabase objects may be taken out of scope too soon, so accessing tables once the geodatabase is loaded may fail.
  • Locator performance may be poor for larger local locator datasets.
  • Calling pause on a job that is downloading a file does not pause the job.
  • Creating a FeatureCollectionTable from a FeatureQueryResult throws an exception.
  • Military symbols requiring geometry conversions where the data is not multipoint are not drawn correctly when you zoom out
  • Military symbols for 2525d dictionary which contain labels with non-printable characters may take long time to display on Linux because of font fallback.
  • ReturnGeometry set to false is not honored when QueryParameter is passed to PopulateFromServiceAsync

    Arcade expressions using date formatting string will get different results compared to the Javascript webclient.