var lic = ArcGIS.Core.Licensing.LicenseInformation.Level;
if (lic < ArcGIS.Core.Licensing.LicenseLevels.Standard)
{
  MessageBox.Show("Insufficient License Level.");
  return;
}

static void Main(string[] args)
{
  Host.Initialize();

  Uri service = new("https://myserver.esri.com/server/rest/services/myFeatureServiceName/FeatureServer");
  ServiceConnectionProperties serviceConnectionProperties = new(service);
  Uri portal_uri = new("https://myserver.esri.com/portal/");
  ArcGIS.Core.SystemCore.ArcGISSignOn.Instance.SignInWithCredentials(
    portal_uri, "admin", "adminpassword", out _, out _);

  if (serviceConnectionProperties != null)
  {
    //connect
    using var featService = new Geodatabase(serviceConnectionProperties);
    ParcelFabric myFabric = featService.OpenDataset<ParcelFabric>("L0MyParcelFabric");
    var schemaVersion = myFabric.GetDefinition().GetSchemaVersion();
  }
}

public static ParcelFabric GetParcelFabricFromTable(Table table)
{
  ParcelFabric parcelFabric = null;
  if (table.IsControllerDatasetSupported())
  {
    // Tables can belong to multiple controller datasets, 
    // but at most one of them will be a parcel fabric
    IReadOnlyList<Dataset> controllerDatasets = table.GetControllerDatasets();
    foreach (Dataset controllerDataset in controllerDatasets)
    {
      if (controllerDataset is ParcelFabric)
      {
        parcelFabric = controllerDataset as ParcelFabric;
      }
      else
      {
        controllerDataset.Dispose();
      }
    }
  }
  return parcelFabric;
}

if (myParcelFabricDataset.IsSystemTableSupported(SystemTableType.AdjustmentPoints))
  var adjPointTable = myParcelFabricDataset.GetSystemTable(SystemTableType.AdjustmentPoints);

var pfDefinition = myParcelFabricDataset.GetDefinition();
string msg = "Parcel Fabric Schema Version: " + pfDefinition.GetSchemaVersion();

Topology topoDS = null;
var pfDefinition = myParcelFabricDataset.GetDefinition();
if (pfDefinition.GetTopologyEnabled())
  topoDS = myParcelFabricDataset.GetParcelTopology();

string msg = "Types\n\n";
var typeInfo = myParcelFabricDataset.GetParcelTypeInfo();
foreach (var info in typeInfo)
  msg += "Name:" + info.Name + "\n  L:" + info.LineFeatureTable.GetName() + "\n  P:" + info.PolygonFeatureTable.GetName() + "\n\n";

protected async override void OnClick()
{
  string path = @"C:\MyTestData\MyFileGeodatabase.gdb\MyFeatureDS\MyFabric";
  await QueuedTask.Run(() =>
  {
    var lyrCreateParams = new ParcelLayerCreationParams(new Uri(path));
    try
    {
      var parcelLayer = LayerFactory.Instance.CreateLayer<ParcelLayer>(
        lyrCreateParams, MapView.Active.Map);
    }
    catch (Exception ex)
    {
      MessageBox.Show(ex.Message, "Add Parcel Fabric Layer"); 
    }
  });
}

var myParcelFabricLayer = 
        MapView.Active.Map.GetLayersAsFlattenedList().OfType<ParcelLayer>().FirstOrDefault();

var lyrCreateParams = new ParcelLayerCreationParams(new Uri(path));
lyrCreateParams.LayerCreationRole = ParcelLayerCreationRole.ParcelPublicationLayers;

ParcelFabric parcelFabric = myParcelFabricLayer.GetParcelFabric();

// Check if a layer has a parcel fabric source
var myFeatureLayer = MapView.Active.GetSelectedLayers().FirstOrDefault();
bool bIsControlledByFabric = 
         await myFeatureLayer.IsControlledByParcelFabricAsync(ParcelFabricType.ParcelFabric);

// Check if a layer has a source that is a parcel fabric for ArcMap 
var myFeatureLayer = MapView.Active.GetSelectedLayers().FirstOrDefault();
bool bIsControlledByArcMapFabric = 
         await myFeatureLayer.IsControlledByParcelFabricAsync(ParcelFabricType.ParcelFabricForArcMap);

string errorMessage = await QueuedTask.Run( async () =>
{
  Dictionary<string, object> RecordAttributes = new Dictionary<string, object>();
  string sNewRecord = "MyRecordName";

  var myParcelFabricLayer = 
      MapView.Active.Map.GetLayersAsFlattenedList().OfType<ParcelLayer>().FirstOrDefault();
  //if there is no fabric in the map then bail
  if (myParcelFabricLayer == null)
    return "Please add a parcel fabric to the map.";
  try
  {
    var recordsLayer = await myParcelFabricLayer.GetRecordsLayerAsync();
    var editOper = new EditOperation()
    {
      Name = "Create Parcel Fabric Record",
      ProgressMessage = "Create Parcel Fabric Record...",
      ShowModalMessageAfterFailure = true,
      SelectNewFeatures = false,
      SelectModifiedFeatures = false
    };
    RecordAttributes.Add("Name", sNewRecord);
    editOper.Create(recordsLayer.FirstOrDefault(), RecordAttributes);
    if (!editOper.Execute())
      return editOper.ErrorMessage;
    await myParcelFabricLayer.SetActiveRecordAsync(sNewRecord);
  }
  catch (Exception ex)
  {
    return ex.Message;
  }
  return "";
});
if (!string.IsNullOrEmpty(errorMessage))
  MessageBox.Show(errorMessage);

var pRec = myParcelFabricLayer.GetActiveRecord();

myParcelFabricLayer.ClearActiveRecord();

string errorMessage = await QueuedTask.Run( async () =>
{
  // check for selected layer
  if (MapView.Active.GetSelectedLayers().Count == 0)
    return "Please select a feature layer in the table of contents.";
  //get the feature layer that's selected in the table of contents
  var featSrcLyr= MapView.Active.GetSelectedLayers().OfType<FeatureLayer>().FirstOrDefault();
  if (featSrcLyr.SelectionCount == 0)
    return "There is no selection on the source layer.";
  var myParcelFabricLayer = 
      MapView.Active.Map.GetLayersAsFlattenedList().OfType<ParcelLayer>().FirstOrDefault();
  string sTargetParcelType = "Tax";
  if (sTargetParcelType.Trim().Length == 0)
    return "";
  try
  {
    var typeNamesEnum = 
       await myParcelFabricLayer.GetParcelPolygonLayerByTypeNameAsync(sTargetParcelType);
    if (typeNamesEnum.Count() == 0)
      return "Target parcel type " + sTargetParcelType + " not found. Please try again.";
    
    var featTargetLyr = typeNamesEnum.FirstOrDefault();
    var pRec = myParcelFabricLayer.GetActiveRecord();
    if (pRec == null)
      return "There is no Active Record. Please set the active record and try again.";
    
    var opMerge = new EditOperation()
    {
      Name = "Merge",
      ProgressMessage = "Merging parcels...",
      ShowModalMessageAfterFailure = true,
      SelectNewFeatures = true,
      SelectModifiedFeatures = false
    };
    opMerge.Merge(featTargetLyr, featSrcLyr, featSrcLyr.GetSelection().GetObjectIDs());
    opMerge.Execute();
  }
  catch (Exception ex)
  {
    return ex.Message;  
  }
  return "";
  //When active record is set, and merging into the same parcel type, the original parcels 
  //are set historic with RetiredByRecord GUID field
  //When active record is set, the new merged parcel will be tagged with the Active record.
});
if (!string.IsNullOrEmpty(errorMessage))
  MessageBox.Show(errorMessage);

// Check if there is an active record. If no active record then prompt user to set it or create it. 
// Otherwise, warn user that new features will not have an active record.
  var myParcelFabricLayer = 
       MapView.Active.Map.GetLayersAsFlattenedList().OfType<ParcelLayer>().FirstOrDefault();
  var pRec = myParcelFabricLayer.GetActiveRecord();
  if (pRec == null)
  {
    System.Windows.MessageBox.Show("There is no Active Record. Please set the active record and try again.", "Merge Parcels");
    return;
  }

var myParcelFabricLayer = 
     MapView.Active.Map.GetLayersAsFlattenedList().OfType<ParcelLayer>().FirstOrDefault();
IEnumerable<string> parcelTypeNames = await myParcelFabricLayer.GetParcelTypeNamesAsync();

var myParcelFabricLayer = 
     MapView.Active.Map.GetLayersAsFlattenedList().OfType<ParcelLayer>().FirstOrDefault();
var polygonLyrEnum = await myParcelFabricLayer.GetParcelPolygonLayerByTypeNameAsync("Lot");
if (polygonLyrEnum.Count() == 0)
  return;
var myLotParcelPolygonLyr = polygonLyrEnum.FirstOrDefault();

var MyParcelEditToken = editOper.ShrinkParcelsToSeeds(myParcelFabricLayer, 
  SelectionSet.FromDictionary(sourceFeatures));
editOper.Execute();
var editOperation2 = editOper.CreateChainedOperation();
Dictionary<string, object> ParcelAttributes = new Dictionary<string, object>();
var FeatSetModified = MyParcelEditToken.ModifiedFeatures;
string sReportResult = "";
if (FeatSetModified != null)
{
  foreach (KeyValuePair<MapMember, List<long>> kvp in FeatSetModified.ToDictionary())
  {
    foreach (long oid in kvp.Value)
    {
      var dictInspParcelFeat = kvp.Key.Inspect(oid).ToDictionary(a => a.FieldName, a => a.CurrentValue);
      ParcelAttributes.Add("Name", "Seed for: " + dictInspParcelFeat["Name"]);
      editOperation2.Modify(kvp.Key, oid, ParcelAttributes);
      ParcelAttributes.Clear();
    }
    sReportResult += "There were " + kvp.Value.Count().ToString() + " " + 
        kvp.Key.Name + " features modified." + Environment.NewLine;
  }
}
if (editOperation2.Execute())
  return sReportResult;

protected async override void OnClick()
{
  string errorMessage = await QueuedTask.Run( () =>
  {
    var myParcelFabricLayer = 
       MapView.Active.Map.GetLayersAsFlattenedList().OfType<ParcelLayer>().FirstOrDefault();
    var theActiveRecord = myParcelFabricLayer.GetActiveRecord();
    if (theActiveRecord == null)
      return "There is no Active Record. Please set the active record and try again.";
    return "";
  });
  if (!string.IsNullOrEmpty(errorMessage))
    MessageBox.Show(errorMessage);
}

string errorMessage = await QueuedTask.Run( async () =>
{
  var myParcelFabricLayer =
     MapView.Active.Map.GetLayersAsFlattenedList().OfType<ParcelLayer>().FirstOrDefault();
  //if there is no fabric in the map then bail
  if (myParcelFabricLayer == null)
    return "Please add a parcel fabric to the map.";
  string sExistingRecord = "MyRecordName";
  if (!await myParcelFabricLayer.SetActiveRecordAsync(sExistingRecord))
  {
    myParcelFabricLayer.ClearActiveRecord();
    return "Record with that name not found.";
  }
  return "";
});
if (!string.IsNullOrEmpty(errorMessage))
  MessageBox.Show(errorMessage);

string errorMessage = await QueuedTask.Run( async () =>
{
  Dictionary<string, object> RecordAttributes = new Dictionary<string, object>();
  string sNewRecord = "MyRecordName";
  var myParcelFabricLayer = 
     MapView.Active.Map.GetLayersAsFlattenedList().OfType<ParcelLayer>().FirstOrDefault();
  //if there is no fabric in the map then bail
  if (myParcelFabricLayer == null)
    return "Please add a parcel fabric to the map.";
  try
  {
    var recordsLayer = await myParcelFabricLayer.GetRecordsLayerAsync();
    var editOper = new EditOperation()
    {
      Name = "Create Parcel Fabric Record",
      ProgressMessage = "Create Parcel Fabric Record...",
      ShowModalMessageAfterFailure = true,
      SelectNewFeatures = false,
      SelectModifiedFeatures = false
    };
    RecordAttributes.Add("Name", sNewRecord);
    editOper.Create(recordsLayer.FirstOrDefault(), RecordAttributes);
    if (!editOper.Execute())
      return editOper.ErrorMessage;
    await myParcelFabricLayer.SetActiveRecordAsync(sNewRecord);
  }
  catch (Exception ex)
  {
    return ex.Message;
  }
  return "";
});
if (!string.IsNullOrEmpty(errorMessage))
  MessageBox.Show(errorMessage);

<modules>
  <insertModule id="GroundToGridFromActiveRecord_Module" className="Module1" autoLoad="true" caption="Module1">

internal Module1()
{
  ActiveParcelRecordChangingEvent.Subscribe(ActiveRecordEventMethod);
}

~Module1()
{
  ActiveParcelRecordChangingEvent.Unsubscribe(ActiveRecordEventMethod);
}

private async void ActiveRecordEventMethod(ParcelRecordEventArgs e)
{
  var theNewActiveRecord = e.IncomingActiveRecord;
  var newRecName = theNewActiveRecord?.Name;
  var thePreviousActiveRecord = e.OutgoingActiveRecord;
  var prevRecName = thePreviousActiveRecord?.Name;

  if (newRecName == null && prevRecName == null)
    return;
  //Write custom code when the user changes the active record.
      :
      :

private async void ActiveRecordEventMethod(ParcelRecordEventArgs e)
{
  var theNewActiveRecord = e.IncomingActiveRecord;
  var newRecName = theNewActiveRecord?.Name;

  var thePreviousActiveRecord = e.OutgoingActiveRecord;
  var prevRecName = thePreviousActiveRecord?.Name;

  if (newRecName == null && prevRecName == null)
    return;
  //Get the active map view
  var mapView = MapView.Active;
  if (mapView?.Map == null)
    return;

  //Get the fabric
  var fabricLyr = 
    mapView.Map.GetLayersAsFlattenedList().OfType<ParcelLayer>().FirstOrDefault();
  if (fabricLyr == null)
    return;

  //get the Records layer
  var recordsLyr = fabricLyr.GetRecordsLayerAsync().Result.FirstOrDefault();
  if (recordsLyr == null)
    return;

  if (theNewActiveRecord == null)
    return;

  List<long> lst = new ();
  lst.Add(theNewActiveRecord.ObjectID);
  var QueryFilter = new QueryFilter { ObjectIDs = lst.ToArray() };
  var cim_g2g = await mapView.Map.GetGroundToGridCorrection();
  // CIM for ground to grid is null for new maps, 
  // so initialize it for the first time here if needed.
  if (cim_g2g == null)
    cim_g2g = new CIMGroundToGridCorrection(); 

  object oScaleFactor = null;
  object oDirectionOffset = null;
  using RowCursor rowCursor = recordsLyr.Search(QueryFilter);
  while (rowCursor.MoveNext()) //should only be one record
  {
    //changing the G2G settings
    var iFldDistanceFactor = rowCursor.FindField("distancefactor");
    var iFldDirectionOffset = rowCursor.FindField("directionoffset");

    if (iFldDistanceFactor == -1 && iFldDirectionOffset == -1)
      return;

    using Row rowRec = rowCursor.Current;
    if (iFldDistanceFactor != -1)
    {
      oScaleFactor = rowRec[iFldDistanceFactor];
      if (oScaleFactor != null)
      {
        cim_g2g.ConstantScaleFactor = Convert.ToDouble(oScaleFactor);
        cim_g2g.Enabled = true;
        cim_g2g.UseScale = true;
        cim_g2g.ScaleType = GroundToGridScaleType.ConstantFactor;
      }
      else
        cim_g2g.UseScale = false;
    }
    if (iFldDirectionOffset != -1)
    {
      oDirectionOffset = rowRec[iFldDirectionOffset];
      if (oDirectionOffset != null)
      {
        cim_g2g.Direction = Convert.ToDouble(oDirectionOffset);
        // store and set this in decimal degrees, irrespective of project unit settings
        cim_g2g.Enabled = true;
        cim_g2g.UseDirection = true;
      }
      else
        cim_g2g.UseDirection = false;
    }
  }
  if (oScaleFactor == null && oDirectionOffset == null)
    return;//if both direction offset and scale are null, do nothing

  await mapView.Map.SetGroundToGridCorrection(cim_g2g);
}

string errorMessage = await QueuedTask.Run( async () =>
{
  var lic = ArcGIS.Core.Licensing.LicenseInformation.Level;
  if (lic < ArcGIS.Core.Licensing.LicenseLevels.Standard)
    return "Insufficient License Level.";
  //make sure there is a fabric and an active record
  var myParcelFabricLayer =
    MapView.Active.Map.GetLayersAsFlattenedList().OfType<ParcelLayer>().FirstOrDefault();
  if (myParcelFabricLayer == null)
    return "Please select a parcel fabric layer in the table of contents.";
  try
  {
    var pRec = myParcelFabricLayer.GetActiveRecord();
    if (pRec == null)
      return "There is no Active Record. Please set the active record and try again.";
    var pointLyrEnum = await myParcelFabricLayer.GetPointsLayerAsync();
    if (pointLyrEnum.Count() == 0)
      return "No point layer found.";
    var pointLyr = pointLyrEnum.FirstOrDefault();
    Dictionary<string, object> PointAttributes = new Dictionary<string, object>();
    //using center of the map extent as the new point for purposes of this example
    var newPoint = MapView.Active.Extent.Center; 
    if (newPoint == null)
      return "";
    PointAttributes.Add("Name", "MyTestPoint");
    PointAttributes.Add("IsFixed", 1);
    var editOper = new EditOperation()
    {
      Name = "Create a test parcel fabric point",
      ProgressMessage = "Create a test parcel fabric point...",
      ShowModalMessageAfterFailure = true,
      SelectNewFeatures = true,
      SelectModifiedFeatures = false
    };
    editOper.Create(pointLyr, newPoint, PointAttributes);
    if (!editOper.Execute())
      return editOper.ErrorMessage;
  }
  catch (Exception ex)
  {
    errorMessage=ex.Message;
  }
  return "";
});
if (!string.IsNullOrEmpty(errorMessage))
  MessageBox.Show(errorMessage, "Add Control Point");

var opMerge = new EditOperation()
{
  Name = "Merge",
  ProgressMessage = "Merging parcels...",
  ShowModalMessageAfterFailure = true,
  SelectNewFeatures = true,
  SelectModifiedFeatures = false
};
opMerge.Merge(featLyrTarget, featLyrSource, featLyrSource.GetSelection().GetObjectIDs());
opMerge.Execute();

editOper.CopyLineFeaturesToParcelType(srcStandardLineFeatureLayer, StandardLineObjectIds, 
              destParcelTypeLineLayer, destParcelTypePolygonLayer);
editOper.Execute();

var ids = new List<long>(srcParcelFeatLyr.GetSelection().GetObjectIDs());
if (ids.Count == 0)
  return "No selected parcels found. Please select parcels and try again.";
var sourceParcFeats = new Dictionary<MapMember, List<long>>();
sourceParcFeats.Add(srcParcelFeatLyr, ids);
var editOper = new EditOperation();
editOper.CopyParcelLinesToParcelType(myParcelFabricLayer, SelectionSet.FromDictionary(sourceParcFeats),
    destLineL, destPolygonL, true,false,true);

var myParcelFabricLayer = 
  MapView.Active.Map.GetLayersAsFlattenedList().OfType<ParcelLayer>().FirstOrDefault();
if (myParcelFabricLayer == null)
{
  MessageBox.Show("Please add a parcel fabric to the map.", "Create Parcel Seeds");
  return;
}
string errorMessage = await QueuedTask.Run( async () =>
{
  try
  {
      var pRec = myParcelFabricLayer.GetActiveRecord();
      if (pRec == null)
        return "There is no Active Record. Please set the active record and try again.";
      var guid = pRec.Guid;
      var editOper = new EditOperation()
      {
        Name = "Create Parcel Seeds",
        ProgressMessage = "Create Parcel Seeds...",
        ShowModalMessageAfterFailure = true,
        SelectNewFeatures = true,
        SelectModifiedFeatures = false
      };
    List<FeatureLayer> parcelLayers = new List<FeatureLayer>();
    List<string> sParcelTypes = new List<string> { "Tax", "Lot" };
    foreach (string sParcTyp in sParcelTypes)
    {
      IEnumerable<FeatureLayer> lyrs = 
          await myParcelFabricLayer.GetParcelPolygonLayerByTypeNameAsync(sParcTyp);
      parcelLayers.Add(lyrs.FirstOrDefault());
      lyrs = await myParcelFabricLayer.GetParcelLineLayerByTypeNameAsync(sParcTyp);
      parcelLayers.Add(lyrs.FirstOrDefault());
    }
    editOper.CreateParcelSeedsByRecord(myParcelFabricLayer, guid, MapView.Active.Extent, parcelLayers);
    if (!editOper.Execute())
      return editOper.ErrorMessage;
  }
  catch (Exception ex)
  {
    return ex.Message;
  }
  return "";
});
if (!string.IsNullOrEmpty(errorMessage))
  MessageBox.Show(errorMessage, "Create Parcel Seeds");

await QueuedTask.Run( () =>
{
  var myParcelFabricLayer =
     MapView.Active.Map.GetLayersAsFlattenedList().OfType<ParcelLayer>().FirstOrDefault();
  if (myParcelFabricLayer == null)
    return;
  try
  {
    var theActiveRecord = myParcelFabricLayer.GetActiveRecord();
    var guid = theActiveRecord.Guid;
    var editOper = new EditOperation()
    {
      Name = "Build Parcels",
      ProgressMessage = "Build Parcels...",
      ShowModalMessageAfterFailure = true,
      SelectNewFeatures = true,
      SelectModifiedFeatures = true
    };
    editOper.BuildParcelsByRecord(myParcelFabricLayer, guid);
    editOper.Execute();
  }
  catch
  {
    return;
  }
});

var myParcelFabricLayer = 
  MapView.Active.Map.GetLayersAsFlattenedList().OfType<ParcelLayer>().FirstOrDefault();
if (myParcelFabricLayer == null)
{
  MessageBox.Show("Please add a parcel fabric to the map.", "Duplicate Parcels");
  return;
}
string sTargetParcelType = "Tax";
string errorMessage = await QueuedTask.Run( async () =>
{
  try
  {
    //get the feature layer that's selected in the table of contents
    var sourceParcelTypePolygonLayer = 
      MapView.Active.GetSelectedLayers().OfType<FeatureLayer>().FirstOrDefault();
    string parcelPolygonType = sourceParcelTypePolygonLayer.Name; //assumes layer name matches parcel type name 
    var ids = new List<long>(sourceParcelTypePolygonLayer.GetSelection().GetObjectIDs());
    if (ids.Count == 0)
      return "No selected " + parcelPolygonType + " parcels found. Please select parcels and try again.";
    var targetFeatLyrEnum = await myParcelFabricLayer.GetParcelPolygonLayerByTypeNameAsync(sTargetParcelType);
    if (targetFeatLyrEnum.Count()== 0)
      return "No parcel type " + sTargetParcelType + " found.";
    var targetFeatLyr = targetFeatLyrEnum.FirstOrDefault();
    if (targetFeatLyr == null)
      return "";
    var sourceParcFeats = new Dictionary<MapMember, List<long>>();
    sourceParcFeats.Add(sourceParcelTypePolygonLayer, ids);
    var pRec = myParcelFabricLayer.GetActiveRecord();
    if (pRec == null)
      return "There is no Active Record. Please set the active record and try again.";
    var editOper = new EditOperation()
    {
      Name = "Duplicate Parcels",
      ProgressMessage = "Duplicate Parcels...",
      ShowModalMessageAfterFailure = true,
      SelectNewFeatures = true,
      SelectModifiedFeatures = false
    };
    editOper.DuplicateParcels(myParcelFabricLayer, SelectionSet.FromDictionary(sourceParcFeats), pRec, targetFeatLyr);
    if (!editOper.Execute())
      return editOper.ErrorMessage;
  }
  catch (Exception ex)
  {
    return ex.Message;
  }
  return "";
});
if (!string.IsNullOrEmpty(errorMessage))
  MessageBox.Show(errorMessage, "Duplicate Parcels");

var myParcelFabricLayer =
  MapView.Active.Map.GetLayersAsFlattenedList().OfType<ParcelLayer>().FirstOrDefault();
if (myParcelFabricLayer == null)
  MessageBox.Show("Please select a parcel fabric layer in the table of contents.","Assign Features To Record");
string errorMessage = await QueuedTask.Run( async () =>
{
  //check for selected layer
  if (MapView.Active.GetSelectedLayers().Count == 0)
    return "Please select a source feature layer in the table of contents.";
  //get the feature layer that's selected in the table of contents
  var srcFeatLyr = MapView.Active.GetSelectedLayers().OfType<FeatureLayer>().FirstOrDefault();
  bool bIsControlledByFabric = await srcFeatLyr.IsControlledByParcelFabric(ParcelFabricType.ParcelFabric);
  if (!bIsControlledByFabric)
    return "Please select a parcel fabric layer in the table of contents.";
  try
  {
    var pRec = myParcelFabricLayer.GetActiveRecord();
    if (pRec == null)
      return "There is no Active Record. Please set the active record and try again.";
    var ids = new List<long>(srcFeatLyr.GetSelection().GetObjectIDs());
    // ------- get the selected parcels ---------
    var sourceParcFeats = new Dictionary<MapMember, List<long>>();
    sourceParcFeats.Add(srcFeatLyr, ids);
    var editOper = new EditOperation()
    {
      Name = "Assign Features to Record",
      ProgressMessage = "Assign Features to Record...",
      ShowModalMessageAfterFailure = true,
      SelectNewFeatures = true,
      SelectModifiedFeatures = false
    };
    editOper.AssignFeaturesToRecord(myParcelFabricLayer, 
      SelectionSet.FromDictionary(sourceParcFeats), pRec);
    if (!editOper.Execute())
      return editOper.ErrorMessage;
  }
  catch (Exception ex)
  {
    errorMessage= ex.Message;
  }
  return "";
});
if (!string.IsNullOrEmpty(errorMessage))
  MessageBox.Show(errorMessage, "Assign Features To Record");

var myParcelFabricLayer = 
  MapView.Active.Map.GetLayersAsFlattenedList().OfType<ParcelLayer>().FirstOrDefault();
if (myParcelFabricLayer == null)
{
  System.Windows.MessageBox.Show("There is no parcel layer in the map.", "Set Parcels Historic");
  return;
}
string errorMessage = await QueuedTask.Run( async () =>
{
  try
  {
    FeatureLayer destPolygonL = null;
    //test to make sure the layer is a parcel type, is non-historic, and has a selection
    bool bFound = false;
    var ParcelTypesEnum = await myParcelFabricLayer.GetParcelTypeNames();
    foreach (FeatureLayer mapFeatLyr in 
      MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>())
    { 
      foreach (string ParcelType in ParcelTypesEnum)
      {
        var layerEnum = await myParcelFabricLayer.GetParcelPolygonLayerByTypeName(ParcelType);
        foreach (FeatureLayer flyr in layerEnum)
        {
          if (flyr == mapFeatLyr)
          {
            bFound = mapFeatLyr.SelectionCount > 0;
            destPolygonL = mapFeatLyr;
            break;
          }
        }
        if (bFound) break;
      }
      if (bFound) break;
    }
    if (!bFound)
      return "Please select parcels to set as historic.";
    var theActiveRecord = myParcelFabricLayer.GetActiveRecord();
    if (theActiveRecord == null)
      return "There is no Active Record. Please set the active record and try again.";

    var ids = new List<long>(destPolygonL.GetSelection().GetObjectIDs()); 
    var sourceParcFeats = new Dictionary<MapMember, List<long>>();
    sourceParcFeats.Add(destPolygonL, ids);
    var editOper = new EditOperation()
    {
      Name = "Set Parcels Historic",
      ProgressMessage = "Set Parcels Historic...",
      ShowModalMessageAfterFailure = true,
      SelectNewFeatures = true,
      SelectModifiedFeatures = false
    };
    editOper.SetParcelHistoryRetired(myParcelFabricLayer, SelectionSet.FromDictionary(sourceParcFeats),
      theActiveRecord);
    if (!editOper.Execute())
      return editOper.ErrorMessage;
  }
  catch (Exception ex)
  {
    return ex.Message;
  }
  return "";
});
if (!string.IsNullOrEmpty(errorMessage))
  MessageBox.Show(errorMessage, "Set Parcels Historic");

var myParcelFabricLayer = 
  MapView.Active.Map.GetLayersAsFlattenedList().OfType<ParcelLayer>().FirstOrDefault();
if (myParcelFabricLayer == null)
{
  MessageBox.Show("Please add a parcel fabric to the map.", "Change Parcel Type");
  return;
}
string sSourceParcelType = "Tax";
string sTargetParcelType = "Lot";
string errorMessage = await QueuedTask.Run( async () =>
{
  try
  {
    var sourcePolygonLotTypeEnum = 
      await myParcelFabricLayer.GetParcelPolygonLayerByTypeName(sSourceParcelType);
    var sourcePolygonLotTypeLayer = sourcePolygonLotTypeEnum.FirstOrDefault();
    Dictionary<string, object> RecordAttributes = new Dictionary<string, object>();
    var recordsLayerEnum = 
      await myParcelFabricLayer.GetRecordsLayerAsync();
    var recordsLayer = recordsLayerEnum.FirstOrDefault();
    var targetParcelTypeFeatLyrEnum = 
      await myParcelFabricLayer.GetParcelPolygonLayerByTypeName(sTargetParcelType);
    var targetParcelTypeFeatLyr = targetParcelTypeFeatLyrEnum.FirstOrDefault();
    if (myParcelFabricLayer == null || sourcePolygonLotTypeLayer == null)
      return "";
    var ids = new List<long>(sourcePolygonLotTypeLayer.GetSelection().GetObjectIDs());
    var sourceParcFeats = new Dictionary<MapMember, List<long>>();
    sourceParcFeats.Add(sourcePolygonLotTypeLayer, ids);
    var opCpToPT = new EditOperation()
    {
      Name = "Change Parcel Type",
      ProgressMessage = "Change Parcel Type...",
      ShowModalMessageAfterFailure = true,
      SelectNewFeatures = true,
      SelectModifiedFeatures = false
    };
    opCpToPT.ChangeParcelType(myParcelFabricLayer, SelectionSet.FromDictionary(sourceParcFeats),
      targetParcelTypeFeatLyr);
    if (!opCpToPT.Execute())
      return opCpToPT.ErrorMessage;
  }
  catch (Exception ex)
  {
    return ex.Message;
  }
  return "";
});
if (!string.IsNullOrEmpty(errorMessage))
  MessageBox.Show(errorMessage, "Change Parcel Type");

string errorMessage = await QueuedTask.Run( async () =>
{
  var myParcelFabricLayer = 
    MapView.Active.Map.GetLayersAsFlattenedList().OfType<ParcelLayer>().FirstOrDefault();
  if (myParcelFabricLayer == null)
    return "Please add a parcel fabric to the map.";
  try
  {
    FeatureLayer parcelPolygonLyr = null;
    //find the first layer that is a polygon parcel type, is non-historic, and has a selection
    bool bFound = false;
    var ParcelTypesEnum = await myParcelFabricLayer.GetParcelTypeNames();
    foreach (FeatureLayer mapFeatLyr in 
      MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>())
    {
      foreach (string ParcelType in ParcelTypesEnum)
      {
        var layerEnum = await myParcelFabricLayer.GetParcelPolygonLayerByTypeName(ParcelType);
        foreach (FeatureLayer flyr in layerEnum)
        {
          if (flyr == mapFeatLyr)
          {
            bFound = mapFeatLyr.SelectionCount > 0;
            parcelPolygonLyr = mapFeatLyr;
            break;
          }
        }
        if (bFound) break;
      }
      if (bFound) break;
    }
    if (!bFound)
      return "Please select parcels to shrink to seeds.";
    var editOper = new EditOperation()
    {
      Name = "Shrink Parcels To Seeds",
      ProgressMessage = "Shrink Parcels To Seeds...",
      ShowModalMessageAfterFailure = true,
      SelectNewFeatures = true,
      SelectModifiedFeatures = false
    };
    var ids = new List<long>(parcelPolygonLyr.GetSelection().GetObjectIDs());
    var sourceParcFeats = new Dictionary<MapMember, List<long>>();
    sourceParcFeats.Add(sourcePolygonLotTypeLayer, ids);
    editOper.ShrinkParcelsToSeeds(myParcelFabricLayer, SelectionSet.FromDictionary(sourceParcFeats));
    if (!editOper.Execute())
      return editOper.ErrorMessage;
  }
  catch (Exception ex)
  {
    return ex.Message;
  }
  return "";
});
if (!string.IsNullOrEmpty(errorMessage))
  MessageBox.Show(errorMessage, "Shrink Parcels To Seeds");

protected async override void OnClick()
{
  var myParcelFabricLayer =
    MapView.Active.Map.GetLayersAsFlattenedList().OfType<ParcelLayer>().FirstOrDefault();
  if (myParcelFabricLayer == null)
  {
    MessageBox.Show("Please add a parcel fabric to the map.", 
      "Reconstruct from Seeds");
    return;
  }

  string sReportResult = "";
  string errorMessage = await QueuedTask.Run(async () =>
  {
    var editOper = new EditOperation()
    {
      Name = "Reconstruct from Seeds",
      ProgressMessage = "Reconstruct from Seeds ...",
      ShowModalMessageAfterFailure = true,
      SelectNewFeatures = true,
      SelectModifiedFeatures = false
    };

    try
    {
      List<FeatureLayer> parcelLayers = new();
      List<string> sParcelTypes = new List<string> { "Tax", "Lot" };
      foreach (string sParcTyp in sParcelTypes)
      {
        IEnumerable<FeatureLayer> lyrs =
          await myParcelFabricLayer.GetParcelPolygonLayerByTypeNameAsync(sParcTyp);
        parcelLayers.Add(lyrs.FirstOrDefault());
        lyrs = await myParcelFabricLayer.GetParcelLineLayerByTypeNameAsync(sParcTyp);
        parcelLayers.Add(lyrs.FirstOrDefault());
      }
      IEnumerable<FeatureLayer> ptLyrs = await myParcelFabricLayer.GetPointsLayerAsync();
      parcelLayers.Add(ptLyrs.FirstOrDefault());
      ParcelEditToken peToken = null;

      peToken = editOper.ReconstructParcelsFromSeeds(myParcelFabricLayer, 
        MapView.Active.Extent.Expand(2.0,2.0,true), parcelLayers);

      if (!editOper.Execute())
      {
        return editOper.ErrorMessage;
      }
      SelectionSet FeatSetCreated = null;
      SelectionSet FeatSetModified = null;
      if (peToken != null)
      {
        FeatSetCreated = peToken.CreatedFeatures;
        FeatSetModified = peToken.ModifiedFeatures;
      }

      var editOperation2 = editOper.CreateChainedOperation();
      sReportResult = "";
      Dictionary<string, object> ParcelAttributes = new Dictionary<string, object>();
      if (FeatSetModified != null)
      {
        foreach (var kvp in FeatSetModified.ToDictionary())
        {
          foreach (long oid in kvp.Value)
          {//uncomment the next 3 lines to apply this example edit:
            //ParcelAttributes.Add("Name", "My" + kvp.Key.Name + " " + oid.ToString());
            //editOperation2.Modify(kvp.Key, oid, ParcelAttributes);
            //ParcelAttributes.Clear();
          }
          sReportResult += "There were " + kvp.Value.Count().ToString() + " " + kvp.Key.Name +
          " features modified." + Environment.NewLine;
        }
      }

      if (FeatSetCreated != null)
      {
        foreach (var kvp in FeatSetCreated.ToDictionary())
        {
          foreach (long oid in kvp.Value)
          {//uncomment the next 3 lines to apply this example edit:
            //ParcelAttributes.Add("Name", "My" + kvp.Key.Name + " " + oid.ToString());
            //editOperation2.Modify(kvp.Key, oid, ParcelAttributes);
            //ParcelAttributes.Clear();
          }
          sReportResult += "There were " + kvp.Value.Count().ToString() + " new " + kvp.Key.Name +
            " features created." + Environment.NewLine;
        }
      }
      if (!editOperation2.IsEmpty)
      {
        if (!editOperation2.Execute())
          return editOperation2.ErrorMessage;
      }
    }
    catch (Exception ex)
    {
      return ex.Message; 
    }
    return "";
  });
  if (!string.IsNullOrEmpty(errorMessage))
    MessageBox.Show(errorMessage, "Reconstruct from Seeds");
  else if (!string.IsNullOrEmpty(sReportResult))
    MessageBox.Show(sReportResult, "Reconstruct from Seeds");
}

await QueuedTask.Run( () =>
{
  // check for selected layer
  if (MapView.Active.GetSelectedLayers().Count == 0)
  {
    MessageBox.Show("Please select a source feature layer in the table of contents", "Delete Parcel");
    return;
  }
  //first get the feature layer that's selected in the table of contents
  var theParcelFeatLyr = MapView.Active.GetSelectedLayers().OfType<FeatureLayer>().First();
  if (theParcelFeatLyr == null)
    return;
  var ids = new List<long>(theParcelFeatLyr.GetSelection().GetObjectIDs());
  if (ids.Count == 0)
    return;
  try
  {
    var editOper = new EditOperation()
    {
      Name = "Delete Parcels",
      ProgressMessage = "Delete Parcels...",
      ShowModalMessageAfterFailure = true,
      SelectNewFeatures = false,
      SelectModifiedFeatures = false
    };
    editOper.DeleteParcels(theParcelFeatLyr, ids);
    editOper.Execute();
  }
  catch
  {
    return;
  }
});

editOper.BuildParcelsByRecord(myParcelFabricLayer, guid);

var peToken = editOper.BuildParcelsByRecord(myParcelFabricLayer, guid, parcelLayers);

var MyParcelEditToken = editOper.BuildParcelsByRecord(myParcelFabricLayer, guid, parcelLayers)

editOper.Execute();
var FeatSetCreated = MyParcelEditToken.CreatedFeatures;
var FeatSetModified = MyParcelEditToken.ModifiedFeatures;

var editOperation2 = editOper.CreateChainedOperation();
string sReportResult="";
Dictionary<string, object> ParcelAttributes = new Dictionary<string, object>();
foreach (KeyValuePair<MapMember, List<long>> kvp in FeatSetModified.ToDictionary())
{
  foreach (long oid in kvp.Value)
  {
    ParcelAttributes.Add("Name", "My" + kvp.Key.Name + " " + oid.ToString());
    editOperation2.Modify(kvp.Key, oid, ParcelAttributes);
    ParcelAttributes.Clear();
  }
  sReportResult += "There were " + kvp.Value.Count().ToString() + " " + kvp.Key.Name + " features modified." +
      Environment.NewLine;
}
foreach (KeyValuePair<MapMember, List<long>> kvp in FeatSetCreated.ToDictionary())
{
  foreach (long oid in kvp.Value)
  {
    //Do things with the created features
  }
  sReportResult += "There were " + kvp.Value.Count().ToString() + " new " + kvp.Key.Name + " features created." +
      Environment.NewLine;
}
if ( editOperation2.Execute())
  return sReportResult;

protected async override void OnClick()
{
  string sReportResult = "Polygon Information --" + Environment.NewLine;
  string sParcelTypeName = "tax";
  string errorMessage = await QueuedTask.Run(async () =>
  {
    var myParcelFabricLayer =
      MapView.Active.Map.GetLayersAsFlattenedList().OfType<ParcelLayer>().FirstOrDefault();
    //if there is no fabric in the map then bail
    if (myParcelFabricLayer == null)
      return "There is no fabric layer in the map.";

    //first get the parcel type feature layer
    var featSrcLyr = myParcelFabricLayer.GetParcelPolygonLayerByTypeNameAsync(sParcelTypeName).Result.FirstOrDefault();

    if (featSrcLyr.SelectionCount == 0)
      return "There is no selection on the " + sParcelTypeName + " layer.";

    sReportResult += " Parcel Type: " + sParcelTypeName + Environment.NewLine;
    sReportResult += " Poygons: " + featSrcLyr.SelectionCount + Environment.NewLine + Environment.NewLine;

    try
    {
      // ------- get the selected parcels ---------
      var ids = new List<long>((featSrcLyr as FeatureLayer).GetSelection().GetObjectIDs());
      var sourceParcFeats = new Dictionary<MapMember, List<long>>();
      sourceParcFeats.Add(featSrcLyr, ids);
      //---------------------------------------------
      ParcelFeatures parcFeatures =
        await myParcelFabricLayer.GetParcelFeaturesAsync(SelectionSet.FromDictionary(sourceParcFeats));
      //since we know that we want to report on Tax lines only, and for this functionality 
      // we can use any of the Tax line layer instances (if there happens to be more than one)
      // we can get the first instance as follows
      FeatureLayer myLineFeatureLyr =
          myParcelFabricLayer.GetParcelLineLayerByTypeName(sParcelTypeName).Result.FirstOrDefault();
      if (myLineFeatureLyr == null)
        return sParcelTypeName + " line layer not found";

      FeatureLayer myPointFeatureLyr =
          myParcelFabricLayer.GetPointsLayerAsync().Result.FirstOrDefault();
      if (myPointFeatureLyr == null)
        return "fabric point layer not found";

      var LineInfo = parcFeatures.Lines; //then get the line information from the parcel features object

      //... and then do some work for each of the lines
      int iRadiusAttributeCnt = 0;
      int iDistanceAttributeCnt = 0;
      sReportResult += "Line Information --";
      foreach (KeyValuePair<string, List<long>> kvp in LineInfo)
      {
        if (kvp.Key.ToLower() != sParcelTypeName)
          continue; // ignore any other lines from different parcel types

        foreach (long oid in kvp.Value)
        {
          var insp = myLineFeatureLyr.Inspect(oid);
          var dRadius = insp["RADIUS"];
          var dDistance = insp["DISTANCE"];

          if (dRadius != DBNull.Value)
            iRadiusAttributeCnt++;
          if (dDistance != DBNull.Value)
            iDistanceAttributeCnt++;
          //Polyline poly = (Polyline)insp["SHAPE"];
        }
        sReportResult += Environment.NewLine + " Distance attributes: " + iDistanceAttributeCnt.ToString();
        sReportResult += Environment.NewLine + " Radius attributes: " +  iRadiusAttributeCnt.ToString();
      }

      var PointInfo = parcFeatures.Points; //get the point information from the parcel features object

      //... and then do some work for each of the points
      sReportResult += Environment.NewLine + Environment.NewLine + "Point Information --";
      int iFixedPointCnt = 0;
      int iNonFixedPointCnt = 0;
      foreach (long oid in PointInfo)
      {
        var insp = myPointFeatureLyr.Inspect(oid);
        var isFixed = insp["ISFIXED"];
        if (isFixed == DBNull.Value || (int)isFixed == 0)
          iNonFixedPointCnt++;
        else
          iFixedPointCnt++;
        // var pt = insp["SHAPE"];

      }
      sReportResult += Environment.NewLine + " Fixed Points: " + iFixedPointCnt.ToString();
      sReportResult += Environment.NewLine + " Non-Fixed Points: " + iNonFixedPointCnt.ToString();
    }
    catch (Exception ex)
    {
      return ex.Message;
    }
    return "";
  });
  if (!string.IsNullOrEmpty(errorMessage))
    MessageBox.Show(errorMessage, "Get Parcel Features");
  else
    MessageBox.Show(sReportResult, "Get Parcel Features");
}

ParcelEdgeCollection myEdgeCollection = await 
   myParcelFabricLayer.GetSequencedParcelEdgeInfoAsync(MyPolygonLyr, myParceloid, pointOfBeginning);

  public enum ParcelLineToEdgeRelationship
  {
    StartVertexOnAnEdge = 1,
    EndVertexOnAnEdge = 2,
    StartVertexMatchesAnEdgeEnd = 4,
    EndVertexMatchesAnEdgeEnd = 8,
    BothVerticesMatchAnEdgeEnd = 16,
    NoEndVerticesTouchAnEdge = 32,
    All = -1
  }

foreach (var edge in myEdgeCollection.Edges)
{
  sReportResult += "Edge: " + edge.EdgeId.ToString() + " Geometry: ";
  sReportResult += edge.EdgeGeometry == null ? "NULL\n\n" : edge.EdgeGeometry.Length.ToString("F2") + " Length\n\n";
  foreach (var myLineInfo in edge.Lines)
  {
    sReportResult += "*Line-OID:" + myLineInfo.ObjectID;
    sReportResult += "\nFromPnt:" + ListToString(myLineInfo.FromPointObjectID);
    sReportResult += " ToPnt:" + ListToString(myLineInfo.ToPointObjectID);
    sReportResult += "\nRecord:" + myLineInfo.RecordGUID.ToString();
    sReportResult += "\nEdge IDs:" + ListToString(myLineInfo.EdgeId);
    sReportResult += "\nRelation:" + myLineInfo.EdgeRelationship.ToString();
    sReportResult += "\nReversed:" + myLineInfo.IsReversed;
    sReportResult += " Closing:" + myLineInfo.IsClosing;
    sReportResult += " NextCon:" + myLineInfo.HasNextLineConnectivity;
    sReportResult += " PrevCon:" + myLineInfo.HasPreviousLineConnectivity;
    sReportResult += "\nStart:" + myLineInfo.StartPositionOnParcelEdge.ToString("F2");
    sReportResult += " End:" + myLineInfo.EndPositionOnParcelEdge.ToString("F2");
    sReportResult += "\nAttributes:" + (myLineInfo.FeatureAttributes == null ? "NULL" : myLineInfo.FeatureAttributes.Count.ToString());
    sReportResult += "\nGeometry:" + (myLineInfo.FeatureGeometry == null ? "NULL" : myLineInfo.FeatureGeometry.Length.ToString("F2") + " Length");
    sReportResult += "\n\n";
  }
}

private static string ListToString<T>(IReadOnlyList<T> ids)
{
  string ret = "";
  foreach (var id in ids)
  {
    if (ret.Count() > 0)
      ret += ",";
    ret += id;
  }
  return ret;
}

.
.
.
#Edge:2 Geometry: 100.19 Length

*Line-OID:16753
FromPnt:10548 ToPnt:10546
Edge IDs:2
Relation:BothVerticesMatchAnEdgeEnd
Reversed:False Closing:False NextCon:False PrevCon:True
Start:0.00 End:1.00
Attributes:29
Geometry:100.19 Length

#Edge:3 Geometry: 29.11 Length

*Line-OID:16751
FromPnt:10550 ToPnt:10551
Edge IDs:3,4,5,6,7,8,9,10,11,12,13,14
Relation:NoEndVerticesTouchAnEdge
Reversed:True Closing:False NextCon:False PrevCon:False
Start:8.59 End:-1.75
Attributes:18
Geometry:363.19 Length

#Edge:4 Geometry: 18.51 Length

*Line-OID:16751
FromPnt:10550 ToPnt:10551
Edge IDs:3,4,5,6,7,8,9,10,11,12,13,14
Relation:NoEndVerticesTouchAnEdge
Reversed:True Closing:False NextCon:False PrevCon:False
Start:13.81 End:-3.22
Attributes:18
Geometry:363.19 Length
.
.
.

ParcelEdgeCollection parcelEdgeCollection = await
  myParcelFabricLayer.GetSequencedParcelEdgeInfoAsync(myPolygonLayer, oid, null, ParcelLineToEdgeRelationship.BothVerticesMatchAnEdgeEnd);

ParcelEdgeCollection parcelEdgeCollection =
  await myParcelFabricLayer.GetSequencedParcelEdgeInfoAsync(myPolygonLayer, oid, null);
  //get the point layer
  var pointLyrEnum = await myParcelFabricLayer.GetPointsLayerAsync();
  if (pointLyrEnum.Count() == 0)
    return "No point layer found.";
  var myPointLyr = pointLyrEnum.FirstOrDefault();

  foreach (var myPoint in parcelEdgeCollection.Points)
  {
    var id = (myPointLyr.Inspect(myPoint).ObjectID).ToString();
    var x = (myPointLyr.Inspect(myPoint).Shape as MapPoint).X.ToString("F2");
    var y = (myPointLyr.Inspect(myPoint).Shape as MapPoint).Y.ToString("F2");
    sReportResult += id + ", X: " + x;
    sReportResult += ", Y: " + y + "\n";
  }

parcelEdgeCollection = await myParcelFabricLayer.GetSequencedParcelEdgeInfoAsync(MyParcelPolygonLayer,
                  MyParcelOID, null, offsetTolerance, ParcelLineToEdgeRelationship.All);

object[] parcelTraverseInfo;
bool isClosedloop = false;
bool allLinesHaveCogo = false;
if (!ParcelEdgeAnalysis(parcelEdgeCollection, out isClosedloop, out allLinesHaveCogo,
   out parcelTraverseInfo))
  MessageBox.Show("No traverse available.");
if (isClosedloop && allLinesHaveCogo)
  MessageBox.Show("Lines form a closed loop, and there is enough COGO information to calculate misclose.");
else if (isClosedloop && !allLinesHaveCogo)
  MessageBox.Show("Lines form a closed loop, but there is not enough COGO information to calculate misclose.");
else if (!isClosedloop && allLinesHaveCogo)
  MessageBox.Show("All lines found have COGO information, but they do not form a closed loop.");
else if (!isClosedloop && !allLinesHaveCogo)
  MessageBox.Show("Lines do not form a closed loop, and one or more lines are missing COGO information.");