public static Task<List<FeatureLayer>> GetParcelLineLayerByTypeNameAsync( 
   ParcelLayer parcelLayer,
   string typeName
)

{
   string errorMessage = await QueuedTask.Run(async () =>
{
  // check for selected layer
  if (MapView.Active.GetSelectedLayers().Count == 0)
    return "Please select a target parcel polygon layer in the table of contents.";
  //get the feature layer that's selected in the table of contents
  var destPolygonL = MapView.Active.GetSelectedLayers().OfType<FeatureLayer>().FirstOrDefault();
  try
  {
    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 in the map.";
    var pRec = myParcelFabricLayer.GetActiveRecord();
    if (pRec == null)
      return "There is no Active Record. Please set the active record and try again.";
    string ParcelTypeName = "";
    IEnumerable<string> parcelTypeNames = await myParcelFabricLayer.GetParcelTypeNamesAsync();
    foreach (string parcelTypeNm in parcelTypeNames)
    {
      var polygonLyrParcelTypeEnum = await myParcelFabricLayer.GetParcelPolygonLayerByTypeNameAsync(parcelTypeNm);
      foreach (FeatureLayer lyr in polygonLyrParcelTypeEnum)
        if (lyr == destPolygonL)
        {
          ParcelTypeName = parcelTypeNm;
          break;
        }
    }
    if (String.IsNullOrEmpty(ParcelTypeName))
      return "Please select a target parcel polygon layer in the table of contents.";
    var srcFeatLyr = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault(l => l.Name.Contains("MySourceLines") && l.IsVisible);
    if (srcFeatLyr == null)
      return "Looking for a layer named 'MySourceLines' in the table of contents.";
    //now get the line layer for this parcel type
    var destLineLyrEnum = await myParcelFabricLayer.GetParcelLineLayerByTypeNameAsync(ParcelTypeName);
    if (destLineLyrEnum.Count == 0) //make sure there is one in the map
      return ParcelTypeName + " not found.";
    var destLineL = destLineLyrEnum.FirstOrDefault();
    if (destLineL == null || destPolygonL == null)
      return "";
    var editOper = new EditOperation()
    {
      Name = "Copy Line Features To Parcel Type",
      ProgressMessage = "Copy Line Features To Parcel Type...",
      ShowModalMessageAfterFailure = true,
      SelectNewFeatures = true,
      SelectModifiedFeatures = false
    };
    var ids = new List<long>((srcFeatLyr as FeatureLayer).GetSelection().GetObjectIDs());
    if (ids.Count == 0)
      return "No selected lines were found. Please select line features and try again.";
    editOper.CopyLineFeaturesToParcelType(srcFeatLyr, ids, destLineL, destPolygonL);
    if (!editOper.Execute())
      return editOper.ErrorMessage;
  }
  catch (Exception ex)
  {
    return ex.Message;
  }
  return "";
});
   if (!string.IsNullOrEmpty(errorMessage))
     MessageBox.Show(errorMessage, "Copy Line Features To Parcel Type.");
 }

{
  string errorMessage = await QueuedTask.Run(async () =>
 {
   // check for selected layer
   if (MapView.Active.GetSelectedLayers().Count == 0)
     return "Please select a source parcel polygon feature layer in the table of contents.";
   try
   {
     var myParcelFabricLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<ParcelLayer>().FirstOrDefault();
     if (myParcelFabricLayer == null)
       return "No parcel layer found in the map.";

     //get the feature layer that's selected in the table of contents
     var srcParcelFeatLyr = MapView.Active.GetSelectedLayers().OfType<FeatureLayer>().FirstOrDefault();
     string sTargetParcelType = "Tax";
     var destLineLEnum = await myParcelFabricLayer.GetParcelLineLayerByTypeNameAsync(sTargetParcelType);
     if (destLineLEnum.Count == 0)
       return "";
     var destLineL = destLineLEnum.FirstOrDefault();
     var destPolygonLEnum = await myParcelFabricLayer.GetParcelPolygonLayerByTypeNameAsync(sTargetParcelType);
     if (destPolygonLEnum.Count == 0)
       return "";
     var destPolygonL = destPolygonLEnum.FirstOrDefault();
     if (destLineL == null || destPolygonL == null)
       return "";
     var theActiveRecord = myParcelFabricLayer.GetActiveRecord();
     if (theActiveRecord == null)
       return "There is no Active Record. Please set the active record and try again.";
     var editOper = new EditOperation()
     {
       Name = "Copy Lines To Parcel Type",
       ProgressMessage = "Copy Lines To Parcel Type ...",
       ShowModalMessageAfterFailure = true,
       SelectNewFeatures = true,
       SelectModifiedFeatures = false
     };
     var ids = new List<long>(srcParcelFeatLyr.GetSelection().GetObjectIDs());
     if (ids.Count == 0)
       return "No selected parcels found. Please select parcels and try again.";
     //add the standard feature line layers source, and their feature ids to a new Dictionary
     var sourceParcelFeatures = new Dictionary<MapMember, List<long>>
     {
       { srcParcelFeatLyr, ids }
     };
     editOper.CopyParcelLinesToParcelType(myParcelFabricLayer, SelectionSet.FromDictionary(sourceParcelFeatures), destLineL, destPolygonL, true, false, true);
     if (!editOper.Execute())
       return editOper.ErrorMessage;
   }
   catch (Exception ex)
   {
     return ex.Message;
   }
   return "";
 });
  if (!string.IsNullOrEmpty(errorMessage))
    MessageBox.Show(errorMessage, "Copy Parcel Lines To Parcel Type.");
}

{
  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 sourceParcels = new Dictionary<MapMember, List<long>>
      {
        { featSrcLyr, ids }
      };
      //---------------------------------------------
      ParcelFeatures parcFeatures =
                      await myParcelFabricLayer.GetParcelFeaturesAsync(SelectionSet.FromDictionary(sourceParcels));
      //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.GetParcelLineLayerByTypeNameAsync(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.Equals(sParcelTypeName, StringComparison.CurrentCultureIgnoreCase))
          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");
}

{
  var theparcelTypeName = await QueuedTask.Run(async () =>
  {
    IEnumerable<string> parcelTypeNames = await myParcelFabricLayer.GetParcelTypeNamesAsync();
    foreach (string parcelTypeName in parcelTypeNames)
    {
      if (geomType == GeometryType.Polygon)
      {
        var polygonLyrParcelTypeEnum = await myParcelFabricLayer.GetParcelPolygonLayerByTypeNameAsync(parcelTypeName);
        foreach (FeatureLayer lyr in polygonLyrParcelTypeEnum)
          if (lyr == featLayer)
            return parcelTypeName;

        polygonLyrParcelTypeEnum = await myParcelFabricLayer.GetHistoricParcelPolygonLayerByTypeNameAsync(parcelTypeName);
        foreach (FeatureLayer lyr in polygonLyrParcelTypeEnum)
          if (lyr == featLayer)
            return parcelTypeName;
      }
      if (geomType == GeometryType.Polyline)
      {
        var lineLyrParcelTypeEnum = await myParcelFabricLayer.GetParcelLineLayerByTypeNameAsync(parcelTypeName);
        foreach (FeatureLayer lyr in lineLyrParcelTypeEnum)
          if (lyr == featLayer)
            return parcelTypeName;

        lineLyrParcelTypeEnum = await myParcelFabricLayer.GetHistoricParcelLineLayerByTypeNameAsync(parcelTypeName);
        foreach (FeatureLayer lyr in lineLyrParcelTypeEnum)
          if (lyr == featLayer)
            return parcelTypeName;
      }
    }
    return String.Empty;
  });
}