diff --git a/src/MAUI/Maui.Samples/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/SnapGeometryEditsWithUtilityNetworkRules.xaml b/src/MAUI/Maui.Samples/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/SnapGeometryEditsWithUtilityNetworkRules.xaml
new file mode 100644
index 0000000000..3815a706cf
--- /dev/null
+++ b/src/MAUI/Maui.Samples/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/SnapGeometryEditsWithUtilityNetworkRules.xaml
@@ -0,0 +1,194 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/MAUI/Maui.Samples/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/SnapGeometryEditsWithUtilityNetworkRules.xaml.cs b/src/MAUI/Maui.Samples/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/SnapGeometryEditsWithUtilityNetworkRules.xaml.cs
new file mode 100644
index 0000000000..69da710062
--- /dev/null
+++ b/src/MAUI/Maui.Samples/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/SnapGeometryEditsWithUtilityNetworkRules.xaml.cs
@@ -0,0 +1,438 @@
+// Copyright 2025 Esri.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at: http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific
+// language governing permissions and limitations under the License.
+
+using Esri.ArcGISRuntime.Data;
+using Esri.ArcGISRuntime.Geometry;
+using Esri.ArcGISRuntime.Mapping;
+using Esri.ArcGISRuntime.Symbology;
+using Esri.ArcGISRuntime.UI;
+using Esri.ArcGISRuntime.UI.Editing;
+using Esri.ArcGISRuntime.UtilityNetworks;
+using ArcGIS.Samples.Managers;
+
+namespace ArcGIS.Samples.SnapGeometryEditsWithUtilityNetworkRules
+{
+ [ArcGIS.Samples.Shared.Attributes.Sample(
+ name: "Snap geometry edits with utility network rules",
+ category: "Utility network",
+ description: "Use the Geometry Editor to edit geometries using utility network connectivity rules.",
+ instructions: "To edit a geometry, tap a point geometry to be edited in the map to select it. Then edit the geometry by clicking the button to start the geometry editor.",
+ tags: new[] { "edit", "feature", "geometry editor", "graphics", "layers", "map", "snapping", "utility network" })]
+ [ArcGIS.Samples.Shared.Attributes.OfflineData("0fd3a39660d54c12b05d5f81f207dffd")]
+ public partial class SnapGeometryEditsWithUtilityNetworkRules
+ {
+ // Layer name for the pipeline subtype feature layer.
+ private const string PipelineLayerName = "PipelineLine";
+
+ // Subtype names for utility network features.
+ private const string ServicePipeLayerName = "Service Pipe";
+ private const string DistributionPipeName = "Distribution Pipe";
+
+ private const string DeviceLayerName = "PipelineDevice";
+ private const string ExcessFlowValveName = "Excess Flow Valve";
+
+ private const string JunctionLayerName = "PipelineJunction";
+ private const string ControllableTeeName = "Controllable Tee";
+
+ // Identifier for non-UN features.
+ private const string GraphicsId = "Graphics";
+
+ // Default symbology for graphic and sublayers used to restore after edit.
+ private readonly Renderer _defaultGraphicRenderer = new SimpleRenderer(new SimpleLineSymbol(SimpleLineSymbolStyle.Dash, System.Drawing.Color.Gray, 3));
+ private Renderer _defaultDistributionRenderer = null;
+ private Renderer _defaultServiceRenderer = null;
+
+ // Hold references to the selected feature.
+ private Feature _selectedFeature;
+
+ // Hold references to the subtype sublayers for the distribution and service pipe layers.
+ private SubtypeSublayer _distributionPipeLayer;
+ private SubtypeSublayer _servicePipeLayer;
+
+ // Hold a reference to the utility network geodatabase.
+ private Geodatabase _geodatabase;
+
+ // Graphic json
+ string graphicJson = "{\"paths\":[[[-9811826.6810284462,5132074.7700250093],[-9811786.4643617794,5132440.9533583419],[-9811384.2976951133,5132354.1700250087],[-9810372.5310284477,5132360.5200250093],[-9810353.4810284469,5132066.3033583425]]],\"spatialReference\":{\"wkid\":102100,\"latestWkid\":3857}}";
+
+ public SnapGeometryEditsWithUtilityNetworkRules()
+ {
+ InitializeComponent();
+ _ = InitializeAsync();
+ }
+
+ private async Task InitializeAsync()
+ {
+ try
+ {
+ // Create a map.
+ MyMapView.Map = new Map(BasemapStyle.ArcGISStreetsNight)
+ {
+ InitialViewpoint = new Viewpoint(new MapPoint(-9811055.156028448, 5131792.19502501, SpatialReferences.WebMercator), 1e4)
+ };
+
+ // Set the map load setting feature tiling mode.
+ // Enabled with full resolution when supported is used to ensure that snapping to geometries occurs in full resolution.
+ // Snapping in full resolution improves snapping accuracy.
+ MyMapView.Map.LoadSettings.FeatureTilingMode = FeatureTilingMode.EnabledWithFullResolutionWhenSupported;
+
+ await AddLayersToMapFromGeodatabase();
+
+ // Create a graphics overlay and add it to the map view.
+ MyMapView.GraphicsOverlays.Add(new GraphicsOverlay() { Id = GraphicsId, Renderer = _defaultGraphicRenderer });
+ MyMapView.GraphicsOverlays[0].Graphics.Add(new Graphic(Geometry.FromJson(graphicJson)));
+
+ // Create and add a geometry editor to the map view.
+ MyMapView.GeometryEditor = new GeometryEditor();
+
+ // Enable snapping on the geometry layer.
+ MyMapView.GeometryEditor.SnapSettings.IsEnabled = true;
+ MyMapView.GeometryEditor.SnapSettings.IsFeatureSnappingEnabled = true;
+
+ // Show the UI.
+ SnappingControls.IsVisible = true;
+ }
+ catch (Exception ex)
+ {
+ // Show an error message.
+ await DisplayAlert("Error", ex.Message, "Ok");
+ }
+ }
+
+ private async Task AddLayersToMapFromGeodatabase()
+ {
+ // Get the path to the local geodatabase for this platform (temp directory, for example).
+ string geodatabasePath = DataManager.GetDataFolder("0fd3a39660d54c12b05d5f81f207dffd", "NapervilleGasUtilities.geodatabase");
+
+ // See if the geodatabase file is already present.
+ if (File.Exists(geodatabasePath))
+ {
+ // Open the geodatabase.
+ _geodatabase = await Geodatabase.OpenAsync(geodatabasePath);
+
+ // Subscribe to the unloaded event to close the geodatabase when the sample is closed.
+ Unloaded += SampleUnloaded;
+
+ // Get and load feature tables from the geodatabase.
+ // Create subtype feature layers from the feature tables and add them to the map.
+ var pipeTable = _geodatabase.GetGeodatabaseFeatureTable(PipelineLayerName);
+ await pipeTable.LoadAsync();
+
+ var pipeLayer = new SubtypeFeatureLayer(pipeTable);
+ MyMapView.Map.OperationalLayers.Add(pipeLayer);
+
+ var deviceTable = _geodatabase.GetGeodatabaseFeatureTable(DeviceLayerName);
+ await deviceTable.LoadAsync();
+
+ SubtypeFeatureLayer devicelayer = new SubtypeFeatureLayer(deviceTable);
+ MyMapView.Map.OperationalLayers.Add(devicelayer);
+
+ var junctionTable = _geodatabase.GetGeodatabaseFeatureTable(JunctionLayerName);
+ await junctionTable.LoadAsync();
+
+ SubtypeFeatureLayer junctionlayer = new SubtypeFeatureLayer(junctionTable);
+ MyMapView.Map.OperationalLayers.Add(junctionlayer);
+
+ // Add the utility network to the map and load it.
+ var utilityNetwork = _geodatabase.UtilityNetworks.FirstOrDefault();
+ MyMapView.Map.UtilityNetworks.Add(utilityNetwork);
+ await utilityNetwork.LoadAsync();
+
+ // Load the map.
+ await MyMapView.Map.LoadAsync();
+
+ // Ensure all layers are loaded.
+ await Task.WhenAll(MyMapView.Map.OperationalLayers.ToList().Select(layer => layer.LoadAsync()).ToList());
+
+ // Set the visibility of the sublayers and store the default renderer for the distribution and service pipe layers.
+ // In this sample we will only set a small subset of sublayers to be visible.
+ foreach (var sublayer in pipeLayer.SubtypeSublayers)
+ {
+ switch (sublayer.Name)
+ {
+ case DistributionPipeName:
+ _distributionPipeLayer = sublayer;
+ _defaultDistributionRenderer = sublayer.Renderer;
+ break;
+ case ServicePipeLayerName:
+ _servicePipeLayer = sublayer;
+ _defaultServiceRenderer = sublayer.Renderer;
+ break;
+ default:
+ sublayer.IsVisible = false;
+ break;
+ }
+ }
+
+ // To avoid too much visual clutter, only show the Excess Flow Valve and Controllable Tee sublayers in the device layer.
+ foreach (var sublayer in devicelayer.SubtypeSublayers)
+ {
+ switch (sublayer.Name)
+ {
+ case ExcessFlowValveName:
+ case ControllableTeeName:
+ sublayer.IsVisible = true;
+ break;
+ default:
+ sublayer.IsVisible = false;
+ break;
+ }
+ }
+ }
+ }
+
+ private async Task SetSnapSettings(UtilityAssetType assetType)
+ {
+ // Get the snap rules associated with the asset type.
+ SnapRules snapRules = await SnapRules.CreateAsync(MyMapView.Map.UtilityNetworks[0], assetType);
+
+ // Synchronize the snap source collection with the map's operational layers using the snap rules.
+ // Setting SnapSourceEnablingBehavior.SetFromRules will enable snapping for the layers and sublayers specified in the snap rules.
+ MyMapView.GeometryEditor.SnapSettings.SyncSourceSettings(snapRules, SnapSourceEnablingBehavior.SetFromRules);
+
+ // Enable snapping for the graphics overlay.
+ var graphicsSourceSetting = MyMapView.GeometryEditor.SnapSettings.SourceSettings.First(sourceSetting => sourceSetting.Source is GraphicsOverlay);
+ graphicsSourceSetting.IsEnabled = true;
+
+ var snapSources = new List();
+
+ foreach (var sourceSetting in MyMapView.GeometryEditor.SnapSettings.SourceSettings)
+ {
+ if (sourceSetting.Source is GraphicsOverlay graphicsOverlay)
+ {
+ snapSources.Add(new SnapSourceSettingsVM(sourceSetting));
+ }
+ else if (sourceSetting.Source is SubtypeFeatureLayer subtypeFeatureLayer && subtypeFeatureLayer.Name == PipelineLayerName)
+ {
+ foreach (var subtypeSublayer in sourceSetting.ChildSourceSettings)
+ {
+ switch ((subtypeSublayer.Source as SubtypeSublayer).Name)
+ {
+ case ServicePipeLayerName:
+ case DistributionPipeName:
+ snapSources.Add(new SnapSourceSettingsVM(subtypeSublayer));
+ break;
+ }
+ }
+ }
+ }
+
+ // Create a list of snap source settings with snapping enabled.
+ SnapSourcesList.ItemsSource = snapSources;
+ }
+
+ private void GeometryEditorButton_Click(object sender, EventArgs e)
+ {
+ // Get the symbol for the selected feature.
+ Symbol symbol = ((GeodatabaseFeatureTable)_selectedFeature.FeatureTable).LayerInfo?.DrawingInfo?.Renderer?.GetSymbol(_selectedFeature);
+
+#if ANDROID || IOS
+ // On mobile default to reticle vertex tool for better touch experience.
+ MyMapView.GeometryEditor.Tool = new ReticleVertexTool();
+#endif
+
+ // Set the vertex symbol for the geometry editor tool.
+ MyMapView.GeometryEditor.Tool.Style.VertexSymbol = MyMapView.GeometryEditor.Tool.Style.FeedbackVertexSymbol = MyMapView.GeometryEditor.Tool.Style.SelectedVertexSymbol = symbol;
+ MyMapView.GeometryEditor.Tool.Style.VertexTextSymbol = null;
+
+ // Hide the selected feature.
+ if (_selectedFeature != null && _selectedFeature.FeatureTable?.Layer is FeatureLayer selectedFeatureLayer)
+ {
+ selectedFeatureLayer.SetFeatureVisible(_selectedFeature, false);
+ }
+
+ // Start the geometry editor.
+ MyMapView.GeometryEditor.Start(_selectedFeature.Geometry);
+ }
+
+ private void DiscardButton_Click(object sender, EventArgs e)
+ {
+ // Discard the current edit.
+ MyMapView.GeometryEditor.Stop();
+
+ // Reset the selection.
+ ResetSelections();
+ }
+
+ private async void SaveButton_Click(object sender, EventArgs e)
+ {
+ // Stop the geometry editor and get the updated geometry.
+ Geometry geometry = MyMapView.GeometryEditor.Stop();
+
+ // Update the feature with the new geometry.
+ _selectedFeature.Geometry = geometry;
+ await ((GeodatabaseFeatureTable)_selectedFeature.FeatureTable).UpdateFeatureAsync(_selectedFeature);
+
+ // Reset the selection.
+ ResetSelections();
+ }
+
+ private async void MyMapView_GeoViewTapped(object sender, Esri.ArcGISRuntime.Maui.GeoViewInputEventArgs e)
+ {
+ if (MyMapView.GeometryEditor.IsStarted) return;
+
+ // Identify the feature at the tapped location.
+ var identifyResult = await MyMapView.IdentifyLayersAsync(e.Position, 5, false);
+
+ // As we are using subtype feature layers in this sample the returned features are contained in the sublayer results.
+ ArcGISFeature feature = identifyResult?.FirstOrDefault()?.SublayerResults?.FirstOrDefault()?.GeoElements?.FirstOrDefault() as ArcGISFeature;
+
+ // In this sample we only allow selection of point features.
+ // If the identified feature is null or the feature is not a point feature then reset the selection and return.
+ if (feature == null || feature.FeatureTable.GeometryType != GeometryType.Point)
+ {
+ ResetSelections();
+ return;
+ }
+ else if (_selectedFeature != null && feature != _selectedFeature && _selectedFeature.FeatureTable?.Layer is FeatureLayer selectedFeatureLayer)
+ {
+ // If a feature is already selected and the tapped feature is not the selected feature then clear the previous selection.
+ selectedFeatureLayer.ClearSelection();
+ }
+
+ // Update the selected feature.
+ _selectedFeature = feature;
+
+ // Select the feature on the layer.
+ (_selectedFeature.FeatureTable?.Layer as FeatureLayer).SelectFeature(_selectedFeature);
+
+ // Create a utility element for the selected feature using the utility network.
+ UtilityElement element = MyMapView.Map.UtilityNetworks[0]?.CreateElement(feature);
+
+ // Update the UI visibility.
+ UpdateUI();
+
+ // Update the UI with the selected feature information.
+ SelectedAssetGroupLabel.Text = element?.AssetGroup.Name;
+ SelectedAssetTypeLabel.Text = element?.AssetType.Name;
+
+ await SetSnapSettings(element.AssetType);
+ }
+
+ private void ResetSelections()
+ {
+ if (_selectedFeature != null && _selectedFeature.FeatureTable?.Layer is FeatureLayer selectedFeatureLayer)
+ {
+ // Clear the existing selection and show the selected feature;
+ selectedFeatureLayer.ClearSelection();
+ selectedFeatureLayer.SetFeatureVisible(_selectedFeature, true);
+ }
+
+ // Reset the selected feature and layer.
+ _selectedFeature = null;
+
+ // Update the UI visibility.
+ UpdateUI();
+
+ // Revert back to the default renderer for the distribution and service pipe layers and graphics overlay.
+ _distributionPipeLayer.Renderer = _defaultDistributionRenderer;
+ _servicePipeLayer.Renderer = _defaultServiceRenderer;
+ MyMapView.GraphicsOverlays[0].Renderer = _defaultGraphicRenderer;
+
+ // Clear the snap sources list.
+ SnapSourcesList.ItemsSource = null;
+ }
+
+ private void UpdateUI()
+ {
+ InstructionsLabel.IsVisible = _selectedFeature == null;
+ SelectedFeaturePanel.IsVisible = _selectedFeature != null;
+ }
+
+ private void SampleUnloaded(object sender, EventArgs e)
+ {
+ // Close the geodatabase when the sample closes.
+ _geodatabase.Close();
+ }
+
+ private void SnapSourcesPopupBackground_Tapped(object sender, TappedEventArgs e)
+ {
+ SnapSourcesPopup.IsVisible = false;
+ SnapSourcesPopupBackground.IsVisible = false;
+ }
+
+ private void SnapSourcesButton_Clicked(object sender, EventArgs e)
+ {
+ SnapSourcesPopup.IsVisible = true;
+ SnapSourcesPopupBackground.IsVisible = true;
+ }
+ }
+
+ public class SnapSourceSettingsVM
+ {
+ public SnapSourceSettings SnapSourceSettings { get; }
+ private Symbol _rulesPreventSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, System.Drawing.Color.Red, 4);
+ private Symbol _rulesLimitSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, System.Drawing.Color.Orange, 3);
+ private Symbol _noneSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Dash, System.Drawing.Color.Green, 3);
+
+ // Wrap the snap source settings in a view model to expose them to the UI.
+ public SnapSourceSettingsVM(SnapSourceSettings snapSourceSettings)
+ {
+ SnapSourceSettings = snapSourceSettings;
+
+ // Set the symbol for the snap source displayed in the UI.
+ _ = SetSymbolAsync();
+ }
+
+ private async Task SetSymbolAsync()
+ {
+ Symbol symbol = null;
+
+ switch (SnapSourceSettings.RuleBehavior)
+ {
+ case SnapRuleBehavior.None:
+ symbol = _noneSymbol;
+ break;
+ case SnapRuleBehavior.RulesLimitSnapping:
+ symbol = _rulesLimitSymbol;
+ break;
+ case SnapRuleBehavior.RulesPreventSnapping:
+ symbol = _rulesPreventSymbol;
+ break;
+ }
+
+ if (SnapSourceSettings.Source is SubtypeSublayer sublayer)
+ {
+ sublayer.Renderer = new SimpleRenderer(symbol);
+ }
+ else if (SnapSourceSettings.Source is GraphicsOverlay graphicsOverlay)
+ {
+ graphicsOverlay.Renderer = new SimpleRenderer(symbol);
+ }
+
+ if (symbol != null)
+ {
+ var swatch = await symbol.CreateSwatchAsync();
+ _symbol = await Esri.ArcGISRuntime.Maui.RuntimeImageExtensions.ToImageSourceAsync(swatch);
+ }
+ }
+
+ private ImageSource _symbol;
+
+ public ImageSource Symbol => _symbol;
+
+ public string Name
+ {
+ get
+ {
+ if (SnapSourceSettings.Source is ILayerContent content)
+ {
+ return content.Name;
+ }
+
+ if (SnapSourceSettings.Source is GraphicsOverlay overlay)
+ {
+ return overlay.Id ?? string.Empty;
+ }
+
+ return string.Empty;
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/MAUI/Maui.Samples/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/readme.md b/src/MAUI/Maui.Samples/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/readme.md
new file mode 100644
index 0000000000..599966ef14
--- /dev/null
+++ b/src/MAUI/Maui.Samples/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/readme.md
@@ -0,0 +1,59 @@
+# Snap geometry edits with utility network rules
+
+Use the Geometry Editor to edit geometries using utility network connectivity rules.
+
+
+
+## Use case
+
+A field worker can create new features in a utility network by editing and snapping the vertices of a geometry to existing features on a map. In a gas utility network, gas pipeline features can be represented with the polyline geometry type. Utility networks use geometric coincident-based connectivity to provide pathways for resources. Rule-based snapping uses utility network connectivity rules when editing features based on their asset type and asset group to help maintain network connectivity.
+
+## How to use the sample
+
+To edit a geometry, tap a point geometry to be edited in the map to select it. Then edit the geometry by clicking the button to start the geometry editor.
+
+Snap sources can be enabled and disabled. Snapping will not occur when `SnapRuleBehavior.RulesPreventSnapping` even when the source is enabled.
+
+To interactively snap a vertex to a feature or graphic, ensure that snapping is enabled for the relevant snap source, then move the mouse pointer or drag a vertex close to an existing feature or graphic. If the existing feature or graphic has valid utility network connectivity rules for the asset type that is being created or edited, the edit position will be adjusted to coincide with (or snap to) edges and vertices of its geometry. Tap or release the touch pointer to place the vertex at the snapped location.
+
+To discard changes and stop the geometry editor, press the discard button.
+
+To save your edits, press the save button.
+
+## How it works
+
+1. Create a map with `LoadSettings.FeatureTilingMode` set to `EnabledWithFullResolutionWhenSupported`.
+2. Create a `Geodatabase` using the mobile geodatabase file location.
+3. Display `Geodatabase.FeatureTables` on the map using subtype feature layers.
+4. Create a `GeometryEditor` and connect it to the map view.
+5. When editing a feature:
+
+ a. Call `SnapRules.CreateAsync(UtilityNetwork, UtilityAssetType)` to get the snap rules associated with a given `UtilityAssetType`.
+
+ b. Use `SyncSourceSettings(SnapRules, SnapSourceEnablingBehavior.SetFromRules)` to populate the `SnapSettings.SourceSettings` with `SnapSourceSettings` enabling the sources with rules.
+
+6. Start the geometry editor with an existing geometry or `GeometryType.Point`.
+
+## Relevant API
+
+* FeatureLayer
+* Geometry
+* GeometryEditor
+* GeometryEditorStyle
+* GraphicsOverlay
+* MapView
+* SnapRuleBehavior
+* SnapRules
+* SnapSettings
+* SnapSource
+* SnapSourceEnablingBehavior
+* SnapSourceSettings
+* UtilityNetwork
+
+## About the data
+
+The [Naperville gas network](https://www.arcgis.com/home/item.html?id=0fd3a39660d54c12b05d5f81f207dffd) mobile geodatabase contains a utility network with a set of connectivity rules that can be used to perform geometry edits with rules based snapping.
+
+## Tags
+
+edit, feature, geometry editor, graphics, layers, map, snapping, utility network
diff --git a/src/MAUI/Maui.Samples/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/readme.metadata.json b/src/MAUI/Maui.Samples/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/readme.metadata.json
new file mode 100644
index 0000000000..9cd446d0f6
--- /dev/null
+++ b/src/MAUI/Maui.Samples/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/readme.metadata.json
@@ -0,0 +1,43 @@
+{
+ "category": "Utility network",
+ "description": "Use the Geometry Editor to edit geometries using utility network connectivity rules.",
+ "formal_name": "SnapGeometryEditsWithUtilityNetworkRules",
+ "ignore": false,
+ "images": [
+ "snapgeometryeditswithutilitynetworkrules.jpg"
+ ],
+ "keywords": [
+ "edit",
+ "feature",
+ "geometry editor",
+ "graphics",
+ "layers",
+ "map",
+ "snapping",
+ "utility network"
+ ],
+ "offline_data": [],
+ "redirect_from": [
+ "/net/latest/maui/sample-code/snap-geometry-edits-with-utility-network-rules.htm"
+ ],
+ "relevant_apis": [
+ "FeatureLayer",
+ "Geometry",
+ "GeometryEditor",
+ "GeometryEditorStyle",
+ "GraphicsOverlay",
+ "MapView",
+ "SnapRuleBehavior",
+ "SnapRules",
+ "SnapSettings",
+ "SnapSource",
+ "SnapSourceEnablingBehavior",
+ "SnapSourceSettings",
+ "UtilityNetwork"
+ ],
+ "snippets": [
+ "SnapGeometryEditsWithUtilityNetworkRules.xaml.cs",
+ "SnapGeometryEditsWithUtilityNetworkRules.xaml"
+ ],
+ "title": "Snap geometry edits with utility network rules"
+}
\ No newline at end of file
diff --git a/src/MAUI/Maui.Samples/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/snapgeometryeditswithutilitynetworkrules.jpg b/src/MAUI/Maui.Samples/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/snapgeometryeditswithutilitynetworkrules.jpg
new file mode 100644
index 0000000000..747a50462c
Binary files /dev/null and b/src/MAUI/Maui.Samples/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/snapgeometryeditswithutilitynetworkrules.jpg differ
diff --git a/src/MAUI/readme.md b/src/MAUI/readme.md
index 69d9e4a183..3a0a3e5b14 100644
--- a/src/MAUI/readme.md
+++ b/src/MAUI/readme.md
@@ -260,5 +260,6 @@
* [Display content of utility network container](Maui.Samples/Samples/UtilityNetwork/DisplayUtilityNetworkContainer) - A utility network container allows a dense collection of features to be represented by a single feature, which can be used to reduce map clutter.
* [Display utility associations](Maui.Samples/Samples/UtilityNetwork/DisplayUtilityAssociations) - Create graphics for utility associations in a utility network.
* [Perform valve isolation trace](Maui.Samples/Samples/UtilityNetwork/PerformValveIsolationTrace) - Run a filtered trace to locate operable features that will isolate an area from the flow of network resources.
+* [Snap geometry edits with utility network rules](Maui.Samples/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules) - Use the Geometry Editor to edit geometries using utility network connectivity rules.
* [Trace utility network](Maui.Samples/Samples/UtilityNetwork/TraceUtilityNetwork) - Discover connected features in a utility network using connected, subnetwork, upstream, and downstream traces.
* [Validate utility network topology](Maui.Samples/Samples/UtilityNetwork/ValidateUtilityNetworkTopology) - Demonstrates the workflow of getting the network state and validating the topology of a utility network.
diff --git a/src/Samples.Shared/Resources/FeaturedSamples.xml b/src/Samples.Shared/Resources/FeaturedSamples.xml
index e033a11519..1b9c4b46cc 100644
--- a/src/Samples.Shared/Resources/FeaturedSamples.xml
+++ b/src/Samples.Shared/Resources/FeaturedSamples.xml
@@ -43,6 +43,7 @@
CreateLoadReportValidateUtilityNetworkTopology
+ SnapGeometryEditsWithUtilityNetworkRules
\ No newline at end of file
diff --git a/src/WPF/WPF.Viewer/Converters/BoolToVisibilityConverter.cs b/src/WPF/WPF.Viewer/Converters/BoolToVisibilityConverter.cs
new file mode 100644
index 0000000000..62051ea3d3
--- /dev/null
+++ b/src/WPF/WPF.Viewer/Converters/BoolToVisibilityConverter.cs
@@ -0,0 +1,28 @@
+using System.Windows.Data;
+using System.Windows;
+
+namespace ArcGIS.WPF.Viewer.Converters
+{
+ internal class BoolToVisibilityConverter : IValueConverter
+ {
+ #region IValueConverter Members
+
+ public object Convert(object value, System.Type targetType, object parameter, System.Globalization.CultureInfo culture)
+ {
+ bool? isVisible = value as bool?;
+ if (parameter != null && isVisible.HasValue)
+ isVisible = !isVisible;
+ if (isVisible.HasValue && isVisible.Value == true)
+ return Visibility.Visible;
+ else
+ return Visibility.Collapsed;
+ }
+
+ public object ConvertBack(object value, System.Type targetType, object parameter, System.Globalization.CultureInfo culture)
+ {
+ throw new System.NotImplementedException();
+ }
+
+ #endregion
+ }
+}
diff --git a/src/WPF/WPF.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/SnapGeometryEditsWithUtilityNetworkRules.jpg b/src/WPF/WPF.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/SnapGeometryEditsWithUtilityNetworkRules.jpg
new file mode 100644
index 0000000000..fd55ee836e
Binary files /dev/null and b/src/WPF/WPF.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/SnapGeometryEditsWithUtilityNetworkRules.jpg differ
diff --git a/src/WPF/WPF.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/SnapGeometryEditsWithUtilityNetworkRules.xaml b/src/WPF/WPF.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/SnapGeometryEditsWithUtilityNetworkRules.xaml
new file mode 100644
index 0000000000..4f6a729b0d
--- /dev/null
+++ b/src/WPF/WPF.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/SnapGeometryEditsWithUtilityNetworkRules.xaml
@@ -0,0 +1,153 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/WPF/WPF.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/SnapGeometryEditsWithUtilityNetworkRules.xaml.cs b/src/WPF/WPF.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/SnapGeometryEditsWithUtilityNetworkRules.xaml.cs
new file mode 100644
index 0000000000..b82bc9534b
--- /dev/null
+++ b/src/WPF/WPF.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/SnapGeometryEditsWithUtilityNetworkRules.xaml.cs
@@ -0,0 +1,431 @@
+// Copyright 2025 Esri.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at: http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific
+// language governing permissions and limitations under the License.
+
+using Esri.ArcGISRuntime.Data;
+using Esri.ArcGISRuntime.Geometry;
+using Esri.ArcGISRuntime.Mapping;
+using Esri.ArcGISRuntime.Symbology;
+using Esri.ArcGISRuntime.UI;
+using Esri.ArcGISRuntime.UI.Controls;
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Media;
+using Esri.ArcGISRuntime.UI.Editing;
+using Geometry = Esri.ArcGISRuntime.Geometry.Geometry;
+using ArcGIS.Samples.Managers;
+using Esri.ArcGISRuntime.UtilityNetworks;
+using System.Collections.Generic;
+
+namespace ArcGIS.WPF.Samples.SnapGeometryEditsWithUtilityNetworkRules
+{
+ [ArcGIS.Samples.Shared.Attributes.Sample(
+ name: "Snap geometry edits with utility network rules",
+ category: "Utility network",
+ description: "Use the Geometry Editor to edit geometries using utility network connectivity rules.",
+ instructions: "To edit a geometry, tap a point geometry to be edited in the map to select it. Then edit the geometry by clicking the button to start the geometry editor.",
+ tags: new[] { "edit", "feature", "geometry editor", "graphics", "layers", "map", "snapping", "utility network" })]
+ [ArcGIS.Samples.Shared.Attributes.OfflineData("0fd3a39660d54c12b05d5f81f207dffd")]
+ public partial class SnapGeometryEditsWithUtilityNetworkRules
+ {
+ // Layer name for the pipeline subtype feature layer.
+ private const string PipelineLayerName = "PipelineLine";
+
+ // Subtype names for utility network features.
+ private const string ServicePipeLayerName = "Service Pipe";
+ private const string DistributionPipeName = "Distribution Pipe";
+
+ private const string DeviceLayerName = "PipelineDevice";
+ private const string ExcessFlowValveName = "Excess Flow Valve";
+
+ private const string JunctionLayerName = "PipelineJunction";
+ private const string ControllableTeeName = "Controllable Tee";
+
+ // Identifier for non-UN features.
+ private const string GraphicsId = "Graphics";
+
+ // Default symbology for graphic and sublayers used to restore after edit.
+ private readonly Renderer _defaultGraphicRenderer = new SimpleRenderer(new SimpleLineSymbol(SimpleLineSymbolStyle.Dash, System.Drawing.Color.Gray, 3));
+ private Renderer _defaultDistributionRenderer = null;
+ private Renderer _defaultServiceRenderer = null;
+
+ // Hold references to the selected feature.
+ private Feature _selectedFeature;
+
+ // Hold references to the subtype sublayers for the distribution and service pipe layers.
+ private SubtypeSublayer _distributionPipeLayer;
+ private SubtypeSublayer _servicePipeLayer;
+
+ // Hold a reference to the utility network geodatabase.
+ private Geodatabase _geodatabase;
+
+ // Graphic json
+ string graphicJson = "{\"paths\":[[[-9811826.6810284462,5132074.7700250093],[-9811786.4643617794,5132440.9533583419],[-9811384.2976951133,5132354.1700250087],[-9810372.5310284477,5132360.5200250093],[-9810353.4810284469,5132066.3033583425]]],\"spatialReference\":{\"wkid\":102100,\"latestWkid\":3857}}";
+
+ public SnapGeometryEditsWithUtilityNetworkRules()
+ {
+ InitializeComponent();
+ _ = InitializeAsync();
+ }
+
+ private async Task InitializeAsync()
+ {
+ try
+ {
+ // Create a map.
+ MyMapView.Map = new Map(BasemapStyle.ArcGISStreetsNight)
+ {
+ InitialViewpoint = new Viewpoint(new MapPoint(-9811055.156028448, 5131792.19502501, SpatialReferences.WebMercator), 1e4)
+ };
+
+ // Set the map load setting feature tiling mode.
+ // Enabled with full resolution when supported is used to ensure that snapping to geometries occurs in full resolution.
+ // Snapping in full resolution improves snapping accuracy.
+ MyMapView.Map.LoadSettings.FeatureTilingMode = FeatureTilingMode.EnabledWithFullResolutionWhenSupported;
+
+ await AddLayersToMapFromGeodatabase();
+
+ // Create a graphics overlay and add it to the map view.
+ MyMapView.GraphicsOverlays.Add(new GraphicsOverlay() { Id = GraphicsId, Renderer = _defaultGraphicRenderer });
+ MyMapView.GraphicsOverlays[0].Graphics.Add(new Graphic(Geometry.FromJson(graphicJson)));
+
+ // Create and add a geometry editor to the map view.
+ MyMapView.GeometryEditor = new GeometryEditor();
+
+ // Enable snapping on the geometry layer.
+ MyMapView.GeometryEditor.SnapSettings.IsEnabled = true;
+ MyMapView.GeometryEditor.SnapSettings.IsFeatureSnappingEnabled = true;
+
+ // Show the UI.
+ SnappingControls.Visibility = Visibility.Visible;
+ }
+ catch (Exception ex)
+ {
+ // Show an error message.
+ MessageBox.Show(ex.Message);
+ }
+ }
+
+ private async Task AddLayersToMapFromGeodatabase()
+ {
+ // Get the path to the local geodatabase for this platform (temp directory, for example).
+ string geodatabasePath = DataManager.GetDataFolder("0fd3a39660d54c12b05d5f81f207dffd", "NapervilleGasUtilities.geodatabase");
+
+ // See if the geodatabase file is already present.
+ if (File.Exists(geodatabasePath))
+ {
+ // Open the geodatabase.
+ _geodatabase = await Geodatabase.OpenAsync(geodatabasePath);
+
+ // Subscribe to the unloaded event to close the geodatabase when the sample is closed.
+ Unloaded += SampleUnloaded;
+
+ // Get and load feature tables from the geodatabase.
+ // Create subtype feature layers from the feature tables and add them to the map.
+ var pipeTable = _geodatabase.GetGeodatabaseFeatureTable(PipelineLayerName);
+ await pipeTable.LoadAsync();
+
+ var pipeLayer = new SubtypeFeatureLayer(pipeTable);
+ MyMapView.Map.OperationalLayers.Add(pipeLayer);
+
+ var deviceTable = _geodatabase.GetGeodatabaseFeatureTable(DeviceLayerName);
+ await deviceTable.LoadAsync();
+
+ SubtypeFeatureLayer devicelayer = new SubtypeFeatureLayer(deviceTable);
+ MyMapView.Map.OperationalLayers.Add(devicelayer);
+
+ var junctionTable = _geodatabase.GetGeodatabaseFeatureTable(JunctionLayerName);
+ await junctionTable.LoadAsync();
+
+ SubtypeFeatureLayer junctionlayer = new SubtypeFeatureLayer(junctionTable);
+ MyMapView.Map.OperationalLayers.Add(junctionlayer);
+
+ // Add the utility network to the map and load it.
+ var utilityNetwork = _geodatabase.UtilityNetworks.FirstOrDefault();
+ MyMapView.Map.UtilityNetworks.Add(utilityNetwork);
+ await utilityNetwork.LoadAsync();
+
+ // Load the map.
+ await MyMapView.Map.LoadAsync();
+
+ // Ensure all layers are loaded.
+ await Task.WhenAll(MyMapView.Map.OperationalLayers.ToList().Select(layer => layer.LoadAsync()).ToList());
+
+ // Set the visibility of the sublayers and store the default renderer for the distribution and service pipe layers.
+ // In this sample we will only set a small subset of sublayers to be visible.
+ foreach (var sublayer in pipeLayer.SubtypeSublayers)
+ {
+ switch (sublayer.Name)
+ {
+ case DistributionPipeName:
+ _distributionPipeLayer = sublayer;
+ _defaultDistributionRenderer = sublayer.Renderer;
+ break;
+ case ServicePipeLayerName:
+ _servicePipeLayer = sublayer;
+ _defaultServiceRenderer = sublayer.Renderer;
+ break;
+ default:
+ sublayer.IsVisible = false;
+ break;
+ }
+ }
+
+ // To avoid too much visual clutter, only show the Excess Flow Valve and Controllable Tee sublayers in the device layer.
+ foreach (var sublayer in devicelayer.SubtypeSublayers)
+ {
+ switch (sublayer.Name)
+ {
+ case ExcessFlowValveName:
+ case ControllableTeeName:
+ sublayer.IsVisible = true;
+ break;
+ default:
+ sublayer.IsVisible = false;
+ break;
+ }
+ }
+ }
+ }
+
+ private async Task SetSnapSettings(UtilityAssetType assetType)
+ {
+ // Get the snap rules associated with the asset type.
+ SnapRules snapRules = await SnapRules.CreateAsync(MyMapView.Map.UtilityNetworks[0], assetType);
+
+ // Synchronize the snap source collection with the map's operational layers using the snap rules.
+ // Setting SnapSourceEnablingBehavior.SetFromRules will enable snapping for the layers and sublayers specified in the snap rules.
+ MyMapView.GeometryEditor.SnapSettings.SyncSourceSettings(snapRules, SnapSourceEnablingBehavior.SetFromRules);
+
+ // Enable snapping for the graphics overlay.
+ var graphicsSourceSetting = MyMapView.GeometryEditor.SnapSettings.SourceSettings.First(sourceSetting => sourceSetting.Source is GraphicsOverlay);
+ graphicsSourceSetting.IsEnabled = true;
+
+ var snapSources = new List();
+
+ foreach (var sourceSetting in MyMapView.GeometryEditor.SnapSettings.SourceSettings)
+ {
+ if (sourceSetting.Source is GraphicsOverlay graphicsOverlay)
+ {
+ snapSources.Add(new SnapSourceSettingsVM(sourceSetting));
+ }
+ else if (sourceSetting.Source is SubtypeFeatureLayer subtypeFeatureLayer && subtypeFeatureLayer.Name == PipelineLayerName)
+ {
+ foreach (var subtypeSublayer in sourceSetting.ChildSourceSettings)
+ {
+ switch ((subtypeSublayer.Source as SubtypeSublayer).Name)
+ {
+ case ServicePipeLayerName:
+ case DistributionPipeName:
+ snapSources.Add(new SnapSourceSettingsVM(subtypeSublayer));
+ break;
+ }
+ }
+ }
+ }
+
+ // Create a list of snap source settings with snapping enabled.
+ SnapSourcesList.ItemsSource = snapSources;
+ }
+
+ private void GeometryEditorButton_Click(object sender, RoutedEventArgs e)
+ {
+ // Get the symbol for the selected feature.
+ Symbol symbol = ((GeodatabaseFeatureTable)_selectedFeature.FeatureTable).LayerInfo?.DrawingInfo?.Renderer?.GetSymbol(_selectedFeature);
+
+ // Set the vertex symbol for the geometry editor tool.
+ MyMapView.GeometryEditor.Tool.Style.VertexSymbol = MyMapView.GeometryEditor.Tool.Style.FeedbackVertexSymbol = MyMapView.GeometryEditor.Tool.Style.SelectedVertexSymbol = symbol;
+ MyMapView.GeometryEditor.Tool.Style.VertexTextSymbol = null;
+
+ // Hide the selected feature.
+ if (_selectedFeature != null && _selectedFeature.FeatureTable?.Layer is FeatureLayer selectedFeatureLayer)
+ {
+ selectedFeatureLayer.SetFeatureVisible(_selectedFeature, false);
+ }
+
+ // Start the geometry editor.
+ MyMapView.GeometryEditor.Start(_selectedFeature.Geometry);
+ }
+
+ private void DiscardButton_Click(object sender, RoutedEventArgs e)
+ {
+ // Discard the current edit.
+ MyMapView.GeometryEditor.Stop();
+
+ // Reset the selection.
+ ResetSelections();
+ }
+
+ private async void SaveButton_Click(object sender, RoutedEventArgs e)
+ {
+ // Stop the geometry editor and get the updated geometry.
+ Geometry geometry = MyMapView.GeometryEditor.Stop();
+
+ // Update the feature with the new geometry.
+ _selectedFeature.Geometry = geometry;
+ await ((GeodatabaseFeatureTable)_selectedFeature.FeatureTable).UpdateFeatureAsync(_selectedFeature);
+
+ // Reset the selection.
+ ResetSelections();
+ }
+
+ private async void MyMapView_GeoViewTapped(object sender, GeoViewInputEventArgs e)
+ {
+ if (MyMapView.GeometryEditor.IsStarted) return;
+
+ // Identify the feature at the tapped location.
+ var identifyResult = await MyMapView.IdentifyLayersAsync(e.Position, 5, false);
+
+ // As we are using subtype feature layers in this sample the returned features are contained in the sublayer results.
+ ArcGISFeature feature = identifyResult?.FirstOrDefault()?.SublayerResults?.FirstOrDefault()?.GeoElements?.FirstOrDefault() as ArcGISFeature;
+
+ // In this sample we only allow selection of point features.
+ // If the identified feature is null or the feature is not a point feature then reset the selection and return.
+ if (feature == null || feature.FeatureTable.GeometryType != GeometryType.Point)
+ {
+ ResetSelections();
+ return;
+ }
+ else if (_selectedFeature != null && feature != _selectedFeature && _selectedFeature.FeatureTable?.Layer is FeatureLayer selectedFeatureLayer)
+ {
+ // If a feature is already selected and the tapped feature is not the selected feature then clear the previous selection.
+ selectedFeatureLayer.ClearSelection();
+ }
+
+ // Update the selected feature.
+ _selectedFeature = feature;
+
+ // Select the feature on the layer.
+ (_selectedFeature.FeatureTable?.Layer as FeatureLayer).SelectFeature(_selectedFeature);
+
+ // Create a utility element for the selected feature using the utility network.
+ UtilityElement element = MyMapView.Map.UtilityNetworks[0]?.CreateElement(feature);
+
+ // Update the UI visibility.
+ UpdateUI();
+
+ // Update the UI with the selected feature information.
+ SelectedAssetGroupLabel.Text = element?.AssetGroup.Name;
+ SelectedAssetTypeLabel.Text = element?.AssetType.Name;
+
+ await SetSnapSettings(element.AssetType);
+ }
+
+ private void ResetSelections()
+ {
+ if (_selectedFeature != null && _selectedFeature.FeatureTable?.Layer is FeatureLayer selectedFeatureLayer)
+ {
+ // Clear the existing selection and show the selected feature;
+ selectedFeatureLayer.ClearSelection();
+ selectedFeatureLayer.SetFeatureVisible(_selectedFeature, true);
+ }
+
+ // Reset the selected feature and layer.
+ _selectedFeature = null;
+
+ // Update the UI visibility.
+ UpdateUI();
+
+ // Revert back to the default renderer for the distribution and service pipe layers and graphics overlay.
+ _distributionPipeLayer.Renderer = _defaultDistributionRenderer;
+ _servicePipeLayer.Renderer = _defaultServiceRenderer;
+ MyMapView.GraphicsOverlays[0].Renderer = _defaultGraphicRenderer;
+
+ // Clear the snap sources list.
+ SnapSourcesList.ItemsSource = null;
+ }
+
+ private void UpdateUI()
+ {
+ InstructionsLabel.Visibility = _selectedFeature != null ? Visibility.Collapsed : Visibility.Visible;
+ SelectedFeaturePanel.Visibility = SnapSourcesPanel.Visibility = _selectedFeature != null ? Visibility.Visible : Visibility.Collapsed;
+ }
+
+ private void SampleUnloaded(object sender, RoutedEventArgs e)
+ {
+ // Close the geodatabase when the sample closes.
+ _geodatabase.Close();
+ }
+
+ }
+
+ public class SnapSourceSettingsVM
+ {
+ public SnapSourceSettings SnapSourceSettings { get; }
+ private Symbol _rulesPreventSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, System.Drawing.Color.Red, 4);
+ private Symbol _rulesLimitSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, System.Drawing.Color.Orange, 3);
+ private Symbol _noneSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Dash, System.Drawing.Color.Green, 3);
+
+ // Wrap the snap source settings in a view model to expose them to the UI.
+ public SnapSourceSettingsVM(SnapSourceSettings snapSourceSettings)
+ {
+ SnapSourceSettings = snapSourceSettings;
+
+ // Set the symbol for the snap source displayed in the UI.
+ _ = SetSymbolAsync();
+ }
+
+ private async Task SetSymbolAsync()
+ {
+ Symbol symbol = null;
+
+ switch (SnapSourceSettings.RuleBehavior)
+ {
+ case SnapRuleBehavior.None:
+ symbol = _noneSymbol;
+ break;
+ case SnapRuleBehavior.RulesLimitSnapping:
+ symbol = _rulesLimitSymbol;
+ break;
+ case SnapRuleBehavior.RulesPreventSnapping:
+ symbol = _rulesPreventSymbol;
+ break;
+ }
+
+ if (SnapSourceSettings.Source is SubtypeSublayer sublayer)
+ {
+ sublayer.Renderer = new SimpleRenderer(symbol);
+ }
+ else if (SnapSourceSettings.Source is GraphicsOverlay graphicsOverlay)
+ {
+ graphicsOverlay.Renderer = new SimpleRenderer(symbol);
+ }
+
+ if (symbol != null)
+ {
+ var swatch = await symbol.CreateSwatchAsync();
+ _symbol = await swatch.ToImageSourceAsync();
+ }
+ }
+
+ private ImageSource _symbol;
+
+ public ImageSource Symbol => _symbol;
+
+ public string Name
+ {
+ get
+ {
+ if (SnapSourceSettings.Source is ILayerContent content)
+ {
+ return content.Name;
+ }
+
+ if (SnapSourceSettings.Source is GraphicsOverlay overlay)
+ {
+ return overlay.Id ?? string.Empty;
+ }
+
+ return string.Empty;
+ }
+ }
+ }
+}
diff --git a/src/WPF/WPF.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/readme.md b/src/WPF/WPF.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/readme.md
new file mode 100644
index 0000000000..dc2342b15e
--- /dev/null
+++ b/src/WPF/WPF.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/readme.md
@@ -0,0 +1,59 @@
+# Snap geometry edits with utility network rules
+
+Use the Geometry Editor to edit geometries using utility network connectivity rules.
+
+
+
+## Use case
+
+A field worker can create new features in a utility network by editing and snapping the vertices of a geometry to existing features on a map. In a gas utility network, gas pipeline features can be represented with the polyline geometry type. Utility networks use geometric coincident-based connectivity to provide pathways for resources. Rule-based snapping uses utility network connectivity rules when editing features based on their asset type and asset group to help maintain network connectivity.
+
+## How to use the sample
+
+To edit a geometry, tap a point geometry to be edited in the map to select it. Then edit the geometry by clicking the button to start the geometry editor.
+
+Snap sources can be enabled and disabled. Snapping will not occur when `SnapRuleBehavior.RulesPreventSnapping` even when the source is enabled.
+
+To interactively snap a vertex to a feature or graphic, ensure that snapping is enabled for the relevant snap source, then move the mouse pointer or drag a vertex close to an existing feature or graphic. If the existing feature or graphic has valid utility network connectivity rules for the asset type that is being created or edited, the edit position will be adjusted to coincide with (or snap to) edges and vertices of its geometry. Click or release the touch pointer to place the vertex at the snapped location.
+
+To discard changes and stop the geometry editor, press the discard button.
+
+To save your edits, press the save button.
+
+## How it works
+
+1. Create a map with `LoadSettings.FeatureTilingMode` set to `EnabledWithFullResolutionWhenSupported`.
+2. Create a `Geodatabase` using the mobile geodatabase file location.
+3. Display `Geodatabase.FeatureTables` on the map using subtype feature layers.
+4. Create a `GeometryEditor` and connect it to the map view.
+5. When editing a feature:
+
+ a. Call `SnapRules.CreateAsync(UtilityNetwork, UtilityAssetType)` to get the snap rules associated with a given `UtilityAssetType`.
+
+ b. Use `SyncSourceSettings(SnapRules, SnapSourceEnablingBehavior.SetFromRules)` to populate the `SnapSettings.SourceSettings` with `SnapSourceSettings` enabling the sources with rules.
+
+6. Start the geometry editor with an existing geometry or `GeometryType.Point`.
+
+## Relevant API
+
+* FeatureLayer
+* Geometry
+* GeometryEditor
+* GeometryEditorStyle
+* GraphicsOverlay
+* MapView
+* SnapRuleBehavior
+* SnapRules
+* SnapSettings
+* SnapSource
+* SnapSourceEnablingBehavior
+* SnapSourceSettings
+* UtilityNetwork
+
+## About the data
+
+The [Naperville gas network](https://www.arcgis.com/home/item.html?id=0fd3a39660d54c12b05d5f81f207dffd) mobile geodatabase contains a utility network with a set of connectivity rules that can be used to perform geometry edits with rules based snapping.
+
+## Tags
+
+edit, feature, geometry editor, graphics, layers, map, snapping, utility network
diff --git a/src/WPF/WPF.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/readme.metadata.json b/src/WPF/WPF.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/readme.metadata.json
new file mode 100644
index 0000000000..2bbd207a3a
--- /dev/null
+++ b/src/WPF/WPF.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/readme.metadata.json
@@ -0,0 +1,43 @@
+{
+ "category": "Utility network",
+ "description": "Use the Geometry Editor to edit geometries using utility network connectivity rules.",
+ "formal_name": "SnapGeometryEditsWithUtilityNetworkRules",
+ "ignore": false,
+ "images": [
+ "SnapGeometryEditsWithUtilityNetworkRules.jpg"
+ ],
+ "keywords": [
+ "edit",
+ "feature",
+ "geometry editor",
+ "graphics",
+ "layers",
+ "map",
+ "snapping",
+ "utility network"
+ ],
+ "offline_data": [],
+ "redirect_from": [
+ "/net/latest/wpf/sample-code/snap-geometry-edits-with-utility-network-rules.htm"
+ ],
+ "relevant_apis": [
+ "FeatureLayer",
+ "Geometry",
+ "GeometryEditor",
+ "GeometryEditorStyle",
+ "GraphicsOverlay",
+ "MapView",
+ "SnapRuleBehavior",
+ "SnapRules",
+ "SnapSettings",
+ "SnapSource",
+ "SnapSourceEnablingBehavior",
+ "SnapSourceSettings",
+ "UtilityNetwork"
+ ],
+ "snippets": [
+ "SnapGeometryEditsWithUtilityNetworkRules.xaml.cs",
+ "SnapGeometryEditsWithUtilityNetworkRules.xaml"
+ ],
+ "title": "Snap geometry edits with utility network rules"
+}
\ No newline at end of file
diff --git a/src/WPF/readme.md b/src/WPF/readme.md
index 1f2c342662..c4c505aacf 100644
--- a/src/WPF/readme.md
+++ b/src/WPF/readme.md
@@ -269,5 +269,6 @@
* [Display content of utility network container](WPF.Viewer/Samples/UtilityNetwork/DisplayUtilityNetworkContainer) - A utility network container allows a dense collection of features to be represented by a single feature, which can be used to reduce map clutter.
* [Display utility associations](WPF.Viewer/Samples/UtilityNetwork/DisplayUtilityAssociations) - Create graphics for utility associations in a utility network.
* [Perform valve isolation trace](WPF.Viewer/Samples/UtilityNetwork/PerformValveIsolationTrace) - Run a filtered trace to locate operable features that will isolate an area from the flow of network resources.
+* [Snap geometry edits with utility network rules](WPF.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules) - Use the Geometry Editor to edit geometries using utility network connectivity rules.
* [Trace utility network](WPF.Viewer/Samples/UtilityNetwork/TraceUtilityNetwork) - Discover connected features in a utility network using connected, subnetwork, upstream, and downstream traces.
* [Validate utility network topology](WPF.Viewer/Samples/UtilityNetwork/ValidateUtilityNetworkTopology) - Demonstrates the workflow of getting the network state and validating the topology of a utility network.
diff --git a/src/WinUI/ArcGIS.WinUI.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/SnapGeometryEditsWithUtilityNetworkRules.jpg b/src/WinUI/ArcGIS.WinUI.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/SnapGeometryEditsWithUtilityNetworkRules.jpg
new file mode 100644
index 0000000000..5f6a10e8f4
Binary files /dev/null and b/src/WinUI/ArcGIS.WinUI.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/SnapGeometryEditsWithUtilityNetworkRules.jpg differ
diff --git a/src/WinUI/ArcGIS.WinUI.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/SnapGeometryEditsWithUtilityNetworkRules.xaml b/src/WinUI/ArcGIS.WinUI.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/SnapGeometryEditsWithUtilityNetworkRules.xaml
new file mode 100644
index 0000000000..49b27ac1e6
--- /dev/null
+++ b/src/WinUI/ArcGIS.WinUI.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/SnapGeometryEditsWithUtilityNetworkRules.xaml
@@ -0,0 +1,154 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/WinUI/ArcGIS.WinUI.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/SnapGeometryEditsWithUtilityNetworkRules.xaml.cs b/src/WinUI/ArcGIS.WinUI.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/SnapGeometryEditsWithUtilityNetworkRules.xaml.cs
new file mode 100644
index 0000000000..9d460ea9a7
--- /dev/null
+++ b/src/WinUI/ArcGIS.WinUI.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/SnapGeometryEditsWithUtilityNetworkRules.xaml.cs
@@ -0,0 +1,430 @@
+// Copyright 2025 Esri.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at: http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific
+// language governing permissions and limitations under the License.
+
+using ArcGIS.Samples.Managers;
+using Esri.ArcGISRuntime.Data;
+using Esri.ArcGISRuntime.Geometry;
+using Esri.ArcGISRuntime.Mapping;
+using Esri.ArcGISRuntime.Symbology;
+using Esri.ArcGISRuntime.UI;
+using Esri.ArcGISRuntime.UI.Controls;
+using Esri.ArcGISRuntime.UI.Editing;
+using Esri.ArcGISRuntime.UtilityNetworks;
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Media;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Geometry = Esri.ArcGISRuntime.Geometry.Geometry;
+
+namespace ArcGIS.WinUI.Samples.SnapGeometryEditsWithUtilityNetworkRules
+{
+ [ArcGIS.Samples.Shared.Attributes.Sample(
+ name: "Snap geometry edits with utility network rules",
+ category: "Utility network",
+ description: "Use the Geometry Editor to edit geometries using utility network connectivity rules.",
+ instructions: "To edit a geometry, tap a point geometry to be edited in the map to select it. Then edit the geometry by clicking the button to start the geometry editor.",
+ tags: new[] { "edit", "feature", "geometry editor", "graphics", "layers", "map", "snapping", "utility network" })]
+ [ArcGIS.Samples.Shared.Attributes.OfflineData("0fd3a39660d54c12b05d5f81f207dffd")]
+ public partial class SnapGeometryEditsWithUtilityNetworkRules
+ {
+ // Layer name for the pipeline subtype feature layer.
+ private const string PipelineLayerName = "PipelineLine";
+
+ // Subtype names for utility network features.
+ private const string ServicePipeLayerName = "Service Pipe";
+ private const string DistributionPipeName = "Distribution Pipe";
+
+ private const string DeviceLayerName = "PipelineDevice";
+ private const string ExcessFlowValveName = "Excess Flow Valve";
+
+ private const string JunctionLayerName = "PipelineJunction";
+ private const string ControllableTeeName = "Controllable Tee";
+
+ // Identifier for non-UN features.
+ private const string GraphicsId = "Graphics";
+
+ // Default symbology for graphic and sublayers used to restore after edit.
+ private readonly Renderer _defaultGraphicRenderer = new SimpleRenderer(new SimpleLineSymbol(SimpleLineSymbolStyle.Dash, System.Drawing.Color.Gray, 3));
+ private Renderer _defaultDistributionRenderer = null;
+ private Renderer _defaultServiceRenderer = null;
+
+ // Hold references to the selected feature.
+ private Feature _selectedFeature;
+
+ // Hold references to the subtype sublayers for the distribution and service pipe layers.
+ private SubtypeSublayer _distributionPipeLayer;
+ private SubtypeSublayer _servicePipeLayer;
+
+ // Hold a reference to the utility network geodatabase.
+ private Geodatabase _geodatabase;
+
+ // Graphic json
+ string graphicJson = "{\"paths\":[[[-9811826.6810284462,5132074.7700250093],[-9811786.4643617794,5132440.9533583419],[-9811384.2976951133,5132354.1700250087],[-9810372.5310284477,5132360.5200250093],[-9810353.4810284469,5132066.3033583425]]],\"spatialReference\":{\"wkid\":102100,\"latestWkid\":3857}}";
+
+ public SnapGeometryEditsWithUtilityNetworkRules()
+ {
+ InitializeComponent();
+ _ = InitializeAsync();
+ }
+
+ private async Task InitializeAsync()
+ {
+ try
+ {
+ // Create a map.
+ MyMapView.Map = new Map(BasemapStyle.ArcGISStreetsNight)
+ {
+ InitialViewpoint = new Viewpoint(new MapPoint(-9811055.156028448, 5131792.19502501, SpatialReferences.WebMercator), 1e4)
+ };
+
+ // Set the map load setting feature tiling mode.
+ // Enabled with full resolution when supported is used to ensure that snapping to geometries occurs in full resolution.
+ // Snapping in full resolution improves snapping accuracy.
+ MyMapView.Map.LoadSettings.FeatureTilingMode = FeatureTilingMode.EnabledWithFullResolutionWhenSupported;
+
+ await AddLayersToMapFromGeodatabase();
+
+ // Create a graphics overlay and add it to the map view.
+ MyMapView.GraphicsOverlays.Add(new GraphicsOverlay() { Id = GraphicsId, Renderer = _defaultGraphicRenderer });
+ MyMapView.GraphicsOverlays[0].Graphics.Add(new Graphic(Geometry.FromJson(graphicJson)));
+
+ // Create and add a geometry editor to the map view.
+ MyMapView.GeometryEditor = new GeometryEditor();
+
+ // Enable snapping on the geometry layer.
+ MyMapView.GeometryEditor.SnapSettings.IsEnabled = true;
+ MyMapView.GeometryEditor.SnapSettings.IsFeatureSnappingEnabled = true;
+
+ // Show the UI.
+ SnappingControls.Visibility = Visibility.Visible;
+ }
+ catch (Exception ex)
+ {
+ // Show an error message.
+ await new MessageDialog2(ex.Message).ShowAsync();
+ }
+ }
+
+ private async Task AddLayersToMapFromGeodatabase()
+ {
+ // Get the path to the local geodatabase for this platform (temp directory, for example).
+ string geodatabasePath = DataManager.GetDataFolder("0fd3a39660d54c12b05d5f81f207dffd", "NapervilleGasUtilities.geodatabase");
+
+ // See if the geodatabase file is already present.
+ if (File.Exists(geodatabasePath))
+ {
+ // Open the geodatabase.
+ _geodatabase = await Geodatabase.OpenAsync(geodatabasePath);
+
+ // Subscribe to the unloaded event to close the geodatabase when the sample is closed.
+ Unloaded += SampleUnloaded;
+
+ // Get and load feature tables from the geodatabase.
+ // Create subtype feature layers from the feature tables and add them to the map.
+ var pipeTable = _geodatabase.GetGeodatabaseFeatureTable(PipelineLayerName);
+ await pipeTable.LoadAsync();
+
+ var pipeLayer = new SubtypeFeatureLayer(pipeTable);
+ MyMapView.Map.OperationalLayers.Add(pipeLayer);
+
+ var deviceTable = _geodatabase.GetGeodatabaseFeatureTable(DeviceLayerName);
+ await deviceTable.LoadAsync();
+
+ SubtypeFeatureLayer devicelayer = new SubtypeFeatureLayer(deviceTable);
+ MyMapView.Map.OperationalLayers.Add(devicelayer);
+
+ var junctionTable = _geodatabase.GetGeodatabaseFeatureTable(JunctionLayerName);
+ await junctionTable.LoadAsync();
+
+ SubtypeFeatureLayer junctionlayer = new SubtypeFeatureLayer(junctionTable);
+ MyMapView.Map.OperationalLayers.Add(junctionlayer);
+
+ // Add the utility network to the map and load it.
+ var utilityNetwork = _geodatabase.UtilityNetworks.FirstOrDefault();
+ MyMapView.Map.UtilityNetworks.Add(utilityNetwork);
+ await utilityNetwork.LoadAsync();
+
+ // Load the map.
+ await MyMapView.Map.LoadAsync();
+
+ // Ensure all layers are loaded.
+ await Task.WhenAll(MyMapView.Map.OperationalLayers.ToList().Select(layer => layer.LoadAsync()).ToList());
+
+ // Set the visibility of the sublayers and store the default renderer for the distribution and service pipe layers.
+ // In this sample we will only set a small subset of sublayers to be visible.
+ foreach (var sublayer in pipeLayer.SubtypeSublayers)
+ {
+ switch (sublayer.Name)
+ {
+ case DistributionPipeName:
+ _distributionPipeLayer = sublayer;
+ _defaultDistributionRenderer = sublayer.Renderer;
+ break;
+ case ServicePipeLayerName:
+ _servicePipeLayer = sublayer;
+ _defaultServiceRenderer = sublayer.Renderer;
+ break;
+ default:
+ sublayer.IsVisible = false;
+ break;
+ }
+ }
+
+ // To avoid too much visual clutter, only show the Excess Flow Valve and Controllable Tee sublayers in the device layer.
+ foreach (var sublayer in devicelayer.SubtypeSublayers)
+ {
+ switch (sublayer.Name)
+ {
+ case ExcessFlowValveName:
+ case ControllableTeeName:
+ sublayer.IsVisible = true;
+ break;
+ default:
+ sublayer.IsVisible = false;
+ break;
+ }
+ }
+ }
+ }
+
+ private async Task SetSnapSettings(UtilityAssetType assetType)
+ {
+ // Get the snap rules associated with the asset type.
+ SnapRules snapRules = await SnapRules.CreateAsync(MyMapView.Map.UtilityNetworks[0], assetType);
+
+ // Synchronize the snap source collection with the map's operational layers using the snap rules.
+ // Setting SnapSourceEnablingBehavior.SetFromRules will enable snapping for the layers and sublayers specified in the snap rules.
+ MyMapView.GeometryEditor.SnapSettings.SyncSourceSettings(snapRules, SnapSourceEnablingBehavior.SetFromRules);
+
+ // Enable snapping for the graphics overlay.
+ var graphicsSourceSetting = MyMapView.GeometryEditor.SnapSettings.SourceSettings.First(sourceSetting => sourceSetting.Source is GraphicsOverlay);
+ graphicsSourceSetting.IsEnabled = true;
+
+ var snapSources = new List();
+
+ foreach (var sourceSetting in MyMapView.GeometryEditor.SnapSettings.SourceSettings)
+ {
+ if (sourceSetting.Source is GraphicsOverlay graphicsOverlay)
+ {
+ snapSources.Add(new SnapSourceSettingsVM(sourceSetting));
+ }
+ else if (sourceSetting.Source is SubtypeFeatureLayer subtypeFeatureLayer && subtypeFeatureLayer.Name == PipelineLayerName)
+ {
+ foreach (var subtypeSublayer in sourceSetting.ChildSourceSettings)
+ {
+ switch ((subtypeSublayer.Source as SubtypeSublayer).Name)
+ {
+ case ServicePipeLayerName:
+ case DistributionPipeName:
+ snapSources.Add(new SnapSourceSettingsVM(subtypeSublayer));
+ break;
+ }
+ }
+ }
+ }
+
+ // Create a list of snap source settings with snapping enabled.
+ SnapSourcesList.ItemsSource = snapSources;
+ }
+
+ private void GeometryEditorButton_Click(object sender, RoutedEventArgs e)
+ {
+ // Get the symbol for the selected feature.
+ Symbol symbol = ((GeodatabaseFeatureTable)_selectedFeature.FeatureTable).LayerInfo?.DrawingInfo?.Renderer?.GetSymbol(_selectedFeature);
+
+ // Set the vertex symbol for the geometry editor tool.
+ MyMapView.GeometryEditor.Tool.Style.VertexSymbol = MyMapView.GeometryEditor.Tool.Style.FeedbackVertexSymbol = MyMapView.GeometryEditor.Tool.Style.SelectedVertexSymbol = symbol;
+ MyMapView.GeometryEditor.Tool.Style.VertexTextSymbol = null;
+
+ // Hide the selected feature.
+ if (_selectedFeature != null && _selectedFeature.FeatureTable?.Layer is FeatureLayer selectedFeatureLayer)
+ {
+ selectedFeatureLayer.SetFeatureVisible(_selectedFeature, false);
+ }
+
+ // Start the geometry editor.
+ MyMapView.GeometryEditor.Start(_selectedFeature.Geometry);
+ }
+
+ private void DiscardButton_Click(object sender, RoutedEventArgs e)
+ {
+ // Discard the current edit.
+ MyMapView.GeometryEditor.Stop();
+
+ // Reset the selection.
+ ResetSelections();
+ }
+
+ private async void SaveButton_Click(object sender, RoutedEventArgs e)
+ {
+ // Stop the geometry editor and get the updated geometry.
+ Geometry geometry = MyMapView.GeometryEditor.Stop();
+
+ // Update the feature with the new geometry.
+ _selectedFeature.Geometry = geometry;
+ await ((GeodatabaseFeatureTable)_selectedFeature.FeatureTable).UpdateFeatureAsync(_selectedFeature);
+
+ // Reset the selection.
+ ResetSelections();
+ }
+
+ private async void MyMapView_GeoViewTapped(object sender, GeoViewInputEventArgs e)
+ {
+ if (MyMapView.GeometryEditor.IsStarted) return;
+
+ // Identify the feature at the tapped location.
+ var identifyResult = await MyMapView.IdentifyLayersAsync(e.Position, 5, false);
+
+ // As we are using subtype feature layers in this sample the returned features are contained in the sublayer results.
+ ArcGISFeature feature = identifyResult?.FirstOrDefault()?.SublayerResults?.FirstOrDefault()?.GeoElements?.FirstOrDefault() as ArcGISFeature;
+
+ // In this sample we only allow selection of point features.
+ // If the identified feature is null or the feature is not a point feature then reset the selection and return.
+ if (feature == null || feature.FeatureTable.GeometryType != GeometryType.Point)
+ {
+ ResetSelections();
+ return;
+ }
+ else if (_selectedFeature != null && feature != _selectedFeature && _selectedFeature.FeatureTable?.Layer is FeatureLayer selectedFeatureLayer)
+ {
+ // If a feature is already selected and the tapped feature is not the selected feature then clear the previous selection.
+ selectedFeatureLayer.ClearSelection();
+ }
+
+ // Update the selected feature.
+ _selectedFeature = feature;
+
+ // Select the feature on the layer.
+ (_selectedFeature.FeatureTable?.Layer as FeatureLayer).SelectFeature(_selectedFeature);
+
+ // Create a utility element for the selected feature using the utility network.
+ UtilityElement element = MyMapView.Map.UtilityNetworks[0]?.CreateElement(feature);
+
+ // Update the UI visibility.
+ UpdateUI();
+
+ // Update the UI with the selected feature information.
+ SelectedAssetGroupLabel.Text = element?.AssetGroup.Name;
+ SelectedAssetTypeLabel.Text = element?.AssetType.Name;
+
+ await SetSnapSettings(element.AssetType);
+ }
+
+ private void ResetSelections()
+ {
+ if (_selectedFeature != null && _selectedFeature.FeatureTable?.Layer is FeatureLayer selectedFeatureLayer)
+ {
+ // Clear the existing selection and show the selected feature;
+ selectedFeatureLayer.ClearSelection();
+ selectedFeatureLayer.SetFeatureVisible(_selectedFeature, true);
+ }
+
+ // Reset the selected feature and layer.
+ _selectedFeature = null;
+
+ // Update the UI visibility.
+ UpdateUI();
+
+ // Revert back to the default renderer for the distribution and service pipe layers and graphics overlay.
+ _distributionPipeLayer.Renderer = _defaultDistributionRenderer;
+ _servicePipeLayer.Renderer = _defaultServiceRenderer;
+ MyMapView.GraphicsOverlays[0].Renderer = _defaultGraphicRenderer;
+
+ // Clear the snap sources list.
+ SnapSourcesList.ItemsSource = null;
+ }
+
+ private void UpdateUI()
+ {
+ InstructionsLabel.Visibility = _selectedFeature != null ? Visibility.Collapsed : Visibility.Visible;
+ SelectedFeaturePanel.Visibility = SnapSourcesPanel.Visibility = _selectedFeature != null ? Visibility.Visible : Visibility.Collapsed;
+ }
+
+ private void SampleUnloaded(object sender, RoutedEventArgs e)
+ {
+ // Close the geodatabase when the sample closes.
+ _geodatabase.Close();
+ }
+ }
+
+ public class SnapSourceSettingsVM
+ {
+ public SnapSourceSettings SnapSourceSettings { get; }
+ private Symbol _rulesPreventSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, System.Drawing.Color.Red, 4);
+ private Symbol _rulesLimitSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Solid, System.Drawing.Color.Orange, 3);
+ private Symbol _noneSymbol = new SimpleLineSymbol(SimpleLineSymbolStyle.Dash, System.Drawing.Color.Green, 3);
+
+ // Wrap the snap source settings in a view model to expose them to the UI.
+ public SnapSourceSettingsVM(SnapSourceSettings snapSourceSettings)
+ {
+ SnapSourceSettings = snapSourceSettings;
+
+ // Set the symbol for the snap source displayed in the UI.
+ _ = SetSymbolAsync();
+ }
+
+ private async Task SetSymbolAsync()
+ {
+ Symbol symbol = null;
+
+ switch (SnapSourceSettings.RuleBehavior)
+ {
+ case SnapRuleBehavior.None:
+ symbol = _noneSymbol;
+ break;
+ case SnapRuleBehavior.RulesLimitSnapping:
+ symbol = _rulesLimitSymbol;
+ break;
+ case SnapRuleBehavior.RulesPreventSnapping:
+ symbol = _rulesPreventSymbol;
+ break;
+ }
+
+ if (SnapSourceSettings.Source is SubtypeSublayer sublayer)
+ {
+ sublayer.Renderer = new SimpleRenderer(symbol);
+ }
+ else if (SnapSourceSettings.Source is GraphicsOverlay graphicsOverlay)
+ {
+ graphicsOverlay.Renderer = new SimpleRenderer(symbol);
+ }
+
+ if (symbol != null)
+ {
+ var swatch = await symbol.CreateSwatchAsync();
+ _symbol = await swatch.ToImageSourceAsync();
+ }
+ }
+
+ private ImageSource _symbol;
+
+ public ImageSource Symbol => _symbol;
+
+ public string Name
+ {
+ get
+ {
+ if (SnapSourceSettings.Source is ILayerContent content)
+ {
+ return content.Name;
+ }
+
+ if (SnapSourceSettings.Source is GraphicsOverlay overlay)
+ {
+ return overlay.Id ?? string.Empty;
+ }
+
+ return string.Empty;
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/WinUI/ArcGIS.WinUI.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/readme.md b/src/WinUI/ArcGIS.WinUI.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/readme.md
new file mode 100644
index 0000000000..dc2342b15e
--- /dev/null
+++ b/src/WinUI/ArcGIS.WinUI.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/readme.md
@@ -0,0 +1,59 @@
+# Snap geometry edits with utility network rules
+
+Use the Geometry Editor to edit geometries using utility network connectivity rules.
+
+
+
+## Use case
+
+A field worker can create new features in a utility network by editing and snapping the vertices of a geometry to existing features on a map. In a gas utility network, gas pipeline features can be represented with the polyline geometry type. Utility networks use geometric coincident-based connectivity to provide pathways for resources. Rule-based snapping uses utility network connectivity rules when editing features based on their asset type and asset group to help maintain network connectivity.
+
+## How to use the sample
+
+To edit a geometry, tap a point geometry to be edited in the map to select it. Then edit the geometry by clicking the button to start the geometry editor.
+
+Snap sources can be enabled and disabled. Snapping will not occur when `SnapRuleBehavior.RulesPreventSnapping` even when the source is enabled.
+
+To interactively snap a vertex to a feature or graphic, ensure that snapping is enabled for the relevant snap source, then move the mouse pointer or drag a vertex close to an existing feature or graphic. If the existing feature or graphic has valid utility network connectivity rules for the asset type that is being created or edited, the edit position will be adjusted to coincide with (or snap to) edges and vertices of its geometry. Click or release the touch pointer to place the vertex at the snapped location.
+
+To discard changes and stop the geometry editor, press the discard button.
+
+To save your edits, press the save button.
+
+## How it works
+
+1. Create a map with `LoadSettings.FeatureTilingMode` set to `EnabledWithFullResolutionWhenSupported`.
+2. Create a `Geodatabase` using the mobile geodatabase file location.
+3. Display `Geodatabase.FeatureTables` on the map using subtype feature layers.
+4. Create a `GeometryEditor` and connect it to the map view.
+5. When editing a feature:
+
+ a. Call `SnapRules.CreateAsync(UtilityNetwork, UtilityAssetType)` to get the snap rules associated with a given `UtilityAssetType`.
+
+ b. Use `SyncSourceSettings(SnapRules, SnapSourceEnablingBehavior.SetFromRules)` to populate the `SnapSettings.SourceSettings` with `SnapSourceSettings` enabling the sources with rules.
+
+6. Start the geometry editor with an existing geometry or `GeometryType.Point`.
+
+## Relevant API
+
+* FeatureLayer
+* Geometry
+* GeometryEditor
+* GeometryEditorStyle
+* GraphicsOverlay
+* MapView
+* SnapRuleBehavior
+* SnapRules
+* SnapSettings
+* SnapSource
+* SnapSourceEnablingBehavior
+* SnapSourceSettings
+* UtilityNetwork
+
+## About the data
+
+The [Naperville gas network](https://www.arcgis.com/home/item.html?id=0fd3a39660d54c12b05d5f81f207dffd) mobile geodatabase contains a utility network with a set of connectivity rules that can be used to perform geometry edits with rules based snapping.
+
+## Tags
+
+edit, feature, geometry editor, graphics, layers, map, snapping, utility network
diff --git a/src/WinUI/ArcGIS.WinUI.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/readme.metadata.json b/src/WinUI/ArcGIS.WinUI.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/readme.metadata.json
new file mode 100644
index 0000000000..61ed4ea82f
--- /dev/null
+++ b/src/WinUI/ArcGIS.WinUI.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules/readme.metadata.json
@@ -0,0 +1,43 @@
+{
+ "category": "Utility network",
+ "description": "Use the Geometry Editor to edit geometries using utility network connectivity rules.",
+ "formal_name": "SnapGeometryEditsWithUtilityNetworkRules",
+ "ignore": false,
+ "images": [
+ "SnapGeometryEditsWithUtilityNetworkRules.jpg"
+ ],
+ "keywords": [
+ "edit",
+ "feature",
+ "geometry editor",
+ "graphics",
+ "layers",
+ "map",
+ "snapping",
+ "utility network"
+ ],
+ "offline_data": [],
+ "redirect_from": [
+ "/net/latest/winui/sample-code/snap-geometry-edits-with-utility-network-rules.htm"
+ ],
+ "relevant_apis": [
+ "FeatureLayer",
+ "Geometry",
+ "GeometryEditor",
+ "GeometryEditorStyle",
+ "GraphicsOverlay",
+ "MapView",
+ "SnapRuleBehavior",
+ "SnapRules",
+ "SnapSettings",
+ "SnapSource",
+ "SnapSourceEnablingBehavior",
+ "SnapSourceSettings",
+ "UtilityNetwork"
+ ],
+ "snippets": [
+ "SnapGeometryEditsWithUtilityNetworkRules.xaml.cs",
+ "SnapGeometryEditsWithUtilityNetworkRules.xaml"
+ ],
+ "title": "Snap geometry edits with utility network rules"
+}
\ No newline at end of file
diff --git a/src/WinUI/readme.md b/src/WinUI/readme.md
index 52497369ca..3d62a04137 100644
--- a/src/WinUI/readme.md
+++ b/src/WinUI/readme.md
@@ -264,5 +264,6 @@
* [Display content of utility network container](ArcGIS.WinUI.Viewer/Samples/UtilityNetwork/DisplayUtilityNetworkContainer) - A utility network container allows a dense collection of features to be represented by a single feature, which can be used to reduce map clutter.
* [Display utility associations](ArcGIS.WinUI.Viewer/Samples/UtilityNetwork/DisplayUtilityAssociations) - Create graphics for utility associations in a utility network.
* [Perform valve isolation trace](ArcGIS.WinUI.Viewer/Samples/UtilityNetwork/PerformValveIsolationTrace) - Run a filtered trace to locate operable features that will isolate an area from the flow of network resources.
+* [Snap geometry edits with utility network rules](ArcGIS.WinUI.Viewer/Samples/UtilityNetwork/SnapGeometryEditsWithUtilityNetworkRules) - Use the Geometry Editor to edit geometries using utility network connectivity rules.
* [Trace utility network](ArcGIS.WinUI.Viewer/Samples/UtilityNetwork/TraceUtilityNetwork) - Discover connected features in a utility network using connected, subnetwork, upstream, and downstream traces.
* [Validate utility network topology](ArcGIS.WinUI.Viewer/Samples/UtilityNetwork/ValidateUtilityNetworkTopology) - Demonstrates the workflow of getting the network state and validating the topology of a utility network.