Edit features

A feature has a geometry, multiple attributes, and, potentially, attachments. For details about editing and creating geometry, see Edit geometry. If you want to allow users to edit existing attributes and attachments, the recommendation is to use feature forms; see Edit using feature forms. If you are calculating values for attributes and attachments without user input, see the following sections about creating, deleting, and updating a feature using the FeatureTable API.

Create, delete, update features with FeatureTable

You can create or delete features, or update existing features, using the FeatureTable API.

The API gives you more fine-grained control over feature editing operations, including create and edit features, add, edit, or remove feature attachments, and edit feature geometry.

For editing workflows that use a local geodatabase A geodatabase is a spatial data storage format that can contain multiple datasets of geographic features and non-spatial tabular data, as well as attachments, field domain definitions, and relationships between layers/tables. Learn more , you can use geodatabase transactions to group and manage a set of edits as a single item (transaction). This makes it easier to control when those edits are committed (saved) or rolled back (discarded) as a single unit.

The enterprise geodatabase can use versioning to support multiuser editing scenarios and long transactions. If you require multiple editors to concurrently access services with the ability to undo and redo their edits, you can implement branch versions in your ArcGIS Enterprise portal. For more information, see Branch versioned data in this guide or Share branch versioned data in the ArcGIS Pro documentation.

For some feature service editing workflows, it’s recommended that an analyst using ArcGIS Pro periodically review edits and verify data integrity. Although the API can perform some types of data validation, other validation tasks, such as validating topologies, cannot be performed using the API alone.

If necessary, feature editing can be separated into two parts: geometry editing and attribute editing. In certain scenarios, you may only be interested in editing the location of a feature, while at other times you might only want to edit attributes and attachments. The referenced documentation explores editing the individual parts of the feature in greater detail.

Add features

Apps often allow users to create a new feature by clicking on the map to indicate the feature’s location. You can provide this capability by listening for a click event on your map view and adding a new feature in the event handler.

To add features to a feature table, create a new feature from geometry (for example, point, line, or polygon), create attributes for the new feature, and then call add feature. This adds the feature to a table stored locally on your device.

If these local edits need to be shared with the parent feature service, call ApplyEditsAsync() on the table’s ServiceGeodatabase. See Apply edits from the service geodatabase for more information.

    private async Task AddFeature(MapPoint structureLocation, string type, string cause)
    {
        // Create attributes for the feature.
        Dictionary<string, object> attributes = new()
        {
            { "typdamage", type },
            { "primcause", cause }
        };

        // Create a new feature from the attributes and the point.
        Feature newFeature = _damagePointsTable.CreateFeature(attributes, structureLocation);

        // Add the feature to the local table.
        await _damagePointsTable.AddFeatureAsync(newFeature);

        // If the feature table is a service feature table then
        // apply edits to its service geodatabase.
        //var editResults = await _serviceGdb.ApplyEditsAsync();
    }

For information on handling true curves when adding features, see Add true curves. To create features using predefined templates, see Use shared templates to create features.

Delete features

You can delete several features from a feature table using the delete features method that accepts a list of features, or just a single feature with a call to delete feature. All edits are stored in the feature table on the client.

If these edits need to be shared with the parent feature service, apply them to the table’s service geodatabase. See Apply edits from the service geodatabase for more information.

    private async Task DeleteSelectedFeatures(FeatureLayer damageLayer)
    {
        // Get all selected features in the layer.
        FeatureQueryResult selectedFeatures = await damageLayer.GetSelectedFeaturesAsync();

        // Delete the selected features.
        await _damagePointsTable.DeleteFeaturesAsync(selectedFeatures);

        // If the feature table is a service feature table then
        // apply edits to its service geodatabase.
        // var editResults = await _serviceGdb.ApplyEditsAsync();
    }

Update features

Feature updates include moving or reshaping a feature’s geometry or making edits to attribute values. All edits are stored in the feature table on the client.

If these edits need to be shared with the parent feature service, apply them to the table’s service geodatabase. See Apply edits from the service geodatabase for more information.

    private async Task UpdateFeature(ArcGISFeature arcgisFeature)
    {
        // Change the feature's attribute value.
        arcgisFeature.Attributes["typdamage"] = "Inaccessible";

        // Change the feature's geometry.
        MapPoint location = arcgisFeature.Geometry as MapPoint;
        MapPoint newLocation = new MapPoint(location.X, location.Y + 50000);
        arcgisFeature.Geometry = newLocation;

        // Update the feature on the local table.
        await _damagePointsTable.UpdateFeatureAsync(arcgisFeature);

        // If the feature table is a service feature table then
        // apply edits to its service geodatabase.
        // var editResults = await _serviceGdb.ApplyEditsAsync();
    }

For information on handling true curves when updating features, see Update true curves.

Edit attachments

If the feature’s table has attachments An attachment is a file, such as a photograph (for example, a .png file) or a document, that is associated with individual features in a geodatabase or feature layer. Learn more enabled, you can associate documents and photographs with individual features. You can add any file, that has a supported attachment format, to the feature’s collection of attachments using ArcGISFeature.AddAttachmentAsync(). You can attach the file directly or provide a path to the file which optimizes memory. Alongside adding attachments, you can associate a keyword. You may add a keyword upon adding an attachment or even update an existing attachment to add a keyword. Keywords can be used to identify or provide context for attachments. For more information about enabling attachments on the feature layer, see the ArcGIS Online, ArcGIS Enterprise, and ArcGIS Pro documentation.

            // Check if the table supports attachments.
            if (_damagePointsTable.HasAttachments)
            {
                // Add an attachment (image).
                // The content type string is the MIME type for JPEG files.
                await _selectedFeature.AddAttachmentAsync
                    (imageFile.Name,
                    "image/jpeg",
                    attachmentData);
            }

If the feature’s table has attachments An attachment is a file, such as a photograph (for example, a .png file) or a document, that is associated with individual features in a geodatabase or feature layer. Learn more enabled and the feature’s attachment collection can be edited, you can update any attachment with new details.

            // Verify the table supports attachments and the feature's attachments can be edited.
            if (_damagePointsTable.HasAttachments &&
                _selectedFeature.CanEditAttachments)
            {
                // Update the attachment with a new image (other properties are retained).
                await _selectedFeature.UpdateAttachmentAsync
                    (selectedAttachment,
                    selectedAttachment.Name,
                    selectedAttachment.ContentType,
                    attachmentData);
            }

Or, you can remove any attachment from the feature’s attachment collection.

            // Delete one of the attachments for the selected feature.
            await _selectedFeature.DeleteAttachmentAsync(selectedAttachment);

Undo changes

There are times when making changes to data that you might want to undo all the edits in all of the local tables you are working with. The ServiceGeodatabase, a container for a collection of ServiceFeatureTables connected to a feature service, provides ServiceGeodatabase.HasLocalEdits() to determine if any of the tables have unapplied edits. If you confirm that edits exist, then you can use ServiceGeodatabase.UndoLocalEditsAsync() to asynchronously undo all of the local edits in all the tables. This logic could be applied before or after you apply or synchronize edits back to the feature service. In addition, you could utilize this logic during an editing workflow where you wish to provide a UI component to allow a user to undo their changes.

        // Undo all local edits for the version
        if (_serviceGdb.HasLocalEdits())
        {
            await _serviceGdb.UndoLocalEditsAsync();
        }

Work with geometry

There are many ways you can create or edit geometries while editing features. If you have your geometry coordinates prepared before you begin, you can use geometry constructors to create the geometry all at once. When a more iterative process is required, you may need geometry builders to build or edit your geometry. Some actions that you perform on existing geometries can result in new geometries. In this case, the geometry engine provides geometric operations to help with that workflow. Lastly, if your application users want to create or edit geometries interactively in a map view, you can use the geometry editor. To learn more about these options and to help you determine which one fits your requirements, see the Edit geometry topic.

Edit true curves

Geometries that appear on a map as curves can be represented in two ways: as true curves or as densified curves. True curves are mathematically defined curves, such as circular or elliptical arcs. Densified curves are made up of many short, straight line segments that approximate the shape of a curve. You can use ArcGISFeatureServiceInfo to find out what type of curve support a feature service provides and adapt your app’s behavior accordingly. For example, if the service supports true curves, you can enable a curve-aware user experience in your app. Or, if the service doesn’t support true curves, you can densify any curve geometries before sending them to the service. By default, your app’s environment has ArcGISRuntimeEnvironment.ServiceCurveGeometryMode set to ServiceCurveGeometryMode.TrueCurveClient.

It is important to bear in mind that some GeometryEngine functionality will produce results by densifying curves. See GeometryEngine in the API Reference documentation for details.

For more information, see True curves in the Geometry topic.

Add true curves

Your app can add features with true curves to ArcGIS feature services that support true curves. Use properties on ArcGISFeatureServiceInfo to find out what curve support a feature service provides.

If your app’s environment has ArcGISRuntimeEnvironment.ServiceCurveGeometryMode set to ServiceCurveGeometryMode.TrueCurveClient (the default value), your app will identify itself to the feature service as a true curve client when requesting existing geometries and when adding new features with true curve geometries.

Feature Service in the ArcGIS REST API ArcGIS REST APIs are the API specifications for all ArcGIS location services and ArcGIS Enterprise services. They define the operations, parameters, and structures required to make HTTPS requests. Learn more documentation also contains details about curve support in a feature service.

Update true curves

Feature services can be published with protections that disallow edits to existing true curves from curve-unaware clients. When a service is published with ArcGISFeatureServiceInfo.OnlyAllowTrueCurveUpdatesByTrueCurveClients set to true, the author intends that feature geometries containing curves should only be changed by those clients that guarantee they correctly handle true curves.

If ArcGISRuntimeEnvironment.ServiceCurveGeometryMode is set to the default value ServiceCurveGeometryMode.TrueCurveClient, your app is identifying itself to a feature service as a true curve client, which has the following effects.

• In online feature service editing workflows, not only will your app receive true curves when fetching existing geometries from the service, but it will also be allowed to submit updates to existing true curve geometries.

• In offline feature service editing workflows, a sync-enabled mobile Geodatabase will contain true curve geometries if ArcGISRuntimeEnvironment.ServiceCurveGeometryMode is set to ServiceCurveGeometryMode.TrueCurveClient at the time the geodatabase is created and downloaded. Thereafter, that geodatabase will always behave as a true curve client when edits are synchronized, as indicated by Geodatabase.IsTrueCurveClient returning true.

• In offline feature service editing workflows, web maps can be configured to maintain and download true curves. An on-demand offline map will honor this setting. Otherwise, the behavior is as above for sync-enabled mobile geodatabases.

Work with attributes and attachments

The code examples illustrated above show a typical workflow for editing attribute values and attachments when adding, deleting, and updating features. In these scenarios, the manner in which the attribute values are obtained and validated are left to your creativity during application development.

Layers that implement IFeatureFormSource support a feature form that is designed to ease attribute and attachment editing and validation for a feature. This form guides the users to the correct fields, constrains allowed values for a field, and supports the addition of new attachments or replacement of existing ones. We recommend that you display this feature form in your app by utilizing the FeatureFormView toolkit component. For more information, see the Edit using toolkit topic in this guide.

Use shared templates to create features

Shared templates simplify feature creation by reducing repetitive edits, improving consistency, and reinforcing data integrity. A SharedTemplate can define default attributes, symbology, tools, and geometry-construction behavior ensuring related content is created consistently. ServiceGeodatabase and Geodatabase support shared templates from ArcGIS Enterprise 11.3+ and ArcGIS Online feature services, as well as from standalone mobile geodatabases exported from ArcGIS Pro 3.6+.

Supported template types include:

• Feature: Creates a single feature with predefined attributes and behavior. For example, place an electric pole already configured as a 40-foot wood pole, or add a building feature with the correct use, height, and materials.
• Preset: Places a complete predefined assembly in one step. Utilities can add transformer banks or switch cabinets, while local governments can place standard site layouts, such as park amenities or traffic control setups, with related features created together.
• Group: Creates multiple related features from one sketch by applying Feature builder transformations (for example, offsets, buffers, and intervals) to a base geometry. This supports workflows such as drawing a service line and automatically adding connected assets, or placing rows of street trees, parking spaces, signs, or streetlights.

Together, these templates help developers deliver guided, high-productivity editing experiences across utility and non-utility datasets, with built-in domain logic and minimal user input.

Typical workflow:

1. Query templates with QuerySharedTemplatesAsync(). Use SharedTemplateQueryParameters to filter by layer, tag, visibility, or source.
2. Build an in-memory feature set with CreateFeaturesAsync(). This returns a SharedTemplateFeatureCreationSet containing features generated by the template, with attributes that can be reviewed and modified before committing.
3. Commit this feature set with AddFeaturesAsync(). The SharedTemplateFeatureCreationSet is committed transactionally (all-or-nothing).

For utility network datasets, preset and group templates can also optionally create utility associations for generated features.

Many apps already use layer-level FeatureTemplate objects to power template pickers and create single features. To support a unified picker workflow, include these templates in shared template queries by setting SharedTemplateQueryParameters.SourceType to Layer or All. Returned FeatureTemplate values are automatically upgraded to SharedTemplate objects with feature-type definitions, enabling a single API surface for both layer templates and datastore shared templates.

Edit data from a branch version

Edits can be made to service feature tables from a branch version Branch versioning is a type of geodatabase versioning that works with the ArcGIS Enterprise Web GIS model. It uses a services-based architecture to allow multi-user editing workflows and long transaction scenarios via feature services. Learn more the same way they are made to any ServiceFeatureTable. You can also follow the process described above for adding, deleting, and updating features or their attachments.