Skip To Content

Symbols and renderers

In this topic

This topic describes the symbology and rendering options available with the ArcGIS Runtime SDK for .NET. Symbols define all the non-geographic aspects of a graphic or feature's appearance, including color, size, border, and transparency. You can apply a symbol directly to individual graphics when you create them. You can also use symbols to create a renderer for graphics layers or feature layers. You can then set the renderer on the layer to symbolize all the features or graphics in the layer. Renderers allow you to symbolize features differently based on one or more of their attribute values.


Remember that a symbol is not the thing being represented on the map. Instead, it controls how those things (graphics or features) display. The relationship is similar, for example, between the words you are reading now (the content) and the font that is used to display them (presentation). Changing the font style, size, and color will not change the meaning of the text, but is likely to have an impact on the effectiveness of the presentation. Likewise, the quality of a map's presentation can improve with the proper use of symbols to convey information.

Each symbol type is specific to a geometry type (point, line, or polygon). Whether you're applying a symbol directly to a graphic or using a symbol to create a renderer, ensure the geometry type of the graphic or feature being symbolized is compatible with the symbol you want to use. The following is a table of the symbols available in the API with the compatible geometry types and a brief description:



(API reference)

Point, MultiPoint

Symbolizes points with basic shapes.


(API reference)

Point, MultiPoint

Symbolizes points with images.


(API reference)


Symbolizes lines with pre-defined styles.


(API reference)


Fills polygons with a color and pre-defined styles.


(API reference)


Fills polygons with a tiled image.


(API reference)

Point, MultiPoint, Polyline, Polygon

Displays text.


(API reference)

Point, MultiPoint, Polyline, Polygon

A collection of other symbols applied in order (first to last) to produce a layering of symbols.

Depending on the type of geometry you want to symbolize, you will have different options available for defining your symbol. Points, lines, and polygons all have a basic symbol you can use: SimpleMarkerSymbol, SimpleLineSymbol, and SimpleFillSymbol respectively. You may also choose to symbolize points or polygons using the appropriate picture symbol: PictureMarkerSymbol or PictureFillSymbol. Finally, a CompositeSymbol may be used to build more complex symbols for any type of geometry by layering a group of symbols together.

Some symbols provide the ability to set an angle for rotating the symbol. This might be useful for showing things like direction (for wind measurements or moving vehicles, for example). You may also have the ability to define an x or y offset, meaning the symbol displays at a specified distance from the location of the feature it represents. This can be especially useful when working with text or with composite symbols (described in a following section) where you may need to arrange several symbols to represent a feature.

Text symbol with rotation and x/y offsets defined

Simple symbols

The simple symbol types (SimpleMarkerSymbol, SimpleLineSymbol, and SimpleFillSymbol) give you the ability to quickly create a symbol by choosing a predefined style, setting a color, and defining a size (for markers) or width (for lines). For markers and fills, you can also define an outline symbol (using a line symbol).

Symbols can be created using C# (in your code behind) or using XAML (in your UI markup). The example below illustrates creating simple marker, line, and fill symbols using XAML. Notice that the outline for the fill symbol is specified using the line symbol that was defined immediately above it.

        <!--Define symbols in the Resources section (of a UIControl, Page, or App)-->
        <symbols:SimpleMarkerSymbol x:Key="RedXSym" Color="Red" Style="X" Size="10"/>
        <symbols:SimpleLineSymbol x:Key="DashedGreenLineSym" Color="Green" Style="Dash" Width="3"/>
        <symbols:SimpleFillSymbol x:Key="BlueDiagonalHashFillSym" Color="Blue" Style="ForwardDiagonal" Outline="{StaticResource DashedGreenLineSym}"/>
   <!-- ... -->

Picture symbols

Picture symbols, such as PictureMarkerSymbol and PictureFillSymbol, allow you to use an image to symbolize a feature. The image may be stored locally, or come from an online source. The size of the image can be specified, and for picture fill symbols, will be repeated (tiled) as necessary to fill the polygon it represents.

Picture marker symbols and picture fill symbols at version 10.2 or later can be created from an image on disk or from the URL to an image on a remote public machine. Supported image formats for picture symbols are .PNG, .BMP and .JPG. Remote images are downloaded once per application and cached for future use.

PictureFillSymbols are created from an image that's suitable for tiling. For example, an image of a tree can be used to create a PictureFillSymbol so that a filled polygon looks like a forest when symbolized. As you zoom in, fewer trees display in the forest since the map scale is getting closer to the image size. In a graphics layer, a minimum of four tiles are used to represent any one polygon even at the most zoomed-in level.


In a graphics layer in the default Dynamic rendering mode, images are not tiled neatly at each polygon boundary, meaning the images look disjoint across boundaries. With a graphics layer set to the Static rendering mode, images are tiled across the whole texture for a layer. Consequently, images are not disjoint across polygon boundaries.

// define a picture fill symbol from a png file in the project's assets folder
var pictureSym = new Esri.ArcGISRuntime.Symbology.PictureFillSymbol();
await pictureSym.SetSourceAsync(new Uri("ms-appx:///Assets/JackAndJane.png"));
pictureSym.Height = 30.0;
pictureSym.Width = 30.0;
A polygon symbolized with a repeating image using PictureFillSymbol

Composite symbols

A composite symbol is nothing more than a collection of other symbols applied in order (first to last) to produce a layering of symbols. A composite symbol can be used to symbolize any type of geometry, as long as the proper symbol types exist in its collection (fill symbols for polygons, for example).

At version 10.2 or later, composite symbols allow you to apply more than one symbol to a single geometry. For example, you can apply both a SimpleMarkerSymbol and a TextSymbol to a point. A composite symbol contains a list of symbols, and symbols are drawn in the order in which they appear in the list. A composite symbol has no significant properties of its own. This means, for example, to offset a composite symbol relative to a geometry, the offset must be applied to each symbol in the list. A composite symbol can contain other CompositeSymbols but cannot contain itself.

The following examples illustrate how various composite symbols would be applied to different geometry types.

Composite symbol contentsGeometryResult

SimpleMarkerSymbol, PictureMarkerSymbol, TextSymbol


All symbols are applied to the point in order. If no offsets were applied to the individual symbols, the picture marker may cover the simple marker beneath it (depending on the size of the symbols). By default, the text symbol displays using the point as the lower left of the text string, and will likely overlap with the marker symbols beneath.

SimpleMarkerSymbol, SimpleLineSymbol, SimpleFillSymbol


Only the SimpleMarkerSymbol can be applied to the point. While no exceptions are thrown, line and fill symbols will not be applied.

PictureMarkerSymbol, SimpleLineSymbol


All symbols are applied to the line, with the PictureMarkerSymbol applied to each of the line's vertices. Since they are applied before the line symbol, the marker symbols appear under the line symbol.

TextSymbol, SimpleLineSymbol, SimpleFillSymbol, PictureFillSymbol


All symbols are applied to the polygon. Because they are applied in order, the simple fill will be covered by the picture fill (unless transparency has been set). The text symbol will be anchored at the center of the polygon's extent beneath both of the fill symbols.

The example below shows how to create a composite symbol that contains two simple marker symbols. The symbol added first (red circle) displays below the symbol added last (blue triangle).

// Create a large red circle
var redCircleSym = new Esri.ArcGISRuntime.Symbology.SimpleMarkerSymbol();
redCircleSym.Color = Colors.Red;
redCircleSym.Style = Esri.ArcGISRuntime.Symbology.SimpleMarkerStyle.Circle;
redCircleSym.Size = 16;

// Create a smaller blue triangle
var blueTriangleSym = new Esri.ArcGISRuntime.Symbology.SimpleMarkerSymbol();
blueTriangleSym.Color = Colors.Blue;
blueTriangleSym.Style = Esri.ArcGISRuntime.Symbology.SimpleMarkerStyle.Triangle;
blueTriangleSym.Size = 8;

// Create a composite symbol and add the symbols created above
var compositeSym = new Esri.ArcGISRuntime.Symbology.CompositeSymbol();
Points symbolized with a composite symbol containing two marker symbols

Applying a symbol to a graphic

Graphics are in-memory features that provide a basic way to display geometry on the map. Graphics are unique in that they can be symbolized using a renderer for the layer that contains them (described later in this topic) or by applying a symbol directly to the graphic. For a description of how to work with graphics, see the Add graphics and text topic.

The following example shows how to create a point graphic, apply a symbol, then display it on the map.

var point = new Esri.ArcGISRuntime.Geometry.MapPoint(-114.5, 35.5, SpatialReferences.Wgs84);
var graphicsLayer = MyMap.Layers["MyGraphicsLayer"] as Esri.ArcGISRuntime.Layers.GraphicsLayer;

var markerSym = new Esri.ArcGISRuntime.Symbology.SimpleMarkerSymbol
    Style = Esri.ArcGISRuntime.Symbology.SimpleMarkerStyle.Diamond,
    Color = Colors.Green,
    Size = 18

var pointGraphic = new Esri.ArcGISRuntime.Layers.Graphic(point, markerSym);



A symbol applied directly to the graphic overrides any symbols applied through the layer's renderer.


As the name implies, a renderer is an object that determines how features in a layer are drawn (rendered) on the display. A renderer is like a collection of symbols that includes logic for applying the appropriate symbol to each feature in a layer. There are a variety of renderer types, each designed to use a different rendering logic. Most renderers use attribute values to determine which symbol should be applied to which features.

In a typical workflow, renderers are used to symbolize features in a feature layer, where the features will all be of the same geometry type. It's up to you to create a renderer with symbols that can be applied to the geometry type of the layer (pursuant to the table above). A renderer can also be applied to a graphics layer, but should not be used for a layer that has graphics of mixed geometry types. For such a scenario, applying a symbol to each graphic as it's created is the preferred workflow.

There are several types of renderers you can create using the Runtime .NET API: including simple renderers, unique value renderers, and class break renderers. Their class diagram is pictured here and each is described below.

Renderers available in the ArcGIS Runtime SDK for .NET

Simple renderer

A simple renderer uses just one symbol such that all features are symbolized with the same symbol regardless of the feature's attribute values.

The following example illustrates creating a simple renderer with XAML and applying it to a graphics layer in the map. Note that this layer will not render geometry other than points (unless a symbol is explicitly defined for the graphic).


    <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
            <!--Define a red "X" marker symbol-->
            <symbols:SimpleMarkerSymbol x:Key="RedXSym" Color="Red" Style="X" Size="10"/>
            <!--Define a simple renderer that uses the symbol above-->
            <symbols:SimpleRenderer x:Key="MySimpleRenderer" Symbol="{StaticResource RedXSym}"/>
        <esri:MapView x:Name="MyMapView">
            <esri:Map x:Name="MyMap">
                <layers:ArcGISTiledMapServiceLayer ID="BaseMap" ServiceUri=""/>
                <layers:GraphicsLayer ID="MyGraphicsLayer" Renderer="{StaticResource MySimpleRenderer}"/>

Unique value renderer

A unique value renderer is used to symbolize features differently based on the value of up to three attributes. It is particularly useful when symbolizing features based on an attribute whose values represent names or categories, usually referred to as nominal data.


When applying a renderer that uses attribute values, such as unique value or class breaks renderers, you must include the required fields in the layer's out fields. By default, only the object id and geometry fields are returned for a feature layer.

The example below creates a unique value renderer that displays cities with different symbols according to the value of their state name attribute. Since only California, Nevada, and Arizona have been defined explicitly in the renderer's UniqueValueInfoCollection, features with any other value for the state name attribute (ST) display with the default symbol.

// create a symbol for each unique value
var californiaSym = new Esri.ArcGISRuntime.Symbology.SimpleMarkerSymbol { Color = Colors.Red, Size = 14, Style = Esri.ArcGISRuntime.Symbology.SimpleMarkerStyle.Circle };
var arizonaSym = new Esri.ArcGISRuntime.Symbology.SimpleMarkerSymbol { Color = Colors.Blue, Size = 12, Style = Esri.ArcGISRuntime.Symbology.SimpleMarkerStyle.Diamond };
var nevadaSym = new Esri.ArcGISRuntime.Symbology.SimpleMarkerSymbol { Color = Colors.Green, Size = 14, Style = Esri.ArcGISRuntime.Symbology.SimpleMarkerStyle.Triangle };

// create a default symbol for values not defined in the renderer's unique value collection
var defaultSym = new Esri.ArcGISRuntime.Symbology.SimpleMarkerSymbol { Color = Colors.Gray, Size = 8, Style = Esri.ArcGISRuntime.Symbology.SimpleMarkerStyle.Circle };

// create a UniqueValueInfo for each value; define the attribute value and associated symbol
var uniqueVal1 = new Esri.ArcGISRuntime.Symbology.UniqueValueInfo("CA", californiaSym);
var uniqueVal2 = new Esri.ArcGISRuntime.Symbology.UniqueValueInfo("AZ", arizonaSym);
var uniqueVal3 = new Esri.ArcGISRuntime.Symbology.UniqueValueInfo("NV", nevadaSym);

// create a unique value info collection; add the info for each unique value
var uniqueInfos = new Esri.ArcGISRuntime.Symbology.UniqueValueInfoCollection();

// create the unique value renderer
var uniqueValRenderer = new Esri.ArcGISRuntime.Symbology.UniqueValueRenderer();

// specify the field that contains the unique values

// provide the unique value info collection
uniqueValRenderer.Infos = uniqueInfos;

// provide a symbol for all other values
uniqueValRenderer.DefaultSymbol = defaultSym;

// apply the renderer to the layer
someLayer.Renderer = uniqueValRenderer;
Unique value renderer applied to US cities


If a default symbol is not defined for a unique value renderer, only features with attribute values defined in the value collection display.

Class breaks renderer

A class breaks renderer is the most flexible of the renderers and is used to symbolize features based on an attribute with numerical values. Features with attribute values in the same range have the same symbol. You can manually create a class breaks renderer by crafting the desired breaks. A break can be constructed using the minimum and maximum value of the interval, and the symbol to use if the feature's attribute value falls in this interval. Breaks cannot overlap, and the range of each break includes the maximum value but does not include the minimum value. With classes 0-10 and 10-20, for example, the value 10 falls in the first class.

The following example illustrates creating a class breaks renderer with three classes of population for US cities: 0-7500, 7500-200000, and 200000-9000000.

// create a symbol for each class of values (low, medium, and high)
var loSym = new Esri.ArcGISRuntime.Symbology.SimpleMarkerSymbol { Color = Colors.Red, Size = 4, Style = Esri.ArcGISRuntime.Symbology.SimpleMarkerStyle.Circle };
var medSym = new Esri.ArcGISRuntime.Symbology.SimpleMarkerSymbol { Color = Colors.Red, Size = 12, Style = Esri.ArcGISRuntime.Symbology.SimpleMarkerStyle.Circle };
var largeSym = new Esri.ArcGISRuntime.Symbology.SimpleMarkerSymbol { Color = Colors.Red, Size = 24, Style = Esri.ArcGISRuntime.Symbology.SimpleMarkerStyle.Circle };

// create a default symbol for values not defined in the renderer's class definitions
var defaultSym = new Esri.ArcGISRuntime.Symbology.SimpleMarkerSymbol { Color = Colors.Gray, Size = 8, Style = Esri.ArcGISRuntime.Symbology.SimpleMarkerStyle.Circle };

// create a ClassBreakInfo for each range; define the min/max attribute values and associated symbol
var classRange1 = new Esri.ArcGISRuntime.Symbology.ClassBreakInfo { Minimum = 0, Maximum = 75000, Symbol = loSym };
var classRange2 = new Esri.ArcGISRuntime.Symbology.ClassBreakInfo { Minimum = 75000, Maximum = 200000, Symbol = medSym };
var classRange3 = new Esri.ArcGISRuntime.Symbology.ClassBreakInfo { Minimum = 200000, Maximum = 9000000, Symbol = largeSym };

// create a class breaks info collection; add the info for each class
var classInfos = new Esri.ArcGISRuntime.Symbology.ClassBreakInfoCollection();

// create the class breaks renderer
var classBreaksRenderer = new Esri.ArcGISRuntime.Symbology.ClassBreaksRenderer();

// specify the field that contains the attribute (population)
classBreaksRenderer.Field = "pop2000";

// provide the class breaks info collection
classBreaksRenderer.Infos = classInfos;

// provide a symbol for values outside the defined classes
classBreaksRenderer.DefaultSymbol = defaultSym;

// apply the renderer to the layer
someLayer.Renderer = classBreaksRenderer;
Class breaks renderer showing three classes of city population


As with UniqueValueRenderer, features whose attribute value falls outside the classes defined for the renderer are symbolized with the default symbol. If a default symbol is not defined, those features will not display.

Temporal renderer

A temporal renderer allows you to define a set of renderers to display time-based data in interesting ways. The temporal renderer has properties for defining an observation renderer, latest observation renderer, track renderer, and ager. Temporal renderers work with the TimeExtent property you've defined for your map view.


Temporal renderers are currently supported for layers that inherit from GraphicsLayer.

The observation renderer defines the symbology for each observation in the layer. For a vehicle tracking application, you might choose a unique value renderer to display each vehicle with a unique symbol. A class breaks renderer would be more appropriate for showing earthquakes by magnitude, for example. The latest observation renderer is used to display only the most recent feature in the layer.

A temporal renderer's track renderer is used to define the symbology for lines that connect related observations. For tracking vehicle locations, for example, you may want to show the path defined by each vehicle's observations. If using a track renderer, you'll also need to define the observation attribute that represents the track ID.

An ager is used to determine how the symbology changes as it ages. You might want older features to appear with more transparency, a lighter color, or with a smaller marker size, for example.

// create a new TemporalRenderer
var temporalRenderer = new Esri.ArcGISRuntime.Symbology.TemporalRenderer();

// assign a simple renderer to display the latest (most recent) observation
temporalRenderer.LatestObservationRenderer = simpleRenderer;

// assign a class breaks renderer to show the observations (earthquakes by magnitude)
temporalRenderer.ObservationRenderer = classBreaksRenderer;

// create a symbol ager to symbolize different classes of age 
var symbolAger = new Esri.ArcGISRuntime.Symbology.TimeClassBreaksAger();

// define the breaks for each age (time range); use a unique symbol for each
var classBreak1 = new Esri.ArcGISRuntime.Symbology.TimeClassBreaks 
    { MinimumAge = new TimeSpan(0, 0, 0, 0), MaximumAge = new TimeSpan(2, 0, 0, 0), 
        Color = Colors.Red, Opacity = 1.0, Size = 24 };
var classBreak2 = new Esri.ArcGISRuntime.Symbology.TimeClassBreaks 
    { MinimumAge = new TimeSpan(2, 0, 0, 0), MaximumAge = new TimeSpan(4, 0, 0, 0), 
        Color = Colors.Red, Opacity = 0.8, Size = 14 };
var classBreak3 = new Esri.ArcGISRuntime.Symbology.TimeClassBreaks 
    { MinimumAge = new TimeSpan(4, 0, 0, 0), MaximumAge = new TimeSpan(8, 0, 0, 0), 
        Color = Colors.Red, Opacity = 0.5, Size = 4 };

// assign the time breaks to the ager's breaks collection
var timeBreaks = new Esri.ArcGISRuntime.Symbology.TimeClassBreaksCollection();
symbolAger.Infos = timeBreaks;

// assign the symbol ager to the temporal renderer
temporalRenderer.SymbolAger = symbolAger;

// assign the temporal renderer to the layer
var quakesLayer = MyMap.Layers["MyEarthquakeLayer"] as Esri.ArcGISRuntime.Layers.GeoRssLayer;
quakesLayer.Renderer = temporalRenderer;

Dictionary renderer

The dictionary renderer is a renderer that works in conjunction with a symbol dictionary for displaying specialized symbols (military, for example) in a message layer. More information about working with specialized symbols can be found in the Display military messages topic.


Classes related to specialized symbols are not available in the ArcGIS Runtime API for Store or the ArcGIS Runtime API for Phone.

Change rendering for a dynamic layer

With ArcGIS for Server version 10.1 or greater, dynamic layers provide the ability to change rendering on the client for data coming from an ArcGIS for Server (non-cached) map service. Setting layer definitions and draw options on a dynamic layer allows you to control the content and the display of sub-layers within the service. See the Maps and layers topic for more information.

The following example illustrates how to update the drawing options for a particular sub-layer in a dynamic layer to apply a new renderer.

// get the dynamic layer from the map
var dynLayer = MyMap.Layers["DynLayer"] as Esri.ArcGISRuntime.Layers.ArcGISDynamicMapServiceLayer;

// get the drawing options for all sublayers in the layer
var drawOptions = dynLayer.LayerDrawingOptions;

// find the drawing options for layer with the ID of 5
foreach (var opt in drawOptions)
    if (opt.LayerID == 5)
        // assign a new renderer for the layer's drawing options
        opt.Renderer = someRenderer;

// refresh the layer

Generate a renderer on the server

For feature layers from services created with ArcGIS for Server version 10.1 or later, you can use a GenerateRendererTask to generate and return either a class breaks or a unique value renderer. The generated renderer can then be applied to the corresponding feature layer or dynamic layer in your map.

Creating a unique value renderer using the task gives you the ability to specify a color ramp from which a unique color can be retrieved for each unique symbol in the renderer. Generating a renderer for a feature layer with several unique values using GenerateRendererTask is more efficient than writing code to explicitly define each class in the renderer.

Generating a class breaks renderer with the task gives you the ability to use statistical classification methods to determine your class ranges. Rather than manually coding the minimum and maximum values for your class breaks, you can specify the number of breaks desired and use one of the following classification methods to determine the values for each break: Natural Breaks, Equal Interval, Quantile, or Standard Deviation. You can also choose to normalize your data by percent of the total, the value of another field, or by log.

The available classification methods are described briefly below.

  • Natural breaks—Creates classes based on natural groupings inherent in the data. Class breaks are identified that best group similar values and that maximize the differences between classes. The features are divided into classes whose boundaries are set where there are relatively big differences in the data values. This classification is based on the Jenks' Natural Breaks algorithm. For further information, see Univariate classification schemes in Geospatial Analysis-A Comprehensive Guide, 3rd edition; © 2006-2009; de Smith, Goodchild, Longley.
  • Equal Interval——Divides the range of attribute values into equal-sized subranges. This allows you to specify the number of intervals, and have the class breaks determined based on the value range. For example, if you specify three classes for a field whose values range from 0 to 300, this method creates three classes with ranges of 0-100, 101-200, and 201-300. Equal interval is best applied to familiar data ranges, such as percentages and temperature. This method emphasizes the amount of an attribute value relative to other values. For example, it shows that a store is part of the group of stores that make up the top one-third of all sales.
  • Quantile—Assigns an equal number of features to each class. A quantile classification is well suited to linearly distributed data. Because features are grouped in equal numbers in each class using Quantile classification, the resulting map can often be misleading. Similar features can be placed in adjacent classes, or features with widely different values can be put in the same class. You can minimize this distortion by increasing the number of classes.
  • Standard Deviation—Classification shows you how much a feature's attribute value varies from the mean for all features. Class breaks are created with equal value ranges that are a proportion of the standard deviation, at the chosen interval of 1, ½, ⅓, or ¼ standard deviations using mean values and the standard deviations from the mean. A standard deviation classification displayed with a two-color ramp, for example, can illustrate values above the mean (perhaps shown in blue) and values below the mean (shown in red).
// define a ClassBreaksDefinition to use for the renderer
var classificationInfo = new Esri.ArcGISRuntime.Tasks.Query.ClassBreaksDefinition();
classificationInfo.ClassificationMethod = Esri.ArcGISRuntime.Tasks.Query.ClassificationMethod.Quantile;
classificationInfo.BreakCount = 5;
classificationInfo.ClassificationField = "pop2000";

// create and assign the base symbol to use: only the color of this symbol will change for each class break
var baseFillSym = new Esri.ArcGISRuntime.Symbology.SimpleFillSymbol 
                                      { Style = Esri.ArcGISRuntime.Symbology.SimpleFillStyle.Solid };
classificationInfo.BaseSymbol = baseFillSym;

// create a color ramp: colors from this ramp will be used to distinguish each class
var redColorRamp = new Esri.ArcGISRuntime.Tasks.Query.ColorRamp();
redColorRamp.Algorithm = Esri.ArcGISRuntime.Tasks.Query.Algorithm.Hsv;
// all colors will be red, ramp will go from more transparent to more opaque
redColorRamp.From = Color.FromArgb(80, 255, 0, 0);  
redColorRamp.To = Color.FromArgb(200, 255, 0, 0);  
// assign a collection of color ramps for the classification (just one, but you could use several)
var rampCollection =  new ObservableCollection<Esri.ArcGISRuntime.Tasks.Query.ColorRamp>() { redColorRamp };
classificationInfo.ColorRamps = rampCollection;

// create a new GenerateRendererParameter and assign the classification definition
var rendererParams = new Esri.ArcGISRuntime.Tasks.Query.GenerateRendererParameters();
rendererParams.ClassificationDefinition = classificationInfo;

// create a new GenerateRendererTask using the URL to the feature layer to render
var layerUri = new Uri("");
var generateRendererTask = new Esri.ArcGISRuntime.Tasks.Query.GenerateRendererTask(layerUri);

// generate the renderer asynchronously and await the result
var taskResult = await generateRendererTask.GenerateRendererAsync(rendererParams);

// apply the generated renderer to the layer in the map
someLayer.Renderer = taskResult.Renderer;

The following image shows a class breaks renderer with 5 class breaks, using the natural breaks classification method. The class breaks renderer is for a US States layer and the classification field is the state population in the year 2000.

A class breaks renderer applied to a US States layer to show classes of population.
Related topics