ArcGIS Pro 3.1 API Reference Guide
ArcGIS.Desktop.Mapping Namespace / ParcelFabricExtensions Class / GetParcelPolygonLayerByTypeNameAsync Method
The parcel layer.
The parcel type name to retrieve layers.
Example

In This Topic
    GetParcelPolygonLayerByTypeNameAsync Method
    In This Topic
    Gets the polygon layer(s) for the given parcel type name.
    Syntax
    public static Task<List<FeatureLayer>> GetParcelPolygonLayerByTypeNameAsync( 
       ParcelLayer parcelLayer,
       string typeName
    )
    Public Shared Function GetParcelPolygonLayerByTypeNameAsync( _
       ByVal parcelLayer As ParcelLayer, _
       ByVal typeName As String _
    ) As Task(Of List(Of FeatureLayer))

    Parameters

    parcelLayer
    The parcel layer.
    typeName
    The parcel type name to retrieve layers.

    Return Value

    A Task to the set of polygon layers.
    Exceptions
    ExceptionDescription
    Insufficient license. This method requires a standard license.
    Example
    Copy standard line features into a parcel type
     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.");
    Copy parcel lines to a 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>>();
        sourceParcelFeatures.Add(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.");
    Duplicate parcels
     var myParcelFabricLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<ParcelLayer>().FirstOrDefault();
    if (myParcelFabricLayer == null)
      return "Parecl layer not found in the map.";
     //get the source polygon layer from the parcel fabric layer type, in this case a layer called Lot
     var srcFeatLyrEnum = await myParcelFabricLayer.GetParcelPolygonLayerByTypeNameAsync("Lot");
    if (srcFeatLyrEnum.Count() == 0)
      return "";
    var sourcePolygonL = srcFeatLyrEnum.FirstOrDefault();
     //get the target polygon layer from the parcel fabric layer type, in this case a layer called Tax
     var targetFeatLyrEnum = await myParcelFabricLayer.GetParcelPolygonLayerByTypeNameAsync("Tax");
    if (targetFeatLyrEnum.Count() == 0)
      return "";
    var targetFeatLyr = targetFeatLyrEnum.FirstOrDefault();
    var ids = new List<long>(sourcePolygonL.GetSelection().GetObjectIDs());
    if (ids.Count == 0)
      return "No selected parcels found. Please select parcels and try again.";
     //add polygon layers and the feature ids to be duplicated to a new Dictionary
     var sourceFeatures = new Dictionary<MapMember, List<long>>();
    sourceFeatures.Add(sourcePolygonL, ids);
    try
    {
      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 = "Duplicate Parcels",
        ProgressMessage = "Duplicate Parcels...",
        ShowModalMessageAfterFailure = true,
        SelectNewFeatures = true,
        SelectModifiedFeatures = false
      };
      editOper.DuplicateParcels(myParcelFabricLayer,
        SelectionSet.FromDictionary(sourceFeatures), theActiveRecord, targetFeatLyr);
      if (!editOper.Execute())
        return editOper.ErrorMessage;
    }
    catch (Exception ex)
    {
      return ex.Message;
    }
    Set parcels historic
    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 destPolygonL = null;
        //find the first layer that is a parcel type, is non-historic, and has a selection
        bool bFound = false;
        var ParcelTypesEnum = await myParcelFabricLayer.GetParcelTypeNamesAsync();
        foreach (FeatureLayer mapFeatLyr in MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>())
        {
          foreach (string ParcelType in ParcelTypesEnum)
          {
            var layerEnum = await myParcelFabricLayer.GetParcelPolygonLayerByTypeNameAsync(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());
        //can do multi layer selection but using single per code above
        var sourceFeatures = new Dictionary<MapMember, List<long>>();
        sourceFeatures.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(sourceFeatures), theActiveRecord);
        if (!editOper.Execute())
          return editOper.ErrorMessage;
      }
      catch (Exception ex)
      {
        return ex.Message;
      }
      return "";
    });
    if (!string.IsNullOrEmpty(errorMessage))
      MessageBox.Show(errorMessage, "Set Parcels Historic.");
    Shrink parcels to seeds
    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.GetParcelTypeNamesAsync();
        foreach (FeatureLayer mapFeatLyr in MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>())
        {
          foreach (string ParcelType in ParcelTypesEnum)
          {
            var layerEnum = await myParcelFabricLayer.GetParcelPolygonLayerByTypeNameAsync(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 sourceParcelFeatures = new Dictionary<MapMember, List<long>>();
        sourceParcelFeatures.Add(parcelPolygonLyr, ids);
        editOper.ShrinkParcelsToSeeds(myParcelFabricLayer, SelectionSet.FromDictionary(sourceParcelFeatures));
        if (!editOper.Execute())
          return editOper.ErrorMessage;
      }
      catch (Exception ex)
      {
        return ex.Message;
      }
      return "";
    });
    if (!string.IsNullOrEmpty(errorMessage))
      MessageBox.Show(errorMessage, "Shrink Parcels To Seeds.");
    Get parcel features
    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>>();
        sourceParcels.Add(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.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");
    Get parcel type name from feature layer
    private async Task<string> GetParcelTypeNameFromFeatureLayer(ParcelLayer myParcelFabricLayer, FeatureLayer featLayer, GeometryType geomType)
    {
      if (featLayer == null) //nothing to do, return empty string
        return String.Empty;
      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;
    }
    Requirements

    Target Platforms: Windows 11, Windows 10

    ArcGIS Pro version: 3.0 or higher.
    See Also