ProConcepts 3.0 Migration Guide - EsriJapan/arcgis-pro-sdk GitHub Wiki

//At 2.x
 public override int GetNativeRowCount() {  
      //your implementation here...
      ...
 }

//3.x - note the return type
public override long GetNativeRowCount() {  
      //your implementation here...
      ...
 }

 //At 2.x - persistence using xml - cimObject.ToXml()
 simpleRenderer.ToXml()
 //and the derived static CIMObject.FromXml() method
 //eg for CIMSimpleRenderer
 var simpleRenderer = CIMSimpleRenderer.FromXml(xml_string);

 //At 3.x
 //addins should use cimObject.ToJson()
 simpleRenderer.ToJson();
 //and the derived static CIMObject.FromJson() method
 //eg for CIMSimpleRenderer
 var simpleRenderer = CIMSimpleRenderer.FromJson(json_string);

//use to convert CIM xml previously persisted at 2.x -consult the 
//CIM Persistence section for more details
 var simpleRenderer = (CIMSimpleRenderer)ArcGIS.Core.CIM.XmlUtils.UpgradeAndDeserializeCIMObject(
                                                               simple_renderer_xml_from_2x);

 //At 2.x - 
 ReconcileDescription reconcileDescription = new ReconcileDescription(parentVersion);
 reconcileDescription.ConflictResolutionMethod = ConflictResolutionMethod.Continue; //continue if 
 reconcileDescription.WithPost = true;                                              //conflicts are found

 // Reconcile and post
 ReconcileResult reconcileResult = currentVersion.Reconcile(reconcileDescription);
 ReconcileResult.HasConflicts can be checked as-needed


 //At 3.x use ReconcileOptions
 var reconcileOptions = new ReconcileOptions(parentVersion);
 reconcileOptions.ConflictResolutionMethod = ConflictResolutionMethod.Continue; //continue if 
                                                                                //conflicts are found
 reconcileOptions.ConflictDetectionType = ConflictDetectionType.ByRow; //Default
 reconcileOptions.ConflictResolutionType = ConflictResolutionType.FavorTargetVersion;//or FavorEditVersion

 // Reconcile and post as two separate actions
 ReconcileResult reconcileResult = currentVersion.Reconcile(reconcileOptions);
 if (!reconcileResult.HasConflicts) {
   //No conflicts, perform the post
   var postOptions = new PostOptions(parentVersion);
   //var postOptions = new PostOptions(); for default version
   postOptions.ServiceSynchronizationType = ServiceSynchronizationType.Synchronous;//Default
   currentVersion.Post(postOptions);
 }

 //Reconcile and post as a single action (similar to 2.x)
 ReconcileResult reconcileResult = currentVersion.Reconcile(reconcileOptions, postOptions);
 if (reconcileResult.HasConflicts) {
   //TODO resolve conflicts
 }

 //At 2.x
 using ArcGIS.Core.Data;
 ...
 try {
   ...
 } catch(GeodatabaseException ge) {

 //At 3.x
 using ArcGIS.Core.Data;
 using ArcGIS.Core.Data.Exceptions

 try {
   ...
 } catch(GeodatabaseException ge) {//or use explicit reference 
                                   //ArcGIS.Core.Data.Exceptions.GeodatabaseException 

 //At 2.x
 var xml = geometry.ToXML();
 var xml = envelope.ToXML();
 var xml = mapPoint.ToXML();
 var xml = polygon.ToXML();
 var xml = polyline.ToXML();

//At 3.x
 var xml = geometry.ToXml();
 var xml = envelope.ToXml();
 var xml = mapPoint.ToXml();
 var xml = polygon.ToXml();
 var xml = polyline.ToXml();

 // At 2.x
 using ArcGIS.Core.Geometry;
 ...
 try {f
   ...
 } catch(GeometryException ge) {

 // At 3.x
 using ArcGIS.Core.Geometry;
 using ArcGIS.Core.Geometry.Exceptions

 try {
   ...
 } catch(GeometryException ge) {//or use explicit reference 
                                //ArcGIS.Core.Data.Exceptions.GeometryException 

enum esriArcOrientation --> enum ArcOrientation  also, `esri` value prefix has been removed
enum esriClothoidCreateMethod -->enum ClothoidCreateMethod
enum esriCurveDensifyMethod -->enum CurveDensifyMethod
enum esriPatchType -->enum PatchType
enum esriTextureCompressionType -->enum TextureCompressionType

enum EsriShapeExportFlags --> all value prefixes changed from `esri` to `Esri`
enum EsriShapeImportFlags --> all value prefixes changed from `esri` to `Esri`

enum GeometryDimension --> enum GeometryDimensionType
enum JSONExportFlags --> enum JsonExportFlags - all value prefixes changed from `json` to `Json`
enum JSONImportFlags --> enum JsonImportFlags - all value prefixes changed from `json` to `Json`
enum Monotonic --> enum MonotonicType
enum SegmentExtension --> enum SegmentExtensionType
enum WKBExportFlags --> enum WkbExportFlags  - all value prefixes changed from `WKB` to `Wkb`

//At        2.x          --->        3.0
class MapPointBuilder    --- > class MapPointBuilderEx
class MultipointBuilder  --- > class MultipointBuilderEx
 
class LineBuilder     --- > class LineBuilderEx
class EllipticArcBuilder    --- > class EllipticArcBuilderEx
class CubicBezierBuilder    --- > class CubicBezierBuilderEx
class PolylineBuilder    --- > class PolylineBuilderEx

class EnvelopeBuilder    --- > class EnvelopeBuilderEx
class PolygonBuilder    --- > class PolygonBuilderEx
class GeometryBagBuilder    --- > class GeometryBagBuilderEx

class MultipatchBuilder    --- > class MultipatchBuilderEx

//class SpatialReferenceBuilder is not replaced

  //2.x
  QueuedTask.Run(() => {
     //Builders at 2.x are IDisposable - can scope lifetime with a "using" block
     using (PolylineBuilder polylineBuilder = new PolylineBuilder(polyline)) { 
       polylineBuilder.ReverseOrientation();
       var reversedPolyline = polylineBuilder.ToGeometry();
     }
  });

   QueuedTask.Run(() => {
     //Run on the MCT
     var circularArc = EllipticArcBuilderEx.CreateEllipticArcSegment(segment1, segment2, maxRadius, hintPoint);
     //etc
   });

 //At 3.x - no using(...) - Builder "Ex" are not IDisposable
 var polylineBuilder = new PolylineBuilderEx(polyline);
 polylineBuilder.ReverseOrientation();
 var reversedPolyline = polylineBuilder.ToGeometry();

  // Most of the BuilderEx convenience methods do not need the MCT.
  var circularArc = EllipticArcBuilderEx.CreateCircularArc(
                          segment1, segment2, maxRadius, hintPoint);

  //However, this particular EllipticArcBuilderEx constructor _does_ need the MCT. Please refer 
  //to the API reference as needed. There are only a handful of such cases
  QueuedTask.Run(() => {
    var cab = new EllipticArcBuilderEx(segment1, segment2, maxRadius, hintPoint);
    var otherCircularArc = cab.ToSegment();
    //etc
  });

//      At 2.x                  At 3.x
ItemFilters.annotation => ItemFilters.Annotation
ItemFilters.cad=>         ItemFilters.Cad
ItemFilters.composite_addToMap => ItemFilters.Composite_AddToMap 
...

 using ArcGIS.Desktop.Editing.Templates;
 ...

 // retrieve the CIM edit template definition - CIMEditingTemplate
 var template = mapTool.CurrentTemplate;
 var templateDef = template.GetDefinition();

 //Property and extension method name changes
 //At 2.x 
 templateDef.ToolProgID = toolContentGUID;
 var toolIds = cimEditTemplate.GetExcludedToolDamlIds().ToList();
 cimEditTemplate.SetExcludedToolDamlIds(toolIds.ToArray());
 cimEditTemplate.AllowToolDamlID("esri_editing_SketchLineTool");

 //get a template definition the feature layer
 var resTemplate = featLayer.GetTemplate("Residential");
 var resTempDef = resTemplate.GetDefinition() as CIMFeatureTemplate;
 //use:    var newTemplate = new CIMFeatureTemplate(); to create a new one      

 //EditOperation.Merge(...)
 mergeFeatures.Merge(this.CurrentTemplate as EditingFeatureTemplate, featureLayer, 
                                                       new List<long>() { 10, 96, 12 });

 //At 3.x
 templateDef.DefaultToolGUID = toolContentGUID;
 var toolIds = cimEditTemplate.GetExcludedToolIDs().ToList();
 cimEditTemplate.SetExcludedToolIDs(toolIds.ToArray());
 cimEditTemplate.AllowToolID("esri_editing_SketchLineTool");

 //get a template definition the feature layer
 var resTemplate = featLayer.GetTemplate("Residential");
 var resTempDef = resTemplate.GetDefinition() as CIMRowTemplate;
 //use:    var newTemplate = new CIMRowTemplate(); to create a new one

 //EditOperation.Merge(...)
 mergeFeatures.Merge(this.CurrentTemplate as EditingRowTemplate, featureLayer, 
                                                       new List<long>() { 10, 96, 12 });

 //at 2.x
 var insp = new Inspector(true | false);
 //At 3.x
 var insp = new Inspector();//isFeatureEditing = true is just assumed.

//At 2.x
long newFeatureID = -1;
editOp.Create(featLayer, poly, (oid) => newFeatureID = oid);
if (editOp.Execute()) {
   //operation executed successfully
   WriteToLog($"{featLayer.Name}: new feature: {newFeatureID}");

//At 3.x
long newFeatureID = -1;
var rowToken = editOp.Create(featLayer, poly);
if (editOp.Execute()) {
   //operation executed successfully
   long newFeatureID = (long)rowToken.ObjectID;
   WriteToLog($"{featLayer.Name}: new feature: {newFeatureID}");

 //At 2.x - construct an enumerable of key value pairs from the mapview selection
 var selFeatures = MapView.Active.GetFeatures(intersectPolygon).Select(
      k => new KeyValuePair<MapMember, List<long>>(k.Key as MapMember, k.Value));

 //pass to edit operation
 editOp.Split(selFeatures, ...);
 editOp.Move(selFeatures, ...);
 editOp.Rotate(selFeatures, origin, ...);
 editOp.Reshape(selFeatures, ...);
 editOp.Scale(selFeatures, ...);

 //At 3.x, MapView will return SelectionSet
 var selSet = MapView.Active.GetFeatures(intersectPolygon);

 //pass to edit operation
 editOp.Split(selSet, ...);
 editOp.Move(selSet, ...);
 editOp.Rotate(selSet, origin, ...);
 editOp.Reshape(selSet, ...);
 editOp.Scale(selSet, ...);

 var editOp = new EditOperation();
 editOp.Name = "Duplicate Features";

 //At 2.x
 editOp.Duplicate(featureLayer, oid, 500.0, 500.0, 0.0);

 //At 3.x, use either of a copy + move or a create + move
 //in this example, an inspector is being used to access the feature attributes
 //
 var insp = new Inspector();
 insp.Load(featureLayer, oid);
 
 //make a copy using create + attributes
 var rtoken = editOp.Create(featureLayer, insp.ToDictionary(a => a.FieldName, a => a.CurrentValue));
 if (editOp.Execute())  {
    //do a move - chain to keep the two operations as a single undo
    var modifyOp = editOp.CreateChainedOperation();
    modifyOp.Modify(featureLayer, (long)rtoken.ObjectID, GeometryEngine.Instance.Move(geom, 500.0, 500.0));
    modifyOp.Execute();
 }

        
 var editOp = new EditOperation();
 editOp.Name = "Transform Features";

 //At 2.x 
 var transformSelection = MapView.Active.GetFeatures(polygon).Select(
                      k => new KeyValuePair<MapMember, List<long>>(k.Key as MapMember, k.Value));
 editOp.Transform(transformSelection, linkLayer);
 //Transform just a layer
 editOp.Transform(featureLayer, linkLayer);
 //Perform an affine transformation
 editOp.TransformAffine(featureLayer, linkLayer);

 //At 3.x
 //Define the transform method
 var affine_transform = new TransformByLinkLayer() {
    LinkLayer = linkLayer,
    TransformType = TransformMethodType.Affine //or TransformMethodType.Similarity
 };
 //Transform a selected set of features
 editOp.Transform(MapView.Active.GetFeatures(polygon), affine_transform);
 //Perform an affine transformation
 editOp.Transform(featureLayer, affine_transform);

 //Execute to execute the operation
 //Must be called within QueuedTask.Run
 editOp.Execute();
 
 //or use async flavor
 //await editOp.ExecuteAsync();

\\At 2.x - embeddable controls associated with construction tools
\\implement IEditingCreateToolControl and IEditingCreateToolMultiple to
\\display configurable UIs
internal class CustomToolToolOptionsViewModel : EmbeddableControl, 
                IEditingCreateToolControl {//most common
   ...

internal class CustomToolToolOptionsViewModel : EmbeddableControl, 
      IEditingCreateToolControl, IEditingCreateToolMultiple {//less common - tool supports multiple templates
  ...


\\At 3.x, derive from ToolOptionsEmbeddableControl, no interfaces needed
internal class CustomToolToolOptionsViewModel : ToolOptionsEmbeddableControl {

 //Occurs when a tool options control is initialized
 public override void OnInitialize(ToolOptions options, bool hostIsActiveTmplatePane) {
    //TODO
    base.OnInitialize(options, hostIsActiveTmplatePane);
  }
  //Occurs when a tool options control is initialized
  public override void OnInitialize(IEnumerable<ToolOptions> optionsCollection, 
                                    bool hostIsActiveTmplatePane) {
    //TODO - handle when the tool options control is initialized
  }

  //Gets and sets the valid state of the tool options - default is true
  public virtual bool IsValid { get; set; } = true;

  //Gets and sets the dirty state of the tool options - default is false
  public virtual bool IsDirty { get; set; }

  //Gets and sets whether the tool options should auto open in the Active Template 
  //pane when the associated tool is activated - default is false
  public virtual bool IsAutoOpen(string toolID) => false;

  //Gets the icon to display when the tool options are displayed in the Active Template pane.
  public override ImageSource SelectorIcon => ... ;

  //Gets a working copy of the ToolOptions
  protected internal ToolOptions ToolOptions { get; }

  // Called at the end of <see cref="OpenAsync"/>, implementations should obtain and interpret the 
  //options stored in the current <see cref="ToolOptions"/> using
  //protected T GetToolOption<T>(string key, T defaultValue, T differentValue = default(T))
  protected override Task LoadFromToolOptions() {
      //eg, this tool checks if it has a stored default value for a "Buffer" option
      double? buffer = GetToolOption<double?>("Buffer", 25.0, null);
      if (buffer.HasValue) {//there is a default
         ...
      }
      return Task.CompletedTask;
    }

//At 2.x, this code would show Name-Title-Subtitle
//At 3.x, only title will show.
 var date_time = System.DateTime.Now.ToString("g");
 FrameworkApplication.Name = date_time;
 FrameworkApplication.SubTitle = "MyMap";
 FrameworkApplication.Title = Project.Current.Name;

//At 3.x, title is set to "", title defaults to FrameworkApplication.Name
 var date_time = System.DateTime.Now.ToString("g");
 FrameworkApplication.Name = date_time;
 FrameworkApplication.SubTitle = "MyMap";
 FrameworkApplication.Title = "";//no title

//At 3.x Subtitle is ignored in the bar
 var date_time = System.DateTime.Now.ToString("g");
 FrameworkApplication.Name = "";//no name
 FrameworkApplication.SubTitle = "MyMap";
 FrameworkApplication.Title = "";//no title

using System.Windows.Interop;// for WindowInteropHelper


//Get a handle to the Pro app window
var parentWindow = new WindowInteropHelper(
    FrameworkApplication.Current.MainWindow).Handle;

//At 2.x
//using ArcGIS.Desktop.Framework.Dialogs;
//
//var browseDialog = new BrowseForFolder();
//var selectedFolder = browseDialog.SelectFolder(
//      "Please select an output folder", @"C:\\The\\Initial\\Path", IntPtr.Zero);
//....or, use the Pro application window handle
//var selectedFolder = browseDialog.SelectFolder(
//     "Please select an output folder", @"C:\\The\\Initial\\Path", parentWindow);

//At 3.x
using System.Windows.Forms;
...

var parentWindow = new WindowInteropHelper(
    FrameworkApplication.Current.MainWindow).Handle;

var browseDialog = new FolderBrowserDialog() {
  InitialDirectory = @"C:\\The\\Initial\\Path",
  Description = "Please select an output folder",
  UseDescriptionForTitle = true
};
var selectedFolder = "";
if (folderBrowserDialog1.ShowDialog(
      new WindowWrapper(parentWindow)) == DialogResult.OK) {
   selectedFolder = folderBrowserDialog1.SelectedPath;
}
//TODO - use selected folder path
...

// http://stackoverflow.com/questions/315164/how-to-use-a-folderbrowserdialog-from-a-wpf-application
public class WindowWrapper : System.Windows.Forms.IWin32Window {
  IntPtr _handle = IntPtr.Zero;

  public WindowWrapper(IntPtr handle) {
    _handle = handle;
  }
 IntPtr System.Windows.Forms.IWin32Window.Handle => _handle;
}

//At 2.x
QueuedTask.Run(()=> {
   //Create point, line, polygon graphic elements - we typically match specific geometries 
   //with specific macros. Overloads for layout, group element, graphics layer as the container
   LayoutElementFactory.Instance.CreateGraphicElement(layout, ...);
   LayoutElementFactory.Instance.CreateGraphicElement(layout, graphic);
   LayoutElementFactory.Instance.CreatePointGraphicElement(layout, ...);
   LayoutElementFactory.Instance.CreateLineGraphicElement(layout, ...);
   LayoutElementFactory.Instance.CreatePolygonGraphicElement(layout, ...);
   LayoutElementFactory.Instance.CreateBezierCurveGraphicElement(layout, ...);
   LayoutElementFactory.Instance.CreateCircleGraphicElement(layout, ...);
   LayoutElementFactory.Instance.CreateEllipseGraphicElement(layout, ...);
   LayoutElementFactory.Instance.CreateFreehandGraphicElement(layout, ...);
   LayoutElementFactory.Instance.CreateLassoGraphicElement(layout, ...);
   LayoutElementFactory.Instance.CreateRectangleGraphicElement(layout, ...);

   //At 3.x use CreateGraphicElement with (optional) ElementInfo. No need for separate
   //overloads for layout, group element, graphics layer as the container at 3.x
   var container = ....;//Layout, GroupElement, or GraphicsLayer
   
   ElementFactory.Instance.CreateGraphicElement(container, bezPl, lineSym, "New Bezier Curve");
   ElementFactory.Instance.CreateGraphicElement(container, linePl, lineSym, "New Freehand");
   ElementFactory.Instance.CreateGraphicElement(container, env, polySym, "New Polygon");
   
   //and with ElemInfo...
   var elemInfo = new ElementInfo() {
     Anchor = Anchor.CenterPoint,
     Rotation = 45
   };
   ElementFactory.Instance.CreateGraphicElement(container, env, polySym, "New Polygon", true, elemInfo);

   //Or, instead of a geometry + symbol, use a CIMGraphic
   var graphic = new CIMPointGraphic() { ..... };
   ElementFactory.Instance.CreateGraphicElement(container, graphic);

   //At 2.x - create text graphic elements
   LayoutElementFactory.Instance.CreateCurvedTextGraphicElement(container, ...);
   LayoutElementFactory.Instance.CreatePointTextGraphicElement(container, ...);
   LayoutElementFactory.Instance.CreateCircleParagraphGraphicElement(container, ...);
   LayoutElementFactory.Instance.CreatePolygonParagraphGraphicElement(container, ...);
   LayoutElementFactory.Instance.CreateEllipseParagraphGraphicElement(container, ...);
   LayoutElementFactory.Instance.CreateRectangleParagraphGraphicElement(container, ...);

   //At 3.x - use CreateTextGraphicElement and TextType enum to specify the type of
   //text to create
   ElementFactory.Instance.CreateTextGraphicElement(
      container, TextType.SplinedText, bezPl, sym, "Curved Text", "New Splined Text");
   ElementFactory.Instance.CreateTextGraphicElement(
      container, TextType.RectangleParagraph, poly, sym, text, "New Polygon Text");
   ElementFactory.Instance.CreateTextGraphicElement(
      container, TextType.CircleParagraph, polyCir, sym, text, "New Circle Text");

   //and with ElementInfo
   var elemInfo = new ElementInfo() {
      Anchor = Anchor.CenterPoint,
      Rotation = 45
   };
   ElementFactory.Instance.CreateTextGraphicElement(
          container, TextType.PointText, coord2D.ToMapPoint(), sym, textString, "New Point Text", true, elemInfo);

   //At 2.x - create map frame and associated surrounds
   LayoutElementFactory.Instance.CreateMapFrame(layout, env, mfMap);

   LayoutElementFactory.Instance.CreateLegend(layout, env, mapFrame);
   LayoutElementFactory.Instance.CreateScaleBar(layout, center, mapFrame, sbStyleItm);
   LayoutElementFactory.Instance.CreateNorthArrow(layout, center, mapFrame, naStyleItm);
   LayoutElementFactory.Instance.CreateTableFrame(layout, env, mapFrame, featLayer, layerFields);
   LayoutElementFactory.Instance.CreateChartFrame(layout, ...);

   //At 3.x, use CreateMapFrameElement and CreateMapSurroundElement along with the
   //relevant ArcGIS.Desktop.Layouts.MapSurroundInfo
   var mfElm = ElementFactory.Instance.CreateMapFrameElement(layout, env, map, "New Map Frame");
   
   var legInfo = new LegendInfo() { MapFrameName = mfElm.Name};
   var sbInfo = new ScaleBarInfo() { MapFrameName = mfElm.Name, ScaleBarStyleItem = sbStyleItm};
   var naInfo = new NorthArrowInfo() { MapFrameName = mfElm.Name, NorthArrowStyleItem = naStyleItm};
   var tfInfo = new TableFrameInfo() { MapFrameName = mfElm.Name, 
                                          MapMemberUri = featLayer.URI, FieldNames = layerFields};
   var cfInfo = new ChartFrameInfo() { MapFrameName = mfElm.Name, MapMemberUri = featLayer.URI};

   var legendElm = ElementFactory.Instance.CreateMapSurroundElement(
                         layout, env, legInfo, "New Legend") as Legend;
   var sbElm = ElementFactory.Instance.CreateMapSurroundElement(
                      layout, center.ToMapPoint(), sbInfo, "New Scale Bar") as ScaleBar;
   var arrowElm = ElementFactory.Instance.CreateMapSurroundElement(
                         layout, center.ToMapPoint(), naInfo, "New North Arrow") as NorthArrow;
   var tabFrame = ElementFactory.Instance.CreateMapSurroundElement(
                         layout, env, tfInfo) as TableFrame;
   var chartFrame = ElementFactory.Instance.CreateMapSurroundElement(
                         layout, env, cfInfo) as ChartFrame;

   //At 2.x - CreateGroupElement has an overload that takes a single element (to be "grouped)
   LayoutElementFactory.Instance.CreateGroupElement(container, titleElm);

   //At 3.x, a list of elements to be grouped must be provided
   ElementFactory.Instance.CreateGroupElement(container, new List<Element>() { titleElm });

 //Layout events
 //   At 2.x         --        At 3.x
 LayoutAddedEvent       ProjectItemsChangedEvent, hint: NotifyCollectionChangedAction.Add
 LayoutRemovedEvent     ProjectItemsChangedEvent, hint: NotifyCollectionChangedAction.Remove
 LayoutChangedEvent     LayoutEvent, hint: LayoutEventArgs.LayoutEventHint
 LayoutClosing          LayoutViewEvent, hint: LayoutViewEventArgs.LayoutViewEventHint.Closing
 LayoutClosed           LayoutViewEvent, hint: LayoutViewEventArgs.LayoutViewEventHint.Closed

 LayoutPauseDrawingChangedEvent       LayoutViewEvent, 
                            hint: LayoutViewEventArgs.LayoutViewEventHint.PauseDrawingChanged

 LayoutViewEvent        LayoutViewEvent, hint: LayoutViewEventArgs.LayoutViewEventHint
 MapSeriesEvent         LayoutEvent, hint: LayoutEventArgs.LayoutEventHint
 PageChangedEvent       LayoutEvent, hint: LayoutEventArgs.LayoutEventHint

 ActiveLayoutViewChangedEvent  LayoutViewEvent, 
                        hint: LayoutViewEventArgs.LayoutViewEventHint.Activated, Deactivated

 ActiveMapFrameEvent    **ElementEvent** (not LayoutViewEvent)
                     hint: ElementEventArgs.ElementEventHint.MapFrameActivated, MapFrameDeactivated

 //Element events
 //   At 2.x         --        At 3.x
 ElementAddedEvent      ElementEvent, hint: ElementEventArgs.ElementEventHint.ElementAdded
 ElementRemovedEvent    ElementEvent, hint: ElementEventArgs.ElementEventHint.ElementRemoved
 ElementsUpdatedEvent   ElementEvent, hint: ElementEventArgs.ElementEventHint

 ElementStyleChangedEvent  ElementEvent, hint: ElementEventArgs.ElementEventHint.StyleChanged
 ElementsPlacementChangedEvent  ElementEvent, hint: ElementEventArgs.ElementEventHint.PlacementChanged

 //At 2.x
 LayoutSelectionChangedEvent    (deprecated at 2.6)
 ArcGIS.Desktop.Mapping.Events.ElementSelectionChangedEvent

 // At 3.x use:
 ElementEvent, hint: ElementEventArgs.ElementEventHint.SelectionChanged

 //At 2.x CreateLayer<T>(...) does not include a LayerPosition position default parameter
 //At 3.0, addins should use the LayerCreationParams MapMemberPosition instead.

 //At 2.x - Addins using
 LayerFactory.Instance.CreateLayer(item, ....);
 LayerFactory.Instance.CreateLayer(cimDataConnection, ....);

 //should use layer creation params.
 //Note: set MapMemberIndex or MapMemberPosition on the LayerCreationParams
 //if the addin was using the relevant parameter at 2.x
 var layerParams = new LayerCreationParams(item | cimDataConnection) { 
                         MapMemberIndex = -1 
                       };
 var layer = LayerFactory.Instance.CreateLayer<Layer>(layerParams, ...);
 
 //Note, 3.x provides the following overload of CreateLayer for scenarios where
 //addins want to create a layer via a path or Uri to the underlying data source
 Layer CreateLayer(Uri dataUri, ILayerContainerEdit container, int index = 0, string layerName = "");

 //At 2.x - Addins using
 LayerFactory.Instance.CreateFeatureLayer(featClass, ....);
 LayerFactory.Instance.CreateFeatureLayer(item, ....);
 LayerFactory.Instance.CreateFeatureLayer(uri, ....);
 LayerFactory.Instance.CreateFeatureLayer(cimDataConnection, ....);

 //At 3.x
 //use feature layer creation params
 //Note: set MapMemberIndex, MapMemberPosition, and RendererDefinition on the 
 //FeatureLayerCreationParams if the addin was using the relevant Create method parameter at 2.x
 var layerParams = new FeatureLayerCreationParams(featClass |item | uri | cimDataConnection) { 
                           MapMemberPosition = MapMemberPosition.AddToBottom 
                       };
 var layer = LayerFactory.Instance.CreateLayer<FeatureLayer>(layerParams, ...);

 //At 2.x - Addins using
 LayerFactory.Instance.CreateRasterLayer(item, ....);
 LayerFactory.Instance.CreateRasterLayer(uri, ....);
 LayerFactory.Instance.CreateRasterLayer(cimDataConnection, ....);

 //At 3.x, should use raster layer creation params.
 //Note: set MapMemberIndex, MapMemberPosition, and ColorizerDefinition on the 
 //RasterLayerCreationParams if the addin was using the relevant Create method parameter at 2.x
 var layerParams = new RasterLayerCreationParams(raster |item | uri | cimDataConnection) { 
                           MapMemberPosition = MapMemberPosition.AddToBottom 
                       };
 var layer = LayerFactory.Instance.CreateLayer<BasicRasterLayer>(layerParams, ...);
 
 //At 2.x - Addins using
 LayerFactory.Instance.CreateMosaicLayer(item, ....);
 LayerFactory.Instance.CreateMosaicLayer(uri, ....);
 LayerFactory.Instance.CreateMosaicLayer(cimDataConnection, ....);

 //At 3.x, should use mosaic layer creation params.
 //Note: set MapMemberIndex, MapMemberPosition, and ColorizerDefinition on the 
 //MosaicLayerCreationParams if the addin was using the relevant Create method 
 //parameter at 2.x
 var layerParams = new MosaicLayerCreationParams(item | uri | cimDataConnection) { 
                           MapMemberPosition = MapMemberPosition.AddToBottom 
                       };
 var layer = LayerFactory.Instance.CreateLayer<MosaicLayer>(layerParams, ...);

 //At 3.x CreateGroupLayer is unchanged
 LayerFactory.Instance.CreateGroupLayer(map, 0, "Group 1");//same as was at 2.x

 //At 2.x
 //use a local path uri
 var table = StandaloneTableFactory.Instance.CreateStandaloneTable(
            new Uri(@"C:\Temp\Data\SDK.gdb\EarthquakeDamage", UriKind.Absolute), map);

 //GDB table
 var table2 = StandaloneTableFactory.Instance.CreateStandaloneTable(gdb_table, map);
 //Item
 var item = ItemFactory.Instance.Create(@"C:\Temp\Data\SDK.gdb\ParcelOwners");
 var table3 = StandaloneTableFactory.Instance.CreateStandaloneTable(item, map);

 //StandaloneTableCreationParams, eg with Item
 var tableParams = new StandaloneTableCreationParams(item);
 var table4 = StandaloneTableFactory.Instance.CreateStandaloneTable(tableParams, map);

 //At 3.x
 //use a local path uri
 var table = StandaloneTableFactory.Instance.CreateStandaloneTable(
            new Uri(@"C:\Temp\Data\SDK.gdb\EarthquakeDamage", UriKind.Absolute), map);
 
 //At 3.x
 //Use StandaloneTableCreationParams - Uri, Item, Table, CIMDataConnection, CIMLayerDocument
 var tableCreationParams = new StandaloneTableCreationParams(uri);
 var tableCreationParams2 = new StandaloneTableCreationParams(gdb_table);
 var tableCreationParams3 = new StandaloneTableCreationParams(dc);
 var tableCreationParams4 = new StandaloneTableCreationParams(layerDoc);
        
 var table = StandaloneTableFactory.Instance.CreateStandaloneTable(tableCreationParams, map);

//At 2.x, using CIMDefinitionFilter
var defFilter = new CIMDefinitionFilter() {
  Name = "California",
  DefinitionExpression = "STATE_NAME = 'California'"
};

//At 3.x, using DefinitionQuery
var defQuery = new DefinitionQuery() {
  Name = "California",
  WhereClause = "STATE_NAME = 'California'"
};

//At 2.x ITableDefinitionQueries uses CIMDefinitionFilter
public class BasicFeatureLayer : Layer, ..., ITableDefinitionQueries {
   //Deprecated at 2.5. Use GetDefinitionFilters()
   public CIMDefinitionFilter[] DefinitionFilterChoices { get; }
}

//Defines required properties and methods for interacting with definition filters
public inteface ITableDefinitionQueries {
  CIMDefinitionFilter DefinitionFilter { get; }
  void SetDefinitionFilter(CIMDefinitionFilter activeFilter);
  IReadOnlyList<CIMDefinitionFilter> GetDefinitionFilters();//replaced DefinitionFilterChoices
  void SetDefinitionFilters(IEnumerable<CIMDefinitionFilter> filters, string activeFilterName = null);
  void RemoveDefinitionFilter(string filterName);
  void RemoveAllDefinitionFilters();
}

//At 3.x ITableDefinitionQueries uses DefinitionQuery
public class BasicFeatureLayer : Layer, ..., ITableDefinitionQueries {
  //DefinitionFilterChoices, deprecated at 2.5, is removed...
}

//Defines required properties and methods for interacting with definition filters
public inteface ITableDefinitionQueries {
  string DefinitionQuery { get; }
  IReadOnlyList<DefinitionQuery> DefinitionQueries { get; }
  DefinitionQuery SetDefinitionQuery(string whereClause);
  DefinitionQuery ActiveDefinitionQuery { get; } //The def query currently active
  void InsertDefinitionQuery(DefinitionQuery definitionQuery, bool makeActive = false);
  void InsertDefinitionQueries(IEnumerable<DefinitionQuery> queries);
  void RemoveActiveDefinitionQuery();
  void RemoveDefinitionQuery(int index);
  void RemoveDefinitionQueries(IEnumerable<string> queryNames);
  void RemoveAllDefinitionQueries();
}

 var us_states = MapView.Active.Map.GetLayersAsFlattenedList()
                     .OfType<FeatureLayer>().First(lyr => lyr.Name == "US States");

 QueuedTask.Run(() => {
    us_states.SetDefinitionQuery("STATE_NAME = 'Iowa'");
    //equivalent to...
    var def_query = new DefinitionQuery() {
      Name = "A Name that is Unique",
      WhereClause = "STATE_NAME = 'Iowa'"
   };
   us_states.InsertDefinitionQuery(def_query, true);

   var active_def_query = us_states.ActiveDefinitionQuery;
   string where_clause = us_states.DefinitionQuery;//just the where clause string
   
  //remove the active query
  us_states.RemoveActiveDefinitionQuery();

  //remove using name
  us_states.RemoveDefinitionQueries(new List<string> { def_query.Name });

  //use LINQ to get just a specific query
  var def_query = us_states.DefinitionQueries.FirstOrDefault(
                                         dq => dq.Name == "Query def name");
  ...

//At 2.x, DefinitionFilter was used with FeatureLayerCreationParams to define
//a definition filter upfront
public class FeatureLayerCreationParams : LayerCreationParams {
  ...
  public CIMDefinitionFilter DefinitionFilter { get; set; }

//At 3.x, use DefinitionQuery with FeatureLayerCreationParams instead
public class FeatureLayerCreationParams : LayerCreationParams {
  ...
  public DefinitionQuery DefinitionQuery { get; set; }

//define a definition query on the feat layer params
var featlayerParams = new FeatureLayerCreationParams() {
      DefinitionQuery = new DefinitionQuery("Name = 'Ponderosa Pine'", "My query1"),
      ...

//At 2.x this was the common pattern - most everything off the layer
var voxelLayer = ...
var vol_size = voxelLayer.GetVolumeSize();
var section = voxelLayer.GetSections().First();
var slice = voxelLayer.GetSlices().First();
... etc...
//At 3.x, most everything is off the volume - so this is the most common pattern:
var voxelLayer = ...
var volume = voxelLayer.SelectedVariableProfile.Volume;
var vol_size = volume.GetVolumeSize();
var section = volume.GetSections().First();
var slice = volume.GetSlices().First();
... etc...

 //At 2.x
 var volume = voxelLayer.GetVolumeSize();
 var x_max = volume.Item1;
 var y_max = volume.Item2;
 var z_max = volume.Item3;

 //At 3.x, there can be more than one volume - use GetVolumes()
 var x_max = voxelLayer.GetVolumes().Max(v => v.GetVolumeSize().X);
 var y_max = voxelLayer.GetVolumes().Max(v => v.GetVolumeSize().Y);
 var z_max = voxelLayer.GetVolumes().Max(v => v.GetVolumeSize().Z);

 //At 2.x
 //use voxelLayer to get slices, create slices
 var slices = voxelLayer.GetSlices();
 ...
 voxelLayer.UpdateSlice(slice);//Update slice via its layer

 //Create a slice on the voxel layer
 voxelLayer.CreateSlice(new SliceDefinition() {
     Name = "Middle Slice",
     VoxelPosition = new Coordinate3D(volume.Item1 / 2, volume.Item2 / 2, volume.Item3 / 2),
     ...

 //Create a section on the voxel layer
 voxelLayer.CreateSection(new SectionDefinition() {
      Name = $"Diagonal {s + 1}",
      VoxelPosition = new Coordinate3D(end_pt.X, end_pt.Y, volumeSize.Item3),
      ....

 //Access sections from the voxel layer
 foreach (var section in voxelLayer.GetSections()) {
    //set each normal to 45.0 orientation and tilt
    section.Normal = voxelLayer.GetNormal(45.0, 45.0);
    //apply the change via the voxel layer
    voxelLayer.UpdateSection(section);

 //Get a list of sections from the voxel layer that are 
 //not currently visible 
 var sections = voxelLayer.GetSections().Where(s => !s.IsVisible);

				
 //At 3.x, 
 //Use the SelectedVariableProfile to get the slices currently in the TOC
 //via its associated volume
 var volume = voxelLayer.SelectedVariableProfile.Volume;
 var slices = volume.GetSlices();
 ...
 volume.UpdateSlice(slice);//Update slice via its volume

 //Create a slice on the voxel -volume-
 var volume = voxelLayer.SelectedVariableProfile.Volume;
 var vol_size = volume.GetVolumeSize();

 volume.CreateSlice(new SliceDefinition() {
    Name = "Middle Slice",
    VoxelPosition = new Coordinate3D(vol_size.X / 2, vol_size.Y / 2, vol_size.Z/ 2),
    ...

 //Create a section on the voxel -volume-
 volume.CreateSection(new SectionDefinition() {
      Name = $"Diagonal {s + 1}",
      VoxelPosition = new Coordinate3D(end_pt.X, end_pt.Y, volumeSize.Z),
      ....

 //Access sections from the voxel -volume-
 foreach (var section in volume.GetSections()) {
    //set each normal to 45.0 orientation and tilt
    section.Normal = voxelLayer.GetNormal(45.0, 45.0);
    //apply the change via the voxel layer
    volume.UpdateSection(section);

 //Get a list of sections from the voxel -volume- that are 
 //not currently visible 
 var sections = volume.GetSections().Where(s => !s.IsVisible);

 //At 2.x
 var variable = voxel.SelectedVariableProfile;
 var min = variable.GetVariableStatistics().MinimumValue;
 var max = variable.GetVariableStatistics().MaximumValue;

 //At 3.x
 var variable = voxel.SelectedVariableProfile;
 var min = variable.Statistics.MinimumValue;
 var max = variable.Statistics.MaximumValue;

//At 2.x
  MapMemberPropertiesChangedEvent.Subscribe((args) => {
     var voxel = args.MapMembers.OfType<VoxelLayer>().FirstOrDefault();
     if (voxel == null)
       return;
  //Anything changed on a voxel layer?
  if (args.EventHints.Any(hint => hint == 
         MapMemberEventHint.VoxelSelectedVariableProfileIndex)) {
    ...

//At 3.x
  MapMemberPropertiesChangedEvent.Subscribe((args) => {
     var voxel = args.MapMembers.OfType<VoxelLayer>().FirstOrDefault();
     if (voxel == null)
       return;
  //Anything changed on a voxel layer?
  if (args.EventHints.Any(hint => hint == 
         MapMemberEventHint.VoxelSelectedVariable)) {
   ...

 //At 2.x - 
 //If you used....
 var cimSurfaces = map.GetElevationSurfaces() ; //IReadOnlyList<CIMMapElevationSurface> 
 var cimSurface = map.GetGroundElevationSurface() ; //CIMMapElevationSurface

 map.SetElevationSurace(cimSurface);//or mapElevationSurfaceDefinition.ToCIM()
 map.SetElevationSuraces(cimSurfacesList);

 map.RemoveElevationSurface(cimSurface);
 map.ClearElevationSurfaces();
 
 //At 3.x use ElevationSurfaceLayer
 var surfaceLayers = map.GetElevationSurfaceLayers();

 var surfaceLayer = map.GetGroundElevationSurfaceLayer();

 //At 3.x Create surfaces using LayerFactory and ElevationLayerCreationParams
 //Surfaces will be created as ElevationMode.CustomSurface
 LayerFactory.Instance.CreateLayer<ElevationSurfaceLayer>(
       new ElevationLayerCreationParams(source_uri), scene);

 //Or create a new scene from scratch with a ground elevation source
 var scene = MapFactory.Instance.CreateScene(
                "My scene", groundSourceUri, MapViewingMode.SceneGlobal);

 //At 3.x, use map.RemoveLayer(s)(...) or ClearElevationSurfaceLayers
 map.RemoveLayer(surfaceLayer);//Cannot remove ground
 map.RemoveLayers(map.GetElevationSurfaceLayers()); //Ground will not be removed

 map.ClearElevationSurfaceLayers();

//At 2.x - if using elevation surface -name-...
var surfaceZResult = await map.GetZsFromSurfaceAsync(
                             pt_location, "custom_elevation_surface");

//At 3.x - use elevation surface -layer-
var elevSurfaceLayer = map.GetElevationSurfaceLayers()
                             .First(sl => sl.Name == "custom_elevation_surface");
var surfaceZResult = await map.GetZsFromSurfaceAsync(pt_location, elevSurfaceLayer);

  //At 2.x - using ISceneLayerInfo, eg on PointCloudSceneLayer
  var slInfo = pointCloudLayer as ISceneLayerInfo;
  if (slInfo.SceneServiceLayerType == SceneServiceLayerType.PointCloud) {
    //TODO - access Point cloud scene layer...

  var dataSourceType = slInfo.GetDataSourceType();
  var dc = slInfo.GetDataConnection();

 //At 2.x 
 var classCodesAndLabels = pcsl.QueryAvailableClassCodesAndLabels();
 var classFlagsAndLabels = pcsl.QueryAvailableClassFlagsAndLabels();
 var flds = pcsl.QueryAvailablePointCloudRendererFields(PointCloudRendererType.UniqueValueRenderer);

 //At 2.x BuildingScenelayer
 var classFieldsAndValues = bsl.QueryAvailableFieldsAndValues();

 var filterBlock = new FilterBlockDefinition();
 filterBlock.FilterBlockMode = Object3DRenderingMode.Wireframe;
 var selValues = new Dictionary<string, List<string>>();
 selValues ["Category"] = new List<string>() { ... };
 filterBlock.SelectedValues =  selValues;
 ...
 var filter1 = bsl.GetFilter(filter_id);
 filter1.Name = "Updated Filter";
 filter1.FilterBlockDefinitions = new List<FilterBlockDefinition>() { filterBlock };
 //At 2.x
 bsl.SetFilter(filter1);
 
 //At 3.x - ISceneLayerInfo is deleted. Use the layer class directly.
  var slInfo = pointCloudLayer as ISceneLayerInfo;
  if (sceneLayer is PointCloudSceneLayer pcsl) {
    //TODO - access Point cloud scene layer...

  var dataSourceType = pcsl.GetDataSourceType();//Off layer
  var dc = pcsl.GetDataConnection();//Off layer

 //At 3.x
 var classCodesAndLabels = pcsl.GetAvailableClassCodesAndLabels();
 var classFlagsAndLabels = pcsl.GetAvailableClassFlagsAndLabels();
 var flds = pcsl.GetAvailablePointCloudRendererFields(PointCloudRendererType.UniqueValueRenderer);

 //At 3.x BuildingScenelayer
 var classFieldsAndValues = bsl.GetAvailableFieldsAndValues();

 var filterBlock = new FilterBlockDefinition();
 filterBlock.FilterBlockMode = Object3DRenderingMode.Wireframe;
 var selValues = new Dictionary<string, List<string>>();
 selValues ["Category"] = new List<string>() { ... };
 filterBlock.SelectedValues =  selValues;
 ...
 var filter1 = bsl.GetFilter(filter_id);
 filter1.Name = "Updated Filter";
 filter1.FilterBlockDefinitions = new List<FilterBlockDefinition>() { filterBlock };
 //At 3.x
 bsl.UpdateFilter(filter1);

 //At 2.x
 interface IMappableItem
 public bool CanAddToMap(MapType? mapType)
 public void OnAddToMap(Map map)
 public void OnAddToMap(Map map, ILayerContainerEdit groupLayer, int index)
 
 interface IMappableItemEx
 public string[] OnAddToMapEx(Map map)
 public string[] OnAddToMapEx(Map map, ILayerContainerEdit groupLayer, int index)

 //At 3.x -single (consolidated) interface IMappableItem
 interface IMappableItem
 public bool CanAddToMap(MapType? mapType)//No change
 public List<string> OnAddToMap(Map map)
 public List<string> OnAddToMap(Map map, ILayerContainerEdit groupLayer, int index)

  public bool CanAddToMap(MapType? mapType) {
    ... //No change

  public List<string> OnAddToMap(Map map) {
    return OnAddToMap(map, null, -1);
  }

  public List<string> OnAddToMap(Map map, ILayerContainerEdit groupLayer, int index) {
    //Create map member content - eg layers
    var layer = LayerFactory.Instance.CreateLayer(.....);
    //return list of URIs of layers that were added (to the map or group layer)
    return new List<string>() { layer.URI };
 }

 //At 2.x, use array
 var rendererDefn1 = new UniqueValueRendererDefinition(new string[] { "field1", "field2" });
 //At 3.x, use list
 var rendererDefn1 = new UniqueValueRendererDefinition(new List<string> { "field1", "field2" });
 
 //At 2.x - various properties use Array
 var colorizerDef = new ColormapColorizerDefinition() {
     Colors = new List<CIMColor>() { ....... }.ToArray(),
     ...

 //At 3.x - corresponding properties changed to use type List
 var colorizerDef = new ColormapColorizerDefinition() {
     Colors = new List<CIMColor>() { ....... },
     ...

 //At 2.x, lineOfSight Get methods do not have 'Async' suffix
 var color = await lineOfSight.GetVisibleColor();
 var color2 = await lineOfSight.GetNotVisibleColor();
 var color3 = await lineOfSight.GetOutOfRangeColor();
 ...
 //At 3.x they do
 var color = await lineOfSight.GetVisibleColorAsync();
 var color2 = await lineOfSight.GetNotVisibleColorAsync();
 var color3 = await lineOfSight.GetOutOfRangeColorAsync();
 ...

 //At 2.x LineOfSight static "Set" methods are not awaitable
 LineOfSight.SetVisibleColor(color);
 LineOfSight.SetNotVisibleColor(color2);
 LineOfSight.SetOutOfRangeColor(color3);

 //At 3.x LineOfSight static "Set" methods are awaitable and have
 //an Async suffix
 await LineOfSight.SetVisibleColorAsync(color);//can await (optional)
 await LineOfSight.SetNotVisibleColorAsync(color2);//can await (optional)
 //not awaited...
 LineOfSight.SetOutOfRangeColorAsync(color3);//can await (optional)
 
 //At 2.x, use "Query...."
 var mask_geom = featLayer.QueryDrawingOutline(oid, mv, DrawingOutlineType.Exact);
 //At 2.x3.0, use "Get...."
 var mask_geom = featLayer.GetDrawingOutline(oid, mv, DrawingOutlineType.Exact);

 // change the layer cache type to maximum age
 QueuedTask.Run(() => {
   //At 2.x
   featureLayer.SetDisplayCacheType(ArcGIS.Core.CIM.DisplayCacheType.MaxAge);
   featureLayer.SetDisplayCacheMaxAge(TimeSpan.FromMinutes(2));

   //At 3.x
   featureLayer.SetCacheOptions(LayerCacheType.MaxAge);
   featureLayer.SetDisplayCacheMaxAge(TimeSpan.FromMinutes(2));  

 // set only Point and Edge snapping modes, clear everything else
 //At 2.x
 ArcGIS.Desktop.Mapping.Snapping.SetSnapModes(SnapMode.Point, SnapMode.Edge);
 ArcGIS.Desktop.Mapping.Snapping.SetSnapModes(); //to clear all snap modes

 //At 3.x
 ArcGIS.Desktop.Mapping.Snapping.SetSnapModes(new List<SnapMode>(){ SnapMode.Point, SnapMode.Edge});
 ArcGIS.Desktop.Mapping.Snapping.SetSnapModes(null); //to clear all snap modes

 //Set snapping options via get/set options
 var snapOptions = ArcGIS.Desktop.Mapping.Snapping.GetOptions(myMap);

 //At 2.x
 snapOptions.SnapToSketchEnabled = true;
 snapOptions.ZToleranceEnabled = true;
 snapOptions.GeometricFeedbackColor = ColorFactory.Instance.RedRGB;

 //At 3.x
 snapOptions.IsSnapToSketchEnabled = true;
 snapOptions.IsZToleranceEnabled = true;
 snapOptions.SnapTipColor = ColorFactory.Instance.RedRGB;

 ArcGIS.Desktop.Mapping.Snapping.SetOptions(snapOptions);

//At 2.x - 
//snapOptions.GeometricSnapping,  snapOptions.SnapRequestType,  snapOptions.VisualFeedbackColor, 
//snapOptions.VisualSnapping are removed at 3.x
      

 //At 2.x -
 QueuedTask.Run(()=> {
    var sel_poly = .... ;//Polygon to use for selection

    //zoom to the extent of the retrieved set of features
    MapView.Active.ZoomTo(MapView.Active.GetFeatures(sel_poly));

    //move the selected set of features
    var editOp = new EditOperation() { ..... };
    editOp.Move(MapView.Active.SelectFeatures(sel_poly), 500.0, 500.0);
    editOp.Execute();

    //rotate
    var editOp = new EditOperation() { ..... };
    editOp.Rotate(MapView.Active.SelectFeatures(sel_poly), origin, 35.0);
    editOp.Execute();
   
    //get the geometry of the first selected feature.
    var dict_sel = MapView.Active.GetFeatures(sel_poly);
    var insp = new Inspector();
    insp.Load(dict_sel.Keys.First(), dict_sel.Values.First());
    var selGeom = insp.Shape;

    //Get the list of object ids from SelectFeaturesEx for a particular layer using LINQ
    var sname = "Points of Interest";
    var dict_sel = MapView.Active.SelectFeaturesEx(env);
    var oids1 = dict_sel.Where(kvp => kvp.Key.Name == sname).First().Value;
    //TODO - use the object ids
 });

 //At 3.x
 QueuedTask.Run(() => {
     var sel_poly = .... ;//Polygon to use for selection

    //zoom to the extent of the retrieved set of features - No change
    MapView.Active.ZoomTo(MapView.Active.GetFeatures(sel_poly));

    //move the selected set of features - No change
    var editOp = new EditOperation() { ..... };
    editOp.Move(MapView.Active.SelectFeatures(sel_poly), 500.0, 500.0);
    editOp.Execute();

    //rotate - no change
    var editOp = new EditOperation() { ..... };
    editOp.Rotate(MapView.Active.SelectFeatures(sel_poly), origin, 35.0);
    editOp.Execute();
   
    //get the geometry of the first selected feature. Use ToDictionary()
    //to apply LINQ
    var selSet = MapView.Active.GetFeatures(sel_poly);
    var insp = new Inspector();
    insp.Load(selSet.ToDictionary().Keys.First(), selSet.ToDictionary().Values.First());
    var selGeom = insp.Shape;

    //Get the list of object ids from SelectFeaturesEx for a particular layer. Use ToDictionary()
    //to apply LINQ
    var sname = "Points of Interest";
    var selSet = MapView.Active.SelectFeaturesEx(env);
    var oids1 = selSet.ToDictionary().Where(kvp => kvp.Key.Name == sname).First().Value;
    //TODO - use the object ids

    //Create a selection set from a list of object ids
    //using FromDictionary
    var addToSelection = new Dictionary<MapMember, List<long>>(); 
    addToSelection.Add(us_zips, new List<long> { 1506, 2696, 2246, 1647, 948 }); 
    var sset = SelectionSet.FromDictionary(addToSelection); 
    //TODO - use sset
    //etc
 });

//At 2.x
//Either - select from all graphics layers
var sel_elems = MapView.Active.SelectElements(
   sel_geom, SelectionCombinationMethod.New, false);
// Or - select just from the specified graphics layer
var gl = mapView.Map.GetLayersAsFlattenedList().OfType<GraphicsLayer>().First();
var sel_elems = MapView.Active.SelectElements(
   gl, sel_geom, SelectionCombinationMethod.New, false);

//At 3.x
MapView.Active.SelectElements(
   sel_geom, SelectionCombinationMethod.New, false);//returns void
//or
var graphicsLayer = mapView.Map.GetLayersAsFlattenedList().OfType<GraphicsLayer>().First();
MapView.Active.SelectElements(
   graphicsLayer, sel_geom, SelectionCombinationMethod.New, false);//returns void

//Get the selected elements
// - if a specific GraphicsLayer was specified then use it
var sel_elems = graphicsLayer.GetSelectedElements();

//No GraphicsLayer was specified, collect selection from all GraphicsLayers
var graphicsLayers = mapView.Map.GetLayersAsFlattenedList().OfType<GraphicsLayer>() ??
				new List<GraphicsLayer>();

var sel_elems = new List<Element>();
foreach (var graphicsLayer in graphicsLayers) {
  sel_elems.AddRange(graphicsLayer.GetSelectedElements());
}

//can also use map.TargetGraphicsLayer
var map = MapView.Active.Map;
var sel_elems = map.TargetGraphicsLayer.GetSelectedElements();

 //At 2.x
 //Access to tasks and task items via TaskAssistantModule
 var taskItem = Project.Current.GetItems<TaskProjectItem>().FirstOrDefault();
 //open a project task item
 await TaskAssistantModule.OpenTaskItemAsync(taskItem.TaskItemGuid);

 //Get task item information
 string taskFile = @"c:\Tasks\Get Started.esriTasks";
 var taskItemInfo = await TaskAssistantModule.GetTaskItemInfoAsync(taskFile);

 // find the first task in the task item
 var taskInfo = taskItemInfo.GetTasks().FirstOrDefault();
 //open the task
 await TaskAssistantModule.OpenTaskAsync(taskFile, taskInfo.Guid);

 //export
 await TaskAssistantModule.ExportTaskAsync(taskItem.TaskItemGuid, @"c:\temp");//also ImportTaskAsync
 ...
 //Close it and remove from project
 TaskAssistantModule.CloseTaskAsync(taskItem.TaskItemGuid);


 //At 3.x
 //use TaskAssistantFactory
 var taskItem = Project.Current.GetItems<TaskProjectItem>().FirstOrDefault();
 //open a project task item
 await TaskAssistantFactory.Instance.OpenTaskItemAsync(taskItem.TaskItemGuid);

 //Get task item information
 string taskFile = @"c:\Tasks\Get Started.esriTasks";
 var taskItemInfo = await TaskAssistantFactory.Instance.GetTaskItemInfoAsync(taskFile);

 // find the first task in the task item
 var taskInfo = taskItemInfo.GetTasks().FirstOrDefault();
 //open the task - notice -OpenTaskFileAsync-
 await TaskAssistantFactory.Instance.OpenTaskFileAsync(taskFile, taskInfo.Guid);

 //export - ExportTaskItemAsync
 await TaskAssistantFactory.Instance.ExportTaskItemAsync(taskItem.TaskItemGuid, @"c:\temp");
 //also ImportTaskFileAsync ...
 ...
 //Close it and remove from project - notice -CloseTaskItemAsync
 TaskAssistantFactory.Instance.CloseTaskItemAsync(taskItem.TaskItemGuid);

 //assume we have a feature layer ....
 var map = MapView.Active.Map;
 var fl = map.GetLayersAsFlattenedList().OfType<FeatureLayer>().First();
			
 QueuedTask.Run(() => {
    //get a cim definition to be serialized - eg the renderer definition
    var simple_renderer = fl.GetRenderer() as CIMSimpleRenderer;

    //To persist serialized state at 3.x, use json
    var renderer_json = original_object.ToJson();//No ToXml() at 3.x
    
    //deserialize json to get back to original object
    var simple_renderer2 = CIMSimpleRenderer.FromJson(renderer_json);//No FromXml() at 3.x

     //Apply to the layer
    fl.SetRenderer(original_object2);
    ...

using ArcGIS.Core.CIM;
...

 //assume we have a feature layer ....
 var map = MapView.Active.Map;
 var fl = map.GetLayersAsFlattenedList().OfType<FeatureLayer>().First();
			
 QueuedTask.Run(() => {
    //2.x CIM xml retrieved from a file, proprietary database, etc.
    var simple_renderer_xml = ... ;
    
    //use XmlUtils.UpgradeAndDeserializeCIMObject(xml) to hydrate the CIM object 
    //at 3.x from 2.x xml - it will do a one-way conversion and upgrade to a 3.x CIMObject
    //No CIMObject.FromXml() at 3.x
    var simple_renderer = (CIMSimpleRenderer)XmlUtils.UpgradeAndDeserializeCIMObject(simple_renderer_xml);

    //Apply to the layer
    fl.SetRenderer(simple_renderer);

    //TODO - change renderer properties, etc. 
    ...
    //persist renderer in json to save back in proprietary database, file on disk, etc.
    var renderer_json = fl.GetRenderer().ToJson();
    //From this point on, addin uses json for CIM persistence workflows

 //At 2.x
 view.ViewXML = new XDocument(new XElement("Root",
               new XElement("custom", "custom value"))).ToString(
                                                    SaveOptions.DisableFormatting);

 //At 3.x
 //Use CIMGenericView ViewProperties Dictionary
 if (view.ViewProperties == null)
   view.ViewProperties = new Dictionary<string, object>();
 view.ViewProperties["My_Custom_Content"] = "Custom content -xml or otherwise";

 internal class CustomPaneViewModel : ViewStatePane, IContentsProvider, IContentsControl {
   private const string _viewPaneID = "....";
   ...
   public CustomPaneViewModel(CIMView view) : base(view) {
     ...
   /// <summary>
   /// Create a new instance of the pane.
   /// </summary>
   internal static CustomPaneViewModel Create() {
      var view = new CIMGenericView();
      view.ViewType = _viewPaneID;
      //At 2.x
      // view.ViewXML = 
      //   "<Root><LastChanged>" + DateTime.Now.ToString("HH:mm:ss tt") + "</LastChanged></Root>";

      //At 3.x, Use ViewProperties
      view.ViewProperties = new Dictionary<string, object>();
      view.ViewProperties["LastChanged"] = DateTime.Now.ToString("HH:mm:ss tt");

      return FrameworkApplication.Panes.Create(
          _viewPaneID, new object[] { view }) as CustomPaneViewModel;
  }
  ...

 /// <summary>
 /// Button implementation to create a new instance of the pane and activate it.
 /// </summary>
 internal class CustomPane_OpenButton : Button {
   protected override void OnClick() {
     CustomPaneViewModel.Create();
   }
 }