ArcGIS Pro 3.8 API Reference Guide
ArcGIS.Core.Geometry Namespace / EnvelopeBuilderEx Class / CreateEnvelope Method / CreateEnvelope(MapPoint,MapPoint,SpatialReference) Method
Lower left corner of the envelope.
Upper right corner of the envelope.
(Optional) The SpatialReference. The default value is null. The spatial reference of each point is ignored.
Example

In This Topic
    CreateEnvelope(MapPoint,MapPoint,SpatialReference) Method
    In This Topic
    Convenience method to create a new instance of the Envelope class.
    Syntax
    Public Overloads Shared Function CreateEnvelope( _
       ByVal minPoint As MapPoint, _
       ByVal maxPoint As MapPoint, _
       Optional ByVal spatialReference As SpatialReference _
    ) As Envelope

    Parameters

    minPoint
    Lower left corner of the envelope.
    maxPoint
    Upper right corner of the envelope.
    spatialReference
    (Optional) The SpatialReference. The default value is null. The spatial reference of each point is ignored.

    Return Value

    Exceptions
    ExceptionDescription
    minPoint or maxPoint is null.
    Remarks
    The spatial references of the two points must be the same or null.The spatial references of the input points are ignored. There is no check to see if the spatial references are equal. If either point has coordinates that are outside the domain of the spatial reference, then unexpected results will occur when using the geometry.

    The resulting envelope is normalized to ensure its XMin <= XMax, YMin <= YMax, ZMin <= ZMax and MMin <= MMax. If either of the xy-coordinate values are NaN, then the envelope is set to empty.

    The resulting envelope inherits attributes, Z, M and ID-values, from the input points. For example, if either minPoint or maxPoint HasZ property is true, then the envelope's HasZ property is true.

    Example
    Construct a Polygon - from an Envelope
    {
      // Use a builderEx convenience method or use a builderEx constructor.
    
      MapPoint minPt = MapPointBuilderEx.CreateMapPoint(1.0, 1.0);
      MapPoint maxPt = MapPointBuilderEx.CreateMapPoint(2.0, 2.0);
    
      // Create an envelope
      Envelope env = EnvelopeBuilderEx.CreateEnvelope(minPt, maxPt);
    
      Polygon polygonFromEnv = PolygonBuilderEx.CreatePolygon(env);
    
      PolygonBuilderEx polygonBuilderEx = new PolygonBuilderEx(env);
      polygonBuilderEx.SpatialReference = SpatialReferences.WGS84;
      polygonFromEnv = polygonBuilderEx.ToGeometry() as Polygon;
    }
    Construct an Envelope
    {
      // Use a builderEx convenience method or use a builderEx constructor.
    
      MapPoint minPt = MapPointBuilderEx.CreateMapPoint(1.0, 1.0);
      MapPoint maxPt = MapPointBuilderEx.CreateMapPoint(2.0, 2.0);
    
      Envelope envelope = EnvelopeBuilderEx.CreateEnvelope(minPt, maxPt);
    
      EnvelopeBuilderEx builderEx = new EnvelopeBuilderEx(minPt, maxPt);
      envelope = builderEx.ToGeometry() as Envelope;
    }
    Import and Export Geometries to EsriShape
    {
      // create an envelope
      List<MapPoint> coordsZM = new List<MapPoint>
    {
      MapPointBuilderEx.CreateMapPoint(1001, 1002, 1003, 1004),
      MapPointBuilderEx.CreateMapPoint(2001, 2002, Double.NaN, 2004),
      MapPointBuilderEx.CreateMapPoint(3001, -3002, 3003, 3004),
      MapPointBuilderEx.CreateMapPoint(1001, -4002, 4003, 4004)
    };
    
      Envelope envelope = EnvelopeBuilderEx.CreateEnvelope(
                 coordsZM[0], coordsZM[2], SpatialReferences.WGS84);
    
      // export and import
      EsriShapeExportFlags exportFlags = EsriShapeExportFlags.EsriShapeExportDefaults;
      EsriShapeImportFlags importFlags = EsriShapeImportFlags.EsriShapeImportDefaults;
      byte[] buffer = GeometryEngine.Instance.ExportToEsriShape(exportFlags, envelope);
      Polygon importedPolygon = GeometryEngine.Instance.ImportFromEsriShape(
                     importFlags, buffer, envelope.SpatialReference) as Polygon;
      Envelope importedEnvelope = importedPolygon.Extent;
    
      // export without z,m
      buffer = GeometryEngine.Instance.ExportToEsriShape(
              EsriShapeExportFlags.EsriShapeExportStripZs |
              EsriShapeExportFlags.EsriShapeExportStripMs, envelope);
      importedPolygon = GeometryEngine.Instance.ImportFromEsriShape(
              importFlags, buffer, SpatialReferences.WGS84) as Polygon;
      importedEnvelope = importedPolygon.Extent;
    
      bool hasZ = importedEnvelope.HasZ;      // hasZ = false
      bool hasM = importedEnvelope.HasM;      // hasM = false
    
      // export with shapeSize
      int bufferSize = GeometryEngine.Instance.GetEsriShapeSize(
                                             exportFlags, envelope);
      buffer = new byte[bufferSize];
    
      bufferSize = GeometryEngine.Instance.ExportToEsriShape(
                                   exportFlags, envelope, ref buffer);
      importedPolygon = GeometryEngine.Instance.ImportFromEsriShape(
                          importFlags, buffer, envelope.SpatialReference) as Polygon;
      importedEnvelope = importedPolygon.Extent;
    
      // or use the envelope and envelopeBuilderEx classes
      buffer = envelope.ToEsriShape();
      // buffer represents a polygon as there is not an envelope Esri shape buffer
      // EnvelopeBuilderEx.FromEsriShape takes a polygon Esri shape buffer and returns the extent of the polygon.
      importedEnvelope = EnvelopeBuilderEx.FromEsriShape(buffer);
    }
    Import and Export Geometries to XML
    {
      MapPoint minPoint = MapPointBuilderEx.CreateMapPoint(1, 1, 1, 1, 3);
      MapPoint maxPoint = MapPointBuilderEx.CreateMapPoint(5, 5, 5);
    
      //
      //  MapPoint
      //
      string xml = minPoint.ToXml();
      MapPoint minPointImport = MapPointBuilderEx.FromXml(xml);
      // minPointImport = minPoint
    
      //
      // Envelope
      //
      Envelope envelopeWithID = EnvelopeBuilderEx.CreateEnvelope(minPoint, maxPoint);
    
      // Envelopes don't have IDs
      // envelopeWithID.HasID = false
      // envelopeWithID.HasM = true
      // envelopeWithID.HasZ = true
    
      xml = envelopeWithID.ToXml();
      Envelope envelopeImport = EnvelopeBuilderEx.FromXml(xml);
    
      //
      // Multipoint
      //
      List<MapPoint> list = new List<MapPoint>();
      list.Add(minPoint);
      list.Add(maxPoint);
    
      Multipoint multiPoint = MultipointBuilderEx.CreateMultipoint(list);
    
      xml = multiPoint.ToXml();
      Multipoint multipointImport = MultipointBuilderEx.FromXml(xml);
      // multipointImport.PointCount == 2
      // multipointImport.HasID = true
      // multipointImport.HasM = true
      // multipointImport.HasZ= true
    }
    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 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
      }
    Difference between two Polygons
    {
        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);
    
        Envelope env = EnvelopeBuilderEx.CreateEnvelope(MapPointBuilderEx.CreateMapPoint(1.0, 1.0), MapPointBuilderEx.CreateMapPoint(4, 4));
        Polygon poly2 = PolygonBuilderEx.CreatePolygon(env);
    
        Geometry result = GeometryEngine.Instance.Difference(poly1, poly2);
        Polygon polyResult = result as Polygon;
        // polyResult.Area = 10.0
    
        result = GeometryEngine.Instance.Difference(poly2, poly1);
        polyResult = result as Polygon;
        // polyResult.Area = 7.0
      }
    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)
    }
    Expand envelopes
    {
      Envelope env = EnvelopeBuilderEx.CreateEnvelope(100.0, 100.0, 500.0, 500.0);
      // env.HasZ = false
    
      Envelope result = GeometryEngine.Instance.Expand(env, 0.5, 0.5, true);
      // result.Center = 300, 300
      // result.XMin = 200
      // result.YMin = 200
      // result.XMax = 400
      // result.YMax = 400
    
      result = GeometryEngine.Instance.Expand(env, 100, 200, false);
      // result.Center = 300, 300
      // result.XMin = 0
      // result.YMin = -100
      // result.XMax = 600
      // result.YMax = 700
    
      try
      {
        // expand in 3 dimensions
        result = GeometryEngine.Instance.Expand(env, 0.5, 0.5, 0.5, true);
      }
      catch (InvalidOperationException)
      {
        // the geometry is not Z-Aware
      }
    
      // expand a 3d envelope
      MapPoint pt1 = MapPointBuilderEx.CreateMapPoint(100, 100, 100);
      MapPoint pt2 = MapPointBuilderEx.CreateMapPoint(200, 200, 200);
    
      env = EnvelopeBuilderEx.CreateEnvelope(pt1, pt2);
      // env.HasZ = true
    
      result = GeometryEngine.Instance.Expand(env, 0.5, 0.5, 0.5, true);
    
      // result.Center = 150, 150, 150
      // result.XMin = 125
      // result.YMin = 125
      // result.ZMin = 125
      // result.XMax = 175
      // result.YMax = 175
      // result.ZMax = 175
    }
    Polygon touches another Polygon
    {
      // two disjoint polygons
      Envelope env = EnvelopeBuilderEx.CreateEnvelope(MapPointBuilderEx.CreateMapPoint(4.0, 4.0), MapPointBuilderEx.CreateMapPoint(8, 8));
      Polygon poly1 = PolygonBuilderEx.CreatePolygon(env);
    
      Envelope env2 = EnvelopeBuilderEx.CreateEnvelope(MapPointBuilderEx.CreateMapPoint(1.0, 1.0), MapPointBuilderEx.CreateMapPoint(5, 5));
      Polygon poly2 = PolygonBuilderEx.CreatePolygon(env2);
    
      bool touches = GeometryEngine.Instance.Touches(poly1, poly2);    // touches = false
    
      // another polygon that touches the first
      Envelope env3 = EnvelopeBuilderEx.CreateEnvelope(MapPointBuilderEx.CreateMapPoint(1.0, 1.0), MapPointBuilderEx.CreateMapPoint(4, 4));
      Polygon poly3 = PolygonBuilderEx.CreatePolygon(env3);
    
      touches = GeometryEngine.Instance.Touches(poly1, poly3);         // touches = true
    }
    Union two Polygons
    {
      // union two polygons
    
      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);
      bool isSimple = GeometryEngine.Instance.IsSimpleAsFeature(poly1);
    
      Envelope env = EnvelopeBuilderEx.CreateEnvelope(MapPointBuilderEx.CreateMapPoint(4.0, 4.0), MapPointBuilderEx.CreateMapPoint(8, 8));
      Polygon poly2 = PolygonBuilderEx.CreatePolygon(env);
      isSimple = GeometryEngine.Instance.IsSimpleAsFeature(poly2);
    
      Geometry g = GeometryEngine.Instance.Union(poly1, poly2);
      Polygon polyResult = g as Polygon;
    }
    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
      }
    Create Map Frame and Set Camera
    {
      //Create a map frame and set its camera by zooming to the extent of an existing bookmark.
      var project = Project.Current;
      await QueuedTask.Run(() =>
      {
    
      //Build 2D envelope geometry
      Coordinate2D mf_ll = new Coordinate2D(6.0, 8.5);
      Coordinate2D mf_ur = new Coordinate2D(8.0, 10.5);
      Envelope mf_env = EnvelopeBuilderEx.CreateEnvelope(mf_ll, mf_ur);
    
      //Reference map, create MF and add to layout
      MapProjectItem mapPrjItem = project.GetItems<MapProjectItem>()
                           .FirstOrDefault(item => item.Name.Equals("Map"));
      Map mfMap = mapPrjItem.GetMap();
      Bookmark bookmark = mfMap.GetBookmarks().FirstOrDefault(
                            b => b.Name == "Great Lakes");
    
      MapFrame mfElm = ElementFactory.Instance.CreateMapFrameElement(
                           layout, mf_env, mfMap, "New Map Frame");
    
      //Zoom to bookmark
      mfElm.SetCamera(bookmark);
      });
    }
    Requirements

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

    ArcGIS Pro version: 3.0 or higher.
    See Also