ProSnippets MapAuthoring

Language:              C#  
Subject:               MapAuthoring  
Contributor:           ArcGIS Pro SDK Team <[email protected]>  
Organization:          Esri, http://www.esri.com  
Date:                  1/5/2017  
ArcGIS Pro:            1.4  
Visual Studio:         2013, 2015  
.NET Target Framework: 4.6.1  

How to get a style in project by name

//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");

How to create a new style

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

How to add a style to project

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

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

How to remove a style from project

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

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

How to add a style item to a style

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

How to remove a style item from a style

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

How to determine if a style can be upgraded

//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 Project.Current.AddStyleAsync(stylePath);
  StyleProjectItem style = Project.Current.GetItems<StyleProjectItem>().First(x => x.Path == stylePath);

  //returns true if style can be upgraded
  return style.CanBeUpgraded();
}

How to determine if a style is read-only

//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 Project.Current.AddStyleAsync(stylePath);
  StyleProjectItem style = Project.Current.GetItems<StyleProjectItem>().First(x => x.Path == stylePath);

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

How to determine if a style is current

//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 Project.Current.AddStyleAsync(stylePath);
  StyleProjectItem style = Project.Current.GetItems<StyleProjectItem>().First(x => x.Path == stylePath);

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

How to upgrade a style

//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 Project.Current.AddStyleAsync(stylePath);
  StyleProjectItem style = Project.Current.GetItems<StyleProjectItem>().First(x => x.Path == stylePath);

  //Verify that style can be upgraded
  if (style.CanBeUpgraded())
  {
    success = await StyleHelper.UpgradeStyleAsync(style);
  }
  //return true if style was upgraded
  return success;
}

How to construct a point symbol of a specific color and size

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

How to construct a point symbol of a specific color, size and shape

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

How to construct a point symbol from a marker

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

How to construct a point symbol from a file on disk

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

CIMPointSymbol pointSymbolFromFile = SymbolFactory.ConstructPointSymbol(markerFromFile);

How to construct a polygon symbol of specific color and fill style

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

How to construct a polygon symbol of specific color, fill style and outline

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

How to construct a polygon symbol without an outline

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

How to construct a line symbol of specific color, size and line style

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

How to construct a line symbol from a stroke

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

How to construct a multilayer line symbol with circle markers on the line ends

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

How to construct a multilayer line symbol with an arrow head on the end

//These methods must be called within the lambda passed to QueuedTask.Run
var markerTriangle = SymbolFactory.ConstructMarker(ColorFactory.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.ConstructStroke(ColorFactory.RedRGB, 2)
          }
};

How to get symbol reference from a symbol

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

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

How to search for a specific item in a style

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

How to search for point symbols in a style

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

  //Search for point symbols
  return style.SearchSymbolsAsync(StyleItemType.PointSymbol, searchString);
}

How to search for line symbols in a style

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

  //Search for line symbols
  return style.SearchSymbolsAsync(StyleItemType.LineSymbol, searchString);
}

How to search for polygon symbols in a style

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

  //Search for polygon symbols
  return style.SearchSymbolsAsync(StyleItemType.PolygonSymbol, searchString);
}

How to search for colors in a style

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

  //Search for colors
  return style.SearchColorsAsync(searchString);
}

How to search for color ramps in a style

public 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 style.SearchColorRampsAsync(searchString);
}

How to search for north arrows in a style

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

  //Search for north arrows
  return style.SearchNorthArrowsAsync(searchString);
}

How to search for scale bars in a style

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

  //Search for scale bars
  return style.SearchScaleBarsAsync(searchString);
}

How to search for label placements in a style

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

  //Search for standard label placement
  return style.SearchLabelPlacementsAsync(StyleItemType.StandardLabelPlacement, searchString);
}

How to set symbol for a feature layer symbolized with simple renderer

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

How to apply a symbol from style to a feature layer

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

How to apply a point symbol from a style to a feature layer

// 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 arcGIS2DStyle.SearchSymbolsAsync(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);
        });            
    }

How to apply a color ramp from a style to a feature layer

Requires C# 6.0 to compile.

public async Task ApplyColorRampAsync(FeatureLayer featureLayer, string[] fields)
{

    StyleProjectItem style =
      Project.Current.GetItems<StyleProjectItem>().FirstOrDefault(s => s.Name == "ColorBrewer Schemes (RGB)");
    if (style == null) return;
    var colorRampList = await style.SearchColorRampsAsync("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);
    });

}

Get the active map

Map map = MapView.Active.Map;

Create a new map with a default basemap layer

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

    });

Find a map within a project and open it

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

}

Open a webmap

Map map = null;

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

Get Map Panes

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

Get The Unique List of Maps From the Map Panes

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;
}

Find a layers using partial name search

Map map = MapView.Active.Map;
IEnumerable<Layer> matches = map.GetLayersAsFlattenedList().Where(l => l.Name.IndexOf(partialName, StringComparison.CurrentCultureIgnoreCase) >= 0);

Create and add a layer to the active map

/*
* 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 = @"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.CreateLayer(uri, MapView.Active.Map));

Create a feature layer with class breaks renderer with defaults

await QueuedTask.Run(() =>
  LayerFactory.CreateFeatureLayer(
    new Uri(@"c:\data\countydata.gdb\counties"),
    MapView.Active.Map,
    layerName: "Population Density (sq mi) Year 2010",
    rendererDefinition: new GraduatedColorsRendererDefinition("POP10_SQMI")
  )
);

Create a feature layer with class breaks renderer

string colorBrewerSchemesName = "ColorBrewer Schemes (RGB)";
StyleProjectItem style = Project.Current.GetItems<StyleProjectItem>().First(s => s.Name == colorBrewerSchemesName);
string colorRampName = "Greens (Continuous)";
IList<ColorRampStyleItem> colorRampList = await style.SearchColorRampsAsync(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.ConstructPolygonSymbol(
                      ColorFactory.Green, SimpleFillStyle.Solid, null).MakeSymbolReference(),
    ExclusionClause = "CROP_ACR07 = -99",
    ExclusionSymbol = SymbolFactory.ConstructPolygonSymbol(
                      ColorFactory.Red, SimpleFillStyle.Solid, null).MakeSymbolReference(),
    ExclusionLabel = "No yield",
  };

  LayerFactory.CreateFeatureLayer(new Uri(@"c:\Data\CountyData.gdb\Counties"),
      MapView.Active.Map, layerName: "Crop", rendererDefinition: gcDef);
});

Set unique value renderer to the selected feature layer of the active map

await QueuedTask.Run(() =>
{
  String[] fields = new string[] { "Type" }; //field to be used to retrieve unique values
  CIMPointSymbol pointSym = SymbolFactory.ConstructPointSymbol(
            ColorFactory.Green, 16.0, SimpleMarkerStyle.Pushpin);  //construting a point symbol as a template symbol
  CIMSymbolReference symbolPointTemplate = pointSym.MakeSymbolReference();

  //constructing rederer definition for unique value renderer
  UniqueValueRendererDefinition uniqueValueRendererDef = new UniqueValueRendererDefinition(fields, symbolPointTemplate);

  //creating a unique value renderer
  var flyr = MapView.Active.GetSelectedLayers()[0] as FeatureLayer;
  CIMUniqueValueRenderer uniqueValueRenderer = (CIMUniqueValueRenderer)flyr.CreateRenderer(uniqueValueRendererDef);

  //setting the renderer to the feature layer
  flyr.SetRenderer(uniqueValueRenderer);
});

Create a query layer

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"
  };
  FeatureLayer flyr = (FeatureLayer)LayerFactory.CreateLayer(sqldc, map, layerName: "States");
});

Change Geodatabase Version of layers off a specified version in a map using version name

await QueuedTask.Run(() =>
    {
//Getting the current version name from the first feature layer of the map
FeatureLayer flyr = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault();  //first feature layer
Datastore dataStore = flyr.GetFeatureClass().GetDatastore();  //getting datasource
Geodatabase geodatabase = dataStore as Geodatabase; //casting to Geodatabase
if (geodatabase == null)
  return;

VersionManager versionManager = geodatabase.GetVersionManager();
String currentVersionName = versionManager.GetCurrentVersion().GetName();

//Getting all available versions except the current one
IEnumerable<ArcGIS.Core.Data.Version> versions = versionManager.GetVersions().Where(v => !v.GetName().Equals(currentVersionName, StringComparison.CurrentCultureIgnoreCase));

//Assuming there is at least one other version we pick the first one from the list
ArcGIS.Core.Data.Version toVersion = versions.FirstOrDefault();
if (toVersion != null)
{
  //Changing version
  MapView.Active.Map.ChangeVersion(currentVersionName, toVersion.GetName());
}
    });

Change Geodatabase Version of layers off a specified version in a map

await QueuedTask.Run(() =>
    {
//Getting the current version name from the first feature layer of the map
FeatureLayer flyr = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault();  //first feature layer
Datastore dataStore = flyr.GetFeatureClass().GetDatastore();  //getting datasource
Geodatabase geodatabase = dataStore as Geodatabase; //casting to Geodatabase
if (geodatabase == null)
  return;

VersionManager versionManager = geodatabase.GetVersionManager();
ArcGIS.Core.Data.Version currentVersion = versionManager.GetCurrentVersion();

//Getting all available versions except the current one
IEnumerable<ArcGIS.Core.Data.Version> versions = versionManager.GetVersions().Where(v => !v.GetName().Equals(currentVersion.GetName(), StringComparison.CurrentCultureIgnoreCase));

//Assuming there is at least one other version we pick the first one from the list
ArcGIS.Core.Data.Version toVersion = versions.FirstOrDefault();
if (toVersion != null)
{
  //Changing version
  MapView.Active.Map.ChangeVersion(currentVersion, toVersion);
}
    });

Querying a feature layer

var count = await QueuedTask.Run(() =>
{
  QueryFilter qf = new QueryFilter()
  {
    WhereClause = "Class = 'city'"
  };

  //Getting the first selected feature layer of the map view
  var flyr = (FeatureLayer)MapView.Active.GetSelectedLayers().OfType<FeatureLayer>().FirstOrDefault();
  RowCursor rows = flyr.Search(qf);//execute

  //Looping through to count
  int i = 0;
  while (rows.MoveNext()) i++;

  return i;
});
MessageBox.Show(String.Format("Total features that matched the search criteria: {0}", count));

Create a raster layer

string url = @"C:\Images\Italy.tif";
RasterLayer rasterLayer = (RasterLayer)LayerFactory.CreateLayer(new Uri(url), aMap);

Update the raster colorizer on a raster layer

// Get the colorizer from the raster layer
CIMRasterColorizer rasterColorizer = rasterLayer.GetColorizer();
// Update raster colorizer properties
rasterColorizer.Brightness = 10;
rasterColorizer.Contrast = -5;
rasterColorizer.ResamplingType = RasterResamplingType.NearestNeighbor;
// Update the raster layer with the changed colorizer
rasterLayer.SetColorizer(rasterColorizer);

Update the RGB colorizer on a raster layer

// Get the colorizer from the raster layer
CIMRasterColorizer rColorizer = rasterLayer.GetColorizer();
// Check if the colorizer is an RGB colorizer
if (rColorizer is CIMRasterRGBColorizer)
{
    CIMRasterRGBColorizer rasterRGBColorizer = (CIMRasterRGBColorizer)rColorizer;
    // Update RGB colorizer properties
    rasterRGBColorizer.StretchType = RasterStretchType.ESRI;
    // Update the raster layer with the changed colorizer
    rasterLayer.SetColorizer((CIMRasterColorizer)rasterRGBColorizer);
}

Create a mosaic layer

string url = @"C:\Images\countries.gdb\Italy";
MosaicLayer mosaicLayer = (MosaicLayer)LayerFactory.CreateLayer(new Uri(url), aMap);

Update the sort order (mosaic method) on a mosaic layer

// Get the Image sub-layer of the mosaic
ImageServiceLayer mosaicImageSubLayer = (ImageServiceLayer)mosaicLayer.GetImageLayer();
// Get the mosaic rule
CIMMosaicRule mosaicingRule = mosaicImageSubLayer.GetMosaicRule();
// Set the Mosaic Method to Center
mosaicingRule.MosaicMethod = RasterMosaicMethod.Center;
// Update the mosaic with the changed mosaic rule
mosaicImageSubLayer.SetMosaicRule(mosaicingRule);

Update the resolve overlap (mosaic operator) on a mosaic layer

// Get the Image sub-layer of the mosaic
ImageServiceLayer mosaicImageSublayer = (ImageServiceLayer)mosaicLayer.GetImageLayer();
// Get the mosaic rule
CIMMosaicRule mosaicRule = mosaicImageSublayer.GetMosaicRule();
// Set the Mosaic Operator to Mean
mosaicRule.MosaicOperatorType = RasterMosaicOperatorType.Mean;
// Update the mosaic with the changed mosaic rule
mosaicImageSublayer.SetMosaicRule(mosaicRule);

Create an image service layer

string url = @"http://imagery.arcgisonline.com/arcgis/services/LandsatGLS/GLS2010_Enhanced/ImageServer";
ImageServiceLayer isLayer = (ImageServiceLayer)LayerFactory.CreateLayer(new Uri(url), aMap);

Update the raster colorizer on an image service layer

// Get the colorizer from the image service layer
CIMRasterColorizer rasterColorizer = isLayer.GetColorizer();
// Update the colorizer properties
rasterColorizer.Brightness = 10;
rasterColorizer.Contrast = -5;
rasterColorizer.ResamplingType = RasterResamplingType.NearestNeighbor;
// Update the image service layer with the changed colorizer
isLayer.SetColorizer(rasterColorizer);

Update the RGB colorizer on an image service layer

// Get the colorizer from the image service layer
CIMRasterColorizer rColorizer = isLayer.GetColorizer();
// Check if the colorizer is an RGB colorizer
if (rColorizer is CIMRasterRGBColorizer)
{
    CIMRasterRGBColorizer rasterRGBColorizer = (CIMRasterRGBColorizer)isLayer.GetColorizer();
    // Update RGB colorizer properties
    rasterRGBColorizer.StretchType = RasterStretchType.ESRI;
    // Update the image service layer with the changed colorizer
    isLayer.SetColorizer((CIMRasterColorizer)rasterRGBColorizer);
}

Update the sort order (mosaic method) on an image service layer

// Get the mosaic rule of the image service
CIMMosaicRule mosaicRule = isLayer.GetMosaicRule();
// Set the Mosaic Method to Center
mosaicRule.MosaicMethod = RasterMosaicMethod.Center;
// Update the image service with the changed mosaic rule
isLayer.SetMosaicRule(mosaicRule);

Update the resolve overlap (mosaic operator) on an image service layer

// Get the mosaic rule of the image service
CIMMosaicRule mosaicingRule = isLayer.GetMosaicRule();
// Set the Mosaic Operator to Mean
mosaicingRule.MosaicOperatorType = RasterMosaicOperatorType.Mean;
// Update the image service with the changed mosaic rule
isLayer.SetMosaicRule(mosaicingRule);

Create a Heatmap Renderer

string colorBrewerSchemesName = "ArcGIS Colors";
StyleProjectItem style = Project.Current.GetItems<StyleProjectItem>().First(s => s.Name == colorBrewerSchemesName);
string colorRampName = "Heat Map 4 - Semitransparent";
IList<ColorRampStyleItem> colorRampList = await style.SearchColorRampsAsync(colorRampName);
ColorRampStyleItem colorRamp = colorRampList[0];

await QueuedTask.Run(() =>
{
  //defining a heatmap renderer that uses values from Population field as the weights
  HeatMapRendererDefinition heatMapDef = new HeatMapRendererDefinition()
  {
    Radius = 20,
    WeightField = "Population",
    ColorRamp = colorRamp.ColorRamp,
    RendereringQuality = 8,
    UpperLabel = "High Density",
    LowerLabel = "Low Density"
  };

  FeatureLayer flyr = MapView.Active.Map.Layers[0] as FeatureLayer;
  CIMHeatMapRenderer heatMapRndr = (CIMHeatMapRenderer)flyr.CreateRenderer(heatMapDef);
  flyr.SetRenderer(heatMapRndr);
});

Create an Unclassed Renderer

string colorBrewerSchemesName = "ArcGIS Colors";
StyleProjectItem style = Project.Current.GetItems<StyleProjectItem>().First(s => s.Name == colorBrewerSchemesName);
string colorRampName = "Heat Map 4 - Semitransparent";
IList<ColorRampStyleItem> colorRampList = await style.SearchColorRampsAsync(colorRampName);
ColorRampStyleItem colorRamp = colorRampList[0];

await QueuedTask.Run(() =>
{
  CIMPointSymbol pointSym = SymbolFactory.ConstructPointSymbol(ColorFactory.GreenRGB, 16.0, SimpleMarkerStyle.Diamond);
  CIMSymbolReference symbolPointTemplate = pointSym.MakeSymbolReference();

  //defining an unclassed renderer with custom upper and lower stops
  //all features with value >= 5,000,000 will be drawn with the upper color from the color ramp
  //all features with value <= 50,000 will be drawn with the lower color from the color ramp
  UnclassedColorsRendererDefinition unclassRndrDef = new UnclassedColorsRendererDefinition
                        ("Population", symbolPointTemplate, colorRamp.ColorRamp, "Highest", "Lowest", 5000000, 50000);

  //drawing features with null values with a different symbol
  unclassRndrDef.ShowNullValues = true;
  unclassRndrDef.NullValueLabel = "Unknown";
  CIMPointSymbol nullSym = SymbolFactory.ConstructPointSymbol(ColorFactory.RedRGB, 16.0, SimpleMarkerStyle.Circle);
  unclassRndrDef.NullValueSymbol = nullSym.MakeSymbolReference();
  FeatureLayer flyr = MapView.Active.Map.Layers[0] as FeatureLayer;
  CIMClassBreaksRenderer cbRndr = (CIMClassBreaksRenderer)flyr.CreateRenderer(unclassRndrDef);
  flyr.SetRenderer(cbRndr);
});

Create a Proportion Renderer with max and min symbol size capped

string colorBrewerSchemesName = "ArcGIS Colors";
StyleProjectItem style = Project.Current.GetItems<StyleProjectItem>().First(s => s.Name == colorBrewerSchemesName);
string colorRampName = "Heat Map 4 - Semitransparent";
IList<ColorRampStyleItem> colorRampList = await style.SearchColorRampsAsync(colorRampName);
ColorRampStyleItem colorRamp = colorRampList[0];

await QueuedTask.Run(() =>
{
  CIMPointSymbol pointSym = SymbolFactory.ConstructPointSymbol(ColorFactory.GreenRGB, 1.0, SimpleMarkerStyle.Circle);
  CIMSymbolReference symbolPointTemplate = pointSym.MakeSymbolReference();

  //minimum symbol size is capped to 4 point while the maximum symbol size is set to 50 point
  ProportionalRendererDefinition prDef = new ProportionalRendererDefinition("POPULATION", symbolPointTemplate, 4, 50, true);
  
  //setting upper and lower size stops to stop symbols growing or shrinking beyond those thresholds
  prDef.UpperSizeStop = 5000000;  //features with values >= 5,000,000 will be drawn with maximum symbol size
  prDef.LowerSizeStop = 50000;    //features with values <= 50,000 will be drawn with minimum symbol size

  FeatureLayer flyr = MapView.Active.Map.Layers[0] as FeatureLayer;
  CIMProportionalRenderer propRndr = (CIMProportionalRenderer)flyr.CreateRenderer(prDef);
  flyr.SetRenderer(propRndr);

});

Create a True Proportion Renderer

string colorBrewerSchemesName = "ArcGIS Colors";
StyleProjectItem style = Project.Current.GetItems<StyleProjectItem>().First(s => s.Name == colorBrewerSchemesName);
string colorRampName = "Heat Map 4 - Semitransparent";
IList<ColorRampStyleItem> colorRampList = await style.SearchColorRampsAsync(colorRampName);
ColorRampStyleItem colorRamp = colorRampList[0];

await QueuedTask.Run(() =>
{
  CIMPointSymbol pointSym = SymbolFactory.ConstructPointSymbol(ColorFactory.GreenRGB, 1.0, SimpleMarkerStyle.Circle);
  CIMSymbolReference symbolPointTemplate = pointSym.MakeSymbolReference();

  //Defining proportional renderer where size of symbol will be same as its value in field used in the renderer.
  ProportionalRendererDefinition prDef = new ProportionalRendererDefinition("POPULATION", esriUnits.esriMeters, symbolPointTemplate, SymbolShapes.Square, ValueRepresentations.Radius);

  FeatureLayer flyr = MapView.Active.Map.Layers[0] as FeatureLayer;
  CIMProportionalRenderer propRndr = (CIMProportionalRenderer)flyr.CreateRenderer(prDef);
  flyr.SetRenderer(propRndr);

});

Update a map's basemap layer

aMap.SetBasemapLayers(Basemap.Gray);

Remove basemap layer from a map

aMap.SetBasemapLayers(Basemap.None);

Find a layer

IReadOnlyList<Layer> layers = aMap.FindLayers("cities", true);

Get a list of layers filtered by layer type from a map

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

Find a standalone table

IReadOnlyList<StandaloneTable> tables = aMap.FindStandaloneTables("addresses");

Enable labeling on a layer

var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault();
ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() => {
    // toggle the label visibility
    featureLayer.SetLabelVisibility(!featureLayer.IsLabelVisible);
});

Access the display field for a layer

var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault(); 
ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() => {
    // get the CIM definition from the layer
    var cimFeatureDefinition = featureLayer.GetDefinition() as ArcGIS.Core.CIM.CIMBasicFeatureLayer;
    // get the view of the source table underlying the layer
    var cimDisplayTable = cimFeatureDefinition.FeatureTable;
    // this field is used as the 'label' to represent the row
    var displayField = cimDisplayTable.DisplayField;
});

Find connected attribute field for rotation

var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault();
ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() => {
    // get the CIM renderer from the layer
    var cimRenderer = featureLayer.GetRenderer() as ArcGIS.Core.CIM.CIMSimpleRenderer;
    // get the collection of connected attributes for rotation
    var cimRotationVariable = cimRenderer.VisualVariables.OfType<ArcGIS.Core.CIM.CIMRotationVisualVariable>().FirstOrDefault();
    // the z direction is describing the heading rotation
    var rotationInfoZ = cimRotationVariable.VisualVariableInfoZ;
    var rotationExpression = rotationInfoZ.Expression; // this expression stores the field name  
});

Toggle "Scale layer symbols when reference scale is set"

var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault(); 
ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() => {
    // get the CIM layer definition
    var cimFeatureLayer = featureLayer.GetDefinition() as ArcGIS.Core.CIM.CIMFeatureLayer;
    // turn on the option to scale the symbols in this layer based in the map's reference scale
    cimFeatureLayer.ScaleSymbols = true;
});

Set the layer cache

var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault();
ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() => {
    // change the layer cache type to maximum age
    featureLayer.SetDisplayCacheType(ArcGIS.Core.CIM.DisplayCacheType.MaxAge);
    // change from the default 5 min to 2 min
    featureLayer.SetDisplayCacheMaxAge(TimeSpan.FromMinutes(2));
});

Change the layer selection color

var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault(); 
ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() => {
    // get the CIM definition of the layer
    var layerDef = featureLayer.GetDefinition() as ArcGIS.Core.CIM.CIMBasicFeatureLayer;
    // disable the default symbol
    layerDef.UseSelectionSymbol = false;
    // assign a new color
    layerDef.SelectionColor = ColorFactory.RedRGB;
    // apply the definition to the layer
    featureLayer.SetDefinition(layerDef);

    if (!featureLayer.IsVisible) featureLayer.SetVisibility(true);
    //Do a selection

    MapView.Active.SelectFeatures(MapView.Active.Extent);
});