ArcGIS Pro 3.8 API Reference Guide
ArcGIS.Core.Geometry Namespace / PolylineBuilderEx Class / CreatePolyline Method / CreatePolyline(IEnumerable<MapPoint>,SpatialReference) Method
Points to create the polyline. Line segments are created from the coordinates of the points. The spatial references of the points are checked for compatibility.
(Optional) The SpatialReference. The default value is null. If spatialReference is null, then the spatial reference will be inherited from points which requires traversing through the enumeration of points. For improved performance, use CreatePolyline(IEnumerable<MapPoint>,AttributeFlags,SpatialReference).
Example

In This Topic
    CreatePolyline(IEnumerable<MapPoint>,SpatialReference) Method
    In This Topic
    Convenience method to create a new instance of the Polyline class.
    Syntax
    Public Overloads Shared Function CreatePolyline( _
       ByVal points As IEnumerable(Of MapPoint), _
       Optional ByVal spatialReference As SpatialReference _
    ) As Polyline

    Parameters

    points
    Points to create the polyline. Line segments are created from the coordinates of the points. The spatial references of the points are checked for compatibility.
    spatialReference
    (Optional) The SpatialReference. The default value is null. If spatialReference is null, then the spatial reference will be inherited from points which requires traversing through the enumeration of points. For improved performance, use CreatePolyline(IEnumerable<MapPoint>,AttributeFlags,SpatialReference).

    Return Value

    Exceptions
    ExceptionDescription
    Incompatible spatial references.
    points is null.
    Remarks
    The HasZ, HasM and HasID properties are inherited from points which requires traversing through the enumeration of points. For improved performance or if you want to set these properties yourself, use CreatePolyline(IEnumerable<MapPoint>,AttributeFlags,SpatialReference).
    Example
    Builder Properties
    {
      // list of points
      List<MapPoint> pointsForBuilder = new List<MapPoint>
    {
      MapPointBuilderEx.CreateMapPoint(0, 0, 2, 3, 1),
      MapPointBuilderEx.CreateMapPoint(1, 1, 5, 6),
      MapPointBuilderEx.CreateMapPoint(2, 1, 6),
      MapPointBuilderEx.CreateMapPoint(0, 0)
    };
    
      // will have attributes because it is created with convenience method
      Polyline polylineWithAttrs = PolylineBuilderEx.CreatePolyline(pointsForBuilder);
      bool hasZ = polylineWithAttrs.HasZ;          // hasZ = true
      bool hasM = polylineWithAttrs.HasM;          // hasM = true
      bool hasID = polylineWithAttrs.HasID;        // hasID = true
    
      // will not have attributes because it is specified as a parameter
      Polyline polylineWithoutAttrs =
        PolylineBuilderEx.CreatePolyline(pointsForBuilder, AttributeFlags.None);
      hasZ = polylineWithoutAttrs.HasZ;          // hasZ = false
      hasM = polylineWithoutAttrs.HasM;          // hasM = false
      hasID = polylineWithoutAttrs.HasID;        // hasID = false
    
      // will have attributes because it is created with convenience method
      Polygon polygonWithAttrs = PolygonBuilderEx.CreatePolygon(pointsForBuilder);
      hasZ = polygonWithAttrs.HasZ;               // hasZ = true
      hasM = polygonWithAttrs.HasM;               // hasM = true
      hasID = polygonWithAttrs.HasID;             // hasID = true
    
      // will not have attributes because it is specified as a parameter
      Polygon polygonWithoutAttrs =
            PolygonBuilderEx.CreatePolygon(pointsForBuilder, AttributeFlags.None);
      hasZ = polygonWithoutAttrs.HasZ;               // hasZ = false
      hasM = polygonWithoutAttrs.HasM;               // hasM = false
      hasID = polygonWithoutAttrs.HasID;             // hasID = false
    
      // will not have attributes because it is specified as a parameter
      PolylineBuilderEx polylineB =
                 new PolylineBuilderEx(pointsForBuilder, AttributeFlags.None);
      hasZ = polylineB.HasZ;                      // hasZ = false
      hasM = polylineB.HasM;                      // hasM = false
      hasID = polylineB.HasID;                    // hasID = false
    
      // will have attributes because it is passed an attributed polyline
      polylineB = new PolylineBuilderEx(polylineWithAttrs);
      hasZ = polylineB.HasZ;                      // hasZ = true
      hasM = polylineB.HasM;                      // hasM = true
      hasID = polylineB.HasID;                    // hasID = true
    
      // will not have attributes because it is passed a non-attributed polyline
      polylineB = new PolylineBuilderEx(polylineWithoutAttrs);
      hasZ = polylineB.HasZ;                      // hasZ = false
      hasM = polylineB.HasM;                      // hasM = false
      hasID = polylineB.HasID;                    // hasID = false
    
      // will not have attributes because it is specified as a parameter
      PolygonBuilderEx polygonB = new PolygonBuilderEx(pointsForBuilder, AttributeFlags.None);
      hasZ = polygonB.HasZ;                       // hasZ = false
      hasM = polygonB.HasM;                       // hasM = false
      hasID = polygonB.HasID;                     // hasID = false
    
      // will have attributes because it is passed an attributed polygon
      polygonB = new PolygonBuilderEx(polygonWithAttrs);
      hasZ = polygonB.HasZ;                       // hasZ = true
      hasM = polygonB.HasM;                       // hasM = true
      hasID = polygonB.HasID;                     // hasID = true
    
      // will not have attributes because it is passed a non-attributed polygon
      polygonB = new PolygonBuilderEx(polygonWithoutAttrs);
      hasZ = polygonB.HasZ;                       // hasZ = true
      hasM = polygonB.HasM;                       // hasM = true
      hasID = polygonB.HasID;                     // hasID = true
    }
    Construct a Polyline - from an enumeration of MapPoints
    {
      // Use a builderEx convenience method or a builderEx constructor.
      // neither need to run on the MCT
    
      MapPoint startPt = MapPointBuilderEx.CreateMapPoint(1.0, 1.0);
      MapPoint endPt = MapPointBuilderEx.CreateMapPoint(2.0, 1.0);
    
      List<MapPoint> list = new List<MapPoint>() { startPt, endPt };
    
      Polyline polylineFromPointList = PolylineBuilderEx.CreatePolyline(list, SpatialReferences.WGS84);
    
      // use AttributeFlags.None since we only have 2D points in the list
      PolylineBuilderEx pb = new PolylineBuilderEx(list, AttributeFlags.None);
      pb.SpatialReference = SpatialReferences.WGS84;
      Polyline polyline2 = pb.ToGeometry();
    
      // Use AttributeFlags.NoAttributes because we only have 2d points in the list
      Polyline polyline4 = PolylineBuilderEx.CreatePolyline(list, AttributeFlags.None);
    }
    Polygon contains MapPoints, Polylines, Polygons
    {
        // build a polygon
        List<MapPoint> pts =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 1.0),
      MapPointBuilderEx.CreateMapPoint(1.0, 2.0),
      MapPointBuilderEx.CreateMapPoint(2.0, 2.0),
      MapPointBuilderEx.CreateMapPoint(2.0, 1.0),
    ];
    
        Polygon poly = PolygonBuilderEx.CreatePolygon(pts);
    
        // test if an inner point is contained
        MapPoint innerPt = MapPointBuilderEx.CreateMapPoint(1.5, 1.5);
        bool contains = GeometryEngine.Instance.Contains(poly, innerPt);   // contains = true
    
        // test a point on a boundary
        contains = GeometryEngine.Instance.Contains(poly, poly.Points[0]);     // contains = false
    
        // test an interior line
        MapPoint innerPt2 = MapPointBuilderEx.CreateMapPoint(1.25, 1.75);
        List<MapPoint> innerLinePts = [innerPt, innerPt2];
    
        // test an inner polyline
        polyline = PolylineBuilderEx.CreatePolyline(innerLinePts);
        contains = GeometryEngine.Instance.Contains(poly, polyline);   // contains = true
    
        // test a line that crosses the boundary
        MapPoint outerPt = MapPointBuilderEx.CreateMapPoint(3, 1.5);
        List<MapPoint> crossingLinePts = [innerPt, outerPt];
    
        polyline = PolylineBuilderEx.CreatePolyline(crossingLinePts);
        contains = GeometryEngine.Instance.Contains(poly, polyline);     // contains = false
    
        // test a polygon in polygon
        Envelope env = EnvelopeBuilderEx.CreateEnvelope(innerPt, innerPt2);
        contains = GeometryEngine.Instance.Contains(poly, env);      // contains = true
      }
    Determine convex hull
    {
        //
        // convex hull around a point - returns a point
        //
    
        MapPoint pt = MapPointBuilderEx.CreateMapPoint(2.0, 2.0);
        Geometry hull = GeometryEngine.Instance.ConvexHull(pt);
        MapPoint hullPt = hull as MapPoint;
        // nullPt.X = 2
        // hullPt.Y = 2
    
    
        List<MapPoint> list =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 1.0),
      MapPointBuilderEx.CreateMapPoint(1.0, 2.0),
      MapPointBuilderEx.CreateMapPoint(2.0, 2.0),
      MapPointBuilderEx.CreateMapPoint(2.0, 1.0),
    ];
    
        //
        // convex hull around a multipoint - returns a polygon
        //
    
        // build a multiPoint
        Multipoint multiPoint = MultipointBuilderEx.CreateMultipoint(list);
    
        hull = GeometryEngine.Instance.ConvexHull(multiPoint);
        Polygon hullPoly = hull as Polygon;
        // hullPoly.Area = 1
        // hullPoly.PointCount = 5
    
        //
        // convex hull around a line - returns a polyline or polygon
        //
    
        List<MapPoint> polylineList = [MapPointBuilderEx.CreateMapPoint(1.0, 1.0), MapPointBuilderEx.CreateMapPoint(2.0, 2.0)];
    
        // 2 point straight line
        polyline = PolylineBuilderEx.CreatePolyline(polylineList);
        hull = GeometryEngine.Instance.ConvexHull(polyline);
        Polyline hullPolyline = hull as Polyline;
        // hullPolyline.Length = Math.Sqrt(2)
        // hullPolyline.PointCount = 2
    
        // 3 point angular line
        polylineList.Add(MapPointBuilderEx.CreateMapPoint(2.0, 1.0));
        polyline = PolylineBuilderEx.CreatePolyline(polylineList);
        hull = GeometryEngine.Instance.ConvexHull(polyline);
        hullPoly = hull as Polygon;
        // hullPoly.Length = 2 + Math.Sqrt(2)
        // hullPoly.Area = 0.5
        // hullPoly.PointCount = 4
    
        //
        // convex hull around a polygon - returns a polygon
        //
    
        // simple polygon
        Polygon poly = PolygonBuilderEx.CreatePolygon(list);
        hull = GeometryEngine.Instance.ConvexHull(poly);
        hullPoly = hull as Polygon;
    
        // hullPoly.Length = 4.0
        // hullPoly.Area = 1.0
        // hullPoly.PointCount = 5
    
        // polygon with concave angles
        List<MapPoint> funkyList =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 1.0),
      MapPointBuilderEx.CreateMapPoint(1.5, 1.5),
      MapPointBuilderEx.CreateMapPoint(1.0, 2.0),
      MapPointBuilderEx.CreateMapPoint(2.0, 2.0),
      MapPointBuilderEx.CreateMapPoint(1.5, 1.5),
      MapPointBuilderEx.CreateMapPoint(2.0, 1.0),
      MapPointBuilderEx.CreateMapPoint(1.0, 1.0),
    ];
    
        Polygon funkyPoly = PolygonBuilderEx.CreatePolygon(funkyList);
        hull = GeometryEngine.Instance.ConvexHull(funkyPoly);
        hullPoly = hull as Polygon;
        // hullPoly.Length = 4.0
        // hullPoly.Area = 1.0
        // hullPoly.PointCount = 5
        // hullPoly.Points[0] = 1.0, 1.0
        // hullPoly.Points[1] = 1.0, 2.0
        // hullPoly.Points[2] = 2.0, 2.0
        // hullPoly.Points[3] = 2.0, 1.0
        // hullPoly.Points[4] = 1.0, 1.0
      }
    Determine if two geometries cross
    {
        //
        // pt on pt
        //
    
        MapPoint pt = MapPointBuilderEx.CreateMapPoint(1.0, 1.0);
        MapPoint pt2 = MapPointBuilderEx.CreateMapPoint(2.0, 2.0);
    
        bool crosses = GeometryEngine.Instance.Crosses(pt, pt2);         // crosses = false
        crosses = GeometryEngine.Instance.Crosses(pt, pt);               // crosses = false
    
        //
        // pt and line
        //
    
        List<MapPoint> list =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 1.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(5.0, 1.0),
    ];
    
        Polyline line1 = PolylineBuilderEx.CreatePolyline(list);
        crosses = GeometryEngine.Instance.Crosses(line1, pt2);           // crosses = false
        crosses = GeometryEngine.Instance.Crosses(pt2, line1);           // crosses = false
                                                                         // end pt of line
        crosses = GeometryEngine.Instance.Crosses(line1, pt);            // crosses = false
    
        //
        // pt and polygon
        //
        List<MapPoint> polyPts =
        [
          MapPointBuilderEx.CreateMapPoint(3.0, 2.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 6.0),
      MapPointBuilderEx.CreateMapPoint(6.0, 6.0),
      MapPointBuilderEx.CreateMapPoint(6.0, 2.0),
    ];
    
        Polygon poly1 = PolygonBuilderEx.CreatePolygon(polyPts);
        crosses = GeometryEngine.Instance.Crosses(poly1, pt);              // crosses = false
        crosses = GeometryEngine.Instance.Crosses(pt, poly1);              // crosses = false
    
        //
        // line and line
        //
        List<MapPoint> list2 =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 1.0),
      MapPointBuilderEx.CreateMapPoint(5.0, 3.0),
    ];
    
        Polyline line2 = PolylineBuilderEx.CreatePolyline(list2);
        crosses = GeometryEngine.Instance.Crosses(line1, line2);           // crosses = true
    
        //
        // line and polygon
        //
        crosses = GeometryEngine.Instance.Crosses(poly1, line1);           // crosses = true
    
        //
        // polygon and polygon
        //
        Envelope env = EnvelopeBuilderEx.CreateEnvelope(MapPointBuilderEx.CreateMapPoint(1.0, 1.0), MapPointBuilderEx.CreateMapPoint(4, 4));
        Polygon poly2 = PolygonBuilderEx.CreatePolygon(env);
        crosses = GeometryEngine.Instance.Crosses(poly1, poly2);           // crosses = false
      }
    Cut a geometry with a polyline
    {
        SpatialReference sr = SpatialReferences.WGS84;
    
        List<MapPoint> list =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 1.0, sr),
      MapPointBuilderEx.CreateMapPoint(1.0, 4.0, sr),
      MapPointBuilderEx.CreateMapPoint(4.0, 4.0, sr),
      MapPointBuilderEx.CreateMapPoint(4.0, 1.0, sr),
    ];
    
        List<Geometry> cutGeometries;
    
        LineSegment line = LineBuilderEx.CreateLineSegment(MapPointBuilderEx.CreateMapPoint(0, 0, sr), MapPointBuilderEx.CreateMapPoint(3, 6, sr));
        Polyline cutter = PolylineBuilderEx.CreatePolyline(line);
    
        // polyline
        polyline = PolylineBuilderEx.CreatePolyline(list);
        bool isSimple = GeometryEngine.Instance.IsSimpleAsFeature(polyline);
        cutGeometries = GeometryEngine.Instance.Cut(polyline, cutter) as List<Geometry>;
    
        Polyline leftPolyline = cutGeometries[0] as Polyline;
        Polyline rightPolyline = cutGeometries[1] as Polyline;
    
        // leftPolyline.Points[0] = 1, 2
        // leftPolyline.Points[1] = 1, 4
        // leftPolyline.Points[2] = 2, 4
    
        // rightPolyline.Points.Count = 5
        // rightPolyline.Parts.Count = 2
    
        ReadOnlySegmentCollection segments0 = rightPolyline.Parts[0];
        // segments0[0].StartCoordinate = 1, 1
        // segments0[0].EndCoordinate = 1, 2
    
        ReadOnlySegmentCollection segments1 = rightPolyline.Parts[1];
        // segments1.Count = 2
        // segments1[0].StartCoordinate = 2, 4
        // segments1[0].EndCoordinate = 4, 4
        // segments1[1].StartCoordinate = 4, 4
        // segments1[1].EndCoordinate = 4, 1
    
        // polygon
        polygon = PolygonBuilderEx.CreatePolygon(list);
        isSimple = GeometryEngine.Instance.IsSimpleAsFeature(polygon);
        cutGeometries = GeometryEngine.Instance.Cut(polygon, cutter) as List<Geometry>;
      }
    Determine if two Geometries are disjoint
    {
        //
        // pt on pt
        //
    
        MapPoint pt = MapPointBuilderEx.CreateMapPoint(1.0, 1.0);
        MapPoint pt2 = MapPointBuilderEx.CreateMapPoint(2.0, 2.5);
    
        bool disjoint = GeometryEngine.Instance.Disjoint(pt, pt2);       // result is true
    
        MultipointBuilderEx mpb = new();
        mpb.AddPoint(pt);
        mpb.AddPoint(pt2);
        Multipoint multiPoint = mpb.ToGeometry();
    
        disjoint = GeometryEngine.Instance.Disjoint(multiPoint, pt);     // result is false
    
        //
        // pt and line
        //
    
        List<MapPoint> list =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 1.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(5.0, 1.0),
    ];
    
        Polyline line1 = PolylineBuilderEx.CreatePolyline(list);
        disjoint = GeometryEngine.Instance.Disjoint(line1, pt2);       // result is true
    
        disjoint = GeometryEngine.Instance.Disjoint(pt2, line1);       // result is true
    
        // end pt of line
        disjoint = GeometryEngine.Instance.Disjoint(line1, pt);        // result is false
    
        //
        // pt and polygon
        //
        List<MapPoint> polyPts =
        [
          MapPointBuilderEx.CreateMapPoint(3.0, 2.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 6.0),
      MapPointBuilderEx.CreateMapPoint(6.0, 6.0),
      MapPointBuilderEx.CreateMapPoint(6.0, 2.0),
    ];
    
        Polygon poly1 = PolygonBuilderEx.CreatePolygon(polyPts);
        disjoint = GeometryEngine.Instance.Disjoint(poly1, pt);          // result is true
        disjoint = GeometryEngine.Instance.Disjoint(pt, poly1);          // result is true
    
        //
        // line and line
        //
    
        List<MapPoint> list2 =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 1.0),
      MapPointBuilderEx.CreateMapPoint(5.0, 3.0),
    ];
    
        Polyline line2 = PolylineBuilderEx.CreatePolyline(list2);
        disjoint = GeometryEngine.Instance.Disjoint(line1, line2);         // result is false
    
        //
        // line and polygon
        //
        disjoint = GeometryEngine.Instance.Disjoint(poly1, line1);         // result is false
        disjoint = GeometryEngine.Instance.Disjoint(line1, poly1);         // result is false
    
        //
        // polygon and polygon
        //
        Envelope env = EnvelopeBuilderEx.CreateEnvelope(MapPointBuilderEx.CreateMapPoint(1.0, 1.0), MapPointBuilderEx.CreateMapPoint(4, 4));
        Polygon poly2 = PolygonBuilderEx.CreatePolygon(env);
    
        disjoint = GeometryEngine.Instance.Disjoint(poly1, poly2);         // result is false
    
    
        // disjoint3D
    
        SpatialReference sr = SpatialReferences.WGS84;
    
        MapPoint pt3D_1 = MapPointBuilderEx.CreateMapPoint(1, 1, 1, sr);
        MapPoint pt3D_2 = MapPointBuilderEx.CreateMapPoint(2, 2, 2, sr);
        MapPoint pt3D_3 = MapPointBuilderEx.CreateMapPoint(1, 1, 2, sr);
    
        MultipointBuilderEx mpbEx = new();
        mpbEx.AddPoint(pt3D_1);
        mpbEx.AddPoint(pt3D_2);
        mpbEx.HasZ = true;
    
        multiPoint = mpbEx.ToGeometry();
        disjoint = GeometryEngine.Instance.Disjoint3D(multiPoint, pt3D_2);     // disjoint = false
        disjoint = GeometryEngine.Instance.Disjoint3D(multiPoint, pt3D_3);     // disjoint = true
      }
    Determine distance between two Geometries
    {
      MapPoint pt1 = MapPointBuilderEx.CreateMapPoint(1.0, 1.0);
      MapPoint pt2 = MapPointBuilderEx.CreateMapPoint(2.0, 2.0);
      MapPoint pt3 = MapPointBuilderEx.CreateMapPoint(4.0, 2.0);
    
      //
      // pt and pt
      //
      double d = GeometryEngine.Instance.Distance(pt1, pt2);         // d = Math.Sqrt(2)
    
      //
      // pt and multipoint
      //
      List<MapPoint> multiPts = [pt2, pt3];
      Multipoint multiPoint = MultipointBuilderEx.CreateMultipoint(multiPts);
      d = GeometryEngine.Instance.Distance(pt1, multiPoint);         // d = Math.Sqrt(2)
    
      //
      // pt and envelope
      //
      Envelope env = EnvelopeBuilderEx.CreateEnvelope(pt1, pt2);
      d = GeometryEngine.Instance.Distance(pt1, env);                // d = 0
    
      //
      // pt and polyline
      //
      List<MapPoint> polylinePts = [MapPointBuilderEx.CreateMapPoint(2.0, 1.0), pt2];
      polyline = PolylineBuilderEx.CreatePolyline(polylinePts);
    
      d = GeometryEngine.Instance.Distance(pt1, polyline);             // d = 1.0
    
      //
      // pt and polygon
      //
      Envelope env2 = EnvelopeBuilderEx.CreateEnvelope(MapPointBuilderEx.CreateMapPoint(3.0, 3.0), MapPointBuilderEx.CreateMapPoint(5.0, 5.0));
      Polygon poly = PolygonBuilderEx.CreatePolygon(env2);
      d = GeometryEngine.Instance.Distance(pt1, poly);                 // d = Math.Sqrt(8)
    
      //
      // envelope and polyline
      //
      d = GeometryEngine.Instance.Distance(env, polyline);             // d = 0
    
      //
      // polyline and polyline
      //
      List<MapPoint> polylineList = [MapPointBuilderEx.CreateMapPoint(4, 3), MapPointBuilderEx.CreateMapPoint(4, 4)];
      Polyline polyline2 = PolylineBuilderEx.CreatePolyline(polylineList);
    
      d = GeometryEngine.Instance.Distance(polyline, polyline2);           // d = Math.Sqrt(5)
    
    
      //
      // polygon and polygon
      //
      Polygon poly2 = PolygonBuilderEx.CreatePolygon(env);
      d = GeometryEngine.Instance.Distance(poly, poly2);                 // d = Math.Sqrt(2)
    }
    Determine 3D distance between two Geometries
    {
      // between points
      MapPoint pt1 = MapPointBuilderEx.CreateMapPoint(1, 1, 1);
      MapPoint pt2 = MapPointBuilderEx.CreateMapPoint(2, 2, 2);
      MapPoint pt3 = MapPointBuilderEx.CreateMapPoint(10, 2, 1);
    
      // pt1 to pt2
      double d = GeometryEngine.Instance.Distance3D(pt1, pt2);        // d = Math.Sqrt(3)
    
      // pt1 to pt3
      d = GeometryEngine.Instance.Distance3D(pt1, pt3);        // d = Math.Sqrt(82)
    
      // pt2 to pt3
      d = GeometryEngine.Instance.Distance3D(pt2, pt3);        // d = Math.Sqrt(65)
    
      // intersecting lines
    
      List<MapPoint> list =
      [
        MapPointBuilderEx.CreateMapPoint(1.0, 1.0, 1.0),
        MapPointBuilderEx.CreateMapPoint(3.0, 3.0, 1.0),
        MapPointBuilderEx.CreateMapPoint(5.0, 1.0, 1.0),
      ];
    
      Polyline line1 = PolylineBuilderEx.CreatePolyline(list);
    
      List<MapPoint> list2 =
      [
        MapPointBuilderEx.CreateMapPoint(1.0, 3.0, 1.0),
        MapPointBuilderEx.CreateMapPoint(3.0, 1.0, 1.0),
        MapPointBuilderEx.CreateMapPoint(5.0, 3.0, 1.0),
      ];
    
      Polyline line2 = PolylineBuilderEx.CreatePolyline(list2);
    
      bool intersects = GeometryEngine.Instance.Intersects(line1, line2);    // intersects = true
      d = GeometryEngine.Instance.Distance3D(line1, line2);                  // d = 0   (distance is 0 when geomtries intersect)
    }
    Extend a polyline
    {
      // build a polyline
      polyline = PolylineBuilderEx.CreatePolyline(
      [
        MapPointBuilderEx.CreateMapPoint(1, 1, 10, 20),
        MapPointBuilderEx.CreateMapPoint(0, 0, 10, 20),
        MapPointBuilderEx.CreateMapPoint(1, -1, 10, 20)
      ]);
    
      // build the extender line
      var extender = PolylineBuilderEx.CreatePolyline(
      [
        MapPointBuilderEx.CreateMapPoint(2, 2),
        MapPointBuilderEx.CreateMapPoint(2, -2),
      ]);
    
      // extend
      var result = GeometryEngine.Instance.Extend(polyline, extender, ExtendFlags.KeepEndAttributes);
      Polyline extendedLine = result as Polyline;
      // result.Parts[0].Points[0] = 2, 2, 10, 20
      // result.parts[0].Points[1] = 1, 1, 10, 20
      // result.Parts[0].Points[2] = 0, 0, 10, 20
      // result.Parts[0].Points[3] = 1, -1, 10, 20
      // result.Parts[0].Points[4] = 2, -2, 10, 20
    
      // change the flags
      result = GeometryEngine.Instance.Extend(polyline, extender, ExtendFlags.NoEndAttributes);
      extendedLine = result as Polyline;
      // result.Parts[0].Points[0] = 2, 2, 0
      // result.parts[0].Points[1] = 1, 1, 10, 20
      // result.Parts[0].Points[2] = 0, 0, 10, 20
      // result.Parts[0].Points[3] = 1, -1, 10, 20
      // result.Parts[0].Points[4] = 2, -2, 0
    
      // extend
      result = GeometryEngine.Instance.Extend(polyline, extender, ExtendFlags.KeepEndAttributes | ExtendFlags.NoExtendAtTo);
      extendedLine = result as Polyline;
      // result.Parts[0].Points[0] = 2, 2, 10, 20
      // result.parts[0].Points[1] = 1, 1, 10, 20
      // result.Parts[0].Points[2] = 0, 0, 10, 20
      // result.Parts[0].Points[3] = 1, -1, 10, 20
    
      // extend with no intersection
    
      polyline = PolylineBuilderEx.CreatePolyline(
      [
        MapPointBuilderEx.CreateMapPoint(1, 1),
        MapPointBuilderEx.CreateMapPoint(3, 1)
      ]);
    
      extender = PolylineBuilderEx.CreatePolyline(
      [
        MapPointBuilderEx.CreateMapPoint(1, 4),
        MapPointBuilderEx.CreateMapPoint(3, 4)
      ]);
    
      result = GeometryEngine.Instance.Extend(polyline, extender, ExtendFlags.Default);
      // result = null
    
      result = GeometryEngine.Instance.Extend(polyline, extender, ExtendFlags.KeepEndAttributes | ExtendFlags.NoExtendAtTo);
    
      // Use the result ...
    }
    Determine geodesic length of a line
    {
      polyline = PolylineBuilderEx.CreatePolyline(
      [
          MapPointBuilderEx.CreateMapPoint(-10018754.1713946, 10018754.1713946),
      MapPointBuilderEx.CreateMapPoint(10018754.1713946, 10018754.1713946)
      ], SpatialReferences.WebMercator);
    
      var length = GeometryEngine.Instance.GeodesicLength(polyline);
      // length is approx 5243784.5551844323 in meters
    
      length = GeometryEngine.Instance.GeodesicLength(polyline, LinearUnit.Miles);
      // length is approx 3258.33666089067 in miles
    
      var polyline2 = GeometryEngine.Instance.Project(polyline, SpatialReferences.WGS84);
      length = GeometryEngine.Instance.GeodesicLength(polyline2);
      // length is approx 5243784.55518443 in meters after projecting
    }
    Intersection between two Polylines
    {
      // determine intersection between two polylines
    
      List<MapPoint> pts =
      [
        MapPointBuilderEx.CreateMapPoint(1.0, 1.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(5.0, 1.0),
    ];
    
      Polyline line1 = PolylineBuilderEx.CreatePolyline(pts);
    
      List<MapPoint> pts2 =
      [
        MapPointBuilderEx.CreateMapPoint(1.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 1.0),
      MapPointBuilderEx.CreateMapPoint(5.0, 3.0),
    ];
    
      Polyline line2 = PolylineBuilderEx.CreatePolyline(pts2);
    
      bool intersects = GeometryEngine.Instance.Intersects(line1, line2);    // intersects = true
      Geometry g = GeometryEngine.Instance.Intersection(line1, line2, GeometryDimensionType.EsriGeometry0Dimension);
      Multipoint resultMultipoint = g as Multipoint;
    
      // result is a multiPoint that intersects at (2,2) and (4,2)
    }
    Move a Polyline
    {
        List<MapPoint> pts =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 1.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 3.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(3, 2, 3.0),
      MapPointBuilderEx.CreateMapPoint(4.0, 2.0, 3.0),
    ];
    
        polyline = PolylineBuilderEx.CreatePolyline(pts);
    
        Geometry geometry = GeometryEngine.Instance.Move(polyline, 3, 2);
        Polyline polylineResult = geometry as Polyline;
        // polylineResult.Points[0] = 4.0, 3.0, 3.0
        // polylineResult.Points[1] = 6.0, 5.0, 3.0
        // polylineResult.Points[2] = 6.0, 4.0, 3.0
        // polylineResult.Points[3] = 7.0, 4.0, 3.0
      }
    MovePointAlongLine
    {
      LineSegment line = LineBuilderEx.CreateLineSegment(MapPointBuilderEx.CreateMapPoint(0, 3), MapPointBuilderEx.CreateMapPoint(5.0, 3.0));
      polyline = PolylineBuilderEx.CreatePolyline(line);
      bool simple = GeometryEngine.Instance.IsSimpleAsFeature(polyline);
    
      // ratio = false
      MapPoint pt = GeometryEngine.Instance.MovePointAlongLine(polyline, 1.0, false, 0.0, SegmentExtensionType.NoExtension);
      // pt = 1.0, 3.0
    
      pt = GeometryEngine.Instance.MovePointAlongLine(polyline, 1.0, false, -1.0, SegmentExtensionType.NoExtension);
      // pt = 1.0, 4.0
    
      pt = GeometryEngine.Instance.MovePointAlongLine(polyline, 1.0, false, 2.0, SegmentExtensionType.NoExtension);
      // pt = 1.0, 1.0
    
      // ratio = true
      pt = GeometryEngine.Instance.MovePointAlongLine(polyline, 0.5, true, 0, SegmentExtensionType.NoExtension);
      // pt = 2.5, 3.0
    
      // move past the line
      pt = GeometryEngine.Instance.MovePointAlongLine(polyline, 7, false, 0, SegmentExtensionType.NoExtension);
      // pt = 5.0, 3.0
    
      // move past the line with extension at "to" point
      pt = GeometryEngine.Instance.MovePointAlongLine(polyline, 7, false, 0, SegmentExtensionType.ExtendEmbeddedAtTo);
      // pt = 7.0, 3.0
    
      // negative distance with extension at "from" point
      pt = GeometryEngine.Instance.MovePointAlongLine(polyline, -2, false, 0, SegmentExtensionType.ExtendEmbeddedAtFrom);
      // pt = -2.0, 3.0
    
      // ratio = true
      pt = GeometryEngine.Instance.MovePointAlongLine(polyline, 0.5, true, 0, SegmentExtensionType.NoExtension);
      // pt = 2.5, 3.0
    
      // line with Z
      List<Coordinate3D> coords3D = [new Coordinate3D(0, 0, 0), new Coordinate3D(1113195, 1118890, 5000)];
      Polyline polylineZ = PolylineBuilderEx.CreatePolyline(coords3D, SpatialReferences.WebMercator);
      // polylineZ.HasZ = true
    
      // ratio = true, no offset
      pt = GeometryEngine.Instance.MovePointAlongLine(polylineZ, 0.5, true, 0, SegmentExtensionType.NoExtension);
      // pt.X = 556597.5
      // pt.Y = 559445
      // pt.Z = 2500
    
      // ratio = true, past the line with "to" extension, no offset
      pt = GeometryEngine.Instance.MovePointAlongLine(polylineZ, 1.5, true, 0, SegmentExtensionType.ExtendEmbeddedAtTo);
      // pt.X = 1669792.5
      // pt.Y = 1678335
      // pt.Z = 7500
    
      // ratio = true, negative distance past the line with no extension, no offset
      pt = GeometryEngine.Instance.MovePointAlongLine(polylineZ, -1.5, true, 0, SegmentExtensionType.NoExtension);
      // pt.X = 0
      // pt.Y = 0
      // pt.Z = -7500
    
      // polyline with Z but 2d distance = 0
      MapPoint pt3 = MapPointBuilderEx.CreateMapPoint(5, 5, 0);
      MapPoint pt4 = MapPointBuilderEx.CreateMapPoint(5, 5, 10);
      List<MapPoint> pts = [pt3, pt4];
    
      polyline = PolylineBuilderEx.CreatePolyline(pts);
      // polyline.HasZ = true
      // polyline.Length3D = 10
      // polyline.Length = 0
    
      MapPoint result = GeometryEngine.Instance.MovePointAlongLine(polyline, 2, false, 0, SegmentExtensionType.NoExtension);
      // result = 5, 5, 2
    
      // polyline with length2d = 0 and length3d = 0
      MapPoint pt5 = MapPointBuilderEx.CreateMapPoint(5, 5, 10);
      MapPoint pt6 = MapPointBuilderEx.CreateMapPoint(5, 5, 10);
      pts.Clear();
      pts.Add(pt5);
      pts.Add(pt6);
    
      polyline = PolylineBuilderEx.CreatePolyline(pts);
      // polyline.HasZ = true
      // polyline.Length3D = 0
      // polyline.Length = 0
    
      result = GeometryEngine.Instance.MovePointAlongLine(polyline, 3, true, 0, SegmentExtensionType.NoExtension);
      // result = 5, 5, 10
    
      result = GeometryEngine.Instance.MovePointAlongLine(polyline, 3, true, 0, SegmentExtensionType.ExtendEmbeddedAtFrom);
      // result = 5, 5, 10
    
      // polyline with Z and M
      List<MapPoint> inputPoints =
      [
          MapPointBuilderEx.CreateMapPoint(1, 2, 3, 4),
        MapPointBuilderEx.CreateMapPoint(1, 2, 33, 44),
    ];
    
      Polyline polylineZM = PolylineBuilderEx.CreatePolyline(inputPoints, SpatialReferences.WGS84);
      // polylineZM.HasZ = true
      // polylineZM.HasM = true
    
      // ratio = true, no offset
      MapPoint pointAlong = GeometryEngine.Instance.MovePointAlongLine(polylineZM, 0.5, true, 0, SegmentExtensionType.NoExtension);
      // pointAlong = 1, 2, 18, 24
    
      // ratio = true with offset
      pointAlong = GeometryEngine.Instance.MovePointAlongLine(polylineZM, 0.2, true, 2.23606797749979, SegmentExtensionType.NoExtension);
      // pointAlong = 1, 2, 9, 12
    }
    Calculate a geometry offset from the source
    {
        List<MapPoint> linePts =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 1.0, SpatialReferences.WGS84),
      MapPointBuilderEx.CreateMapPoint(10.0, 1.0, SpatialReferences.WGS84),
    ];
    
        polyline = PolylineBuilderEx.CreatePolyline(linePts);
    
        Geometry g = GeometryEngine.Instance.Offset(polyline, 10, OffsetType.Square, 0);
        Polyline gResult = g as Polyline;
        // gResult.PointCount = 2
        // gResult.Points[0] = (1, -9)
        // gResult.Points[1] = (10, -9)
    
        g = GeometryEngine.Instance.Offset(polyline, -10, OffsetType.Round, 0.5);
        gResult = g as Polyline;
        // gResult.PointCount = 2
        // gResult.Points[0] = (1, -11
        // gResult.Points[1] = (10, 11)
    
        //
        // elliptic arc curve
        //
        Coordinate2D fromPt = new(2, 1);
        Coordinate2D toPt = new(1, 2);
        Coordinate2D interiorPt = new(1 + Math.Sqrt(2) / 2, 1 + Math.Sqrt(2) / 2);
    
        EllipticArcSegment circularArc = EllipticArcBuilderEx.CreateCircularArc(fromPt.ToMapPoint(), toPt.ToMapPoint(), interiorPt);
    
        polyline = PolylineBuilderEx.CreatePolyline(circularArc);
        g = GeometryEngine.Instance.Offset(polyline, -0.25, OffsetType.Miter, 0.5);
        gResult = g as Polyline;
    
        g = GeometryEngine.Instance.Offset(polyline, 0.25, OffsetType.Bevel, 0.5);
        gResult = g as Polyline;
    
        //
        //  offset for a polygon
        //
        List<MapPoint> list =
        [
          MapPointBuilderEx.CreateMapPoint(10.0, 10.0, SpatialReferences.WGS84),
        MapPointBuilderEx.CreateMapPoint(10.0, 20.0, SpatialReferences.WGS84),
        MapPointBuilderEx.CreateMapPoint(20.0, 20.0, SpatialReferences.WGS84),
        MapPointBuilderEx.CreateMapPoint(20.0, 10.0, SpatialReferences.WGS84),
      ];
    
        polygon = PolygonBuilderEx.CreatePolygon(list);
    
        g = GeometryEngine.Instance.Offset(polygon, 2, OffsetType.Square, 0);
        Polygon gPolygon = g as Polygon;
    
        g = GeometryEngine.Instance.Offset(polygon, -2, OffsetType.Round, 0.3);
        gPolygon = g as Polygon;
    
        g = GeometryEngine.Instance.Offset(polygon, -0.5, OffsetType.Miter, 0.6);
        gPolygon = g as Polygon;
      }
    Determine if geometries overlap
    {
      MapPoint pt1 = MapPointBuilderEx.CreateMapPoint(1.5, 1.5);
      MapPoint pt2 = MapPointBuilderEx.CreateMapPoint(1.25, 1.75);
      MapPoint pt3 = MapPointBuilderEx.CreateMapPoint(3, 1.5);
      MapPoint pt4 = MapPointBuilderEx.CreateMapPoint(1.5, 2);
    
      //
      // point and point overlap
      //
      bool overlaps = GeometryEngine.Instance.Overlaps(pt1, pt2);        // overlaps = false
      overlaps = GeometryEngine.Instance.Overlaps(pt1, pt1);             // overlaps = false
                                                                         // Two geometries overlap if the region of their intersection is of the same dimension as the geometries involved and
                                                                         // is not equivalent to either of the geometries.
    
      List<MapPoint> pts = [pt1, pt2, pt3];
    
      List<MapPoint> pts2 = [pt2, pt3, pt4];
    
      //
      // pt and line overlap
      //
      polyline = PolylineBuilderEx.CreatePolyline(pts);
      bool isSimple = GeometryEngine.Instance.IsSimpleAsFeature(polyline);         // isSimple = true
      overlaps = GeometryEngine.Instance.Overlaps(polyline, pt1);                  // overlaps = false
    
      //
      // line and line
      //
      Polyline polyline2 = PolylineBuilderEx.CreatePolyline(pts2);
      isSimple = GeometryEngine.Instance.IsSimpleAsFeature(polyline2);             // isSimple = true
      overlaps = GeometryEngine.Instance.Overlaps(polyline, polyline2);            // overlaps = true
    }
    QueryPointAndDistance
    {
        // Horizontal line segment
        List<MapPoint> linePts =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 1.0, SpatialReferences.WGS84),
      MapPointBuilderEx.CreateMapPoint(11.0, 1.0, SpatialReferences.WGS84),
    ];
        polyline = PolylineBuilderEx.CreatePolyline(linePts);
        bool isSimple = GeometryEngine.Instance.IsSimpleAsFeature(polyline);
    
        // Don't extend the segment
        SegmentExtensionType extension = SegmentExtensionType.NoExtension;
    
        // A point on the line segment
        MapPoint inPoint = MapPointBuilderEx.CreateMapPoint(2, 1, SpatialReferences.WGS84);
    
        AsRatioOrLength asRatioOrLength = AsRatioOrLength.AsLength;
    
        MapPoint outPoint = GeometryEngine.Instance.QueryPointAndDistance(polyline, extension, inPoint, asRatioOrLength, out double distanceAlongCurve, out double distanceFromCurve, out LeftOrRightSide whichSide);
        // outPoint = 2, 1
        // distanceAlongCurve = 1
        // distanceFromCurve = 0
        // whichSide = GeometryEngine.Instance.LeftOrRightSide.LeftSide
    
        // Extend infinitely in both directions
        extension = SegmentExtensionType.ExtendTangents;
    
        // A point on the left side
        inPoint = MapPointBuilderEx.CreateMapPoint(16, 6, SpatialReferences.WGS84);
        asRatioOrLength = AsRatioOrLength.AsRatio;
    
        outPoint = GeometryEngine.Instance.QueryPointAndDistance(polyline, extension, inPoint, asRatioOrLength, out distanceAlongCurve, out distanceFromCurve, out whichSide);
        // outPoint = 16, 1
        // distanceAlongCurve = 1.5
        // distanceFromCurve = 5
        // whichSide = GeometryEngine.Instance.LeftOrRightSide.LeftSide
      }
    Rotate a Polyline
    {
      // rotate a polyline
    
      MapPoint fixedPt = MapPointBuilderEx.CreateMapPoint(3.0, 3.0);
    
      List<MapPoint> pts =
      [
        MapPointBuilderEx.CreateMapPoint(1.0, 1.0),
      MapPointBuilderEx.CreateMapPoint(1.0, 5.0),
      MapPointBuilderEx.CreateMapPoint(5, 5),
      MapPointBuilderEx.CreateMapPoint(5.0, 1.0),
    ];
      polyline = PolylineBuilderEx.CreatePolyline(pts);
    
      Polyline rotated = GeometryEngine.Instance.Rotate(polyline, fixedPt, Math.PI / 4) as Polyline;  // rotate 45 deg
    }
    Scale a geometry
    {
      List<MapPoint> pts =
      [
        MapPointBuilderEx.CreateMapPoint(1.0, 1.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(1.0, 3.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(3, 3, 3.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 1.0, 3.0),
    ];
    
      MapPoint midPt = MapPointBuilderEx.CreateMapPoint(1.5, 1.5);
    
      // polyline
      polyline = PolylineBuilderEx.CreatePolyline(pts);
      // polyline.Length = 6
      // polyline.Length3D = 0
      Geometry g = GeometryEngine.Instance.Scale(polyline, midPt, 0.5, 0.5);
      Polyline resultPolyline = g as Polyline;
      // resultPolyline.length  = 3
      // resultPolyline.Points[0] = 1.25, 1.25, 3
      // resultPolyline.Points[1] = 1.25, 2.25, 3
      // resultPolyline.Points[2] = 2.25, 2.25, 3
      // resultPolyline.Points[3] = 2.25, 1.25, 3
    
      // 3D point - scale in 3d
      MapPoint midPtZ = MapPointBuilderEx.CreateMapPoint(1.5, 1.5, 1);
      g = GeometryEngine.Instance.Scale(polyline, midPtZ, 0.5, 0.5, 0.25);
      resultPolyline = g as Polyline;
      // resultPolyline.Points[0] = 1.25, 1.25, 1.5
      // resultPolyline.Points[1] = 1.25, 2.25, 1.5
      // resultPolyline.Points[2] = 2.25, 2.25, 1.5
      // resultPolyline.Points[3] = 2.25, 1.25, 1.5
    }
    Calculate area of geometry on surface of Earth's ellipsoid - ShapePreservingArea
    {
      // pt
      MapPoint pt = MapPointBuilderEx.CreateMapPoint(1.0, 3.0, SpatialReferences.WebMercator);
      double area = GeometryEngine.Instance.ShapePreservingArea(pt);         // area = 0
    
      List<MapPoint> pts =
      [
        MapPointBuilderEx.CreateMapPoint(1.0, 1.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(1.0, 3.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(3, 3, 3.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 1.0, 3.0),
    ];
    
      // multipoint
      Multipoint mPt = MultipointBuilderEx.CreateMultipoint(pts);
      area = GeometryEngine.Instance.ShapePreservingArea(mPt);               // area = 0
    
      // polyline
      polyline = PolylineBuilderEx.CreatePolyline(pts);
      area = GeometryEngine.Instance.ShapePreservingArea(polyline);          // area = 0
    
      // polygon
      polygon = PolygonBuilderEx.CreatePolygon(pts, SpatialReferences.WGS84);
      area = GeometryEngine.Instance.ShapePreservingArea(polygon);
    
      polygon = PolygonBuilderEx.CreatePolygon(pts, SpatialReferences.WebMercator);
      area = GeometryEngine.Instance.ShapePreservingArea(polygon);
    
      polygon = PolygonBuilderEx.CreatePolygon(
      [
        MapPointBuilderEx.CreateMapPoint( -170, 45),
      MapPointBuilderEx.CreateMapPoint( 170, 45),
      MapPointBuilderEx.CreateMapPoint( 170, -45),
      MapPointBuilderEx.CreateMapPoint( -170, -54)
      ], SpatialReferences.WGS84);
    
      var area_meters = GeometryEngine.Instance.ShapePreservingArea(polygon);// , AreaUnits.SquareMeters);
      var area_miles = GeometryEngine.Instance.ShapePreservingArea(polygon, AreaUnit.SquareMiles);
    
      // area_meters - 352556425383104.37
      // area_miles - 136122796.848425
    }
    Calculate length of geometry on surface of Earth's ellipsoid - ShapePreservingLength
    {
      // pt
      MapPoint pt = MapPointBuilderEx.CreateMapPoint(1.0, 3.0, SpatialReferences.WebMercator);
      double len = GeometryEngine.Instance.ShapePreservingLength(pt);          // len = 0
    
      List<MapPoint> pts =
      [
        MapPointBuilderEx.CreateMapPoint(1.0, 1.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(1.0, 3.0, 3.0),
      MapPointBuilderEx.CreateMapPoint(3, 3, 3.0),
      MapPointBuilderEx.CreateMapPoint(3.0, 1.0, 3.0),
    ];
    
      // multipoint
      Multipoint mPt = MultipointBuilderEx.CreateMultipoint(pts);
      len = GeometryEngine.Instance.ShapePreservingLength(mPt);                // len = 0
    
      // polyline
      polyline = PolylineBuilderEx.CreatePolyline(pts, SpatialReferences.WGS84);
      len = GeometryEngine.Instance.ShapePreservingLength(polyline);
    
      // polygon
      polygon = PolygonBuilderEx.CreatePolygon(pts, SpatialReferences.WGS84);
      len = GeometryEngine.Instance.ShapePreservingLength(polygon);
    
      polyline = PolylineBuilderEx.CreatePolyline(
      [
        MapPointBuilderEx.CreateMapPoint( -170, 0),
      MapPointBuilderEx.CreateMapPoint( 170, 0)
      ], SpatialReferences.WGS84);
    
    
      var length_meters = GeometryEngine.Instance.ShapePreservingLength(polyline); // , LinearUnits.Meters);
      var length_miles = GeometryEngine.Instance.ShapePreservingLength(polyline, LinearUnit.Miles);
    
      // length_meters - 37848626.869713023
      // length_miles - 23518.046402579574
    }
    Split multipart at point
    {
      // define a polyline
      MapPoint startPointZ = MapPointBuilderEx.CreateMapPoint(1, 1, 5);
      MapPoint endPointZ = MapPointBuilderEx.CreateMapPoint(20, 1, 5);
    
      Polyline polylineZ = PolylineBuilderEx.CreatePolyline([startPointZ, endPointZ]);
    
      // define a split point
      MapPoint splitPointAboveLine = MapPointBuilderEx.CreateMapPoint(10, 10, 10);
    
      // split the polyline at the point. Don't project the split point onto the line, don't create a new part
      var splitPolyline = GeometryEngine.Instance.SplitAtPoint(polylineZ, splitPointAboveLine, false, false, out bool splitOccurred, out int partIndex, out int segmentIndex);
    
      // splitOccurred = true
      // partIndex = 0
      // segmentIndex = 1
      // splitPolyline.PointCount = 3
      // splitPolyline.PartCount = 1
      // splitPolyline coordinates are (1, 1, 5), (10, 10, 10), (20, 1, 5)
    
      // split the polyline at the point.  dont project the split point onto the line, do create a new part
      splitPolyline = GeometryEngine.Instance.SplitAtPoint(polylineZ, splitPointAboveLine, false, false, out splitOccurred, out partIndex, out segmentIndex);
    
      // splitOccurred = true
      // partIndex = 1
      // segmentIndex = 0
      // splitPolyline.PointCount = 4
      // splitPolyline.PartCount = 2
      // splitPolyline first part coordinates are (1, 1, 5), (10, 10, 10)
      // splitPolyline second part coordinates are (10, 10, 10), (20, 1, 5)
    
      // split the polyline at the point.  do project the split point onto the line, don't create a new part
      splitPolyline = GeometryEngine.Instance.SplitAtPoint(polylineZ, splitPointAboveLine, false, false, out splitOccurred, out partIndex, out segmentIndex);
    
      // splitOccurred = true
      // partIndex = 0
      // segmentIndex = 1
      // splitPolyline.PointCount = 3
      // splitPolyline.PartCount = 1
      // splitPolyline coordinates are (1, 1, 5), (10, 10, 5), (20, 1, 5)
    
      // split the polyline at the point.  do project the split point onto the line, do create a new part
      splitPolyline = GeometryEngine.Instance.SplitAtPoint(polylineZ, splitPointAboveLine, false, false, out splitOccurred, out partIndex, out segmentIndex);
    
      // splitOccurred = true
      // partIndex = 1
      // segmentIndex = 0
      // splitPolyline.PointCount = 4
      // splitPolyline.PartCount = 2
      // splitPolyline first part coordinates are (1, 1, 5), (10, 10, 5)
      // splitPolyline second part coordinates are (10, 10, 5), (20, 1, 5)
    
      //
      // try to split with a point that won't split the line  - pt extends beyond the line
      //
    
      var pointAfterLine = MapPointBuilderEx.CreateMapPoint(50, 1, 10);
      splitPolyline = GeometryEngine.Instance.SplitAtPoint(polylineZ, pointAfterLine, false, false, out splitOccurred, out partIndex, out segmentIndex);
    
      // splitOccurred = false
      // ignore partIndex, sgementIndex
      // splitPolyline is the same as polylineZ
    
      ///
      ///  multipart polygon
      ///
      List<Coordinate3D> coordsZ =
      [
        new Coordinate3D(10,10,5),
      new Coordinate3D(10,20,5),
      new Coordinate3D(20,20,5),
      new Coordinate3D(20,10,5)
      ];
    
      List<Coordinate3D> coordsZ_2ndPart =
      [
        new Coordinate3D(30,20,10),
      new Coordinate3D(30,30,10),
      new Coordinate3D(35,28,10),
      new Coordinate3D(40,30,10),
      new Coordinate3D(40,20,10)
      ];
    
      var builder = new PolygonBuilderEx
      {
        HasZ = true
      };
      builder.AddPart(coordsZ);
      builder.AddPart(coordsZ_2ndPart);
    
      Polygon multipart = builder.ToGeometry();
    
      // pointA is closer to the first part of the multipart - the split occurs in the first part
      var pointA = MapPointBuilderEx.CreateMapPoint(22, 18, 7);
      var splitPolygon = GeometryEngine.Instance.SplitAtPoint(multipart, pointA, false, false, out splitOccurred, out partIndex, out segmentIndex);
    
      // splitPolygon.PointCount = 12
      // splitPolygon.PartCount = 2
      // splitPolygon first part coordinates  (10, 10, 5), (10, 20, 5), (20, 20, 5), (22, 18, 7), (20, 10, 5), (10, 10, 5)
    
      // pointB is midPoint between the 2 parts - no split will occur
      var pointB = MapPointBuilderEx.CreateMapPoint(25, 20, 7);
      splitPolygon = GeometryEngine.Instance.SplitAtPoint(multipart, pointB, true, false, out splitOccurred, out partIndex, out segmentIndex);
    
      // splitOccurred = false
      // ignore partIndex, sgementIndex
      // splitPolyline is the same as polylineZ
    }
    MapPoints, Polylines, Polygons within Polygon
    {
        // build a polygon
        List<MapPoint> pts =
        [
          MapPointBuilderEx.CreateMapPoint(1.0, 1.0),
      MapPointBuilderEx.CreateMapPoint(1.0, 2.0),
      MapPointBuilderEx.CreateMapPoint(2.0, 2.0),
      MapPointBuilderEx.CreateMapPoint(2.0, 1.0),
    ];
    
        Polygon poly = PolygonBuilderEx.CreatePolygon(pts);
    
        // an inner point
        MapPoint innerPt = MapPointBuilderEx.CreateMapPoint(1.5, 1.5);
        bool within = GeometryEngine.Instance.Within(innerPt, poly);   // within = true
    
        // point on a boundary
        within = GeometryEngine.Instance.Within(pts[0], poly);     // within = false
    
        // an interior line
        MapPoint innerPt2 = MapPointBuilderEx.CreateMapPoint(1.25, 1.75);
        List<MapPoint> innerLinePts = [innerPt, innerPt2];
    
        polyline = PolylineBuilderEx.CreatePolyline(innerLinePts);
        within = GeometryEngine.Instance.Within(polyline, poly);   // within = true
    
        // a line that crosses the boundary
        MapPoint outerPt = MapPointBuilderEx.CreateMapPoint(3, 1.5);
        List<MapPoint> crossingLinePts = [innerPt, outerPt];
    
        polyline = PolylineBuilderEx.CreatePolyline(crossingLinePts);
        within = GeometryEngine.Instance.Within(polyline, poly);     // within = false
    
        // polygon in polygon
        Envelope env = EnvelopeBuilderEx.CreateEnvelope(innerPt, innerPt2);
        within = GeometryEngine.Instance.Within(env, poly);      // within = true
      }
    Construct a Polyline - from a Cubic Bezier
    {
      polyline = PolylineBuilderEx.CreatePolyline(bezierSegment);
    }
    Requirements

    Target Platforms: Windows 11 Home, Pro, Enterprise (64 bit)

    ArcGIS Pro version: 3.0 or higher.
    See Also