ProSnippets Renderer - Esri/arcgis-pro-sdk GitHub Wiki

internal static Task PieChartRendererAsync()
{
  //Check feature layer name
  //Code works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data
  var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault(f => f.Name == "USDemographics");
  if (featureLayer == null)
  {
    MessageBox.Show("This renderer works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data", "Data missing");
    return Task.FromResult(0);
  }
  return QueuedTask.Run(() =>
  {
    //Fields to use for the pie chart slices
    var chartFields = new List<string>
    {
            "WHITE10",
             "BLACK10",
             "AMERIND10",
             "ASIAN10",
             "HISPPOP10",
             "HAMERIND10",
             "HWHITE10",
             "HASIAN10",
             "HPACIFIC10",
             "HBLACK10",
              "HOTHRACE10"
    };

    PieChartRendererDefinition pieChartRendererDefn = new PieChartRendererDefinition()
    {
      ChartFields = chartFields,
      ColorRamp = SDKHelpers.GetColorRamp(),
      SizeOption = PieChartSizeOptions.Field,
      FieldName = "BLACK10",
      FixedSize = 36.89,
      DisplayIn3D = true,
      ShowOutline = true,
      Orientation = PieChartOrientation.CounterClockwise,
    };
    //Creates a "Renderer"
    var pieChartRenderer = featureLayer.CreateRenderer(pieChartRendererDefn);

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

internal static Task BarChartRendererAsync()
{
  //Check feature layer name
  //Code works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data
  var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault(f => f.Name == "USDemographics");
  if (featureLayer == null)
  {
    MessageBox.Show("This renderer works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data", "Data missing");
    return Task.FromResult(0);
  }
  return QueuedTask.Run(() =>
  {
    var chartFields = new List<string>
        {
            "WHITE10",
             "BLACK10",
             "AMERIND10",
             "ASIAN10",
             "HISPPOP10",
             "HAMERIND10",
             "HWHITE10",
             "HASIAN10",
             "HPACIFIC10",
             "HBLACK10",
              "HOTHRACE10"
        };

      BarChartRendererDefinition barChartRendererDefn = new BarChartRendererDefinition()
      {
        ChartFields = chartFields,
        BarWidth = 12,
        BarSpacing = 1,
        MaximumBarLength = 65,
        Orientation = ChartOrientation.Vertical,
        DisplayIn3D = true,
        ShowAxes = true,
        ColorRamp = SDKHelpers.GetColorRamp()

      };
      //Creates a "Renderer"
      var barChartChartRenderer = featureLayer.CreateRenderer(barChartRendererDefn);

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

internal static Task StackedBarChartRendererAsync()
{
  //Check feature layer name
  //Code works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data
  var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault(f => f.Name == "USDemographics");
  if (featureLayer == null)
  {
    MessageBox.Show("This renderer works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data", "Data missing");
    return Task.FromResult(0);
  }
  return QueuedTask.Run(() =>
  {
    var chartFields = new List<string>
        {
            "WHITE10",
             "BLACK10",
             "AMERIND10",
             "ASIAN10",
             "HISPPOP10",
             "HAMERIND10",
             "HWHITE10",
             "HASIAN10",
             "HPACIFIC10",
             "HBLACK10",
              "HOTHRACE10"
        };
    
      StackedChartRendererDefinition barChartpieChartRendererDefn = new StackedChartRendererDefinition()
      {
        ChartFields = chartFields,
        SizeOption = StackChartSizeOptions.SumSelectedFields,
        Orientation = ChartOrientation.Horizontal,
        ShowOutline = true,
        DisplayIn3D = true,
        StackWidth = 8,
        StackLength = 25.87,
        ColorRamp = SDKHelpers.GetColorRamp()

      };
      //Creates a "Renderer"
      var stackedBarChartChartRenderer = featureLayer.CreateRenderer(barChartpieChartRendererDefn);

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

internal static Task CBRendererGraduatedColors()
{
    //Check feature layer name
    //Code works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data
    var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault(f => f.Name == "USDemographics");
    if (featureLayer == null)
    {
      MessageBox.Show("This renderer works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data", "Data missing");
      return Task.FromResult(0);
    }
    return QueuedTask.Run(() =>
    {
        GraduatedColorsRendererDefinition gcDef = new GraduatedColorsRendererDefinition()
        {                    
            ClassificationField = SDKHelpers.GetNumericField(featureLayer),
            ClassificationMethod = ClassificationMethod.NaturalBreaks,
            BreakCount = 5,
            ColorRamp = SDKHelpers.GetColorRamp(),
        };
        CIMClassBreaksRenderer renderer = (CIMClassBreaksRenderer)featureLayer.CreateRenderer(gcDef);
        featureLayer?.SetRenderer(renderer);
    });
}

internal static Task CBRendererGraduatedColorsOutlineAsync()
{
    //Check feature layer name
    //Code works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data
    var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault(f => f.Name == "USDemographics");
    if (featureLayer == null)
    {
      MessageBox.Show("This renderer works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data", "Data missing");
      return Task.FromResult(0);
    }
    return QueuedTask.Run(() =>
    {
        //Gets the first numeric field of the feature layer
        var firstNumericFieldOfFeatureLayer = SDKHelpers.GetNumericField(featureLayer);
        //Gets the min and max value of the field
        var minMax = SDKHelpers.GetFieldMinMax(featureLayer, firstNumericFieldOfFeatureLayer);
        GraduatedColorsRendererDefinition gcDef = new GraduatedColorsRendererDefinition()
        {
             ClassificationField = SDKHelpers.GetNumericField(featureLayer),
             ClassificationMethod = ClassificationMethod.NaturalBreaks,
             BreakCount = 5,
             ColorRamp = SDKHelpers.GetColorRamp()
             
        };
        CIMClassBreaksRenderer renderer = (CIMClassBreaksRenderer)featureLayer.CreateRenderer(gcDef);
        //Create array of CIMVisualVariables to hold the outline information.
        var visualVariables = new CIMVisualVariable[] {
            new CIMSizeVisualVariable
            {
                ValueExpressionInfo = new CIMExpressionInfo
                {
                   Title = "Custom",
                   Expression = "$feature.AREA",
                   ReturnType = ExpressionReturnType.Default
                },
                AuthoringInfo = new CIMVisualVariableAuthoringInfo
                {
                    MinSliderValue = Convert.ToDouble(minMax.Item1),
                    MaxSliderValue = Convert.ToDouble(minMax.Item2),         
                    ShowLegend = false,
                    Heading = firstNumericFieldOfFeatureLayer
                },
                VariableType = SizeVisualVariableType.Graduated,
                Target = "outline",
                MinSize = 1,
                MaxSize = 13,
                MinValue = Convert.ToDouble(minMax.Item1),
                MaxValue = Convert.ToDouble(minMax.Item2)
            },
            
        };
        renderer.VisualVariables = visualVariables;
        featureLayer?.SetRenderer(renderer);
});

}

internal static Task CBRendererGraduatedSymbols()
{
  //Check feature layer name
  //Code works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data
  var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault(f => f.Name == "USDemographics");
  if (featureLayer == null)
  {
    MessageBox.Show("This renderer works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data", "Data missing");
    return Task.FromResult(0);
  }
  return QueuedTask.Run(() =>
    {
        GraduatedSymbolsRendererDefinition gsDef = new GraduatedSymbolsRendererDefinition()
        {                   
            ClassificationField = SDKHelpers.GetNumericField(featureLayer), //getting the first numeric field
            ClassificationMethod = ClassificationMethod.NaturalBreaks,
            SymbolTemplate = SymbolFactory.Instance.ConstructPointSymbol(CIMColor.CreateRGBColor(76,230,0)).MakeSymbolReference(),
            MinimumSymbolSize = 4,
            MaximumSymbolSize = 50,
            BreakCount = 5,
            ColorRamp = SDKHelpers.GetColorRamp(), //getting a color ramp
        };
        CIMClassBreaksRenderer renderer = (CIMClassBreaksRenderer)featureLayer.CreateRenderer(gsDef);
        featureLayer?.SetRenderer(renderer);
    });
}

internal static Task UnclassedRenderer()
{
    //Check feature layer name
    //Code works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data
    var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault(f => f.Name == "U.S. National Transportation Atlas Interstate Highways");
    if (featureLayer == null)
    {
      MessageBox.Show("This renderer works with the U.S. National Transportation Atlas Interstate Highways feature layer available with the ArcGIS Pro SDK Sample data", "Data missing");
      return Task.FromResult(0);
    }
    return QueuedTask.Run(() =>
    {                
        //Gets the first numeric field of the feature layer
        var firstNumericFieldOfFeatureLayer = SDKHelpers.GetNumericField(featureLayer);
        //Gets the min and max value of the field
        var labels = SDKHelpers.GetFieldMinMax(featureLayer, firstNumericFieldOfFeatureLayer);              
        UnclassedColorsRendererDefinition ucDef = new UnclassedColorsRendererDefinition()
        {
            Field = firstNumericFieldOfFeatureLayer,
            ColorRamp = SDKHelpers.GetColorRamp(),
            LowerColorStop = Convert.ToDouble(labels.Item1),
            UpperColorStop = Convert.ToDouble(labels.Item2),                    
            UpperLabel = labels.Item2,
            LowerLabel = labels.Item1,
        };
        CIMClassBreaksRenderer renderer = (CIMClassBreaksRenderer)featureLayer.CreateRenderer(ucDef);
        featureLayer?.SetRenderer(renderer);
    });
}

internal static Task CBGraduatedColorsManualBreaks()
{
    //Check feature layer name
    //Code works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data
    var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault(f => f.Name == "USDemographics");
    if (featureLayer == null)
    {
      MessageBox.Show("This renderer works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data", "Data missing");
      return Task.FromResult(0);
    }
    //Change these class breaks to be appropriate for your data. These class breaks defined below apply to the US States feature class
    List<CIMClassBreak> listClassBreaks = new List<CIMClassBreak>
    {
        new CIMClassBreak
        {
            Symbol = SymbolFactory.Instance.ConstructPolygonSymbol(ColorFactory.Instance.RedRGB).MakeSymbolReference(),
            UpperBound = 24228 
        },
        new CIMClassBreak
        {
            Symbol = SymbolFactory.Instance.ConstructPolygonSymbol(ColorFactory.Instance.GreenRGB).MakeSymbolReference(),
            UpperBound = 67290
        },
        new CIMClassBreak
        {
            Symbol = SymbolFactory.Instance.ConstructPolygonSymbol(ColorFactory.Instance.BlueRGB).MakeSymbolReference(),
            UpperBound = 121757
        },
         new CIMClassBreak
        {
            Symbol = SymbolFactory.Instance.ConstructPolygonSymbol(ColorFactory.Instance.GreyRGB).MakeSymbolReference(),
            UpperBound = 264435
        },
          new CIMClassBreak
        {
            Symbol = SymbolFactory.Instance.ConstructPolygonSymbol(ColorFactory.Instance.WhiteRGB).MakeSymbolReference(),
            UpperBound = 576594
        }
    };
    return QueuedTask.Run(() =>
    {
        CIMClassBreaksRenderer cimClassBreakRenderer = new CIMClassBreaksRenderer
        {
            ClassBreakType = ClassBreakType.GraduatedColor,
            ClassificationMethod = ClassificationMethod.Manual,
            Field = SDKHelpers.GetNumericField(featureLayer),
            //Important to add the Minimum break for your data to be classified correctly.
            //This is vital especially if you have data with negative values.
            //MinimumBreak = 
            Breaks = listClassBreaks.ToArray()
        };
   
        featureLayer?.SetRenderer(cimClassBreakRenderer);
    });

}

internal static Task DotDensityRendererAsync()
{
  //Check feature layer name
  //Code works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data
  var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault(f => f.Name == "USDemographics");
  if (featureLayer == null)
  {
    MessageBox.Show("This renderer works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data", "Data missing");
    return Task.FromResult(0);
  }
  return QueuedTask.Run(() =>
  {
    //Define size of the dot to use for the renderer
    int dotSize = 3;
    //Check if the TOTPOP10 field exists
    int idxField = -1;
    using (var table = featureLayer.GetTable())
    {
      var def = table.GetDefinition();
      idxField = def.FindField("TOTPOP10");
    }
    // "TOTPOP10" field was not found
    if (idxField == -1)
      return;

    //array of fields to be represented in the renderer
    var valueFields = new List<string> { "TOTPOP10" };
    //Create the DotDensityRendererDefinition object
    var dotDensityDef = new DotDensityRendererDefinition(valueFields, SDKHelpers.GetColorRamp(),
                                                                      dotSize, 30000, "Dot", "people");
    //Create the renderer using the DotDensityRendererDefinition
    CIMDotDensityRenderer dotDensityRndr = (CIMDotDensityRenderer)featureLayer.CreateRenderer(dotDensityDef);

      //if you want to customize the dot symbol for the renderer, create a "DotDensitySymbol" which is an
      //Amalgamation of 3 symbol layers: CIMVectorMarker, CIMSolidFill and CIMSolidStroke
      //Define CIMVectorMarker layer          
      var cimMarker = SymbolFactory.Instance.ConstructMarker(ColorFactory.Instance.RedRGB, dotSize);
      var dotDensityMarker = cimMarker as CIMVectorMarker;
      //Definte the placement
      CIMMarkerPlacementInsidePolygon markerPlacement = new CIMMarkerPlacementInsidePolygon { Randomness = 100, GridType = PlacementGridType.RandomFixedQuantity, Clipping = PlacementClip.RemoveIfCenterOutsideBoundary };
      dotDensityMarker.MarkerPlacement = markerPlacement;

      //Define CIMSolidFill layer
      CIMSolidFill solidFill = new CIMSolidFill { Color = new CIMRGBColor { R = 249, G = 232, B = 189, Alpha = 50 } };

      //Define CIMSolidStroke
      CIMSolidStroke solidStroke = new CIMSolidStroke { Color = ColorFactory.Instance.GreyRGB, Width = .5 };

      //Create the amalgamated CIMPolygonSymbol that includes the 3 layers
      var dotDensitySymbol = new CIMPolygonSymbol
      {
        SymbolLayers = new CIMSymbolLayer[] { dotDensityMarker, solidFill, solidStroke }
      };

      //Apply the dotDensitySymbol to the CIMDotDenstityRenderer's DotDensitySymbol property.
      dotDensityRndr.DotDensitySymbol = dotDensitySymbol.MakeSymbolReference();

      //Apply the renderer to the polygon Feature Layer.
      featureLayer.SetRenderer(dotDensityRndr);       
  });
}

internal static Task HeatMapRenderersAsync()
{
    //Check feature layer name
    //Code works with the U.S. Cities feature layer available with the ArcGIS Pro SDK Sample data
    var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault(f => f.Name == "U.S. Cities");
    if (featureLayer == null)
    {
      MessageBox.Show("This renderer works with the U.S. Cities feature layer available with the ArcGIS Pro SDK Sample data", "Data missing");
      return Task.FromResult(0);
    }
    return QueuedTask.Run(() =>
    {
        //defining a heatmap renderer that uses values from Population field as the weights
        HeatMapRendererDefinition heatMapDef = new HeatMapRendererDefinition()
        {
            Radius = 20,
            WeightField = SDKHelpers.GetNumericField(featureLayer),
            ColorRamp = SDKHelpers.GetColorRamp(),
            RendereringQuality = 8,
            UpperLabel = "High Density",
            LowerLabel = "Low Density"
        };

        CIMHeatMapRenderer heatMapRndr = (CIMHeatMapRenderer)featureLayer.CreateRenderer(heatMapDef);
        featureLayer.SetRenderer(heatMapRndr);
    });
}

internal static Task ProportionalRendererAsync()
{
    //Check feature layer name
    //Code works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data
    var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault(f => f.Name == "USDemographics");
    if (featureLayer == null)
    {
      MessageBox.Show("This renderer works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data", "Data missing");
      return Task.FromResult(0);
    }
    return QueuedTask.Run(() =>
    {
        //Gets the first numeric field of the feature layer
        var firstNumericFieldOfFeatureLayer = SDKHelpers.GetNumericField(featureLayer);
        //Gets the min and max value of the field
        var sizes = SDKHelpers.GetFieldMinMax(featureLayer, firstNumericFieldOfFeatureLayer);
        ProportionalRendererDefinition prDef = new ProportionalRendererDefinition()
        {
            Field = firstNumericFieldOfFeatureLayer,
            MinimumSymbolSize = 4,
            MaximumSymbolSize = 50,                   
            LowerSizeStop = Convert.ToDouble(sizes.Item1),
            UpperSizeStop = Convert.ToDouble(sizes.Item2)
        };
        CIMProportionalRenderer propRndr = (CIMProportionalRenderer)featureLayer.CreateRenderer(prDef);
        featureLayer.SetRenderer(propRndr);
    });
}

internal static Task SimpleRendererPolygon()
{
    //Check feature layer name
    //Code works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data
    var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault(f => f.Name == "USDemographics");
    if (featureLayer == null)
    {
      MessageBox.Show("This renderer works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data", "Data missing");
      return Task.FromResult(0);
    }
    return QueuedTask.Run(() =>
    {
        //Creating a polygon with a red fill and blue outline.
        CIMStroke outline = SymbolFactory.Instance.ConstructStroke(
             ColorFactory.Instance.BlueRGB, 2.0, SimpleLineStyle.Solid);
        CIMPolygonSymbol fillWithOutline = SymbolFactory.Instance.ConstructPolygonSymbol(
             ColorFactory.Instance.CreateRGBColor(255, 190, 190), SimpleFillStyle.Solid, outline);
        //Get the layer's current renderer
        CIMSimpleRenderer renderer = featureLayer.GetRenderer() as CIMSimpleRenderer;

        //Update the symbol of the current simple renderer
        renderer.Symbol = fillWithOutline.MakeSymbolReference();

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

internal static Task SimpleRendererPoint()
{
    //Check feature layer name
    //Code works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data
    var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault(f => f.ShapeType == esriGeometryType.esriGeometryPoint);
    if (featureLayer == null)
    {
      MessageBox.Show("This renderer works with a point feature layer", "Data missing");
      return Task.FromResult(0);
    }
    return QueuedTask.Run(() =>
    {
        //Create a circle marker
        var pointSymbol = SymbolFactory.Instance.ConstructPointSymbol(ColorFactory.Instance.RedRGB, 8, SimpleMarkerStyle.Circle);

        //Get the layer's current renderer
        CIMSimpleRenderer renderer = featureLayer.GetRenderer() as CIMSimpleRenderer;

        //Update the symbol of the current simple renderer
        renderer.Symbol = pointSymbol.MakeSymbolReference();

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

internal static Task SimpleRendererLine()
{
    //Check feature layer name
    //Code works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data
    var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault(f => f.Name == "U.S. National Transportation Atlas Interstate Highways");
    if (featureLayer == null)
    {
      MessageBox.Show("This renderer works with the U.S. National Transportation Atlas Interstate Highways feature layer available with the ArcGIS Pro SDK Sample data", "Data missing");
      return Task.FromResult(0);
    }
    return QueuedTask.Run(() =>
    {
        //Create a circle marker
        var lineSymbol = SymbolFactory.Instance.ConstructLineSymbol(ColorFactory.Instance.RedRGB, 2, SimpleLineStyle.DashDotDot);

        //Get the layer's current renderer
        CIMSimpleRenderer renderer = featureLayer.GetRenderer() as CIMSimpleRenderer;

        //Update the symbol of the current simple renderer
        renderer.Symbol = lineSymbol.MakeSymbolReference();

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

internal static Task SimpleRendererLineFromStyeItem()
    {
      //Check feature layer name
      //Code works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data
      var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault(f => f.Name == "U.S. National Transportation Atlas Interstate Highways");
      if (featureLayer == null)
      {
        MessageBox.Show("This renderer works with the U.S. National Transportation Atlas Interstate Highways feature layer available with the ArcGIS Pro SDK Sample data", "Data missing");
        return Task.FromResult(0);
      }
      //Get all styles in the project
      var styleProjectItem2D = Project.Current.GetItems<StyleProjectItem>().FirstOrDefault(s => s.Name == "ArcGIS 2D");

      return QueuedTask.Run(() => {
        //Get a specific style in the project by name
        var arrowLineSymbol = styleProjectItem2D.SearchSymbols(StyleItemType.LineSymbol, "Arrow Line 2 (Mid)")[0];
        if (arrowLineSymbol == null) return;

        //Get the layer's current renderer
        var renderer = featureLayer?.GetRenderer() as CIMSimpleRenderer;

        //Update the symbol of the current simple renderer
        renderer.Symbol = arrowLineSymbol.Symbol.MakeSymbolReference();

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

internal static Task UniqueValueRendererAsync()
{
  //Check feature layer name
  //Code works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data
  var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault(f => f.Name == "USDemographics");
  if (featureLayer == null)
  {
    MessageBox.Show("This renderer works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data", "Data missing");
    return Task.FromResult(0);
  }
  return QueuedTask.Run(() =>
  {
          //construct unique value renderer definition                
    UniqueValueRendererDefinition uvr = new
             UniqueValueRendererDefinition()
    {
      ValueFields = new List<string> { SDKHelpers.GetDisplayField(featureLayer) }, //multiple fields in the array if needed.
      ColorRamp = SDKHelpers.GetColorRamp(), //Specify color ramp
    };

          //Creates a "Renderer"
    var cimRenderer = featureLayer.CreateRenderer(uvr);

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