public void SetRenderer( 
   CIMRenderer renderer,
   FeatureRendererTarget featureRendererTarget
)

var lyr = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault(f => f.ShapeType == esriGeometryType.esriGeometryPolygon);
if (lyr == null) return;
QueuedTask.Run(() =>
{
  // GetRenderer from Layer (assumes it is a unique value renderer)
  var uvRenderer = lyr.GetRenderer() as CIMUniqueValueRenderer;
  if (uvRenderer == null) return;
  //layer has STATE_NAME field
  //community sample Data\Admin\AdminSample.aprx
  string expression = "if ($view.scale > 21000000) { return $feature.STATE_NAME } else { return 'All' }";
  CIMExpressionInfo updatedExpressionInfo = new CIMExpressionInfo
  {
    Expression = expression,
    Title = "Custom" // can be any string used for UI purpose.
  };
  //set the renderer's expression
  uvRenderer.ValueExpressionInfo = updatedExpressionInfo;

  //SetRenderer on Layer
  lyr.SetRenderer(uvRenderer);
});

var lyr = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault(f => f.ShapeType == esriGeometryType.esriGeometryPolygon);
if (lyr == null) return;
QueuedTask.Run(() =>
{
  //Get the layer's definition
  //community sample Data\Admin\AdminSample.aprx
  var lyrDefn = lyr.GetDefinition() as CIMFeatureLayer;
  if (lyrDefn == null) return;
  //Get the label classes - we need the first one
  var listLabelClasses = lyrDefn.LabelClasses.ToList();
  var theLabelClass = listLabelClasses.FirstOrDefault();
  //set the label class Expression to use the Arcade expression
  theLabelClass.Expression = "return $feature.STATE_NAME + TextFormatting.NewLine + $feature.POP2000;";
  //Set the label definition back to the layer.
  lyr.SetDefinition(lyrDefn);
});

public Task SetFeatureLayerSymbolAsync(FeatureLayer ftrLayer, CIMSymbol symbolToApply)
{
  if (ftrLayer == null || symbolToApply == null)
    throw new System.ArgumentNullException();

  return QueuedTask.Run(() =>
  {

    //Get simple renderer from the feature layer
    CIMSimpleRenderer currentRenderer = ftrLayer.GetRenderer() as CIMSimpleRenderer;
    if (currentRenderer == null)
      return;

    //Set symbol's real world setting to be the same as that of the feature layer
    symbolToApply.SetRealWorldUnits(ftrLayer.UsesRealWorldSymbolSizes);

    //Update the symbol of the current simple renderer
    currentRenderer.Symbol = symbolToApply.MakeSymbolReference();
    //Update the feature layer renderer
    ftrLayer.SetRenderer(currentRenderer);
  });
}

public Task SetFeatureLayerSymbolFromStyleItemAsync(
           FeatureLayer ftrLayer, SymbolStyleItem symbolItem)
{
  if (ftrLayer == null || symbolItem == null)
    throw new System.ArgumentNullException();

  return QueuedTask.Run(() =>
  {
    //Get simple renderer from the feature layer
    CIMSimpleRenderer currentRenderer = ftrLayer.GetRenderer() as CIMSimpleRenderer;
    if (currentRenderer == null)
      return;
    //Get symbol from the SymbolStyleItem
    CIMSymbol symbol = symbolItem.Symbol;

    //Set symbol's real world setting to be the same as that of the feature layer
    symbol.SetRealWorldUnits(ftrLayer.UsesRealWorldSymbolSizes);

    //Update the symbol of the current simple renderer
    currentRenderer.Symbol = symbol.MakeSymbolReference();
    //Update the feature layer renderer
    ftrLayer.SetRenderer(currentRenderer);
  });
}

  // var map = MapView.Active.Map;
  // if (map == null)
  //        return;
  // var pointFeatureLayer =
  //       map.GetLayersAsFlattenedList()
  //          .OfType<FeatureLayer>()
  //         .Where(fl => fl.ShapeType == esriGeometryType.esriGeometryPoint);
  //   await ApplySymbolToFeatureLayerAsync(pointFeatureLayer.FirstOrDefault(), "Fire Station");

  public Task ApplySymbolToFeatureLayerAsync(FeatureLayer featureLayer, string symbolName)
  {
    return QueuedTask.Run(async () =>
    {
      //Get the ArcGIS 2D System style from the Project
      var arcGIS2DStyle =
Project.Current.GetItems<StyleProjectItem>().FirstOrDefault(s => s.Name == "ArcGIS 2D");

      //Search for the symbolName style items within the ArcGIS 2D style project item.
      var items = await QueuedTask.Run(() =>
      arcGIS2DStyle.SearchSymbols(StyleItemType.PointSymbol, symbolName));

      //Gets the CIMSymbol
      CIMSymbol symbol = items.FirstOrDefault().Symbol;

      //Get the renderer of the point feature layer
      CIMSimpleRenderer renderer = featureLayer.GetRenderer() as CIMSimpleRenderer;

      //Set symbol's real world setting to be the same as that of the feature layer
      symbol.SetRealWorldUnits(featureLayer.UsesRealWorldSymbolSizes);

      //Apply the symbol to the feature layer's current renderer
      renderer.Symbol = symbol.MakeSymbolReference();

      //Appy the renderer to the feature layer
      featureLayer.SetRenderer(renderer);
    });
  }

public async Task ApplyColorRampAsync(FeatureLayer featureLayer, List<string> fields)
{

    StyleProjectItem style =
        Project.Current.GetItems<StyleProjectItem>()
            .FirstOrDefault(s => s.Name == "ColorBrewer Schemes (RGB)");
    if (style == null) return;
    var colorRampList = await QueuedTask.Run(() => 
                style.SearchColorRamps("Red-Gray (10 Classes)"));
    if (colorRampList == null || colorRampList.Count == 0) return;
    CIMColorRamp cimColorRamp = null;
    CIMRenderer renderer = null;
    await QueuedTask.Run(() =>
    {
        cimColorRamp = colorRampList[0].ColorRamp;
        var rendererDef = new UniqueValueRendererDefinition(fields, null, cimColorRamp);
        renderer = featureLayer?.CreateRenderer(rendererDef);
        featureLayer?.SetRenderer(renderer);
    });

}

//The layer must be track aware and spatial
if (streamLayer.TrackType != TrackType.Spatial)
  return;
//Must be on QueuedTask!
//Define unique value classes same as we do for current observations
//or use "CreateRenderer(...)" to assign them automatically
CIMUniqueValueClass uvcB727Prev = new CIMUniqueValueClass()
{
  Values = new CIMUniqueValue[] { new CIMUniqueValue() {
    FieldValues = new string[] { "B727" } } },
  Visible = true,
  Label = "Boeing 727",
  Symbol = SymbolFactory.Instance.ConstructPointSymbol(
    CIMColor.CreateRGBColor(255, 0, 0), 4, SimpleMarkerStyle.Hexagon)
    .MakeSymbolReference()
};

CIMUniqueValueClass uvcD9Prev = new CIMUniqueValueClass()
{
  Values = new CIMUniqueValue[] { new CIMUniqueValue() {
    FieldValues = new string[] { "DC9" } } },
  Visible = true,
  Label = "DC 9",
  Symbol = SymbolFactory.Instance.ConstructPointSymbol(
    CIMColor.CreateRGBColor(0, 255, 0), 4, SimpleMarkerStyle.Hexagon)
    .MakeSymbolReference()
};

CIMUniqueValueGroup uvGrpPrev = new CIMUniqueValueGroup()
{
  Classes = new CIMUniqueValueClass[] { uvcB727Prev, uvcD9Prev }
};

var UVrndrPrev = new CIMUniqueValueRenderer()
{
  Fields = new string[] { "ACTYPE" },
  Groups = new CIMUniqueValueGroup[] { uvGrpPrev },
  UseDefaultSymbol = true,
  DefaultLabel = "Others",
  DefaultSymbol = SymbolFactory.Instance.ConstructPointSymbol(
    CIMColor.CreateRGBColor(185, 185, 185), 4, SimpleMarkerStyle.Hexagon)
    .MakeSymbolReference()
};
        
streamLayer.SetRenderer(UVrndr, FeatureRendererTarget.PreviousObservations);

//The layer must be track aware and spatial
if (streamLayer.TrackType != TrackType.Spatial)
  return;
//Must be on QueuedTask!
//Note: only a simple renderer with solid line symbol is supported for track 
//line renderer
var trackRenderer = new SimpleRendererDefinition()
{
  SymbolTemplate = SymbolFactory.Instance.ConstructLineSymbol(
      ColorFactory.Instance.BlueRGB, 2, SimpleLineStyle.Solid)
        .MakeSymbolReference()
};
streamLayer.SetRenderer(
     streamLayer.CreateRenderer(trackRenderer), 
       FeatureRendererTarget.TrackLines);