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

//Get all styles in the project
var ProjectStyles = Project.Current.GetItems<StyleProjectItem>();

//Get a specific style in the project by name
StyleProjectItem style = ProjectStyles.First(x => x.Name == "NameOfTheStyle");

//Full path for the new style file (.stylx) to be created
string styleToCreate = @"C:\Temp\NewStyle.stylx";
await QueuedTask.Run(() => StyleHelper.CreateStyle(Project.Current, styleToCreate));

//For ArcGIS Pro system styles, just pass in the name of the style to add to the project
await QueuedTask.Run(() => StyleHelper.AddStyle(Project.Current, "3D Vehicles"));

//For custom styles, pass in the full path to the style file on disk
string customStyleToAdd = @"C:\Temp\CustomStyle.stylx";
await QueuedTask.Run(() => StyleHelper.AddStyle(Project.Current, customStyleToAdd));

//For ArcGIS Pro system styles, just pass in the name of the style to remove from the project
await QueuedTask.Run(() => StyleHelper.RemoveStyle(Project.Current, "3D Vehicles"));

//For custom styles, pass in the full path to the style file on disk
string customStyleToAdd = @"C:\Temp\CustomStyle.stylx";
await QueuedTask.Run(() => StyleHelper.RemoveStyle(Project.Current, customStyleToAdd));

public Task AddStyleItemAsync(StyleProjectItem style, StyleItem itemToAdd)
{
  return QueuedTask.Run(() =>
  {
    if (style == null || itemToAdd == null)
      throw new System.ArgumentNullException();

    //Add the item to style
    style.AddItem(itemToAdd);
  });
}

public Task RemoveStyleItemAsync(StyleProjectItem style, StyleItem itemToRemove)
{
  return QueuedTask.Run(() =>
  {
    if (style == null || itemToRemove == null)
      throw new System.ArgumentNullException();

    //Remove the item from style
    style.RemoveItem(itemToRemove);
  });
}

//Pass in the full path to the style file on disk
public async Task<bool> CanUpgradeStyleAsync(string stylePath)
{
  //Add the style to the current project
  await QueuedTask.Run(() => StyleHelper.AddStyle(Project.Current, stylePath));
  StyleProjectItem style = Project.Current.GetItems<StyleProjectItem>().First(x => x.Path == stylePath);

  //returns true if style can be upgraded
  return style.CanUpgrade;
}

//Pass in the full path to the style file on disk
public async Task<bool> IsReadOnly(string stylePath)
{
  //Add the style to the current project
  await QueuedTask.Run(() => StyleHelper.AddStyle(Project.Current, stylePath));
  StyleProjectItem style = Project.Current.GetItems<StyleProjectItem>().First(x => x.Path == stylePath);

  //returns true if style is read-only
  return style.IsReadOnly;
}

//Pass in the full path to the style file on disk
public async Task<bool> IsCurrent(string stylePath)
{
  //Add the style to the current project
  await QueuedTask.Run(() => StyleHelper.AddStyle(Project.Current, stylePath));
  StyleProjectItem style = Project.Current.GetItems<StyleProjectItem>().First(x => x.Path == stylePath);

  //returns true if style matches the current Pro version
  return style.IsCurrent;
}

//Pass in the full path to the style file on disk
public async Task<bool> UpgradeStyleAsync(string stylePath)
{
  bool success = false;

  //Add the style to the current project
  await QueuedTask.Run(() => StyleHelper.AddStyle(Project.Current, stylePath));
  StyleProjectItem style = Project.Current.GetItems<StyleProjectItem>().First(x => x.Path == stylePath);

  //Verify that style can be upgraded
  if (style.CanUpgrade)
  {
    success = await QueuedTask.Run(() => StyleHelper.UpgradeStyle(style));
  }
  //return true if style was upgraded
  return success;
}

await QueuedTask.Run(() =>
{
  CIMPointSymbol pointSymbol = SymbolFactory.Instance.ConstructPointSymbol(ColorFactory.Instance.RedRGB, 10.0);
});

await QueuedTask.Run(() =>
{
  CIMPointSymbol starPointSymbol = SymbolFactory.Instance.ConstructPointSymbol(ColorFactory.Instance.RedRGB, 10.0, SimpleMarkerStyle.Star);
});

await QueuedTask.Run(() =>
{
  CIMMarker marker = SymbolFactory.Instance.ConstructMarker(ColorFactory.Instance.GreenRGB, 8.0, SimpleMarkerStyle.Pushpin);
  CIMPointSymbol pointSymbolFromMarker = SymbolFactory.Instance.ConstructPointSymbol(marker);
});

//The following file formats can be used to create the marker: DAE, 3DS, FLT, EMF, JPG, PNG, BMP, GIF
CIMMarker markerFromFile = await QueuedTask.Run(() => SymbolFactory.Instance.ConstructMarkerFromFile(@"C:\Temp\fileName.dae"));

CIMPointSymbol pointSymbolFromFile = SymbolFactory.Instance.ConstructPointSymbol(markerFromFile);

//Create a stream for the image
//At 3.0 you need https://www.nuget.org/packages/Microsoft.Windows.Compatibility
//System.Drawing

System.Drawing.Image newImage = System.Drawing.Image.FromFile(@"C:\PathToImage\Image.png");
var stream = new System.IO.MemoryStream();
newImage.Save(stream, System.Drawing.Imaging.ImageFormat.Png);
stream.Position = 0;
//Create marker using the stream
CIMMarker markerFromStream = SymbolFactory.Instance.ConstructMarkerFromStream(stream);
//Create the point symbol from the marker
CIMPointSymbol pointSymbolFromStream = SymbolFactory.Instance.ConstructPointSymbol(markerFromStream);

CIMPolygonSymbol polygonSymbol = SymbolFactory.Instance.ConstructPolygonSymbol(ColorFactory.Instance.RedRGB, SimpleFillStyle.Solid);

CIMStroke outline = SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.BlueRGB, 2.0, SimpleLineStyle.Solid);
CIMPolygonSymbol fillWithOutline = SymbolFactory.Instance.ConstructPolygonSymbol(ColorFactory.Instance.RedRGB, SimpleFillStyle.Solid, outline);

CIMPolygonSymbol fillWithoutOutline = SymbolFactory.Instance.ConstructPolygonSymbol(ColorFactory.Instance.RedRGB, SimpleFillStyle.Solid, null);

CIMLineSymbol lineSymbol = SymbolFactory.Instance.ConstructLineSymbol(ColorFactory.Instance.BlueRGB, 4.0, SimpleLineStyle.Solid);

CIMStroke stroke = SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.BlackRGB, 2.0);
CIMLineSymbol lineSymbolFromStroke = SymbolFactory.Instance.ConstructLineSymbol(stroke);

//These methods must be called within the lambda passed to QueuedTask.Run
var lineStrokeRed = SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.RedRGB, 4.0);
var markerCircle = SymbolFactory.Instance.ConstructMarker(ColorFactory.Instance.RedRGB, 12, SimpleMarkerStyle.Circle);
markerCircle.MarkerPlacement = new CIMMarkerPlacementOnVertices()
{
  AngleToLine = true,
  PlaceOnEndPoints = true,
  Offset = 0
};
var lineSymbolWithCircles = new CIMLineSymbol()
{
  SymbolLayers = new CIMSymbolLayer[2] { markerCircle, lineStrokeRed }
};

//These methods must be called within the lambda passed to QueuedTask.Run
var markerTriangle = SymbolFactory.Instance.ConstructMarker(ColorFactory.Instance.RedRGB, 12, SimpleMarkerStyle.Triangle);
markerTriangle.Rotation = -90; // or -90
markerTriangle.MarkerPlacement = new CIMMarkerPlacementOnLine() { AngleToLine = true, RelativeTo = PlacementOnLineRelativeTo.LineEnd };

var lineSymbolWithArrow = new CIMLineSymbol()
{
  SymbolLayers = new CIMSymbolLayer[2] { markerTriangle,
              SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.RedRGB, 2)
          }
};

CIMPolygonSymbol symbol = SymbolFactory.Instance.ConstructPolygonSymbol(ColorFactory.Instance.RedRGB);

//Get symbol reference from the symbol
CIMSymbolReference symbolReference = symbol.MakeSymbolReference();

//create marker from the Font, char index,size,color
var cimMarker = SymbolFactory.Instance.ConstructMarker(125, "Wingdings 3", "Regular", 6, ColorFactory.Instance.BlueRGB) as CIMCharacterMarker;
  var polygonMarker = cimMarker.Symbol;
  //modifying the polygon's outline and fill
  //This is the outline
  polygonMarker.SymbolLayers[0] = SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.GreenRGB, 2, SimpleLineStyle.Solid);
  //This is the fill
  polygonMarker.SymbolLayers[1] = SymbolFactory.Instance.ConstructSolidFill(ColorFactory.Instance.BlueRGB);
  //create a symbol from the marker 
  //Note this overload of ConstructPointSymbol does not need to be run within QueuedTask.Run.
  var pointSymbol = SymbolFactory.Instance.ConstructPointSymbol(cimMarker);

//Must use QueuedTask.Run(...)
//returns a tuple per font: (string fontName, List<string> fontStyles)
var fonts = SymbolFactory.Instance.GetAvailableFonts();
foreach(var font in fonts)
      {
  var styles = string.Join(",", font.fontStyles);
  System.Diagnostics.Debug.WriteLine($"{font.fontName}, styles: {styles}");
      }

//Must use QueuedTask.Run(...)
var def_font = SymbolFactory.Instance.DefaultFont;
System.Diagnostics.Debug.WriteLine($"{def_font.fontName}, styles: {def_font.styleName}");

//set default font - set through application options
//Must use QueuedTask
ApplicationOptions.TextAndGraphicsElementsOptions.SetDefaultFont("tahoma");
ApplicationOptions.TextAndGraphicsElementsOptions.SetDefaultFont("tahoma","bold");

QueuedTask.Run(() =>
{
  //using the default font
  var textSym1 = SymbolFactory.Instance.ConstructTextSymbol();
  var textSym2 = SymbolFactory.Instance.ConstructTextSymbol(
                     ColorFactory.Instance.BlueRGB, 14);

  //using a specific font
  var textSym3 = SymbolFactory.Instance.ConstructTextSymbol("Arial");
  var textSym4 = SymbolFactory.Instance.ConstructTextSymbol(
                    "Arial", "Narrow Bold");

  //or query available fonts to ensure the font is there
  var all_fonts = SymbolFactory.Instance.GetAvailableFonts();
  var font = all_fonts.FirstOrDefault(f => f.fontName == "Arial");
  if (!string.IsNullOrEmpty(font.fontName))
  {
    var textSym5 = SymbolFactory.Instance.ConstructTextSymbol(font.fontName);
    //or with a font+style
    var textSym6 = SymbolFactory.Instance.ConstructTextSymbol(
                                    font.fontName, font.fontStyles.First());
  }

  //overloads - font + color and size, etc
  var textSym7 = SymbolFactory.Instance.ConstructTextSymbol(
                  ColorFactory.Instance.BlueRGB, 14, "Times New Roman", "Italic");

  //custom symbol - black stroke, red fill
  var poly_symbol = SymbolFactory.Instance.ConstructPolygonSymbol(
    SymbolFactory.Instance.ConstructSolidFill(ColorFactory.Instance.RedRGB),
    SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.BlackRGB, 1));
  var textSym8 = SymbolFactory.Instance.ConstructTextSymbol(
          poly_symbol, 14, "Georgia", "Bold");

});

//Note: call within QueuedTask.Run()
CIMSymbol symbol = SymbolFactory.Instance.ConstructPointSymbol(ColorFactory.Instance.GreenRGB, 1.0, SimpleMarkerStyle.Circle);
  //You can generate a swatch for a text symbols also.
  var si = new SymbolStyleItem()
  {
      Symbol = symbol,
      PatchHeight = 64,
      PatchWidth = 64
  };
  return si.PreviewImage;

//Note: Run within QueuedTask.Run
//Create a point symbol
var pointSymbol = SymbolFactory.Instance.ConstructPointSymbol(
  ColorFactory.Instance.RedRGB, 24, SimpleMarkerStyle.RoundedSquare);

//Generate image returns a stream
//OutputImageFormat specified the format for the image - in this case
//we want SVG (an xml-based format)
//
//output fmt: SVG, scale factor x2, centerAnchorPoint = true
//dpi = 300, wd x ht: 100x100px, background: white
var mem_strm = SymbolFactory.Instance.GenerateImage(
  pointSymbol, OutputImageFormat.SVG, 2.0, true, 300, 100, 100,
  ColorFactory.Instance.WhiteRGB);

//Set the memory stream position to the beginning
mem_strm.Seek(0, SeekOrigin.Begin);

//File path and name for saving the SVG file
var fileName = "RoundedSquareSymbol.svg";
string path_svg = Path.Combine(Path.GetTempPath() + fileName);

//Write the memory stream to the file
System.IO.File.WriteAllBytes(path_svg, mem_strm.ToArray());

//////////////////////////////////////////////
//Note: to convert SVG to image format, use a 3rd party
//e.g. Aspose.SVG for .NET, for example convert SVG to PNG
//using (var svg_doc = new Aspose.Svg.SVGDocument(path_svg))
//{
//  string path_png = Path.Combine(Path.GetTempPath() + "RoundedSquareSymbol.png");
//  using (var img_png = new Aspose.Svg.Rendering.Image.ImageDevice(
//    new ImageRenderingOptions(ImageFormat.Png), path_png))
//  {
//    svg_doc.RenderTo(img_png);
//  }
//  //also: https://docs.aspose.com/imaging/net/convert-svg-to-png/
//}

//Note: Run within QueuedTask.Run
//Create a point symbol
var pointSymbol = SymbolFactory.Instance.ConstructPointSymbol(
  ColorFactory.Instance.RedRGB, 24, SimpleMarkerStyle.RoundedSquare);

//Generate image returns a stream
//OutputImageFormat specified the format for the image - in this case
//we want PNG
//
//output fmt: PNG, scale factor x2, centerAnchorPoint = true
//dpi = 300, wd x ht: 100x100px, background: white
var mem_strm = SymbolFactory.Instance.GenerateImage(
  pointSymbol, OutputImageFormat.PNG, 2.0, true, 300, 100, 100,
  ColorFactory.Instance.WhiteRGB);

//Set the memory stream position to the beginning
mem_strm.Seek(0, SeekOrigin.Begin);

//Write the stream to a bit map
var bitmapImage = new System.Windows.Media.Imaging.BitmapImage();

bitmapImage.BeginInit();
bitmapImage.StreamSource = mem_strm;
bitmapImage.CacheOption = System.Windows.Media.Imaging.BitmapCacheOption.OnLoad;
bitmapImage.EndInit();
bitmapImage.Freeze();

//Write the bit map out to a file
//File path and name for saving the PNG file
var fileName = "RoundedSquareSymbol.png";
string path_png = Path.Combine(Path.GetTempPath() + fileName);

BitmapEncoder encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(bitmapImage));

using (var fileStream = new System.IO.FileStream(
  path_png, System.IO.FileMode.Create))
{
  encoder.Save(fileStream);
}

//Note: Run within QueuedTask.Run
//Get the selection
var selection = featureLayer.GetSelection();
  //Get the first Object ID
  var firstOID = selection.GetObjectIDs().FirstOrDefault();
  //Determine whether the layer's renderer type supports symbol lookup.
  if (featureLayer.CanLookupSymbol())
  {
      //Looks up the symbol for the corresponding feature identified by the object id.
      var symbol = featureLayer.LookupSymbol(firstOID, MapView.Active);
      var jSon = symbol.ToJson(); //Create a JSON encoding of the symbol
      //Do something with symbol
  }

public Task<SymbolStyleItem> GetSymbolFromStyleAsync(StyleProjectItem style, string key)
{
  return QueuedTask.Run(() =>
  {
    if (style == null)
        throw new System.ArgumentNullException();

    //Search for a specific point symbol in style
    SymbolStyleItem item = (SymbolStyleItem)style.LookupItem(StyleItemType.PointSymbol, key);
    return item;
  });
}

public Task<IList<SymbolStyleItem>> GetPointSymbolsFromStyleAsync(StyleProjectItem style, string searchString)
{
  if (style == null)
    throw new System.ArgumentNullException();

  //Search for point symbols
  return QueuedTask.Run(() => style.SearchSymbols(StyleItemType.PointSymbol, searchString));
}

public Task<IList<SymbolStyleItem>> GetLineSymbolsFromStyleAsync(StyleProjectItem style, string searchString)
{
  if (style == null)
    throw new System.ArgumentNullException();

  //Search for line symbols
  return QueuedTask.Run(() => style.SearchSymbols(StyleItemType.LineSymbol, searchString));
}

public async Task<IList<SymbolStyleItem>> GetPolygonSymbolsFromStyleAsync(StyleProjectItem style, string searchString)
{
  if (style == null)
    throw new System.ArgumentNullException();

  //Search for polygon symbols
  return await QueuedTask.Run(() => style.SearchSymbols(StyleItemType.PolygonSymbol, searchString));
}

public async Task<IList<ColorStyleItem>> GetColorsFromStyleAsync(StyleProjectItem style, string searchString)
{
  if (style == null)
    throw new System.ArgumentNullException();

  //Search for colors
  return await QueuedTask.Run(() => style.SearchColors(searchString));
}

public async Task<IList<ColorRampStyleItem>> GetColorRampsFromStyleAsync(StyleProjectItem style, string searchString)
{
  //StyleProjectItem can be "ColorBrewer Schemes (RGB)", "ArcGIS 2D"...
  if (style == null)
    throw new System.ArgumentNullException();

  //Search for color ramps
  //Color Ramp searchString can be "Spectral (7 Classes)", "Pastel 1 (3 Classes)", "Red-Gray (10 Classes)"..
  return await QueuedTask.Run(() => style.SearchColorRamps(searchString));
}

public Task<IList<NorthArrowStyleItem>> GetNorthArrowsFromStyleAsync(StyleProjectItem style, string searchString)
{
  if (style == null)
    throw new System.ArgumentNullException();

  //Search for north arrows
  return QueuedTask.Run(() => style.SearchNorthArrows(searchString));
}

public Task<IList<ScaleBarStyleItem>> GetScaleBarsFromStyleAsync(StyleProjectItem style, string searchString)
{
  if (style == null)
    throw new System.ArgumentNullException();

  //Search for scale bars
  return QueuedTask.Run(() => style.SearchScaleBars(searchString));
}

public Task<IList<LabelPlacementStyleItem>> GetLabelPlacementsFromStyleAsync(StyleProjectItem style, string searchString)
{
  if (style == null)
    throw new System.ArgumentNullException();

  //Search for standard label placement
  return QueuedTask.Run(() => style.SearchLabelPlacements(StyleItemType.StandardLabelPlacement, searchString));
}

public Task<IList<LegendStyleItem>> GetLegendFromStyleAsync(StyleProjectItem style, string searchString)
{
  if (style == null)
    throw new System.ArgumentNullException();

  return QueuedTask.Run(() => style.SearchLegends(searchString));
}

public Task<IList<LegendItemStyleItem>> GetLegendItemsFromStyleAsync(StyleProjectItem style, string searchString)
{
  if (style == null)
    throw new System.ArgumentNullException();

  return QueuedTask.Run(() => style.SearchLegendItems(searchString));
}

public Task<IList<GridStyleItem>> GetGridsFromStyleAsync(StyleProjectItem style, string searchString)
{
  if (style == null)
    throw new System.ArgumentNullException();

  return QueuedTask.Run(() => style.SearchGrids(searchString));
}

public Task<IList<MapSurroundStyleItem>> GetMapSurroundsFromStyleAsync(StyleProjectItem style, string searchString)
{
  if (style == null)
    throw new System.ArgumentNullException();

  return QueuedTask.Run(() => style.SearchMapSurrounds(searchString));
}

public Task<IList<TableFrameStyleItem>> GetTableFramesFromStyleAsync(StyleProjectItem style, string searchString)
{
  if (style == null)
    throw new System.ArgumentNullException();

  return QueuedTask.Run(() => style.SearchTableFrames(searchString));
}

public Task<IList<TableFrameFieldStyleItem>> GetTableFrameFieldsFromStyleAsync(StyleProjectItem style, string searchString)
{
  if (style == null)
    throw new System.ArgumentNullException();

  return QueuedTask.Run(() => style.SearchTableFrameFields(searchString));
}

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();

    //Apply 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);
    });

}

Map map = MapView.Active.Map;

await QueuedTask.Run(() =>
{
  var map = MapFactory.Instance.CreateMap(mapName, basemap: Basemap.ProjectDefault);
  //TODO: use the map...
});

public static async Task<Map> FindOpenExistingMapAsync(string mapName)
{
  return await QueuedTask.Run(async () =>
  {
    Map map = null;
    Project proj = Project.Current;

    //Finding the first project item with name matches with mapName
    MapProjectItem mpi = proj.GetItems<MapProjectItem>()
      .FirstOrDefault(m => m.Name.Equals(mapName, StringComparison.CurrentCultureIgnoreCase));
    if (mpi != null)
    {
      map = mpi.GetMap();
      //Opening the map in a mapview
      await ProApp.Panes.CreateMapPaneAsync(map);
    }
    return map;
  });

}

Map map = null;

//Assume we get the selected webmap from the Project pane's Portal tab
if (Project.Current.SelectedItems.Count > 0)
{
  if (MapFactory.Instance.CanCreateMapFrom(Project.Current.SelectedItems[0]))
  {
    map = MapFactory.Instance.CreateMapFromItem(Project.Current.SelectedItems[0]);
    await ProApp.Panes.CreateMapPaneAsync(map);
  }
}

public static IEnumerable<IMapPane> GetMapPanes()
{
  //Sorted by Map Uri
  return ProApp.Panes.OfType<IMapPane>().OrderBy((mp) => mp.MapView.Map.URI ?? mp.MapView.Map.Name);
}

public static IReadOnlyList<Map> GetMapsFromMapPanes()
{
  //Gets the unique list of Maps from all the MapPanes.
  //Note: The list of maps retrieved from the MapPanes
  //maybe less than the total number of Maps in the project.
  //It depends on what maps the user has actually opened.
  var mapPanes = ProApp.Panes.OfType<IMapPane>()
              .GroupBy((mp) => mp.MapView.Map.URI).Select(grp => grp.FirstOrDefault());
  List<Map> uniqueMaps = new List<Map>();
  foreach (var pane in mapPanes)
    uniqueMaps.Add(pane.MapView.Map);
  return uniqueMaps;
}

MapView.Active.Map.SetName("Test");

ProApp.Panes.ActivePane.Caption = "Caption";

//Note: Run within the context of QueuedTask.Run
bool canConvertMap = MapFactory.Instance.CanConvertMap(map, MapConversionType.SceneLocal);
if (canConvertMap)
  MapFactory.Instance.ConvertMap(map, MapConversionType.SceneLocal, true);

//Basemaps stored locally in the project. This is usually an empty collection
string localBasemapTypeID = "cim_map_basemap";
var localBasemaps = await QueuedTask.Run(() =>
{
  var mapContainer = Project.Current.GetProjectItemContainer("Map");
  return mapContainer.GetItems().Where(i => i.TypeID == localBasemapTypeID).ToList();
});

//portal basemaps. If there is no current active portal, the usual default
//is arcgis online
var portal = ArcGISPortalManager.Current.GetActivePortal();
var portalBaseMaps = await portal.GetBasemapsAsync();

//use one of them...local or portal...
//var map = MapView.Active.Map;
//QueuedTask.Run(() => map?.SetBasemapLayers(portalBaseMaps[0]));

map.SaveAsFile(@"C:\Data\MyMap.mapx", true);

//2D maps only
//Must be on the QueuedTask.Run(...)
if (map.DefaultViewingMode == MapViewingMode.Map)
  //Only webmap compatible layers will be saved out to the file
  map.SaveAsWebMapFile(@"C:\Data\MyMap.json");

//Run within QueuedTask
var map = MapView.Active.Map;
//A layer to use for the clip extent
var lyrOfInterest = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().Where(l => l.Name == "TestPoly").FirstOrDefault();
//Get the polygon to use to clip the map
var extent = lyrOfInterest.QueryExtent();
var polygonForClipping = PolygonBuilderEx.CreatePolygon(extent);
//Clip the map using the layer's extent
map.SetClipGeometry(polygonForClipping,
      SymbolFactory.Instance.ConstructLineSymbol(
      SymbolFactory.Instance.ConstructStroke(
        ColorFactory.Instance.BlueRGB, 2.0, SimpleLineStyle.Dash)));

//Run within QueuedTask
var map = MapView.Active.Map;
//Clear the Map clip.
//If no clipping is set then this is a no-op.
map.ClearClipGeometry();

var map = MapView.Active.Map;
//If clipping is set to ArcGIS.Core.CIM.ClippingMode.None or ArcGIS.Core.CIM.ClippingMode.MapSeries null is returned
//If clipping is set to ArcGIS.Core.CIM.ClippingMode.MapExtent the ArcGIS.Core.CIM.CIMMap.CustomFullExtent is returned.
//Otherwise, if clipping is set to ArcGIS.Core.CIM.ClippingMode.CustomShape the custom clip polygon is returned.
var poly = map.GetClipGeometry();
//You can use the polygon returned
//For example: We make a polygon graphic element and add it to a Graphics Layer.
var gl = map.GetLayersAsFlattenedList().OfType<GraphicsLayer>().FirstOrDefault();
if (gl == null) return;
var polygonSymbol = SymbolFactory.Instance.ConstructPolygonSymbol(CIMColor.CreateRGBColor(255, 255, 0));
var cimGraphicElement = new CIMPolygonGraphic
{
  Polygon = poly,
  Symbol = polygonSymbol.MakeSymbolReference()
};
gl.AddElement(cimGraphicElement);

//var map = MapView.Active.Map;
//Must be on the QueuedTask.Run()

//Get the current location unit
var loc_unit = map.GetLocationUnitFormat();
var line = $"{loc_unit.DisplayName}, {loc_unit.UnitCode}";
System.Diagnostics.Debug.WriteLine(line);

//var map = MapView.Active.Map;
//Must be on the QueuedTask.Run()

//Linear location unit formats are not included if the map sr
//is geographic.
var loc_units = map.GetAvailableLocationUnitFormats();

var mv = MapView.Active;
var map = mv.Map;

QueuedTask.Run(() =>
{
  //Get the current view camera location
  var center_pt = new Coordinate2D(mv.Camera.X, mv.Camera.Y);
  //Get the current location unit
  var loc_unit = map.GetLocationUnitFormat();

  //Format the camera location
  var str = loc_unit.FormatLocation(center_pt, map.SpatialReference);
  System.Diagnostics.Debug.WriteLine($"Formatted location: {str}");
});

var mv = MapView.Active;
var map = mv.Map;

QueuedTask.Run(() =>
{
  //Get the list of available location unit formats
  //for the current map
  var loc_units = map.GetAvailableLocationUnitFormats();

  //arbitrarily use the last unit in the list
  map.SetLocationUnitFormat(loc_units.Last());
});

//var map = MapView.Active.Map;
//Must be on the QueuedTask.Run()

//If the map is not a scene, the default Project distance
//unit will be returned
var elev_unit = map.GetElevationUnitFormat();
var line = $"{elev_unit.DisplayName}, {elev_unit.UnitCode}";
System.Diagnostics.Debug.WriteLine(line);

//var map = MapView.Active.Map;
//Must be on the QueuedTask.Run()

//If the map is not a scene, the list of current
//Project distance units will be returned
var elev_units = map.GetAvailableElevationUnitFormats();

var mv = MapView.Active;
var map = mv.Map;

QueuedTask.Run(() =>
{
  //Get the current elevation unit. If the map is not
  //a scene the default Project distance unit is returned
  var elev_unit = map.GetElevationUnitFormat();

  //Format the view camera elevation
  var str = elev_unit.FormatValue(mv.Camera.Z);

  System.Diagnostics.Debug.WriteLine($"Formatted elevation: {str}");
});

var map = MapView.Active.Map;

QueuedTask.Run(() =>
{
  //Trying to set the elevation unit on a map other than
  //a scene will throw an InvalidOperationException
  if (map.IsScene)
  {
    //Get the list of available elevation unit formats
    //for the current map
    var loc_units = map.GetAvailableElevationUnitFormats();
    //arbitrarily use the last unit in the list
    map.SetElevationUnitFormat(loc_units.Last());
  }

});

//namespace ArcGIS.Desktop.Mapping.Offline
var map = MapView.Active.Map;

//await if needed...
QueuedTask.Run(() =>
{
  var hasSyncEnabledContent = GenerateOfflineMap.Instance.GetCanGenerateReplicas(map);
  if (hasSyncEnabledContent)
  {
    //TODO - use status...
  }
});

//namespace ArcGIS.Desktop.Mapping.Offline
var extent = MapView.Active.Extent;
var map = MapView.Active.Map;

//await if needed...
QueuedTask.Run(() =>
{
  //Check map has sync-enabled content that can be taken offline
  var hasSyncEnabledContent = GenerateOfflineMap.Instance.GetCanGenerateReplicas(map);
  if (hasSyncEnabledContent)
  {
    //Generate Replicas and take the content offline
    //sync-enabled content gets copied local into a SQLite DB
    var gen_params = new GenerateReplicaParams()
    {
      Extent = extent, //SR of extent must match map SR

      //DestinationFolder can be left blank, if specified,
      //it must exist. Defaults to project offline maps location
      DestinationFolder = @"C:\Data\Offline"
    };
    //Sync-enabled layer content will be resourced to point to the
    //local replica content.
    GenerateOfflineMap.Instance.GenerateReplicas(map, gen_params);

  }
});

//namespace ArcGIS.Desktop.Mapping.Offline
var map = MapView.Active.Map;

//await if needed...
QueuedTask.Run(() =>
{
  //Check map has local syncable content
  var canSyncContent = GenerateOfflineMap.Instance.GetCanSynchronizeReplicas(map);
  if (canSyncContent)
  {
    //TODO - use status
  }
});

//namespace ArcGIS.Desktop.Mapping.Offline
var map = MapView.Active.Map;

//await if needed...
QueuedTask.Run(() =>
{
  //Check map has local syncable content
  var canSyncContent = GenerateOfflineMap.Instance.GetCanSynchronizeReplicas(map);
  if (canSyncContent)
  {
    //Sync Replicas - changes since last sync are pushed to the
    //parent replica. Parent changes are pulled to the client.
    //Unsaved edits are _not_ sync'd. 
    GenerateOfflineMap.Instance.SynchronizeReplicas(map);
  }
});

//namespace ArcGIS.Desktop.Mapping.Offline
var extent = MapView.Active.Extent;
var map = MapView.Active.Map;

//await if needed...
QueuedTask.Run(() =>
{
  //Check map has local syncable content
  //Either..
  //var canSyncContent = GenerateOfflineMap.Instance.GetCanSynchronizeReplicas(map);
  //Or...both accomplish the same thing...
  var canRemove = GenerateOfflineMap.Instance.GetCanRemoveReplicas(map);
  if (canRemove)
  {
    //Remove Replicas - any unsync'd changes are lost
    //Call sync _first_ to push any outstanding changes if
    //needed. Local syncable content is re-sourced
    //to point to the service
    GenerateOfflineMap.Instance.RemoveReplicas(map);
  }
});

//namespace ArcGIS.Desktop.Mapping.Offline
var extent = MapView.Active.Extent;
var map = MapView.Active.Map;

//await if needed...
QueuedTask.Run(() =>
{
  //Does the map have any exportable raster content?
  var canExport = GenerateOfflineMap.Instance.GetCanExportRasterTileCache(map);
  if (canExport)
  {
    //Check the available LOD scale ranges
    var scales = GenerateOfflineMap.Instance.GetExportRasterTileCacheScales(map, extent);
    //Pick the desired LOD scale
    var max_scale = scales[scales.Count() / 2];

    //Configure the export parameters
    var export_params = new ExportTileCacheParams()
    {
      Extent = extent,//Use same extent as was used to retrieve scales
      MaximumUserDefinedScale = max_scale
      //DestinationFolder = .... (optional)
    };
    //If DestinationFolder is not set, output defaults to project
    //offline maps location set in the project properties. If that is 
    //not set, output defaults to the current project folder location.

    //Do the export. Depending on the MaximumUserDefinedScale and the
    //area of the extent requested, this can take minutes for tile packages
    //over 1 GB or less if your network speed is slow...
    GenerateOfflineMap.Instance.ExportRasterTileCache(map, export_params);
  }
});

//namespace ArcGIS.Desktop.Mapping.Offline
var extent = MapView.Active.Extent;
var map = MapView.Active.Map;

//await if needed...
QueuedTask.Run(() =>
{
  //Does the map have any exportable vector tile content?
  var canExport = GenerateOfflineMap.Instance.GetCanExportVectorTileCache(map);
  if (canExport)
  {
    //Check the available LOD scale ranges
    var scales = GenerateOfflineMap.Instance.GetExportVectorTileCacheScales(map, extent);
    //Pick the desired LOD scale
    var max_scale = scales[scales.Count() / 2];

    //Configure the export parameters
    var export_params = new ExportTileCacheParams()
    {
      Extent = extent,//Use same extent as was used to retrieve scales
      MaximumUserDefinedScale = max_scale,
      DestinationFolder = @"C:\Data\Offline"
    };
    //If DestinationFolder is not set, output defaults to project
    //offline maps location set in the project properties. If that is 
    //not set, output defaults to the current project folder location.

    //Do the export. Depending on the MaximumUserDefinedScale and the
    //area of the extent requested, this can take minutes for tile packages
    //over 1 GB or less if your network speed is slow...
    GenerateOfflineMap.Instance.ExportVectorTileCache(map, export_params);
  }
});

/*
* string url = @"c:\data\project.gdb\DEM";  //Raster dataset from a FileGeodatabase
* string url = @"c:\connections\mySDEConnection.sde\roads";  //FeatureClass of a SDE
* string url = @"c:\connections\mySDEConnection.sde\States\roads";  //FeatureClass within a FeatureDataset from a SDE
* string url = @"c:\data\roads.shp";  //Shapefile
* string url = @"c:\data\imagery.tif";  //Image from a folder
* string url = @"c:\data\mySDEConnection.sde\roads";  //.lyrx or .lpkx file
* string url = @"c:\data\CAD\Charlottesville\N1W1.dwg\Polyline";  //FeatureClass in a CAD dwg file
* string url = @"C:\data\CAD\UrbanHouse.rvt\Architectural\Windows"; //Features in a Revit file
* string url = @"http://sampleserver1.arcgisonline.com/ArcGIS/rest/services/Demographics/ESRI_Census_USA/MapServer";  //map service
* string url = @"http://sampleserver6.arcgisonline.com/arcgis/rest/services/NapervilleShelters/FeatureServer/0";  //FeatureLayer off a map service or feature service
*/
string url = @"c:\data\project.gdb\roads";  //FeatureClass of a FileGeodatabase

Uri uri = new Uri(url);
await QueuedTask.Run(() => LayerFactory.Instance.CreateLayer(uri, MapView.Active.Map));

var flyrCreatnParam = new FeatureLayerCreationParams(new Uri(@"c:\data\world.gdb\cities"))
{
  Name = "World Cities",
  IsVisible = false,
  MinimumScale = 1000000,
  MaximumScale = 5000,
  // At 2.x - DefinitionFilter = new CIMDefinitionFilter()
  //{
  //  DefinitionExpression = "Population > 100000",
  //  Name = "More than 100k"
  //},
  DefinitionQuery = new DefinitionQuery(whereClause: "Population > 100000", name: "More than 100k"),
  RendererDefinition = new SimpleRendererDefinition()
  {
    SymbolTemplate = SymbolFactory.Instance.ConstructPointSymbol(
      CIMColor.CreateRGBColor(255, 0, 0), 8, SimpleMarkerStyle.Hexagon).MakeSymbolReference()
  }
};

var featureLayer = LayerFactory.Instance.CreateLayer<FeatureLayer>(
  flyrCreatnParam, map);

//Note: Call within QueuedTask.Run()
var layerDoc = new LayerDocument(@"E:\Data\SDK\Default2DPointSymbols.lyrx");
var createParams = new LayerCreationParams(layerDoc.GetCIMLayerDocument());
LayerFactory.Instance.CreateLayer<FeatureLayer>(createParams, MapView.Active.Map);

//The catalog path of the feature layer to add to the map
var featureClassUriVisibility = new Uri(@"C:\Data\Admin\AdminData.gdb\USA\cities");
//Define the Feature Layer's parameters.
var layerParamsVisibility = new FeatureLayerCreationParams(featureClassUriVisibility)
{
  //Set visibility
  IsVisible = false,
};
//Create the layer with the feature layer parameters and add it to the active map
var createdFC = LayerFactory.Instance.CreateLayer<FeatureLayer>(layerParamsVisibility, MapView.Active.Map);

//Note: Call within QueuedTask.Run()
//Define a simple renderer to draw the Point US Cities feature class.
var simpleRender = new SimpleRendererDefinition
{
  SymbolTemplate = SymbolFactory.Instance.ConstructPointSymbol(ColorFactory.Instance.RedRGB, 4.0, SimpleMarkerStyle.Circle).MakeSymbolReference()

};
//The catalog path of the feature layer to add to the map
var featureClassUri = new Uri(@"C:\Data\Admin\AdminData.gdb\USA\cities");
//Define the Feature Layer's parameters.
var layerParams = new FeatureLayerCreationParams(featureClassUri)
{
  //Set visibility
  IsVisible = true,
  //Set Renderer
  RendererDefinition = simpleRender,
};
//Create the layer with the feature layer parameters and add it to the active map
var createdFCWithRenderer = LayerFactory.Instance.CreateLayer<FeatureLayer>(layerParams, MapView.Active.Map);

//The catalog path of the feature layer to add to the map
var featureClassUriDefinition = new Uri(@"C:\Data\Admin\AdminData.gdb\USA\cities");
//Define the Feature Layer's parameters.
//At 2.x - var layerParamsQueryDefn = new FeatureLayerCreationParams(featureClassUriDefinition)
//{
//  IsVisible = true,
//  DefinitionFilter = new CIMDefinitionFilter()
//  {
//    Name = "CACities",
//    DefinitionExpression = "STATE_NAME = 'California'"
//  }
//};
var layerParamsQueryDefn = new FeatureLayerCreationParams(featureClassUriDefinition)
{
  IsVisible = true,
  DefinitionQuery = new DefinitionQuery(whereClause: "STATE_NAME = 'California'", name: "CACities")
};

//Create the layer with the feature layer parameters and add it to the active map
var createdFCWithQueryDefn = LayerFactory.Instance.CreateLayer<FeatureLayer>(layerParamsQueryDefn, MapView.Active.Map);

var uriShp = new Uri(@"c:\data\roads.shp");
var uriSde = new Uri(@"c:\MyDataConnections\MySDE.sde\Census");
var uri = new Uri(@"http://sampleserver6.arcgisonline.com/arcgis/rest/services/NapervilleShelters/FeatureServer/0");

var uris = new List<Uri>() { uriShp, uriSde, uri };

var layers = LayerFactory.Instance.CreateLayers(uris, MapView.Active.Map);

var uriShp = new Uri(@"c:\data\roads.shp");
var uriSde = new Uri(@"c:\MyDataConnections\MySDE.sde\Census");
var uri = new Uri(@"http://sampleserver6.arcgisonline.com/arcgis/rest/services/NapervilleShelters/FeatureServer/0");

var uris = new List<Uri>() { uriShp, uriSde, uri }; ;

// set the index and visibility
var blkParams = new BulkLayerCreationParams(uris);
blkParams.MapMemberPosition = MapMemberPosition.Index;
blkParams.MapMemberIndex = 2;
blkParams.IsVisible = false;

var layers = LayerFactory.Instance.CreateLayers(blkParams, MapView.Active.Map);
      }

string pathToGeoPackage = @"C:\Data\Geopackage\flooding.gpkg";
//Create lists to hold the URIs of the layers and tables in the geopackage
var layerUris = new List<Uri>();
var tableUris = new List<Uri>();
//Create an item from the geopackage
var item = ItemFactory.Instance.Create(pathToGeoPackage, ItemFactory.ItemType.PathItem);
var children = item.GetItems();
//Collect the table and spatial data in the geopackage
foreach (var child in children)
{
  var childPath = child.Path;

  if (child.TypeID == "sqlite_table")
    tableUris.Add(new Uri(childPath));
  else
    layerUris.Add(new Uri(childPath));
}
//Add the spatial data in the geopackage using the BulkLayerCreationParams
if (layerUris.Count > 0)
{
  BulkLayerCreationParams bulklcp = new BulkLayerCreationParams(layerUris);
  LayerFactory.Instance.CreateLayers(bulklcp, MapView.Active.Map);
}
// add the tables separately
foreach (var tableUri in tableUris)
{
  StandaloneTableFactory.Instance.CreateStandaloneTable(tableUri, MapView.Active.Map);
}

var path = @"D:\Data\CommunitySamplesData\Topology\GrandTeton.gdb\BackCountry\Backcountry_Topology";
var lcp = new TopologyLayerCreationParams(new Uri(path));
lcp.Name = "GrandTeton_Backcountry";
lcp.AddAssociatedLayers = true;
var topoLayer = LayerFactory.Instance.CreateLayer<ArcGIS.Desktop.Mapping.TopologyLayer>(lcp, MapView.Active.Map);

//Note: Call within QueuedTask.Run()
//Get the Topology of another Topology layer
var existingTopology = MapView.Active.Map.GetLayersAsFlattenedList().OfType<TopologyLayer>().FirstOrDefault();
if (existingTopology != null)
{
  var topology = existingTopology.GetTopology();
  //Configure the settings for a new Catalog layer using the CatalogDataset of an existing layer
  var topologyLyrParams = new TopologyLayerCreationParams(topology);
  topologyLyrParams.Name = "NewTopologyLayerFromAnotherTopologyLayer";
  topologyLyrParams.AddAssociatedLayers = true;
  LayerFactory.Instance.CreateLayer<TopologyLayer>(topologyLyrParams, MapView.Active.Map);
}

//Note: Call within QueuedTask.Run()
var createParams = new CatalogLayerCreationParams(new Uri(@"C:\CatalogLayer\CatalogDS.gdb\HurricaneCatalogDS"));
//Set the definition query
createParams.DefinitionQuery = new DefinitionQuery("Query1", "cd_itemname = 'PuertoRico'");
//Set name of the new Catalog Layer
createParams.Name = "PuertoRico";
//Create Layer
var catalogLayer = LayerFactory.Instance.CreateLayer<CatalogLayer>(createParams, MapView.Active.Map);

//Note: Call within QueuedTask.Run()
//Get the CatalogDataset of another Catalog layer
var existingCatalogLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<CatalogLayer>().FirstOrDefault();
if (existingCatalogLayer != null)
{
  var catalogDataset = existingCatalogLayer.GetCatalogDataset();
  //Configure the settings for a new Catalog layer using the CatalogDataset of an existing layer
  var catalogLyrParams = new CatalogLayerCreationParams(catalogDataset);
  catalogLyrParams.Name = "NewCatalogLayerFromAnotherCatalogLayer";
  catalogLyrParams.DefinitionQuery = new DefinitionQuery("Query1", "cd_itemname = 'Asia'");
  LayerFactory.Instance.CreateLayer<CatalogLayer>(catalogLyrParams, MapView.Active.Map);
}

//Gets the collection of layer template packages installed with Pro for use with maps
var items = MapView.Active.Map.LayerTemplatePackages;
//Iterate through the collection of items to add each Map Note to the active map
foreach (var item in items)
{
  //Create a parameter item for the map note
  var layer_params = new LayerCreationParams(item);
  layer_params.IsVisible = false;
  await QueuedTask.Run(() =>
  {
    //Create a feature layer for the map note
    var layer = LayerFactory.Instance.CreateLayer<Layer>(layer_params, MapView.Active.Map);
  });
}

//Note: Call within QueuedTask.Run()
if (MapView.Active.Map == null) return;

//Get an existing Layer. This layer has a symbol you want to use in a new layer.
var lyr = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>()
      .Where(l => l.ShapeType == esriGeometryType.esriGeometryPoint).FirstOrDefault();
//This is the renderer to use in the new Layer
var renderer = lyr.GetRenderer() as CIMSimpleRenderer;
//Set the DataConnection for the new layer
Geodatabase geodatabase = new Geodatabase(
  new FileGeodatabaseConnectionPath(new Uri(@"E:\Data\Admin\AdminData.gdb")));
FeatureClass featureClass = geodatabase.OpenDataset<FeatureClass>("Cities");
var dataConnection = featureClass.GetDataConnection();
//Create the definition for the new feature layer
var featureLayerParams = new FeatureLayerCreationParams(dataConnection)
{
  RendererDefinition = new SimpleRendererDefinition(renderer.Symbol),
  IsVisible = true,
};
//create the new layer
LayerFactory.Instance.CreateLayer<FeatureLayer>(
  featureLayerParams, MapView.Active.Map);

var subtypeGroupLayerCreateParam = new SubtypeGroupLayerCreationParams
(
    new Uri(@"c:\data\SubtypeAndDomain.gdb\Fittings")
);

// Define Subtype layers
//At 2.x - var rendererDefn1 = new UniqueValueRendererDefinition(new string[] { "type" });
var rendererDefn1 = new UniqueValueRendererDefinition(new List<string> { "type" });
var renderDefn2 = new SimpleRendererDefinition()
{
  SymbolTemplate = SymbolFactory.Instance.ConstructPointSymbol(
          CIMColor.CreateRGBColor(255, 0, 0), 8, SimpleMarkerStyle.Hexagon).MakeSymbolReference()
};
subtypeGroupLayerCreateParam.SubtypeLayers = new List<SubtypeFeatureLayerCreationParams>()
{
  //define first subtype layer with unique value renderer
  //At 2.x - new SubtypeFeatureLayerCreationParams(new UniqueValueRendererDefinition(new string[] { "type" }), 1),
  new SubtypeFeatureLayerCreationParams(new UniqueValueRendererDefinition(new List<string> { "type" }), 1),

  //define second subtype layer with simple symbol renderer
  new SubtypeFeatureLayerCreationParams(renderDefn2, 2)
};

// Define additional parameters
//At - 2.x subtypeGroupLayerCreateParam.DefinitionFilter = new CIMDefinitionFilter()
//{
//  Name = "IsActive",
//  DefinitionExpression = "Enabled = 1"
//};
subtypeGroupLayerCreateParam.DefinitionQuery = new DefinitionQuery(whereClause: "Enabled = 1", name: "IsActive");
subtypeGroupLayerCreateParam.IsVisible = true;
subtypeGroupLayerCreateParam.MinimumScale = 50000;

SubtypeGroupLayer subtypeGroupLayer2 = LayerFactory.Instance.CreateLayer<SubtypeGroupLayer>(
              subtypeGroupLayerCreateParam, MapView.Active.Map);

var lyrDocFromLyrxFile = new LayerDocument(@"d:\data\cities.lyrx");
var cimLyrDoc = lyrDocFromLyrxFile.GetCIMLayerDocument();

//modifying its renderer symbol to red
var r = ((CIMFeatureLayer)cimLyrDoc.LayerDefinitions[0]).Renderer as CIMSimpleRenderer;
r.Symbol.Symbol.SetColor(new CIMRGBColor() { R = 255 });

//optionally save the updates out as a file
lyrDocFromLyrxFile.Save(@"c:\data\cities_red.lyrx");

//get a json representation of the layer document and you want store away...
var aJSONString = lyrDocFromLyrxFile.AsJson();

//... and load it back when needed
lyrDocFromLyrxFile.Load(aJSONString);
cimLyrDoc = lyrDocFromLyrxFile.GetCIMLayerDocument();

//create a layer and add it to a map
var lcp = new LayerCreationParams(cimLyrDoc);
var lyr = LayerFactory.Instance.CreateLayer<FeatureLayer>(lcp, map);

//Note: Run within QueuedTask.Run
//Get the Layer Document from the lyrx file
var lyrDocFromLyrxFile = new LayerDocument(layerFile);
var cimLyrDoc = lyrDocFromLyrxFile.GetCIMLayerDocument();

//Get the renderer from the layer file
var rendererFromLayerFile = ((CIMFeatureLayer)cimLyrDoc.LayerDefinitions[0]).Renderer as CIMUniqueValueRenderer;

//Apply the renderer to the feature layer
//Note: If working with a raster layer, use the SetColorizer method.
featureLayer?.SetRenderer(rendererFromLayerFile);

// Create a connection to the WMS server
var serverConnection = new CIMInternetServerConnection { URL = "URL of the WMS service" };
var connection = new CIMWMSServiceConnection { ServerConnection = serverConnection };

// Add a new layer to the map
var layerParams = new LayerCreationParams(connection);
await QueuedTask.Run(() =>
{
  var layer = LayerFactory.Instance.CreateLayer<FeatureLayer>(layerParams, MapView.Active.Map);
});

CIMStandardDataConnection cIMStandardDataConnection = new CIMStandardDataConnection()
{
  WorkspaceConnectionString = @"SWAPXY=TRUE;SWAPXYFILTER=FALSE;URL=http://sampleserver6.arcgisonline.com/arcgis/services/SampleWorldCities/MapServer/WFSServer;VERSION=2.0.0",
  WorkspaceFactory = WorkspaceFactory.WFS,
  Dataset = "Continent",
  DatasetType = esriDatasetType.esriDTFeatureClass
};

// Add a new layer to the map
var layerPamsDC = new LayerCreationParams(cIMStandardDataConnection);
await QueuedTask.Run(() =>
{
  Layer layer = LayerFactory.Instance.CreateLayer<FeatureLayer>(layerPamsDC, MapView.Active.Map);
});

var serverConnection = new CIMInternetServerConnection { URL = "https://spritle.esri.com/arcgis/services/sanfrancisco_sld/MapServer/WMSServer" };
var connection = new CIMWMSServiceConnection { ServerConnection = serverConnection };
LayerCreationParams parameters = new LayerCreationParams(connection);
parameters.MapMemberPosition = MapMemberPosition.AddToBottom;
await QueuedTask.Run(() =>
{
  var compositeLyr = LayerFactory.Instance.CreateLayer<WMSLayer>(parameters, MapView.Active.Map);
  //wms layer in ArcGIS Pro always has a composite layer inside it
  var wmsLayers = compositeLyr.Layers[0] as ServiceCompositeSubLayer;
  //each wms sublayer belongs in that composite layer
  var highwayLayerWMSSub = wmsLayers.Layers[1] as WMSSubLayer;
  //toggling a sublayer's visibility
  if ((highwayLayerWMSSub != null))
  {
    bool visibility = highwayLayerWMSSub.IsVisible;
    highwayLayerWMSSub.SetVisibility(!visibility);
  }
  //applying an existing style to a wms sub layer
  var pizzaLayerWMSSub = wmsLayers.Layers[0] as WMSSubLayer;
  var currentStyles = pizzaLayerWMSSub.GetStyleNames();
  pizzaLayerWMSSub.SetStyleName(currentStyles[1]);
});

await QueuedTask.Run(() =>
{
  Map map = MapView.Active.Map;
  Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri(@"C:\Connections\mySDE.sde")));
  CIMSqlQueryDataConnection sqldc = new CIMSqlQueryDataConnection()
  {
    WorkspaceConnectionString = geodatabase.GetConnectionString(),
    GeometryType = esriGeometryType.esriGeometryPolygon,
    OIDFields = "OBJECTID",
    Srid = "102008",
    SqlQuery = "select * from MySDE.dbo.STATES",
    Dataset = "States"
  };
  var lcp = new LayerCreationParams(sqldc)
  {
    Name = "States"
  };
  FeatureLayer flyr = LayerFactory.Instance.CreateLayer<FeatureLayer>(lcp, map);
});

await QueuedTask.Run(() =>
{
  var featureLayerCreationParams = new FeatureLayerCreationParams(new Uri(@"c:\data\countydata.gdb\counties"))
  {
    Name = "Population Density (sq mi) Year 2010",
    RendererDefinition = new GraduatedColorsRendererDefinition("POP10_SQMI")
  };
  LayerFactory.Instance.CreateLayer<FeatureLayer>(
    featureLayerCreationParams,
    MapView.Active.Map
  );
});

string colorBrewerSchemesName = "ColorBrewer Schemes (RGB)";
StyleProjectItem style = Project.Current.GetItems<StyleProjectItem>().First(s => s.Name == colorBrewerSchemesName);
string colorRampName = "Greens (Continuous)";
IList<ColorRampStyleItem> colorRampList = await QueuedTask.Run(() =>
{
  return style.SearchColorRamps(colorRampName);
});
ColorRampStyleItem colorRamp = colorRampList[0];

await QueuedTask.Run(() =>
{
  GraduatedColorsRendererDefinition gcDef = new GraduatedColorsRendererDefinition()
  {
    ClassificationField = "CROP_ACR07",
    ClassificationMethod = ArcGIS.Core.CIM.ClassificationMethod.NaturalBreaks,
    BreakCount = 6,
    ColorRamp = colorRamp.ColorRamp,
    SymbolTemplate = SymbolFactory.Instance.ConstructPolygonSymbol(
                            ColorFactory.Instance.GreenRGB, SimpleFillStyle.Solid, null).MakeSymbolReference(),
    ExclusionClause = "CROP_ACR07 = -99",
    ExclusionSymbol = SymbolFactory.Instance.ConstructPolygonSymbol(
                            ColorFactory.Instance.RedRGB, SimpleFillStyle.Solid, null).MakeSymbolReference(),
    ExclusionLabel = "No yield",
  };
  var featureLayerCreationParams = new FeatureLayerCreationParams((new Uri(@"c:\Data\CountyData.gdb\Counties")))
  {
    Name = "Crop",
    RendererDefinition = gcDef
  };
  LayerFactory.Instance.CreateLayer<FeatureLayer>(featureLayerCreationParams, MapView.Active.Map);
});

aMap.SetBasemapLayers(Basemap.Gray);

aMap.SetBasemapLayers(Basemap.None);

List<FeatureLayer> featureLayerList = aMap.GetLayersAsFlattenedList().OfType<FeatureLayer>().ToList();

//Get an existing Layer. This layer has a symbol you want to use in a new layer.
var lyr = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>()
      .Where(l => l.ShapeType == esriGeometryType.esriGeometryPoint).FirstOrDefault();

//Finds layers by name and returns a read only list of Layers
IReadOnlyList<Layer> layers = aMap.FindLayers("cities", true);

//Finds a layer using a URI.
//The Layer URI you pass in helps you search for a specific layer in a map
var lyrFindLayer = MapView.Active.Map.FindLayer("CIMPATH=map/u_s__states__generalized_.xml");

//This returns a collection of layers of the "name" specified. You can use any Linq expression to query the collection.  
var lyrExists = MapView.Active.Map.GetLayersAsFlattenedList()
                   .OfType<FeatureLayer>().Any(f => f.Name == "U.S. States (Generalized)");