ArcGIS Pro 3.8 API Reference Guide
ArcGIS.Core.Geometry Namespace / Geometry Class / ToJson Method
(Optional) Indicates if the spatial reference is to be skipped in the JSON output string. Default value is false.
Example

In This Topic
    ToJson Method (Geometry)
    In This Topic
    Serializes this geometry instance into an ArcGIS JSON geometry representation.
    Syntax
    public string ToJson( 
       bool skipSR
    )
    Public Function ToJson( _
       Optional ByVal skipSR As Boolean _
    ) As String

    Parameters

    skipSR
    (Optional) Indicates if the spatial reference is to be skipped in the JSON output string. Default value is false.

    Return Value

    Geometry represented as a JSON string.
    Remarks
    Note that if the geometry contains ID information, this property will not be preserved in the JSON string. ID is not part of the JSON specification.
    Example
    Import and Export Geometries to JSON
    {
      // MapPoint
      string inputString =
        "{\"x\":1,\"y\":2,\"spatialReference\":{\"wkid\":4326,\"latestWkid\":4326}}";
      Geometry geometryFromJson = GeometryEngine.Instance.ImportFromJson(
        JsonImportFlags.JsonImportDefaults, inputString);
    
      MapPoint importPoint = geometryFromJson as MapPoint;
      // importPoint = 1, 2
      // importPoint.SpatialReference.WKid = 4326
    
      // use the MapPointBuilderEx convenience method
      MapPoint importPoint2 = MapPointBuilderEx.FromJson(inputString);
      // importPoint2 = 1, 2
      // impointPoint2.SpatialReference.Wkid = 4326
    
      string outputString = GeometryEngine.Instance.ExportToJson(
        JsonExportFlags.JsonExportDefaults, importPoint);
      // outputString =
      //   "{\"x\":1,\"y\":2,\"spatialReference\":{\"wkid\":4326,\"latestWkid\":4326}}"
    
      string outputString2 = importPoint.ToJson();
    
      inputString =
        "{\"spatialReference\":{\"wkid\":4326},\"z\":3,\"m\":4,\"x\":1,\"y\":2}";
      importPoint = GeometryEngine.Instance.ImportFromJson(
        JsonImportFlags.JsonImportDefaults, inputString) as MapPoint;
      // importPoint.HasM = true
      // importPoint.HasZ = true
      // importPoint.X = 1
      // importPoint.Y = 2
      // importPoint.M = 4
      // importPoint.Z = 3
    
      importPoint2 = MapPointBuilderEx.FromJson(inputString);
    
      // export to json - skip spatial reference
      outputString = GeometryEngine.Instance.ExportToJson(
                    JsonExportFlags.JsonExportSkipCRS, importPoint);
      // outputString = "{\"x\":1,\"y\":2,\"z\":3,\"m\":4}"
    
      // export from mappoint, skipping the sr - same as GeometryEngine.Instance.ExportToJson w JsonExportFlags.JsonExportSkipCRS
      outputString2 = importPoint.ToJson(true);
    
      //
      // Multipoint
      //
      List<Coordinate2D> coords = new List<Coordinate2D>()
    {
      new Coordinate2D(100, 200),
      new Coordinate2D(201, 300),
      new Coordinate2D(301, 400),
      new Coordinate2D(401, 500)
    };
    
      Multipoint multipointFromCoords = MultipointBuilderEx.CreateMultipoint(
        coords, SpatialReferences.WebMercator);
    
      inputString =
        "{\"points\":[[100,200],[201,300],[301,400],[401,500]],\"spatialReference\":{\"wkid\":3857}}";
      Multipoint importMultipoint =
        GeometryEngine.Instance.ImportFromJson(
               JsonImportFlags.JsonImportDefaults, inputString) as Multipoint;
      // importMultipoint.IsEqual(multipoint) = true
    
      ReadOnlyPointCollection pointsFromMultipoint = importMultipoint.Points;
      // points.Count = 4
      // points[0] = 100, 200
      // points[1] = 201, 300
      // points[2] = 301, 400
      // points[3] = 401, 500
    
      // use the MultipointbuilderEx convenience method
      Multipoint importMultipoint2 = MultipointBuilderEx.FromJson(inputString);
      // importMultipoint2.IsEqual(multipoint) = true
    
      // export to json
      outputString = GeometryEngine.Instance.ExportToJson(
                      JsonExportFlags.JsonExportDefaults, multipointFromCoords);
      // outputString = inputString
    
      // or use the multipoint itself
      outputString2 = multipointFromCoords.ToJson();
    
      //
      // Polyline
      //
      Polyline polylineFromCoords = PolylineBuilderEx.CreatePolyline(
                               coords, SpatialReferences.WebMercator);
    
      // export without the spatial reference
      outputString = GeometryEngine.Instance.ExportToJson(
                              JsonExportFlags.JsonExportSkipCRS, polylineFromCoords);
      // import
      geometry = GeometryEngine.Instance.ImportFromJson(
                   JsonImportFlags.JsonImportDefaults, outputString);
      Polyline importPolyline = geometryFromJson as Polyline;
      // importPolyline.SpatialReference = null
    
    
      pointsFromMultipoint = importPolyline.Points;
      // points.Count = 4
      // points[0] = 100, 200
      // points[1] = 201, 300
      // points[2] = 301, 400
      // points[3] = 401, 500
    
      // use the polylineBuilderEx convenience method
      Polyline importPolyline2 = PolylineBuilderEx.FromJson(outputString);
      // importPolyline2 = importPolyline
    
      outputString2 = importPolyline2.ToJson();
      // outputString2 = outputString
    
      //
      // Polygon
      //
      Polygon polygonFromCoords = PolygonBuilderEx.CreatePolygon(
                                    coords, SpatialReferences.WebMercator);
    
      // export without the spatial reference
      outputString = GeometryEngine.Instance.ExportToJson(
                                JsonExportFlags.JsonExportSkipCRS, polygonFromCoords);
      // import
      geometryFromJson = GeometryEngine.Instance.ImportFromJson(
                           JsonImportFlags.JsonImportDefaults, outputString);
    
      Polygon importPolygon = geometry as Polygon;
      // importPolygon.SpatialReference = null
      pointsFromMultipoint = importPolygon.Points;
      // points.Count = 5
    
      // polygonBuilderEx convenience method
      Polygon importPolyon2 = PolygonBuilderEx.FromJson(outputString);
      // importPolygon2 = importPolygon
    
      // export from the polygon
      outputString2 = importPolyon2.ToJson(true);
    
      // Empty polygon
      polygon = PolygonBuilderEx.CreatePolygon(SpatialReferences.WebMercator);
      outputString = GeometryEngine.Instance.ExportToJson(
                                     JsonExportFlags.JsonExportDefaults, polygon);
      importPolygon = GeometryEngine.Instance.ImportFromJson(
                          JsonImportFlags.JsonImportDefaults, outputString) as Polygon;
    
      // importPolygon.IsEmpty = true
      // importPolygon.SpatialReference.Wkid = 3857
    }
    Insert M value at the given distance - InsertMAtDistance
    {
      string json = "{\"hasM\":true,\"paths\":[[[-3000,-2000,-3],[-2000,-2000,-2],[-1000,-2000,null]]]}";
      polyline = PolylineBuilderEx.FromJson(json);
    
      // A point already exists at the given distance
      double m = -1;
      double distance = 2000;
      bool createNewPart = false;
      Polyline outputPolyline = GeometryEngine.Instance.InsertMAtDistance(polyline, m, distance, AsRatioOrLength.AsLength, createNewPart, out bool splitHappened, out int partIndex, out int segmentIndex) as Polyline;
    
      // splitHappened = false, partIndex = 0, segmentIndex = 2
      // outputPolyline.Points[2].M = -1
    
      json = "{\"hasM\":true,\"paths\":[[[-3000,-2000,-3],[-2000,-2000,-2],[-1000,-2000,-1]],[[0,0,0],[0,1000,0],[0,2000,2]]],\"spatialReference\":{\"wkid\":3857}}";
      polyline = PolylineBuilderEx.FromJson(json);
    
      // A point already exists at the given distance, but createNewPart = true
      m = 1;
      distance = 3000;
      createNewPart = true;
      outputPolyline = GeometryEngine.Instance.InsertMAtDistance(polyline, m, distance, AsRatioOrLength.AsLength, createNewPart, out splitHappened, out partIndex, out segmentIndex) as Polyline;
      string outputJson = outputPolyline.ToJson();
    
      // splitHappened = true, partIndex = 2, segmentIndex = 0
      // outputJson = {"hasM":true,"paths":[[[-3000,-2000,-3],[-2000,-2000,-2],[-1000,-2000,-1]],[[0,0,0],[0,1000,1]],[[0,1000,1],[0,2000,2]]]}}
      // A new part has been created and the M values for outputPolyline.Points[4] and outputPolyline.Points[5] have been modified
    
      // A point does not exist at the given distance
      m = 1;
      distance = 3500;
      createNewPart = false;
      outputPolyline = GeometryEngine.Instance.InsertMAtDistance(polyline, m, distance, AsRatioOrLength.AsLength, createNewPart, out splitHappened, out partIndex, out segmentIndex) as Polyline;
      outputJson = outputPolyline.ToJson();
    
      // splitHappened = true even though createNewPart = false because a new point was created
      // partIndex = 1, segmentIndex = 2
      // outputJson = {"hasM":true,"paths":[[[-3000,-2000,-3],[-2000,-2000,-2],[-1000,-2000,-1]],[[0,0,0],[0,1000,0],[0,1500,1],[0,2000,2]]]}
      // A new point has been inserted (0, 1500, 1) by interpolating the X and Y coordinates and M value set to the input M value.
    }
    Requirements

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

    ArcGIS Pro version: 3.0 or higher.
    See Also