Style a feature layer

Learn how to apply renderers and label definitions to a feature layer based on attribute values.

style a feature layer

Applications can display feature layer data with different styles to enhance the visualization. The type of Renderer you choose depends on your application. A SimpleRenderer applies the same symbol to all features, a UniqueValueRenderer applies a different symbol to each unique attribute value, and a ClassBreaksRenderer applies a symbol to a range of numeric values. Renderers are responsible for accessing the data and applying the appropriate symbol to each feature when the layer draws. You can also use a LabelDefinition to show attribute information for features. Visit the Styles and data visualization documentation to learn more about styling layers.

You can also author, style and save web maps, web scenes, and layers as portal items and then add them to the map in your application. Visit the following tutorials to learn more about adding portal items.

In this tutorial, you will apply different renderers to enhance the visualization of three feature layers with data for the Santa Monica Mountains: Trailheads with a single symbol, Trails based on elevation change and bike use, and Parks and Open Spaces based on the type of park.

Prerequisites

Before starting this tutorial, you should:

  • Have an ArcGIS account and an API key to access ArcGIS services. If you don't have an account, sign up for free.
  • Ensure your development environment meets the system requirements.

Optionally, you may want to install the ArcGIS Runtime SDK for .NET to get access to project templates in Visual Studio (Windows only) and offline copies of the NuGet packages.

Steps

Open a Visual Studio solution

  1. To start the tutorial, complete the Display a map tutorial or download and unzip the solution.

  2. Open the .sln file in Visual Studio.

  3. If you downloaded the solution project, set your API key.

    An API Key enables access to services, web maps, and web scenes hosted in ArcGIS Online.

    If necessary, set the API Key.
    1. Go to your developer dashboard to get your API key. For these tutorials, use your default API key. It is scoped to include all of the services demonstrated in the tutorials.

    2. In Visual Studio, in the Solution Explorer, click App.xaml.cs.

    3. In the App class, add an override for the OnStartup() function to set the ApiKey property on ArcGISRuntimeEnvironment.

      App.xaml.cs
      Use dark colors for code blocks
                                              
      Add line.Add line.Add line.Add line.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
      //   Copyright 2021 Esri
      //   Licensed under the Apache License, Version 2.0 (the "License");
      //   you may not use this file except in compliance with the License.
      //   You may obtain a copy of the License at
      //
      //   https://www.apache.org/licenses/LICENSE-2.0
      //
      //   Unless required by applicable law or agreed to in writing, software
      //   distributed under the License is distributed on an "AS IS" BASIS,
      //   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      //   See the License for the specific language governing permissions and
      //   limitations under the License.
      
      using System;
      using System.Collections.Generic;
      using System.Configuration;
      using System.Data;
      using System.Linq;
      using System.Threading.Tasks;
      using System.Windows;
      
      namespace DisplayAMap
      {
          /// <summary>
          /// Interaction logic for App.xaml
          /// </summary>
      
          public partial class App : Application
          {
      
              protected override void OnStartup(StartupEventArgs e)
              {
                  base.OnStartup(e);
                  // Note: it is not best practice to store API keys in source code.
                  // The API key is referenced here for the convenience of this tutorial.
                  Esri.ArcGISRuntime.ArcGISRuntimeEnvironment.ApiKey = "YOUR_API_KEY";
              }
      
          }
      }
      

If developing with Visual Studio for Windows, ArcGIS Runtime for .NET provides a set of project templates for each of the supported .NET platforms. These templates provide all of the code needed for a basic Model-View-ViewModel (MVVM) app. You need to install the ArcGIS Runtime for .NET Visual Studio Extension to add the templates to Visual Studio (Windows only). See Install and set up for details.

Update the tutorial name used in the project (optional)

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.

The tutorial instructions and code use the name StyleAFeatureLayer for the solution, project, and namespace. You can choose any name you like, but it should be the same for each of these.

  1. 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.
  2. 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.
  3. Build the project.

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

Steps

Create a function to add a feature layer

A feature layer can be added from a feature service hosted in ArcGIS. Each feature layer contains features with a single geometry type (point, line, or polygon), and a set of attributes. Once added to the map, feature layers can be symbolized, styled, and labeled in a variety of ways.

You will define variables to store feature service URLs used by the app's layers and then create a helper method to add a layer to the map's collection of operational layers. You will use this code throughout the tutorial as you add and symbolize various layers.

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

    The project uses the Model-View-ViewModel (MVVM) design pattern to separate the application logic (view model) from the user interface (view). MapViewModel.cs contains the view model class for the application, called MapViewModel. See the Microsoft documentation for more information about the Model-View-ViewModel pattern.

  2. Add additional required using statements near the top of the .cs file. Using statements make your code more concise by allowing you to use classes from these namespaces without having to fully qualify them.

    MapViewModel.cs
    Use dark colors for code blocks
                                                                                                                                                                                                                                             
    Add line.Add line.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
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    
    //   Copyright 2022 Esri
    //   Licensed under the Apache License, Version 2.0 (the "License");
    //   you may not use this file except in compliance with the License.
    //   You may obtain a copy of the License at
    //
    //   https://www.apache.org/licenses/LICENSE-2.0
    //
    //   Unless required by applicable law or agreed to in writing, software
    //   distributed under the License is distributed on an "AS IS" BASIS,
    //   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    //   See the License for the specific language governing permissions and
    //   limitations under the License.
    
    using System;
    using System.Collections.Generic;
    using System.Text;
    using Esri.ArcGISRuntime.Geometry;
    using Esri.ArcGISRuntime.Mapping;
    using System.ComponentModel;
    using System.Runtime.CompilerServices;
    
    using Esri.ArcGISRuntime.Data;
    using Esri.ArcGISRuntime.Mapping.Labeling;
    using Esri.ArcGISRuntime.Symbology;
    using System.Diagnostics;
    using System.Drawing;
    
    namespace StyleAFeatureLayer
    {
    
        class MapViewModel : INotifyPropertyChanged
        {
    
            // Application constants used to connect to data and resources.
            static Uri parksAndOpenSpaces = new Uri("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space/FeatureServer/0");
            static Uri trails = new Uri("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0");
            static Uri trailheads = new Uri("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads/FeatureServer/0");
            static Uri trailheadImage = new Uri("https://static.arcgis.com/images/Symbols/NPS/npsPictograph_0231b.png");
    
            public MapViewModel()
            {
                SetupMap();
            }
    
            public event PropertyChangedEventHandler PropertyChanged;
            protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
            {
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
            }
    
    
            private Map _map;
            public Map Map
            {
                get { return _map; }
                set
                {
                    _map = value;
                    OnPropertyChanged();
                }
            }
    
            private FeatureLayer AddFeatureLayer(Uri featureServiceUri)
            {
                // Create a service feature table from a Uri.
                ServiceFeatureTable serviceFeatureTable = new ServiceFeatureTable(featureServiceUri);
    
                // Create a feature layer from the service feature table.
                FeatureLayer featureLayer = new FeatureLayer(serviceFeatureTable);
    
                // Add the feature layer to the maps operational layers collection.
                Map.OperationalLayers.Add(featureLayer);
    
                // Return the feature layer.
                return featureLayer;
            }
    
            private void AddOpenSpaceLayer()
            {
                // Create a parks and open spaces feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(parksAndOpenSpaces);
    
                // Create fill symbols.
                SimpleFillSymbol purpleFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Purple, null);
                SimpleFillSymbol greenFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Green, null);
                SimpleFillSymbol blueFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Blue, null);
                SimpleFillSymbol redFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Red, null);
    
                // Create a unique value for natural areas, regional open spaces, local parks, and regional recreation parks.
                UniqueValue naturalAreas = new UniqueValue("Natural Areas", "Natural Areas", purpleFillSymbol, "Natural Areas");
                UniqueValue regionalOpenSpace = new UniqueValue("Regional Open Space", "Regional Open Space", greenFillSymbol, "Regional Open Space");
                UniqueValue localPark = new UniqueValue("Local Park", "Local Park", blueFillSymbol, "Local Park");
                UniqueValue regionalRecreationPark = new UniqueValue("Regional Recreation Park", "Regional Recreation Park", redFillSymbol, "Regional Recreation Park");
    
                // Create a unique value renderer to display these values.
                UniqueValueRenderer openSpacesUniqueValueRenderer = new UniqueValueRenderer
                    (new List<string>() {
                        "TYPE"
                    },
                    new List<UniqueValue>() {
                        naturalAreas, regionalOpenSpace, localPark, regionalRecreationPark
                    },
                    "Open Spaces",
                    null);
    
                // Assign the unique value renderer to the open spaces layer.
                featureLayer.Renderer = openSpacesUniqueValueRenderer;
    
                // Set the layer opacity to semi-transparent.
                featureLayer.Opacity = 0.2;
            }
    
            private void AddTrailsLayer()
            {
                // Create a trails feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trails);
    
                // Create simple line symbols.
                SimpleLineSymbol firstClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 3.0);
                SimpleLineSymbol secondClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 4.0);
                SimpleLineSymbol thirdClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 5.0);
                SimpleLineSymbol fourthClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 6.0);
                SimpleLineSymbol fifthClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 7.0);
    
                // Create five class breaks.
                ClassBreak firstClassBreak = new ClassBreak("Under 500", "0 - 500", 0.0, 500.0, firstClassSymbol);
                ClassBreak secondClassBreak = new ClassBreak("501 to 1000", "501 - 1000", 501.0, 1000.0, secondClassSymbol);
                ClassBreak thirdClassBreak = new ClassBreak("1001 to 1500", "1001 - 1500", 1001.0, 1500.0, thirdClassSymbol);
                ClassBreak fourthClassBreak = new ClassBreak("1501 to 2000", "1501 - 2000", 1501.0, 2000.0, fourthClassSymbol);
                ClassBreak fifthClassBreak = new ClassBreak("2001 to 2300", "2001 to 2300", 2001.0, 2300.0, fifthClassSymbol);
                List<ClassBreak> elevationBreaks = new List<ClassBreak>() { firstClassBreak, secondClassBreak, thirdClassBreak, fourthClassBreak, fifthClassBreak };
    
                // Create and assign a class breaks renderer to the feature layer.
                ClassBreaksRenderer elevationClassBreaksRenderer = new ClassBreaksRenderer("ELEV_GAIN", elevationBreaks);
                featureLayer.Renderer = elevationClassBreaksRenderer;
    
                // Set the layer opacity to semi-transparent.
                featureLayer.Opacity = 0.75;
            }
    
            private void AddBikeOnlyTrailsLayer()
            {
                // Create a trails feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trails);
    
                // Write a definition expression to filter for trails that permit the use of bikes.
                featureLayer.DefinitionExpression = "USE_BIKE = 'Yes'";
    
                // Create and assign a simple renderer to the feature layer.
                SimpleLineSymbol bikeTrailSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.Blue, 2.0);
                SimpleRenderer bikeTrailRenderer = new SimpleRenderer(bikeTrailSymbol);
                featureLayer.Renderer = bikeTrailRenderer;
            }
    
            private void AddNoBikeTrailsLayer()
            {
                // Create a trails feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trails);
    
                // Write a definition expression to filter for trails that don't permit the use of bikes.
                featureLayer.DefinitionExpression = "USE_BIKE = 'No'";
    
                // Create and assign a simple renderer to the feature layer.
                SimpleLineSymbol noBikeTrailSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.Red, 2.0);
                SimpleRenderer noBikeTrailRenderer = new SimpleRenderer(noBikeTrailSymbol);
                featureLayer.Renderer = noBikeTrailRenderer;
            }
    
            private LabelDefinition MakeLabelDefinition(string labelAttribute)
            {
                // Create a new text symbol.
                TextSymbol labelTextSymbol  = new TextSymbol
                {
                    Color = Color.White,
                    Size = 12.0,
                    HaloColor = Color.Red,
                    HaloWidth = 1.0,
                    FontFamily = "Arial",
                    FontStyle = FontStyle.Italic,
                    FontWeight = FontWeight.Normal
                };
    
                // Create a new Arcade label expression based on the field name.
                ArcadeLabelExpression labelExpression = new ArcadeLabelExpression("$feature." + labelAttribute);
    
                // Create and return the label definition.
                return new LabelDefinition(labelExpression, labelTextSymbol );
            }
    
            private void AddTrailheadsLayer()
            {
                // Create a trailheads feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trailheads);
    
                // Create a new picture marker symbol that uses the trailhead image.
                PictureMarkerSymbol pictureMarkerSymbol = new PictureMarkerSymbol(trailheadImage);
                pictureMarkerSymbol.Height = 18.0;
                pictureMarkerSymbol.Width = 18.0;
    
                // Create a new simple renderer based on the picture marker symbol.
                SimpleRenderer simpleRenderer = new SimpleRenderer(pictureMarkerSymbol);
    
                // Set the feature layer's renderer and enable labels.
                featureLayer.Renderer = simpleRenderer;
                featureLayer.LabelsEnabled = true;
    
                // Create the label definition and pass the "TRL_NAME" attribute to label features by trail name.
                LabelDefinition trailHeadsDefinition = MakeLabelDefinition("TRL_NAME");
    
                // Add the label definition to the layer's label definition collection.
                featureLayer.LabelDefinitions.Add(trailHeadsDefinition);
            }
    
            private void SetupMap()
            {
                // Create a new map with a 'topographic vector' basemap.
                Map = new Map(BasemapStyle.ArcGISTopographic);
    
                AddOpenSpaceLayer();
    
                AddTrailsLayer();
    
                AddNoBikeTrailsLayer();
    
                AddBikeOnlyTrailsLayer();
    
                AddTrailheadsLayer();
    
            }
    
        }
    }
    
  3. Create four static URIs: three for accessing feature layers, and a fourth for accessing a static image for use in a picture marker symbol. You will use these resources in future steps.

    MapViewModel.cs
    Use dark colors for code blocks
                                                                                                                                                                                                                                             
    Add line.Add line.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
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    
    //   Copyright 2022 Esri
    //   Licensed under the Apache License, Version 2.0 (the "License");
    //   you may not use this file except in compliance with the License.
    //   You may obtain a copy of the License at
    //
    //   https://www.apache.org/licenses/LICENSE-2.0
    //
    //   Unless required by applicable law or agreed to in writing, software
    //   distributed under the License is distributed on an "AS IS" BASIS,
    //   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    //   See the License for the specific language governing permissions and
    //   limitations under the License.
    
    using System;
    using System.Collections.Generic;
    using System.Text;
    using Esri.ArcGISRuntime.Geometry;
    using Esri.ArcGISRuntime.Mapping;
    using System.ComponentModel;
    using System.Runtime.CompilerServices;
    
    using Esri.ArcGISRuntime.Data;
    using Esri.ArcGISRuntime.Mapping.Labeling;
    using Esri.ArcGISRuntime.Symbology;
    using System.Diagnostics;
    using System.Drawing;
    
    namespace StyleAFeatureLayer
    {
    
        class MapViewModel : INotifyPropertyChanged
        {
    
            // Application constants used to connect to data and resources.
            static Uri parksAndOpenSpaces = new Uri("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space/FeatureServer/0");
            static Uri trails = new Uri("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0");
            static Uri trailheads = new Uri("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads/FeatureServer/0");
            static Uri trailheadImage = new Uri("https://static.arcgis.com/images/Symbols/NPS/npsPictograph_0231b.png");
    
            public MapViewModel()
            {
                SetupMap();
            }
    
            public event PropertyChangedEventHandler PropertyChanged;
            protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
            {
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
            }
    
    
            private Map _map;
            public Map Map
            {
                get { return _map; }
                set
                {
                    _map = value;
                    OnPropertyChanged();
                }
            }
    
            private FeatureLayer AddFeatureLayer(Uri featureServiceUri)
            {
                // Create a service feature table from a Uri.
                ServiceFeatureTable serviceFeatureTable = new ServiceFeatureTable(featureServiceUri);
    
                // Create a feature layer from the service feature table.
                FeatureLayer featureLayer = new FeatureLayer(serviceFeatureTable);
    
                // Add the feature layer to the maps operational layers collection.
                Map.OperationalLayers.Add(featureLayer);
    
                // Return the feature layer.
                return featureLayer;
            }
    
            private void AddOpenSpaceLayer()
            {
                // Create a parks and open spaces feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(parksAndOpenSpaces);
    
                // Create fill symbols.
                SimpleFillSymbol purpleFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Purple, null);
                SimpleFillSymbol greenFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Green, null);
                SimpleFillSymbol blueFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Blue, null);
                SimpleFillSymbol redFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Red, null);
    
                // Create a unique value for natural areas, regional open spaces, local parks, and regional recreation parks.
                UniqueValue naturalAreas = new UniqueValue("Natural Areas", "Natural Areas", purpleFillSymbol, "Natural Areas");
                UniqueValue regionalOpenSpace = new UniqueValue("Regional Open Space", "Regional Open Space", greenFillSymbol, "Regional Open Space");
                UniqueValue localPark = new UniqueValue("Local Park", "Local Park", blueFillSymbol, "Local Park");
                UniqueValue regionalRecreationPark = new UniqueValue("Regional Recreation Park", "Regional Recreation Park", redFillSymbol, "Regional Recreation Park");
    
                // Create a unique value renderer to display these values.
                UniqueValueRenderer openSpacesUniqueValueRenderer = new UniqueValueRenderer
                    (new List<string>() {
                        "TYPE"
                    },
                    new List<UniqueValue>() {
                        naturalAreas, regionalOpenSpace, localPark, regionalRecreationPark
                    },
                    "Open Spaces",
                    null);
    
                // Assign the unique value renderer to the open spaces layer.
                featureLayer.Renderer = openSpacesUniqueValueRenderer;
    
                // Set the layer opacity to semi-transparent.
                featureLayer.Opacity = 0.2;
            }
    
            private void AddTrailsLayer()
            {
                // Create a trails feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trails);
    
                // Create simple line symbols.
                SimpleLineSymbol firstClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 3.0);
                SimpleLineSymbol secondClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 4.0);
                SimpleLineSymbol thirdClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 5.0);
                SimpleLineSymbol fourthClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 6.0);
                SimpleLineSymbol fifthClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 7.0);
    
                // Create five class breaks.
                ClassBreak firstClassBreak = new ClassBreak("Under 500", "0 - 500", 0.0, 500.0, firstClassSymbol);
                ClassBreak secondClassBreak = new ClassBreak("501 to 1000", "501 - 1000", 501.0, 1000.0, secondClassSymbol);
                ClassBreak thirdClassBreak = new ClassBreak("1001 to 1500", "1001 - 1500", 1001.0, 1500.0, thirdClassSymbol);
                ClassBreak fourthClassBreak = new ClassBreak("1501 to 2000", "1501 - 2000", 1501.0, 2000.0, fourthClassSymbol);
                ClassBreak fifthClassBreak = new ClassBreak("2001 to 2300", "2001 to 2300", 2001.0, 2300.0, fifthClassSymbol);
                List<ClassBreak> elevationBreaks = new List<ClassBreak>() { firstClassBreak, secondClassBreak, thirdClassBreak, fourthClassBreak, fifthClassBreak };
    
                // Create and assign a class breaks renderer to the feature layer.
                ClassBreaksRenderer elevationClassBreaksRenderer = new ClassBreaksRenderer("ELEV_GAIN", elevationBreaks);
                featureLayer.Renderer = elevationClassBreaksRenderer;
    
                // Set the layer opacity to semi-transparent.
                featureLayer.Opacity = 0.75;
            }
    
            private void AddBikeOnlyTrailsLayer()
            {
                // Create a trails feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trails);
    
                // Write a definition expression to filter for trails that permit the use of bikes.
                featureLayer.DefinitionExpression = "USE_BIKE = 'Yes'";
    
                // Create and assign a simple renderer to the feature layer.
                SimpleLineSymbol bikeTrailSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.Blue, 2.0);
                SimpleRenderer bikeTrailRenderer = new SimpleRenderer(bikeTrailSymbol);
                featureLayer.Renderer = bikeTrailRenderer;
            }
    
            private void AddNoBikeTrailsLayer()
            {
                // Create a trails feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trails);
    
                // Write a definition expression to filter for trails that don't permit the use of bikes.
                featureLayer.DefinitionExpression = "USE_BIKE = 'No'";
    
                // Create and assign a simple renderer to the feature layer.
                SimpleLineSymbol noBikeTrailSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.Red, 2.0);
                SimpleRenderer noBikeTrailRenderer = new SimpleRenderer(noBikeTrailSymbol);
                featureLayer.Renderer = noBikeTrailRenderer;
            }
    
            private LabelDefinition MakeLabelDefinition(string labelAttribute)
            {
                // Create a new text symbol.
                TextSymbol labelTextSymbol  = new TextSymbol
                {
                    Color = Color.White,
                    Size = 12.0,
                    HaloColor = Color.Red,
                    HaloWidth = 1.0,
                    FontFamily = "Arial",
                    FontStyle = FontStyle.Italic,
                    FontWeight = FontWeight.Normal
                };
    
                // Create a new Arcade label expression based on the field name.
                ArcadeLabelExpression labelExpression = new ArcadeLabelExpression("$feature." + labelAttribute);
    
                // Create and return the label definition.
                return new LabelDefinition(labelExpression, labelTextSymbol );
            }
    
            private void AddTrailheadsLayer()
            {
                // Create a trailheads feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trailheads);
    
                // Create a new picture marker symbol that uses the trailhead image.
                PictureMarkerSymbol pictureMarkerSymbol = new PictureMarkerSymbol(trailheadImage);
                pictureMarkerSymbol.Height = 18.0;
                pictureMarkerSymbol.Width = 18.0;
    
                // Create a new simple renderer based on the picture marker symbol.
                SimpleRenderer simpleRenderer = new SimpleRenderer(pictureMarkerSymbol);
    
                // Set the feature layer's renderer and enable labels.
                featureLayer.Renderer = simpleRenderer;
                featureLayer.LabelsEnabled = true;
    
                // Create the label definition and pass the "TRL_NAME" attribute to label features by trail name.
                LabelDefinition trailHeadsDefinition = MakeLabelDefinition("TRL_NAME");
    
                // Add the label definition to the layer's label definition collection.
                featureLayer.LabelDefinitions.Add(trailHeadsDefinition);
            }
    
            private void SetupMap()
            {
                // Create a new map with a 'topographic vector' basemap.
                Map = new Map(BasemapStyle.ArcGISTopographic);
    
                AddOpenSpaceLayer();
    
                AddTrailsLayer();
    
                AddNoBikeTrailsLayer();
    
                AddBikeOnlyTrailsLayer();
    
                AddTrailheadsLayer();
    
            }
    
        }
    }
    
  4. Add a new method named AddFeatureLayer() that takes a feature service URI as an argument, creates a feature layer from it, and adds the layer to the map.

    MapViewModel.cs
    Use dark colors for code blocks
                                                                                                                                                                                                                                             
    Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.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
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    
    //   Copyright 2022 Esri
    //   Licensed under the Apache License, Version 2.0 (the "License");
    //   you may not use this file except in compliance with the License.
    //   You may obtain a copy of the License at
    //
    //   https://www.apache.org/licenses/LICENSE-2.0
    //
    //   Unless required by applicable law or agreed to in writing, software
    //   distributed under the License is distributed on an "AS IS" BASIS,
    //   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    //   See the License for the specific language governing permissions and
    //   limitations under the License.
    
    using System;
    using System.Collections.Generic;
    using System.Text;
    using Esri.ArcGISRuntime.Geometry;
    using Esri.ArcGISRuntime.Mapping;
    using System.ComponentModel;
    using System.Runtime.CompilerServices;
    
    using Esri.ArcGISRuntime.Data;
    using Esri.ArcGISRuntime.Mapping.Labeling;
    using Esri.ArcGISRuntime.Symbology;
    using System.Diagnostics;
    using System.Drawing;
    
    namespace StyleAFeatureLayer
    {
    
        class MapViewModel : INotifyPropertyChanged
        {
    
            // Application constants used to connect to data and resources.
            static Uri parksAndOpenSpaces = new Uri("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space/FeatureServer/0");
            static Uri trails = new Uri("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0");
            static Uri trailheads = new Uri("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads/FeatureServer/0");
            static Uri trailheadImage = new Uri("https://static.arcgis.com/images/Symbols/NPS/npsPictograph_0231b.png");
    
            public MapViewModel()
            {
                SetupMap();
            }
    
            public event PropertyChangedEventHandler PropertyChanged;
            protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
            {
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
            }
    
    
            private Map _map;
            public Map Map
            {
                get { return _map; }
                set
                {
                    _map = value;
                    OnPropertyChanged();
                }
            }
    
            private FeatureLayer AddFeatureLayer(Uri featureServiceUri)
            {
                // Create a service feature table from a Uri.
                ServiceFeatureTable serviceFeatureTable = new ServiceFeatureTable(featureServiceUri);
    
                // Create a feature layer from the service feature table.
                FeatureLayer featureLayer = new FeatureLayer(serviceFeatureTable);
    
                // Add the feature layer to the maps operational layers collection.
                Map.OperationalLayers.Add(featureLayer);
    
                // Return the feature layer.
                return featureLayer;
            }
    
            private void AddOpenSpaceLayer()
            {
                // Create a parks and open spaces feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(parksAndOpenSpaces);
    
                // Create fill symbols.
                SimpleFillSymbol purpleFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Purple, null);
                SimpleFillSymbol greenFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Green, null);
                SimpleFillSymbol blueFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Blue, null);
                SimpleFillSymbol redFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Red, null);
    
                // Create a unique value for natural areas, regional open spaces, local parks, and regional recreation parks.
                UniqueValue naturalAreas = new UniqueValue("Natural Areas", "Natural Areas", purpleFillSymbol, "Natural Areas");
                UniqueValue regionalOpenSpace = new UniqueValue("Regional Open Space", "Regional Open Space", greenFillSymbol, "Regional Open Space");
                UniqueValue localPark = new UniqueValue("Local Park", "Local Park", blueFillSymbol, "Local Park");
                UniqueValue regionalRecreationPark = new UniqueValue("Regional Recreation Park", "Regional Recreation Park", redFillSymbol, "Regional Recreation Park");
    
                // Create a unique value renderer to display these values.
                UniqueValueRenderer openSpacesUniqueValueRenderer = new UniqueValueRenderer
                    (new List<string>() {
                        "TYPE"
                    },
                    new List<UniqueValue>() {
                        naturalAreas, regionalOpenSpace, localPark, regionalRecreationPark
                    },
                    "Open Spaces",
                    null);
    
                // Assign the unique value renderer to the open spaces layer.
                featureLayer.Renderer = openSpacesUniqueValueRenderer;
    
                // Set the layer opacity to semi-transparent.
                featureLayer.Opacity = 0.2;
            }
    
            private void AddTrailsLayer()
            {
                // Create a trails feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trails);
    
                // Create simple line symbols.
                SimpleLineSymbol firstClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 3.0);
                SimpleLineSymbol secondClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 4.0);
                SimpleLineSymbol thirdClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 5.0);
                SimpleLineSymbol fourthClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 6.0);
                SimpleLineSymbol fifthClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 7.0);
    
                // Create five class breaks.
                ClassBreak firstClassBreak = new ClassBreak("Under 500", "0 - 500", 0.0, 500.0, firstClassSymbol);
                ClassBreak secondClassBreak = new ClassBreak("501 to 1000", "501 - 1000", 501.0, 1000.0, secondClassSymbol);
                ClassBreak thirdClassBreak = new ClassBreak("1001 to 1500", "1001 - 1500", 1001.0, 1500.0, thirdClassSymbol);
                ClassBreak fourthClassBreak = new ClassBreak("1501 to 2000", "1501 - 2000", 1501.0, 2000.0, fourthClassSymbol);
                ClassBreak fifthClassBreak = new ClassBreak("2001 to 2300", "2001 to 2300", 2001.0, 2300.0, fifthClassSymbol);
                List<ClassBreak> elevationBreaks = new List<ClassBreak>() { firstClassBreak, secondClassBreak, thirdClassBreak, fourthClassBreak, fifthClassBreak };
    
                // Create and assign a class breaks renderer to the feature layer.
                ClassBreaksRenderer elevationClassBreaksRenderer = new ClassBreaksRenderer("ELEV_GAIN", elevationBreaks);
                featureLayer.Renderer = elevationClassBreaksRenderer;
    
                // Set the layer opacity to semi-transparent.
                featureLayer.Opacity = 0.75;
            }
    
            private void AddBikeOnlyTrailsLayer()
            {
                // Create a trails feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trails);
    
                // Write a definition expression to filter for trails that permit the use of bikes.
                featureLayer.DefinitionExpression = "USE_BIKE = 'Yes'";
    
                // Create and assign a simple renderer to the feature layer.
                SimpleLineSymbol bikeTrailSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.Blue, 2.0);
                SimpleRenderer bikeTrailRenderer = new SimpleRenderer(bikeTrailSymbol);
                featureLayer.Renderer = bikeTrailRenderer;
            }
    
            private void AddNoBikeTrailsLayer()
            {
                // Create a trails feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trails);
    
                // Write a definition expression to filter for trails that don't permit the use of bikes.
                featureLayer.DefinitionExpression = "USE_BIKE = 'No'";
    
                // Create and assign a simple renderer to the feature layer.
                SimpleLineSymbol noBikeTrailSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.Red, 2.0);
                SimpleRenderer noBikeTrailRenderer = new SimpleRenderer(noBikeTrailSymbol);
                featureLayer.Renderer = noBikeTrailRenderer;
            }
    
            private LabelDefinition MakeLabelDefinition(string labelAttribute)
            {
                // Create a new text symbol.
                TextSymbol labelTextSymbol  = new TextSymbol
                {
                    Color = Color.White,
                    Size = 12.0,
                    HaloColor = Color.Red,
                    HaloWidth = 1.0,
                    FontFamily = "Arial",
                    FontStyle = FontStyle.Italic,
                    FontWeight = FontWeight.Normal
                };
    
                // Create a new Arcade label expression based on the field name.
                ArcadeLabelExpression labelExpression = new ArcadeLabelExpression("$feature." + labelAttribute);
    
                // Create and return the label definition.
                return new LabelDefinition(labelExpression, labelTextSymbol );
            }
    
            private void AddTrailheadsLayer()
            {
                // Create a trailheads feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trailheads);
    
                // Create a new picture marker symbol that uses the trailhead image.
                PictureMarkerSymbol pictureMarkerSymbol = new PictureMarkerSymbol(trailheadImage);
                pictureMarkerSymbol.Height = 18.0;
                pictureMarkerSymbol.Width = 18.0;
    
                // Create a new simple renderer based on the picture marker symbol.
                SimpleRenderer simpleRenderer = new SimpleRenderer(pictureMarkerSymbol);
    
                // Set the feature layer's renderer and enable labels.
                featureLayer.Renderer = simpleRenderer;
                featureLayer.LabelsEnabled = true;
    
                // Create the label definition and pass the "TRL_NAME" attribute to label features by trail name.
                LabelDefinition trailHeadsDefinition = MakeLabelDefinition("TRL_NAME");
    
                // Add the label definition to the layer's label definition collection.
                featureLayer.LabelDefinitions.Add(trailHeadsDefinition);
            }
    
            private void SetupMap()
            {
                // Create a new map with a 'topographic vector' basemap.
                Map = new Map(BasemapStyle.ArcGISTopographic);
    
                AddOpenSpaceLayer();
    
                AddTrailsLayer();
    
                AddNoBikeTrailsLayer();
    
                AddBikeOnlyTrailsLayer();
    
                AddTrailheadsLayer();
    
            }
    
        }
    }
    

Add a layer with a unique value renderer

Create a method to apply a different symbol for each type of park area to the Parks and Open Spaces feature layer.

  1. Add a new method named AddOpenSpaceLayer() just after the newly added AddFeatureLayer() method.

    UniqueValue assigns a symbol to a value or values. A unique value renderer uses a collection of unique values to assign the appropriate symbol for each feature it renderers.

    For this example, the renderer uses a feature's TYPE attribute value to apply the correct symbol.

    MapViewModel.cs
    Use dark colors for code blocks
                                                                                                                                                                                                                                             
    Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.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
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    
    //   Copyright 2022 Esri
    //   Licensed under the Apache License, Version 2.0 (the "License");
    //   you may not use this file except in compliance with the License.
    //   You may obtain a copy of the License at
    //
    //   https://www.apache.org/licenses/LICENSE-2.0
    //
    //   Unless required by applicable law or agreed to in writing, software
    //   distributed under the License is distributed on an "AS IS" BASIS,
    //   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    //   See the License for the specific language governing permissions and
    //   limitations under the License.
    
    using System;
    using System.Collections.Generic;
    using System.Text;
    using Esri.ArcGISRuntime.Geometry;
    using Esri.ArcGISRuntime.Mapping;
    using System.ComponentModel;
    using System.Runtime.CompilerServices;
    
    using Esri.ArcGISRuntime.Data;
    using Esri.ArcGISRuntime.Mapping.Labeling;
    using Esri.ArcGISRuntime.Symbology;
    using System.Diagnostics;
    using System.Drawing;
    
    namespace StyleAFeatureLayer
    {
    
        class MapViewModel : INotifyPropertyChanged
        {
    
            // Application constants used to connect to data and resources.
            static Uri parksAndOpenSpaces = new Uri("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space/FeatureServer/0");
            static Uri trails = new Uri("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0");
            static Uri trailheads = new Uri("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads/FeatureServer/0");
            static Uri trailheadImage = new Uri("https://static.arcgis.com/images/Symbols/NPS/npsPictograph_0231b.png");
    
            public MapViewModel()
            {
                SetupMap();
            }
    
            public event PropertyChangedEventHandler PropertyChanged;
            protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
            {
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
            }
    
    
            private Map _map;
            public Map Map
            {
                get { return _map; }
                set
                {
                    _map = value;
                    OnPropertyChanged();
                }
            }
    
            private FeatureLayer AddFeatureLayer(Uri featureServiceUri)
            {
                // Create a service feature table from a Uri.
                ServiceFeatureTable serviceFeatureTable = new ServiceFeatureTable(featureServiceUri);
    
                // Create a feature layer from the service feature table.
                FeatureLayer featureLayer = new FeatureLayer(serviceFeatureTable);
    
                // Add the feature layer to the maps operational layers collection.
                Map.OperationalLayers.Add(featureLayer);
    
                // Return the feature layer.
                return featureLayer;
            }
    
            private void AddOpenSpaceLayer()
            {
                // Create a parks and open spaces feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(parksAndOpenSpaces);
    
                // Create fill symbols.
                SimpleFillSymbol purpleFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Purple, null);
                SimpleFillSymbol greenFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Green, null);
                SimpleFillSymbol blueFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Blue, null);
                SimpleFillSymbol redFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Red, null);
    
                // Create a unique value for natural areas, regional open spaces, local parks, and regional recreation parks.
                UniqueValue naturalAreas = new UniqueValue("Natural Areas", "Natural Areas", purpleFillSymbol, "Natural Areas");
                UniqueValue regionalOpenSpace = new UniqueValue("Regional Open Space", "Regional Open Space", greenFillSymbol, "Regional Open Space");
                UniqueValue localPark = new UniqueValue("Local Park", "Local Park", blueFillSymbol, "Local Park");
                UniqueValue regionalRecreationPark = new UniqueValue("Regional Recreation Park", "Regional Recreation Park", redFillSymbol, "Regional Recreation Park");
    
                // Create a unique value renderer to display these values.
                UniqueValueRenderer openSpacesUniqueValueRenderer = new UniqueValueRenderer
                    (new List<string>() {
                        "TYPE"
                    },
                    new List<UniqueValue>() {
                        naturalAreas, regionalOpenSpace, localPark, regionalRecreationPark
                    },
                    "Open Spaces",
                    null);
    
                // Assign the unique value renderer to the open spaces layer.
                featureLayer.Renderer = openSpacesUniqueValueRenderer;
    
                // Set the layer opacity to semi-transparent.
                featureLayer.Opacity = 0.2;
            }
    
            private void AddTrailsLayer()
            {
                // Create a trails feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trails);
    
                // Create simple line symbols.
                SimpleLineSymbol firstClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 3.0);
                SimpleLineSymbol secondClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 4.0);
                SimpleLineSymbol thirdClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 5.0);
                SimpleLineSymbol fourthClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 6.0);
                SimpleLineSymbol fifthClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 7.0);
    
                // Create five class breaks.
                ClassBreak firstClassBreak = new ClassBreak("Under 500", "0 - 500", 0.0, 500.0, firstClassSymbol);
                ClassBreak secondClassBreak = new ClassBreak("501 to 1000", "501 - 1000", 501.0, 1000.0, secondClassSymbol);
                ClassBreak thirdClassBreak = new ClassBreak("1001 to 1500", "1001 - 1500", 1001.0, 1500.0, thirdClassSymbol);
                ClassBreak fourthClassBreak = new ClassBreak("1501 to 2000", "1501 - 2000", 1501.0, 2000.0, fourthClassSymbol);
                ClassBreak fifthClassBreak = new ClassBreak("2001 to 2300", "2001 to 2300", 2001.0, 2300.0, fifthClassSymbol);
                List<ClassBreak> elevationBreaks = new List<ClassBreak>() { firstClassBreak, secondClassBreak, thirdClassBreak, fourthClassBreak, fifthClassBreak };
    
                // Create and assign a class breaks renderer to the feature layer.
                ClassBreaksRenderer elevationClassBreaksRenderer = new ClassBreaksRenderer("ELEV_GAIN", elevationBreaks);
                featureLayer.Renderer = elevationClassBreaksRenderer;
    
                // Set the layer opacity to semi-transparent.
                featureLayer.Opacity = 0.75;
            }
    
            private void AddBikeOnlyTrailsLayer()
            {
                // Create a trails feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trails);
    
                // Write a definition expression to filter for trails that permit the use of bikes.
                featureLayer.DefinitionExpression = "USE_BIKE = 'Yes'";
    
                // Create and assign a simple renderer to the feature layer.
                SimpleLineSymbol bikeTrailSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.Blue, 2.0);
                SimpleRenderer bikeTrailRenderer = new SimpleRenderer(bikeTrailSymbol);
                featureLayer.Renderer = bikeTrailRenderer;
            }
    
            private void AddNoBikeTrailsLayer()
            {
                // Create a trails feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trails);
    
                // Write a definition expression to filter for trails that don't permit the use of bikes.
                featureLayer.DefinitionExpression = "USE_BIKE = 'No'";
    
                // Create and assign a simple renderer to the feature layer.
                SimpleLineSymbol noBikeTrailSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.Red, 2.0);
                SimpleRenderer noBikeTrailRenderer = new SimpleRenderer(noBikeTrailSymbol);
                featureLayer.Renderer = noBikeTrailRenderer;
            }
    
            private LabelDefinition MakeLabelDefinition(string labelAttribute)
            {
                // Create a new text symbol.
                TextSymbol labelTextSymbol  = new TextSymbol
                {
                    Color = Color.White,
                    Size = 12.0,
                    HaloColor = Color.Red,
                    HaloWidth = 1.0,
                    FontFamily = "Arial",
                    FontStyle = FontStyle.Italic,
                    FontWeight = FontWeight.Normal
                };
    
                // Create a new Arcade label expression based on the field name.
                ArcadeLabelExpression labelExpression = new ArcadeLabelExpression("$feature." + labelAttribute);
    
                // Create and return the label definition.
                return new LabelDefinition(labelExpression, labelTextSymbol );
            }
    
            private void AddTrailheadsLayer()
            {
                // Create a trailheads feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trailheads);
    
                // Create a new picture marker symbol that uses the trailhead image.
                PictureMarkerSymbol pictureMarkerSymbol = new PictureMarkerSymbol(trailheadImage);
                pictureMarkerSymbol.Height = 18.0;
                pictureMarkerSymbol.Width = 18.0;
    
                // Create a new simple renderer based on the picture marker symbol.
                SimpleRenderer simpleRenderer = new SimpleRenderer(pictureMarkerSymbol);
    
                // Set the feature layer's renderer and enable labels.
                featureLayer.Renderer = simpleRenderer;
                featureLayer.LabelsEnabled = true;
    
                // Create the label definition and pass the "TRL_NAME" attribute to label features by trail name.
                LabelDefinition trailHeadsDefinition = MakeLabelDefinition("TRL_NAME");
    
                // Add the label definition to the layer's label definition collection.
                featureLayer.LabelDefinitions.Add(trailHeadsDefinition);
            }
    
            private void SetupMap()
            {
                // Create a new map with a 'topographic vector' basemap.
                Map = new Map(BasemapStyle.ArcGISTopographic);
    
                AddOpenSpaceLayer();
    
                AddTrailsLayer();
    
                AddNoBikeTrailsLayer();
    
                AddBikeOnlyTrailsLayer();
    
                AddTrailheadsLayer();
    
            }
    
        }
    }
    
  2. Update SetupMap() to call the new AddOpenSpaceLayer() method.

    MapViewModel.cs
    Use dark colors for code blocks
                                                                                                                                                                                                                                             
    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
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    
    //   Copyright 2022 Esri
    //   Licensed under the Apache License, Version 2.0 (the "License");
    //   you may not use this file except in compliance with the License.
    //   You may obtain a copy of the License at
    //
    //   https://www.apache.org/licenses/LICENSE-2.0
    //
    //   Unless required by applicable law or agreed to in writing, software
    //   distributed under the License is distributed on an "AS IS" BASIS,
    //   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    //   See the License for the specific language governing permissions and
    //   limitations under the License.
    
    using System;
    using System.Collections.Generic;
    using System.Text;
    using Esri.ArcGISRuntime.Geometry;
    using Esri.ArcGISRuntime.Mapping;
    using System.ComponentModel;
    using System.Runtime.CompilerServices;
    
    using Esri.ArcGISRuntime.Data;
    using Esri.ArcGISRuntime.Mapping.Labeling;
    using Esri.ArcGISRuntime.Symbology;
    using System.Diagnostics;
    using System.Drawing;
    
    namespace StyleAFeatureLayer
    {
    
        class MapViewModel : INotifyPropertyChanged
        {
    
            // Application constants used to connect to data and resources.
            static Uri parksAndOpenSpaces = new Uri("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space/FeatureServer/0");
            static Uri trails = new Uri("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0");
            static Uri trailheads = new Uri("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads/FeatureServer/0");
            static Uri trailheadImage = new Uri("https://static.arcgis.com/images/Symbols/NPS/npsPictograph_0231b.png");
    
            public MapViewModel()
            {
                SetupMap();
            }
    
            public event PropertyChangedEventHandler PropertyChanged;
            protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
            {
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
            }
    
    
            private Map _map;
            public Map Map
            {
                get { return _map; }
                set
                {
                    _map = value;
                    OnPropertyChanged();
                }
            }
    
            private FeatureLayer AddFeatureLayer(Uri featureServiceUri)
            {
                // Create a service feature table from a Uri.
                ServiceFeatureTable serviceFeatureTable = new ServiceFeatureTable(featureServiceUri);
    
                // Create a feature layer from the service feature table.
                FeatureLayer featureLayer = new FeatureLayer(serviceFeatureTable);
    
                // Add the feature layer to the maps operational layers collection.
                Map.OperationalLayers.Add(featureLayer);
    
                // Return the feature layer.
                return featureLayer;
            }
    
            private void AddOpenSpaceLayer()
            {
                // Create a parks and open spaces feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(parksAndOpenSpaces);
    
                // Create fill symbols.
                SimpleFillSymbol purpleFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Purple, null);
                SimpleFillSymbol greenFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Green, null);
                SimpleFillSymbol blueFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Blue, null);
                SimpleFillSymbol redFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Red, null);
    
                // Create a unique value for natural areas, regional open spaces, local parks, and regional recreation parks.
                UniqueValue naturalAreas = new UniqueValue("Natural Areas", "Natural Areas", purpleFillSymbol, "Natural Areas");
                UniqueValue regionalOpenSpace = new UniqueValue("Regional Open Space", "Regional Open Space", greenFillSymbol, "Regional Open Space");
                UniqueValue localPark = new UniqueValue("Local Park", "Local Park", blueFillSymbol, "Local Park");
                UniqueValue regionalRecreationPark = new UniqueValue("Regional Recreation Park", "Regional Recreation Park", redFillSymbol, "Regional Recreation Park");
    
                // Create a unique value renderer to display these values.
                UniqueValueRenderer openSpacesUniqueValueRenderer = new UniqueValueRenderer
                    (new List<string>() {
                        "TYPE"
                    },
                    new List<UniqueValue>() {
                        naturalAreas, regionalOpenSpace, localPark, regionalRecreationPark
                    },
                    "Open Spaces",
                    null);
    
                // Assign the unique value renderer to the open spaces layer.
                featureLayer.Renderer = openSpacesUniqueValueRenderer;
    
                // Set the layer opacity to semi-transparent.
                featureLayer.Opacity = 0.2;
            }
    
            private void AddTrailsLayer()
            {
                // Create a trails feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trails);
    
                // Create simple line symbols.
                SimpleLineSymbol firstClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 3.0);
                SimpleLineSymbol secondClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 4.0);
                SimpleLineSymbol thirdClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 5.0);
                SimpleLineSymbol fourthClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 6.0);
                SimpleLineSymbol fifthClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 7.0);
    
                // Create five class breaks.
                ClassBreak firstClassBreak = new ClassBreak("Under 500", "0 - 500", 0.0, 500.0, firstClassSymbol);
                ClassBreak secondClassBreak = new ClassBreak("501 to 1000", "501 - 1000", 501.0, 1000.0, secondClassSymbol);
                ClassBreak thirdClassBreak = new ClassBreak("1001 to 1500", "1001 - 1500", 1001.0, 1500.0, thirdClassSymbol);
                ClassBreak fourthClassBreak = new ClassBreak("1501 to 2000", "1501 - 2000", 1501.0, 2000.0, fourthClassSymbol);
                ClassBreak fifthClassBreak = new ClassBreak("2001 to 2300", "2001 to 2300", 2001.0, 2300.0, fifthClassSymbol);
                List<ClassBreak> elevationBreaks = new List<ClassBreak>() { firstClassBreak, secondClassBreak, thirdClassBreak, fourthClassBreak, fifthClassBreak };
    
                // Create and assign a class breaks renderer to the feature layer.
                ClassBreaksRenderer elevationClassBreaksRenderer = new ClassBreaksRenderer("ELEV_GAIN", elevationBreaks);
                featureLayer.Renderer = elevationClassBreaksRenderer;
    
                // Set the layer opacity to semi-transparent.
                featureLayer.Opacity = 0.75;
            }
    
            private void AddBikeOnlyTrailsLayer()
            {
                // Create a trails feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trails);
    
                // Write a definition expression to filter for trails that permit the use of bikes.
                featureLayer.DefinitionExpression = "USE_BIKE = 'Yes'";
    
                // Create and assign a simple renderer to the feature layer.
                SimpleLineSymbol bikeTrailSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.Blue, 2.0);
                SimpleRenderer bikeTrailRenderer = new SimpleRenderer(bikeTrailSymbol);
                featureLayer.Renderer = bikeTrailRenderer;
            }
    
            private void AddNoBikeTrailsLayer()
            {
                // Create a trails feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trails);
    
                // Write a definition expression to filter for trails that don't permit the use of bikes.
                featureLayer.DefinitionExpression = "USE_BIKE = 'No'";
    
                // Create and assign a simple renderer to the feature layer.
                SimpleLineSymbol noBikeTrailSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.Red, 2.0);
                SimpleRenderer noBikeTrailRenderer = new SimpleRenderer(noBikeTrailSymbol);
                featureLayer.Renderer = noBikeTrailRenderer;
            }
    
            private LabelDefinition MakeLabelDefinition(string labelAttribute)
            {
                // Create a new text symbol.
                TextSymbol labelTextSymbol  = new TextSymbol
                {
                    Color = Color.White,
                    Size = 12.0,
                    HaloColor = Color.Red,
                    HaloWidth = 1.0,
                    FontFamily = "Arial",
                    FontStyle = FontStyle.Italic,
                    FontWeight = FontWeight.Normal
                };
    
                // Create a new Arcade label expression based on the field name.
                ArcadeLabelExpression labelExpression = new ArcadeLabelExpression("$feature." + labelAttribute);
    
                // Create and return the label definition.
                return new LabelDefinition(labelExpression, labelTextSymbol );
            }
    
            private void AddTrailheadsLayer()
            {
                // Create a trailheads feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trailheads);
    
                // Create a new picture marker symbol that uses the trailhead image.
                PictureMarkerSymbol pictureMarkerSymbol = new PictureMarkerSymbol(trailheadImage);
                pictureMarkerSymbol.Height = 18.0;
                pictureMarkerSymbol.Width = 18.0;
    
                // Create a new simple renderer based on the picture marker symbol.
                SimpleRenderer simpleRenderer = new SimpleRenderer(pictureMarkerSymbol);
    
                // Set the feature layer's renderer and enable labels.
                featureLayer.Renderer = simpleRenderer;
                featureLayer.LabelsEnabled = true;
    
                // Create the label definition and pass the "TRL_NAME" attribute to label features by trail name.
                LabelDefinition trailHeadsDefinition = MakeLabelDefinition("TRL_NAME");
    
                // Add the label definition to the layer's label definition collection.
                featureLayer.LabelDefinitions.Add(trailHeadsDefinition);
            }
    
            private void SetupMap()
            {
                // Create a new map with a 'topographic vector' basemap.
                Map = new Map(BasemapStyle.ArcGISTopographic);
    
                AddOpenSpaceLayer();
    
                AddTrailsLayer();
    
                AddNoBikeTrailsLayer();
    
                AddBikeOnlyTrailsLayer();
    
                AddTrailheadsLayer();
    
            }
    
        }
    }
    
  3. Click Debug > Start Debugging (or press <F5> on the keyboard) to run the app.

When the app opens, Parks and Open Spaces feature layer is added to the map. The map displays the different types of parks and open spaces with four unique symbols.

Add a layer with a class breaks renderer

Create a method to apply a different symbol for each of the five ranges of elevation gain to the Trails feature layer.

  1. Add a new method named AddTrailsLayer() just after the AddOpenSpaceLayer() method you created above.

    A ClassBreak assigns a symbol to a range of values.

    For this example, the renderer uses each feature's ELEV_GAIN attribute value to classify it into a defined range (class break) and apply the corresponding symbol.

    MapViewModel.cs
    Use dark colors for code blocks
                                                                                                                                                                                                                                             
    Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.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
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    
    //   Copyright 2022 Esri
    //   Licensed under the Apache License, Version 2.0 (the "License");
    //   you may not use this file except in compliance with the License.
    //   You may obtain a copy of the License at
    //
    //   https://www.apache.org/licenses/LICENSE-2.0
    //
    //   Unless required by applicable law or agreed to in writing, software
    //   distributed under the License is distributed on an "AS IS" BASIS,
    //   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    //   See the License for the specific language governing permissions and
    //   limitations under the License.
    
    using System;
    using System.Collections.Generic;
    using System.Text;
    using Esri.ArcGISRuntime.Geometry;
    using Esri.ArcGISRuntime.Mapping;
    using System.ComponentModel;
    using System.Runtime.CompilerServices;
    
    using Esri.ArcGISRuntime.Data;
    using Esri.ArcGISRuntime.Mapping.Labeling;
    using Esri.ArcGISRuntime.Symbology;
    using System.Diagnostics;
    using System.Drawing;
    
    namespace StyleAFeatureLayer
    {
    
        class MapViewModel : INotifyPropertyChanged
        {
    
            // Application constants used to connect to data and resources.
            static Uri parksAndOpenSpaces = new Uri("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space/FeatureServer/0");
            static Uri trails = new Uri("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0");
            static Uri trailheads = new Uri("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads/FeatureServer/0");
            static Uri trailheadImage = new Uri("https://static.arcgis.com/images/Symbols/NPS/npsPictograph_0231b.png");
    
            public MapViewModel()
            {
                SetupMap();
            }
    
            public event PropertyChangedEventHandler PropertyChanged;
            protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
            {
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
            }
    
    
            private Map _map;
            public Map Map
            {
                get { return _map; }
                set
                {
                    _map = value;
                    OnPropertyChanged();
                }
            }
    
            private FeatureLayer AddFeatureLayer(Uri featureServiceUri)
            {
                // Create a service feature table from a Uri.
                ServiceFeatureTable serviceFeatureTable = new ServiceFeatureTable(featureServiceUri);
    
                // Create a feature layer from the service feature table.
                FeatureLayer featureLayer = new FeatureLayer(serviceFeatureTable);
    
                // Add the feature layer to the maps operational layers collection.
                Map.OperationalLayers.Add(featureLayer);
    
                // Return the feature layer.
                return featureLayer;
            }
    
            private void AddOpenSpaceLayer()
            {
                // Create a parks and open spaces feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(parksAndOpenSpaces);
    
                // Create fill symbols.
                SimpleFillSymbol purpleFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Purple, null);
                SimpleFillSymbol greenFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Green, null);
                SimpleFillSymbol blueFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Blue, null);
                SimpleFillSymbol redFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Red, null);
    
                // Create a unique value for natural areas, regional open spaces, local parks, and regional recreation parks.
                UniqueValue naturalAreas = new UniqueValue("Natural Areas", "Natural Areas", purpleFillSymbol, "Natural Areas");
                UniqueValue regionalOpenSpace = new UniqueValue("Regional Open Space", "Regional Open Space", greenFillSymbol, "Regional Open Space");
                UniqueValue localPark = new UniqueValue("Local Park", "Local Park", blueFillSymbol, "Local Park");
                UniqueValue regionalRecreationPark = new UniqueValue("Regional Recreation Park", "Regional Recreation Park", redFillSymbol, "Regional Recreation Park");
    
                // Create a unique value renderer to display these values.
                UniqueValueRenderer openSpacesUniqueValueRenderer = new UniqueValueRenderer
                    (new List<string>() {
                        "TYPE"
                    },
                    new List<UniqueValue>() {
                        naturalAreas, regionalOpenSpace, localPark, regionalRecreationPark
                    },
                    "Open Spaces",
                    null);
    
                // Assign the unique value renderer to the open spaces layer.
                featureLayer.Renderer = openSpacesUniqueValueRenderer;
    
                // Set the layer opacity to semi-transparent.
                featureLayer.Opacity = 0.2;
            }
    
            private void AddTrailsLayer()
            {
                // Create a trails feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trails);
    
                // Create simple line symbols.
                SimpleLineSymbol firstClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 3.0);
                SimpleLineSymbol secondClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 4.0);
                SimpleLineSymbol thirdClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 5.0);
                SimpleLineSymbol fourthClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 6.0);
                SimpleLineSymbol fifthClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 7.0);
    
                // Create five class breaks.
                ClassBreak firstClassBreak = new ClassBreak("Under 500", "0 - 500", 0.0, 500.0, firstClassSymbol);
                ClassBreak secondClassBreak = new ClassBreak("501 to 1000", "501 - 1000", 501.0, 1000.0, secondClassSymbol);
                ClassBreak thirdClassBreak = new ClassBreak("1001 to 1500", "1001 - 1500", 1001.0, 1500.0, thirdClassSymbol);
                ClassBreak fourthClassBreak = new ClassBreak("1501 to 2000", "1501 - 2000", 1501.0, 2000.0, fourthClassSymbol);
                ClassBreak fifthClassBreak = new ClassBreak("2001 to 2300", "2001 to 2300", 2001.0, 2300.0, fifthClassSymbol);
                List<ClassBreak> elevationBreaks = new List<ClassBreak>() { firstClassBreak, secondClassBreak, thirdClassBreak, fourthClassBreak, fifthClassBreak };
    
                // Create and assign a class breaks renderer to the feature layer.
                ClassBreaksRenderer elevationClassBreaksRenderer = new ClassBreaksRenderer("ELEV_GAIN", elevationBreaks);
                featureLayer.Renderer = elevationClassBreaksRenderer;
    
                // Set the layer opacity to semi-transparent.
                featureLayer.Opacity = 0.75;
            }
    
            private void AddBikeOnlyTrailsLayer()
            {
                // Create a trails feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trails);
    
                // Write a definition expression to filter for trails that permit the use of bikes.
                featureLayer.DefinitionExpression = "USE_BIKE = 'Yes'";
    
                // Create and assign a simple renderer to the feature layer.
                SimpleLineSymbol bikeTrailSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.Blue, 2.0);
                SimpleRenderer bikeTrailRenderer = new SimpleRenderer(bikeTrailSymbol);
                featureLayer.Renderer = bikeTrailRenderer;
            }
    
            private void AddNoBikeTrailsLayer()
            {
                // Create a trails feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trails);
    
                // Write a definition expression to filter for trails that don't permit the use of bikes.
                featureLayer.DefinitionExpression = "USE_BIKE = 'No'";
    
                // Create and assign a simple renderer to the feature layer.
                SimpleLineSymbol noBikeTrailSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.Red, 2.0);
                SimpleRenderer noBikeTrailRenderer = new SimpleRenderer(noBikeTrailSymbol);
                featureLayer.Renderer = noBikeTrailRenderer;
            }
    
            private LabelDefinition MakeLabelDefinition(string labelAttribute)
            {
                // Create a new text symbol.
                TextSymbol labelTextSymbol  = new TextSymbol
                {
                    Color = Color.White,
                    Size = 12.0,
                    HaloColor = Color.Red,
                    HaloWidth = 1.0,
                    FontFamily = "Arial",
                    FontStyle = FontStyle.Italic,
                    FontWeight = FontWeight.Normal
                };
    
                // Create a new Arcade label expression based on the field name.
                ArcadeLabelExpression labelExpression = new ArcadeLabelExpression("$feature." + labelAttribute);
    
                // Create and return the label definition.
                return new LabelDefinition(labelExpression, labelTextSymbol );
            }
    
            private void AddTrailheadsLayer()
            {
                // Create a trailheads feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trailheads);
    
                // Create a new picture marker symbol that uses the trailhead image.
                PictureMarkerSymbol pictureMarkerSymbol = new PictureMarkerSymbol(trailheadImage);
                pictureMarkerSymbol.Height = 18.0;
                pictureMarkerSymbol.Width = 18.0;
    
                // Create a new simple renderer based on the picture marker symbol.
                SimpleRenderer simpleRenderer = new SimpleRenderer(pictureMarkerSymbol);
    
                // Set the feature layer's renderer and enable labels.
                featureLayer.Renderer = simpleRenderer;
                featureLayer.LabelsEnabled = true;
    
                // Create the label definition and pass the "TRL_NAME" attribute to label features by trail name.
                LabelDefinition trailHeadsDefinition = MakeLabelDefinition("TRL_NAME");
    
                // Add the label definition to the layer's label definition collection.
                featureLayer.LabelDefinitions.Add(trailHeadsDefinition);
            }
    
            private void SetupMap()
            {
                // Create a new map with a 'topographic vector' basemap.
                Map = new Map(BasemapStyle.ArcGISTopographic);
    
                AddOpenSpaceLayer();
    
                AddTrailsLayer();
    
                AddNoBikeTrailsLayer();
    
                AddBikeOnlyTrailsLayer();
    
                AddTrailheadsLayer();
    
            }
    
        }
    }
    
  2. Update SetupMap() to call the new AddTrailsLayer() method.

    MapViewModel.cs
    Use dark colors for code blocks
                                                                                                                                                                                                                                             
    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
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    
    //   Copyright 2022 Esri
    //   Licensed under the Apache License, Version 2.0 (the "License");
    //   you may not use this file except in compliance with the License.
    //   You may obtain a copy of the License at
    //
    //   https://www.apache.org/licenses/LICENSE-2.0
    //
    //   Unless required by applicable law or agreed to in writing, software
    //   distributed under the License is distributed on an "AS IS" BASIS,
    //   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    //   See the License for the specific language governing permissions and
    //   limitations under the License.
    
    using System;
    using System.Collections.Generic;
    using System.Text;
    using Esri.ArcGISRuntime.Geometry;
    using Esri.ArcGISRuntime.Mapping;
    using System.ComponentModel;
    using System.Runtime.CompilerServices;
    
    using Esri.ArcGISRuntime.Data;
    using Esri.ArcGISRuntime.Mapping.Labeling;
    using Esri.ArcGISRuntime.Symbology;
    using System.Diagnostics;
    using System.Drawing;
    
    namespace StyleAFeatureLayer
    {
    
        class MapViewModel : INotifyPropertyChanged
        {
    
            // Application constants used to connect to data and resources.
            static Uri parksAndOpenSpaces = new Uri("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space/FeatureServer/0");
            static Uri trails = new Uri("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0");
            static Uri trailheads = new Uri("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads/FeatureServer/0");
            static Uri trailheadImage = new Uri("https://static.arcgis.com/images/Symbols/NPS/npsPictograph_0231b.png");
    
            public MapViewModel()
            {
                SetupMap();
            }
    
            public event PropertyChangedEventHandler PropertyChanged;
            protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
            {
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
            }
    
    
            private Map _map;
            public Map Map
            {
                get { return _map; }
                set
                {
                    _map = value;
                    OnPropertyChanged();
                }
            }
    
            private FeatureLayer AddFeatureLayer(Uri featureServiceUri)
            {
                // Create a service feature table from a Uri.
                ServiceFeatureTable serviceFeatureTable = new ServiceFeatureTable(featureServiceUri);
    
                // Create a feature layer from the service feature table.
                FeatureLayer featureLayer = new FeatureLayer(serviceFeatureTable);
    
                // Add the feature layer to the maps operational layers collection.
                Map.OperationalLayers.Add(featureLayer);
    
                // Return the feature layer.
                return featureLayer;
            }
    
            private void AddOpenSpaceLayer()
            {
                // Create a parks and open spaces feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(parksAndOpenSpaces);
    
                // Create fill symbols.
                SimpleFillSymbol purpleFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Purple, null);
                SimpleFillSymbol greenFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Green, null);
                SimpleFillSymbol blueFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Blue, null);
                SimpleFillSymbol redFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Red, null);
    
                // Create a unique value for natural areas, regional open spaces, local parks, and regional recreation parks.
                UniqueValue naturalAreas = new UniqueValue("Natural Areas", "Natural Areas", purpleFillSymbol, "Natural Areas");
                UniqueValue regionalOpenSpace = new UniqueValue("Regional Open Space", "Regional Open Space", greenFillSymbol, "Regional Open Space");
                UniqueValue localPark = new UniqueValue("Local Park", "Local Park", blueFillSymbol, "Local Park");
                UniqueValue regionalRecreationPark = new UniqueValue("Regional Recreation Park", "Regional Recreation Park", redFillSymbol, "Regional Recreation Park");
    
                // Create a unique value renderer to display these values.
                UniqueValueRenderer openSpacesUniqueValueRenderer = new UniqueValueRenderer
                    (new List<string>() {
                        "TYPE"
                    },
                    new List<UniqueValue>() {
                        naturalAreas, regionalOpenSpace, localPark, regionalRecreationPark
                    },
                    "Open Spaces",
                    null);
    
                // Assign the unique value renderer to the open spaces layer.
                featureLayer.Renderer = openSpacesUniqueValueRenderer;
    
                // Set the layer opacity to semi-transparent.
                featureLayer.Opacity = 0.2;
            }
    
            private void AddTrailsLayer()
            {
                // Create a trails feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trails);
    
                // Create simple line symbols.
                SimpleLineSymbol firstClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 3.0);
                SimpleLineSymbol secondClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 4.0);
                SimpleLineSymbol thirdClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 5.0);
                SimpleLineSymbol fourthClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 6.0);
                SimpleLineSymbol fifthClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 7.0);
    
                // Create five class breaks.
                ClassBreak firstClassBreak = new ClassBreak("Under 500", "0 - 500", 0.0, 500.0, firstClassSymbol);
                ClassBreak secondClassBreak = new ClassBreak("501 to 1000", "501 - 1000", 501.0, 1000.0, secondClassSymbol);
                ClassBreak thirdClassBreak = new ClassBreak("1001 to 1500", "1001 - 1500", 1001.0, 1500.0, thirdClassSymbol);
                ClassBreak fourthClassBreak = new ClassBreak("1501 to 2000", "1501 - 2000", 1501.0, 2000.0, fourthClassSymbol);
                ClassBreak fifthClassBreak = new ClassBreak("2001 to 2300", "2001 to 2300", 2001.0, 2300.0, fifthClassSymbol);
                List<ClassBreak> elevationBreaks = new List<ClassBreak>() { firstClassBreak, secondClassBreak, thirdClassBreak, fourthClassBreak, fifthClassBreak };
    
                // Create and assign a class breaks renderer to the feature layer.
                ClassBreaksRenderer elevationClassBreaksRenderer = new ClassBreaksRenderer("ELEV_GAIN", elevationBreaks);
                featureLayer.Renderer = elevationClassBreaksRenderer;
    
                // Set the layer opacity to semi-transparent.
                featureLayer.Opacity = 0.75;
            }
    
            private void AddBikeOnlyTrailsLayer()
            {
                // Create a trails feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trails);
    
                // Write a definition expression to filter for trails that permit the use of bikes.
                featureLayer.DefinitionExpression = "USE_BIKE = 'Yes'";
    
                // Create and assign a simple renderer to the feature layer.
                SimpleLineSymbol bikeTrailSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.Blue, 2.0);
                SimpleRenderer bikeTrailRenderer = new SimpleRenderer(bikeTrailSymbol);
                featureLayer.Renderer = bikeTrailRenderer;
            }
    
            private void AddNoBikeTrailsLayer()
            {
                // Create a trails feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trails);
    
                // Write a definition expression to filter for trails that don't permit the use of bikes.
                featureLayer.DefinitionExpression = "USE_BIKE = 'No'";
    
                // Create and assign a simple renderer to the feature layer.
                SimpleLineSymbol noBikeTrailSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.Red, 2.0);
                SimpleRenderer noBikeTrailRenderer = new SimpleRenderer(noBikeTrailSymbol);
                featureLayer.Renderer = noBikeTrailRenderer;
            }
    
            private LabelDefinition MakeLabelDefinition(string labelAttribute)
            {
                // Create a new text symbol.
                TextSymbol labelTextSymbol  = new TextSymbol
                {
                    Color = Color.White,
                    Size = 12.0,
                    HaloColor = Color.Red,
                    HaloWidth = 1.0,
                    FontFamily = "Arial",
                    FontStyle = FontStyle.Italic,
                    FontWeight = FontWeight.Normal
                };
    
                // Create a new Arcade label expression based on the field name.
                ArcadeLabelExpression labelExpression = new ArcadeLabelExpression("$feature." + labelAttribute);
    
                // Create and return the label definition.
                return new LabelDefinition(labelExpression, labelTextSymbol );
            }
    
            private void AddTrailheadsLayer()
            {
                // Create a trailheads feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trailheads);
    
                // Create a new picture marker symbol that uses the trailhead image.
                PictureMarkerSymbol pictureMarkerSymbol = new PictureMarkerSymbol(trailheadImage);
                pictureMarkerSymbol.Height = 18.0;
                pictureMarkerSymbol.Width = 18.0;
    
                // Create a new simple renderer based on the picture marker symbol.
                SimpleRenderer simpleRenderer = new SimpleRenderer(pictureMarkerSymbol);
    
                // Set the feature layer's renderer and enable labels.
                featureLayer.Renderer = simpleRenderer;
                featureLayer.LabelsEnabled = true;
    
                // Create the label definition and pass the "TRL_NAME" attribute to label features by trail name.
                LabelDefinition trailHeadsDefinition = MakeLabelDefinition("TRL_NAME");
    
                // Add the label definition to the layer's label definition collection.
                featureLayer.LabelDefinitions.Add(trailHeadsDefinition);
            }
    
            private void SetupMap()
            {
                // Create a new map with a 'topographic vector' basemap.
                Map = new Map(BasemapStyle.ArcGISTopographic);
    
                AddOpenSpaceLayer();
    
                AddTrailsLayer();
    
                AddNoBikeTrailsLayer();
    
                AddBikeOnlyTrailsLayer();
    
                AddTrailheadsLayer();
    
            }
    
        }
    }
    
  3. Click Debug > Start Debugging (or press <F5> on the keyboard) to run the app.

When the app opens, the Trails feature layer is added to the map. The map displays trails with different symbols depending on trail elevation.

Add layers with definition expressions

You can use a definition expression to define a subset of features to display. Features that do not meet the expression criteria are not displayed by the layer. In the following steps, you will create two methods that use a definition expression to apply a symbol to a subset of features in the Trails feature layer.

FeatureLayer.DefinitionExpression uses a SQL expression to limit the features available for query and display. Your code will create two layers that each display a different subset of trails based on the value for the USE_BIKE field. Trails that allow bikes will be symbolized with a blue symbol ("USE_BIKE = 'Yes'") and those that don't will be red ("USE_BIKE = 'No'"). Another way to symbolize these features would be to create a UniqueValueRenderer that applies a different symbol for these values.

  1. Add a method named AddBikeOnlyTrailsLayer() with a definition expression to filter for trails that permit bikes. Add this method just after the newly added AddTrailsLayer() method.

    MapViewModel.cs
    Use dark colors for code blocks
                                                                                                                                                                                                                                             
    Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.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
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    
    //   Copyright 2022 Esri
    //   Licensed under the Apache License, Version 2.0 (the "License");
    //   you may not use this file except in compliance with the License.
    //   You may obtain a copy of the License at
    //
    //   https://www.apache.org/licenses/LICENSE-2.0
    //
    //   Unless required by applicable law or agreed to in writing, software
    //   distributed under the License is distributed on an "AS IS" BASIS,
    //   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    //   See the License for the specific language governing permissions and
    //   limitations under the License.
    
    using System;
    using System.Collections.Generic;
    using System.Text;
    using Esri.ArcGISRuntime.Geometry;
    using Esri.ArcGISRuntime.Mapping;
    using System.ComponentModel;
    using System.Runtime.CompilerServices;
    
    using Esri.ArcGISRuntime.Data;
    using Esri.ArcGISRuntime.Mapping.Labeling;
    using Esri.ArcGISRuntime.Symbology;
    using System.Diagnostics;
    using System.Drawing;
    
    namespace StyleAFeatureLayer
    {
    
        class MapViewModel : INotifyPropertyChanged
        {
    
            // Application constants used to connect to data and resources.
            static Uri parksAndOpenSpaces = new Uri("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space/FeatureServer/0");
            static Uri trails = new Uri("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0");
            static Uri trailheads = new Uri("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads/FeatureServer/0");
            static Uri trailheadImage = new Uri("https://static.arcgis.com/images/Symbols/NPS/npsPictograph_0231b.png");
    
            public MapViewModel()
            {
                SetupMap();
            }
    
            public event PropertyChangedEventHandler PropertyChanged;
            protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
            {
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
            }
    
    
            private Map _map;
            public Map Map
            {
                get { return _map; }
                set
                {
                    _map = value;
                    OnPropertyChanged();
                }
            }
    
            private FeatureLayer AddFeatureLayer(Uri featureServiceUri)
            {
                // Create a service feature table from a Uri.
                ServiceFeatureTable serviceFeatureTable = new ServiceFeatureTable(featureServiceUri);
    
                // Create a feature layer from the service feature table.
                FeatureLayer featureLayer = new FeatureLayer(serviceFeatureTable);
    
                // Add the feature layer to the maps operational layers collection.
                Map.OperationalLayers.Add(featureLayer);
    
                // Return the feature layer.
                return featureLayer;
            }
    
            private void AddOpenSpaceLayer()
            {
                // Create a parks and open spaces feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(parksAndOpenSpaces);
    
                // Create fill symbols.
                SimpleFillSymbol purpleFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Purple, null);
                SimpleFillSymbol greenFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Green, null);
                SimpleFillSymbol blueFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Blue, null);
                SimpleFillSymbol redFillSymbol = new SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.Red, null);
    
                // Create a unique value for natural areas, regional open spaces, local parks, and regional recreation parks.
                UniqueValue naturalAreas = new UniqueValue("Natural Areas", "Natural Areas", purpleFillSymbol, "Natural Areas");
                UniqueValue regionalOpenSpace = new UniqueValue("Regional Open Space", "Regional Open Space", greenFillSymbol, "Regional Open Space");
                UniqueValue localPark = new UniqueValue("Local Park", "Local Park", blueFillSymbol, "Local Park");
                UniqueValue regionalRecreationPark = new UniqueValue("Regional Recreation Park", "Regional Recreation Park", redFillSymbol, "Regional Recreation Park");
    
                // Create a unique value renderer to display these values.
                UniqueValueRenderer openSpacesUniqueValueRenderer = new UniqueValueRenderer
                    (new List<string>() {
                        "TYPE"
                    },
                    new List<UniqueValue>() {
                        naturalAreas, regionalOpenSpace, localPark, regionalRecreationPark
                    },
                    "Open Spaces",
                    null);
    
                // Assign the unique value renderer to the open spaces layer.
                featureLayer.Renderer = openSpacesUniqueValueRenderer;
    
                // Set the layer opacity to semi-transparent.
                featureLayer.Opacity = 0.2;
            }
    
            private void AddTrailsLayer()
            {
                // Create a trails feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trails);
    
                // Create simple line symbols.
                SimpleLineSymbol firstClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 3.0);
                SimpleLineSymbol secondClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 4.0);
                SimpleLineSymbol thirdClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 5.0);
                SimpleLineSymbol fourthClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 6.0);
                SimpleLineSymbol fifthClassSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.Purple, 7.0);
    
                // Create five class breaks.
                ClassBreak firstClassBreak = new ClassBreak("Under 500", "0 - 500", 0.0, 500.0, firstClassSymbol);
                ClassBreak secondClassBreak = new ClassBreak("501 to 1000", "501 - 1000", 501.0, 1000.0, secondClassSymbol);
                ClassBreak thirdClassBreak = new ClassBreak("1001 to 1500", "1001 - 1500", 1001.0, 1500.0, thirdClassSymbol);
                ClassBreak fourthClassBreak = new ClassBreak("1501 to 2000", "1501 - 2000", 1501.0, 2000.0, fourthClassSymbol);
                ClassBreak fifthClassBreak = new ClassBreak("2001 to 2300", "2001 to 2300", 2001.0, 2300.0, fifthClassSymbol);
                List<ClassBreak> elevationBreaks = new List<ClassBreak>() { firstClassBreak, secondClassBreak, thirdClassBreak, fourthClassBreak, fifthClassBreak };
    
                // Create and assign a class breaks renderer to the feature layer.
                ClassBreaksRenderer elevationClassBreaksRenderer = new ClassBreaksRenderer("ELEV_GAIN", elevationBreaks);
                featureLayer.Renderer = elevationClassBreaksRenderer;
    
                // Set the layer opacity to semi-transparent.
                featureLayer.Opacity = 0.75;
            }
    
            private void AddBikeOnlyTrailsLayer()
            {
                // Create a trails feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trails);
    
                // Write a definition expression to filter for trails that permit the use of bikes.
                featureLayer.DefinitionExpression = "USE_BIKE = 'Yes'";
    
                // Create and assign a simple renderer to the feature layer.
                SimpleLineSymbol bikeTrailSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.Blue, 2.0);
                SimpleRenderer bikeTrailRenderer = new SimpleRenderer(bikeTrailSymbol);
                featureLayer.Renderer = bikeTrailRenderer;
            }
    
            private void AddNoBikeTrailsLayer()
            {
                // Create a trails feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trails);
    
                // Write a definition expression to filter for trails that don't permit the use of bikes.
                featureLayer.DefinitionExpression = "USE_BIKE = 'No'";
    
                // Create and assign a simple renderer to the feature layer.
                SimpleLineSymbol noBikeTrailSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.Red, 2.0);
                SimpleRenderer noBikeTrailRenderer = new SimpleRenderer(noBikeTrailSymbol);
                featureLayer.Renderer = noBikeTrailRenderer;
            }
    
            private LabelDefinition MakeLabelDefinition(string labelAttribute)
            {
                // Create a new text symbol.
                TextSymbol labelTextSymbol  = new TextSymbol
                {
                    Color = Color.White,
                    Size = 12.0,
                    HaloColor = Color.Red,
                    HaloWidth = 1.0,
                    FontFamily = "Arial",
                    FontStyle = FontStyle.Italic,
                    FontWeight = FontWeight.Normal
                };
    
                // Create a new Arcade label expression based on the field name.
                ArcadeLabelExpression labelExpression = new ArcadeLabelExpression("$feature." + labelAttribute);
    
                // Create and return the label definition.
                return new LabelDefinition(labelExpression, labelTextSymbol );
            }
    
            private void AddTrailheadsLayer()
            {
                // Create a trailheads feature layer and add it to the map view.
                FeatureLayer featureLayer = AddFeatureLayer(trailheads);
    
                // Create a new picture marker symbol that uses the trailhead image.
                PictureMarkerSymbol pictureMarkerSymbol = new PictureMarkerSymbol(trailheadImage);
                pictureMarkerSymbol.Height = 18.0;
                pictureMarkerSymbol.Width = 18.0;
    
                // Create a new simple renderer based on the picture marker symbol.
                SimpleRenderer simpleRenderer = new SimpleRenderer(pictureMarkerSymbol);
    
                // Set the feature layer's renderer and enable labels.
                featureLayer.Renderer = simpleRenderer;
                featureLayer.LabelsEnabled = true;
    
                // Create the label definition and pass the "TRL_NAME" attribute to label features by trail name.
                LabelDefinition trailHeadsDefinition = MakeLabelDefinition("TRL_NAME");
    
                // Add the label definition to the layer's label definition collection.
                featureLayer.LabelDefinitions.Add(trailHeadsDefinition);
            }
    
            private void SetupMap()
            {
                // Create a new map with a 'topographic vector' basemap.
                Map = new Map(BasemapStyle.ArcGISTopographic);
    
                AddOpenSpaceLayer();
    
                AddTrailsLayer();
    
                AddNoBikeTrailsLayer();
    
                AddBikeOnlyTrailsLayer();
    
                AddTrailheadsLayer();
    
            }
    
        }
    }
    
  2. Add another method named AddNoBikeTrailsLayer() with a definition expression to filter for trails that don't allow bikes. Add this method just after the AddBikeOnlyTrailsLayer() method.

    MapViewModel.cs
    Use dark colors for code blocks