We are excited to announce the release of the Toolkit for ArcGIS Runtime SDK for .NET v100.4. The Toolkit contains controls and utilities you can use out-of-the-box to accelerate the development of your .NET apps for Android, iOS, and Windows. You also have access to the complete Toolkit source code on Github enabling you to fully customize the Toolkit for your specific project requirements.

Features

• Legend: Display a legend for a single layer in your map or scene and optionally for its sub layers.
• SymbolDisplay: Render a symbol in a control (also used in the Legend).
• PopupViewer: Display details and media, edit attributes, geometry and related records, and manage the attachments of features and graphics (popups are defined in the popup property of features and graphics).
• Compass: Automatically show a compass when the user rotates map. Optionally auto-hide the compass when the user rotates the map north up.
• FeatureDataField: Display and optionally allow editing of a single field attribute of a feature.
• MeasureToolbar: Measure distances and areas on the map view.
• ScaleLine: Display the current scale of the map view.
• TimeSlider: Allow the interactive definition of a time extent and animate time moving forward or backward. Can be used to manipulate the time extent in a map or scene view.

Where possible each control is available for all APIs supported for development with ArcGIS Runtime SDK for .NET: UWP, WPF, Xamarin.Android, Xamarin.iOS, and Xamarin.Forms for Android, iOS, and UWP. Feature availability by platform/API is indicated in the Github repo readme.

Getting started

As a developer you have three options for working with the Toolkit:

1. Reference the latest stable or pre-release package from NuGet.org
2. Reference the latest master branch commit NuGet package from AppVeyor
3. Build the Toolkit source

A set of basic samples are included in the Toolkit repo.

Roadmap

The Toolkit is an active development project with more controls and utilities on the roadmap. You can even get an early glimpse of some of these new controls in the Toolkit Preview package (currently in preview are the SignInForm and TableOfContents for WPF). Also on the roadmap are improved Guide and API reference documentation and additional samples.

Reporting issues

We encourage you to try out and use the Toolkit within your projects and we look forward to hearing your feedback. If you find any bugs while using the Toolkit please submit new issues in the Toolkit repo. At this time we are not accepting new PRs for full features but if there are new controls you would like to see included please submit an issue to request the enhancement.  

Cheers

The ArcGIS Runtime .NET Team

The good news: Features and graphics in your ArcGIS Runtime SDK for .NET app can be labeled using a combination of attribute values, text strings, and values calculated with an expression. You can set font characteristics, determine how labels are positioned and prioritized, and how conflicts between overlapping labels are automatically and dynamically resolved. By creating one or more label classes, you can define distinct labels for groups of features.

The bad news: As of the 100.2.1 release, there's no API exposed for this. To implement labeling for a feature layer, graphics overlay, or map image sub-layer, you need to craft the appropriate JSON definition (text) to define your label classes (as described here). Bummer.

But don't worry, a simple JSON serializable class is all it takes to simplify your labeling code. I'll walk you through the basic process in the steps below. If that's still too much work for you, feel free to simply download the attached code and try it out. The labeling class in the project (LabelClassInfo.cs) can be brought into any ArcGIS Runtime for .NET project and used to create labels for your layers.

1. Start Visual Studio and create a new ArcGIS Runtime SDK for .NET app. 
2. Add a new class to the project. Let's name it LabelClassInfo.cs. Add the following using statements at the top of the class.

   using Esri.ArcGISRuntime.Geometry;
   using Esri.ArcGISRuntime.Symbology;
   using System;
   using System.IO;
   using System.Runtime.Serialization;
   using System.Runtime.Serialization.Json;

    

3. Decorate the class with the DataContract attribute. This indicates that the class will be serializable. 

       [DataContract]
       public class LabelClassInfo
       {

    

4. Create properties for everything expected in the JSON definition of the label class. This information is defined under labelingInfo in the Web map specification. The specification defines an "allowOverrun" value, for example. This could be implemented with the following simple bool property. Note that the name of the property in the class does not need to match the name in the specification.

           public bool AllowOverrun { get; set; }

   Based on the specification, here are the properties (and corresponding data type) needed for the label class: allowOverrun (bool), deconflictionStrategy (string), labelExpression (string), labelExpressionInfo (object), labelPlacement (string), minScale (int), maxScale (int), name (string), priority (int), removeDuplicates (string), removeDuplicatesDistance (int), repeatLabel (bool), repeatLabelDistance (int), stackLabel (bool), stackAlignment (string), symbol (TextSymbol), useCodedValues (bool), where (string).
5. OK, the list above looks pretty straightforward, except for the two properties that don't return primitive data types. Go ahead and create properties for everything except labelExpressionInfo and symbol (we'll circle back to those). 
6. After you've defined the properties, in order to make them serializable you'll need to decorate them with the DataMember attribute. The string you supply for "Name" will be used in the output JSON and must match the name used in the Web map specification. Add the appropriate DataMember attribute to all properties.

           [DataMember(Name = "deconflictionStrategy")]
           public LabelPosition LabelPosition { get; set; }

    

7. The labelExpressionInfo property, returns object. What kind of object do we need here? In the specification, the JSON describes a class with a single property (not counting the deprecated "value" property). You'll therefore need to create a new private class (nested under your main class) with a single property that holds a (string) expression. This class will also be serializable, so you need the DataContract and DataMember attributes. 

           [DataContract]
           private class ExpressionInfo
           {
               [DataMember(Name = "expression")]
               public string Expression { get; set; }
   
               public ExpressionInfo(string expression)
               {
                   Expression = expression;
               }
           }

    

8. The labelExpressionInfo property should be based on the new ExpressionInfo type. To simplify the API, you might want to expose just the expression property (ArcadeExpression in the example below) and build the ExpressionInfo object that contains it internally. 

           [DataMember(Name ="labelExpressionInfo")]
           private ExpressionInfo _labelExpressionInfo = new ExpressionInfo("");
   
           public string ArcadeExpression
           {
               get { return _labelExpressionInfo.Expression; }
               set { _labelExpressionInfo = new ExpressionInfo(value); }
           }

    

9. What about the symbol property that returns TextSymbol? You can handle this is much the same way: expose a public Symbol property of type TextSymbol, then use an internal property to get its JSON representation (yes, Esri.ArcGISRuntime.Symbology.Symbol is serializable!).

           public TextSymbol Symbol { get; set; }
   
           [DataMember(Name = "symbol")]
           private string SymbolString
           {
               get { return this.Symbol.ToJson(); }
               set { this.Symbol = (TextSymbol)TextSymbol.FromJson(value); }
           }

    

10. Finally, create a method on LabelClassInfo to return the JSON representation of the object.

            public string GetJson()
            {
                // Create a JSON serializer for the label class.
                DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(LabelClassInfo));
    
                // Write the object to a memory stream.
                MemoryStream stream = new MemoryStream();
                jsonSerializer.WriteObject(stream, this);
    
                // Read the stream to a string.
                stream.Position = 0;
                StreamReader reader = new StreamReader(stream);
                string json = reader.ReadToEnd();
    
                // HACK: clean up the json a bit.
                json = json.Replace("\"{", "{").Replace("}\"", "}").Replace("\\", "\"").Replace("\"\"", "\"");
    
                // Return the serialized string.
                return json;
            }

     

11. You should now be able to use the new LabelClassInfo class to write code like the following to apply labels to a feature layer!

                TextSymbol textSymbol = new TextSymbol
                {
                    FontFamily = "Arial",
                    FontWeight = weight,
                    Size = (int)TextSizeComboBox.SelectedValue,
                    HorizontalAlignment = Esri.ArcGISRuntime.Symbology.HorizontalAlignment.Left,
                    VerticalAlignment = Esri.ArcGISRuntime.Symbology.VerticalAlignment.Bottom,
                    Color = (Color)ColorComboBox.SelectedValue
                };
    
                // Create a new LabelInfo object and set the relevant properties (including the text symbol).
                LabelClassInfo labelInfo = new LabelClassInfo()
                {
                    LabelPosition = "static",
                    ArcadeExpression = "return $feature['" + LabelFieldComboBox.SelectedItem + "'];",
                    MinScale = 0,
                    MaxScale = 0,
                    Priority = 30,
                    RemoveDuplicateLabels = "featureType",
                    StackLabel = true,
                    Symbol = textSymbol
                };
    
                // Get the raw JSON from the label info object.
                labelJson = labelInfo.GetJson();
    
                // Create a new label definition from the JSON string.
                LabelDefinition labelDef = LabelDefinition.FromJson(labelJson);
    
                // Clear existing label definitions.
                _parcelsLayer.LabelDefinitions.Clear();
    
                // Add the new label definition.
                _parcelsLayer.LabelDefinitions.Add(labelDef);

     

OK, so it might not be the easiest thing to code, but once you have it you can reuse this class anytime you need to add labels for a layer.

Apologies if the steps above were too vague or if you got stuck because I left something out! I've attached a project with the LabelClassInfo class and a WPF app for testing. The attached example also includes some enums for defining label position, placement, and handling of stacking and duplicates.

Update (2018 March 13):

• I've attached a much cleaner version of the LabelClassInfo class ("LabelClassInfo2.cs") that uses Newtonsoft.Json (thanks to Matvei Stefarov on the ArcGIS Runtime SDK for .NET team).
• Including a link to a a utility that helps create your serializable class from JSON: Instantly parse JSON in any language | quicktype 

We like to think that the world is mostly digital and that all field personnel hop from job site to job site armed with tablets that are auto-magically kept in sync for them by highly sophisticated software and nobody uses paper maps anymore. While that is certainly true for some, the reality is that paper maps are a long way from being replaced. So why, with all the global efforts going on to eliminate paper, are paper maps so hard to replace?

One of the most common reasons is a budgetary constraint. Companies cannot afford to invest in tablets, training, and mapping software for each field worker. Publishing a web map that the field worker could access on their laptop is a solution to the budgetary constraint, but that introduces the issue of not being able to access the maps in a disconnected environment. Another cause is that some of the existing apps are just too complicated. So paper maps do the job because they are simple, inexpensive, and available anywhere.

How Offline Mapbook competes with paper maps

We have engineered the Offline Mapbook example application to be a very simple, easy to use map viewing app. It works on any Windows device running Windows 7 and above and is designed to work fully offline. The interface is simple, intuitive and touch friendly. It's free and open sourced so it can be modified to fit anyone's needs.

One mapbook, multiple maps

Using a mobile map package makes it easy to have multiple maps in one app.

Table of Contents and Legend

Maps with multiple superimposed data layers are hard to discern. The Table of Contents in the Offline Mapbook lets users turn layers on and off as needed.

Locate

Multiple locators can be configured within the mobile map package to facilitate searching for both map features and addresses. 

Identify

More information about a feature is available by clicking or tapping on it. 

Offline capabilities and syncing

While the app is designed to function in a fully disconnected environment, that does not mean the data becomes stale once loaded. Every time the app is started, if an internet connection is present, it checks the location of the mobile map package to see if a new one is available to download. 

Get more info

Often times we try to do everything at once. We try to make an app that visualizes and collects and analyzes, but we lack the budget or the skill set. More often than not, the intended audience is overwhelmed by the amount of features they are presented with, and the uptake is slow and painful. This app was designed with all that in mind, to give you a simple way to get digital data into people's hands now, and let you worry about collecting and analyzing later. 

Click here to read more about the app.

The ArcGIS Runtime .NET team is proud to announce that the Quartz betas of the ArcGIS Runtime SDKs for .NET and Xamarin are now available.

The beta contains exciting new functionality not previously available in the 10.2.X releases, including: mobile map packages, vector tiled layers, and raster layers, plus full support for Windows 10 Universal Windows Platform (UWP) apps. Did I forget to say your awesome GIS C# code will also now run on Windows, AND Android, AND iOS?! Beta releases don't get more exciting than this!! Learn all about the Betas in the .NET release notes, Xamarin release notes and blog post. Download the Beta software from the Early Adopter Community site by signing in with your ArcGIS Online account or create a new beta account.

We appreciate you taking the time to test our beta and look forward to hearing your feedback in the Early Adopter Community forum.

Cheers

The .NET team

We have uploaded demos that were shown in Developer Summit 2015 sessions to ArcGIS Online as a code samples.

Please follow links below to the items for download.

• Transitioning to ArcGIS Runtime SDK for .NET
• Using MVVM to build ArcGIS Runtime applications
• ArcGIS Runtime SDK for .NET: Tips and Tricks
• Geo-enable your .NET apps with ArcGIS Online and Runtime

Also see related post about session recordings

.NET Runtime - DevSummit 2015 Sessions

When using the MVVM style pattern to build your XAML-based app, you don't want to include references to your View objects from within your ViewModel. This means that the ViewModel won't be able to for instance call "Zoom" on the MapView, because this operation is on the MapView, and the ViewModel is not allowed to have a reference to anything on the View. You'll find similar common challenge with ScrollViewer, where you want to scroll to a certain item in a list, but again the scroll operation is on the view, since this is a view operation.

The pattern to handle this is to create a controller your ViewModel owns, and you bind this to the view object, using an attached property. The ViewModel can then 'request' zoom operations on the controller, and if that controller is bound to a map view, it will handle executing the SetView call on the MapView.

I've added an example of this to the WPF Desktop Sample App:

arcgis-runtime-samples-dotnet/NavigateFromViewModel.xaml.cs at master · Esri/arcgis-runtime-samples-dotnet · GitHub

arcgis-runtime-samples-dotnet/NavigateFromViewModel.xaml at master · Esri/arcgis-runtime-samples-dotnet · GitHub

The attached property is shown here on line 1:

<esri:MapView local:MapViewController.Controller="{Binding Controller}">
     <esri:Map>
          <esri:ArcGISTiledMapServiceLayer
                ServiceUri="http://services.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer" />
     </esri:Map>
</esri:MapView>

The ViewModel class defines an instance of MapViewController, and exposes it in the property "Controller", which is what is being bound above.

Inside the controller, code is triggered when it is bound to the MapView and will keep an internal weak reference* to the map view, so that it can perform the operation if it is bound. The Controller can also expose properties from the MapView back out, like in this example where the current 'Extent' property is available for use to add bookmarks. You could add more properties like the current Scale or Rotation, or add more commands to perform on the view.

Using this pattern, the ViewModel never knows anything about the MapView, but is still able to perform zoom operations.

This pattern works just as well with Windows Store and Windows Phone as well, and you can copy the MapViewController class over to use the as well.

*We're using weak references to the MapView and it's events. It complicates the sample a little, but it ensure that if the ViewModel stays around for a long time, but you close the page/window that the MapView is on, the MapView control won't stay around in memory, but can be garbage collected.

We just published several demo apps on GitHub: Esri/arcgis-runtime-demos-dotnet · GitHub

We'll be adding more demos over time, but currently these are the demos available today:

• Geocode & Route on MouseMove - Demonstrates fast reverse geocoding and routing during mouse-move on Windows Store and Windows Desktop.
• Turn-by-Turn Routing - A universal turn-by-turn app that shows routing and navigation on Windows Phone, Windows Store and Windows Desktop.
• Simple Portal Browser - A universal ArcGIS Portal Map Browser app on Windows Phone, Windows Store and Windows Desktop.
• Using an External GPS Device - A Windows Desktop app showing how to use data from an external GPS or NMEA log file to power the MapView's LocationDisplay.

If you have suggestions for other demo apps, please feel free to share in this thread and we might be able to add them as well.