Brian,
Let me see if I can clarify things a bit
- Any edits performed in ArcGIS Pro need to be wrapped in an EditOperation.
- Each EditOperation puts an item on the undo/redo stack (assuming it is a long transaction)
- An EditOperation can contain a single edit (for example a modify) or multiple edits at once (for example a create, 2 modifies and 3 deletes). Caveat - the multiple edits MUST be independent of each other. For example I cannot perform a create and then an attribute update of the same feature in the same EditOperation, because setting up the Modify method requires an objectID which depends on the create having been committed to the database.
- The edit(s) are 'committed' when the Execute or ExecuteAsync method is called
For example, the following Edit operation contains a create, 2 modifies and 1 delete. This edit operation will succeed assuming that i'm modifying and deleting valid features.
var op = new EditOperation();
op.Name = "Multiple edits";
op.Create(featureLayer, geometry);
op.Modify(featureLayer2, 1);
op.Modify(featureLayer3, 2);
op.Delete(featureLayer2, 3);
bool result = op.Execute(); // <= create, modifies and delete are committed here
- A chained operation is simply an edit operation that links to a previous EditOperation allowing all edits from both operations to be part of the same undo/redo item. You use a chained operation when the edit you require is dependent on the results of a previous EditOperation being commited.
- As you can have multiple edits in an EditOperation you can also have multiple edits in a Chained operation.
Using the previous example, technically there's no reason why you can't do the following with a chained operation but it is not best practice - you're adding additional overhead to the database and the code is not as easy to read or maintain.
var op = new EditOperation();
op.Name = "Multiple edits";
op.Create(featureLayer, geometry);
op.Modify(featureLayer2, 1);
bool result = op.Execute(); // <= create, modify are committed here
if (result)
{
// create chained op
var chainedOp = op.CreateChainedOperation();
chainedOp.Modify(featureLayer3, 2);
chainedOp.Delete(featureLayer2, 3);
result = chainedOp.Execute(); // <= modify and delete are committed here
}
The example we mostly use with chained operations is the 'create a feature and add an attachment' example. The method signature of AddAttachment requires the objectID of the feature which means that the creation needs to be committed in order for that objectID to exist. The creation occurs in the main edit operation and adding the attachment occurs in the chained operation.
//create an edit operation and name.
var op1 = new EditOperation();
op1.Name = string.Format("Create point in '{0}'", CurrentTemplate.Layer.Name);
//create a new feature and return the oid.
long newFeatureID = -1;
op1.Create(CurrentTemplate, geometry, oid => newFeatureID = oid);
// newFeatureID is populated when the Execute is called
op1.Execute();
//create a chained operation and add the attachment.
var op2 = op1.CreateChainedOperation();
// use the newFeatureID and template layer to identify the new feature
op2.AddAttachment(CurrentTemplate.Layer, newFeatureID, @"C:\Hydrant.jpg");
op2.Execute();
With regards to the examples in your posts;
It made sense to use the ChainedOperation in your previous post because the updates you were performing incremented values from features whose attributes were also required to be updated. You wanted all these operations to appear in one undo/redo item AND you were dependent on the attribute values of previous edit commits.
The scenario in this post doesn't appear to have the same constraints; all the updates are independent of each other as the values come from the form. This is why Sean posted about not requiring the ChainedOperation.
I've reworked your code into multiple snippets.
The first illustrating how to perform the chainedOperation in a loop to give you an example of how it might be structured if it was required (note - this is just one way of structuring it, not the only way);. The update you posted is pretty similar to this. You're correct in saying that having to do a 'fake' edit (as per your first code snippet) is counter-intuitive... that's generally an indication that you either need to restructure your code or think of a different approach.
the second snippet is the preferred solution with regards to Edit Operations to the problem in this post. It uses a single EditOperation and queues the multiple Modify methods. You should use this rather than the chainedOperation because the edits you're performing are all independent of each other and not reliant on values from a previous operation.
the third snippet shows you an optimization with respect to the Inspector object. Because the selected features in each layer will have the exact same fields updated to the same values we can load the inspector once per layer with all the selected features.rather than for every feature. (you can use this optimization with the chainedOperation snippet too - i just didn't include it)
snippet one - illustrates looping of a chainedOperation
private void btnSave_Click(object sender, EventArgs e)
{
try
{
//Give the user a chance to get out
. if (ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Are you sure you want to update all the selected layers?", "Update Selected Features?", System.Windows.MessageBoxButton.YesNo) == System.Windows.MessageBoxResult.No)
return;
this.Cursor = Cursors.WaitCursor;
QueuedTask.Run(() =>
{
Map map = MapView.Active.Map;
//Create the MAIN edit operation...this will show up on the Undo Stack
var editOperation = new ArcGIS.Desktop.Editing.EditOperation();
editOperation.Name = "Update Multiple Features";
editOperation.EditOperationType = ArcGIS.Desktop.Editing.EditOperationType.Long;
ArcGIS.Desktop.Editing.EditOperation chainedOp = null;
// create an inspector object
var inspector = new ArcGIS.Desktop.Editing.Attributes.Inspector(true);
// set a flag - we will be using the main operation first
bool isMainOperation = true;
//Go through each layer in the Layers listbox
foreach (string layer in lstLayers.Items)
{
var currentLayer = map.FindLayers(layer).FirstOrDefault() as BasicFeatureLayer;
var selection = currentLayer.GetSelection();
IReadOnlyList<long> selectedOIDs = selection.GetObjectIDs();
foreach (var oid in selectedOIDs)
{
inspector.Clear();
inspector.Load(currentLayer, oid);
//use the current selected OBJECTID as you go through the loop of selected features
for (int i = 0; i < gridFields.Rows.Count; i++)
{
if (gridFields.Rows.Cells[1].Value != null)
{
insp[gridFields.Rows.Cells[0].Value.ToString()] = gridFields.Rows.Cells[1].Value;
}
}
if (isMainOperation)
{
// set up the edit
editOperation.Modify(inspector);
// execute it
bool result = editOperation.Execute();
// change the flag so we'll use the chainedOperation next
isMainOperation = false;
}
else
{
// only create the chained operation once
if (chainedOp == null)
chainedOp = editOperation.CreateChainedOperation();
// queue up a modify
chainedOp.Modify(inspector);
}
}
}
// finished the layer loop, lets commit anything in the chained operation
if ((chainedOp != null) && !chainedOp.IsEmpty)
{
bool chainedResult = chainedOp.Execute();
}
}); //end of QueuedTask
}
catch
{
}
finally
{
this.Cursor = Cursors.Default;
}
}snippet two - illustrates the preferred EditOperation solution - queues all edits into a single EditOperation
private void btnSave_Click_NoChain(object sender, EventArgs e)
{
try
{
//Give the user a chance to get out.
if (ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Are you sure you want to update all the selected layers?", "Update Selected Features?", System.Windows.MessageBoxButton.YesNo) == System.Windows.MessageBoxResult.No)
return;
this.Cursor = Cursors.WaitCursor;
QueuedTask.Run(() =>
{
Map map = MapView.Active.Map;
//Create the MAIN edit operation...this will show up on the Undo Stack
var editOperation = new ArcGIS.Desktop.Editing.EditOperation();
editOperation.Name = "Update Multiple Features";
editOperation.EditOperationType = ArcGIS.Desktop.Editing.EditOperationType.Long;
var inspector = new ArcGIS.Desktop.Editing.Attributes.Inspector(true);
//Go through each layer in the Layers listbox
foreach (string layer in lstLayers.Items)
{
var currentLayer = map.FindLayers(layer).FirstOrDefault() as BasicFeatureLayer;
var selection = currentLayer.GetSelection();
IReadOnlyList<long> selectedOIDs = selection.GetObjectIDs();
foreach (var oid in selectedOIDs)
{
inspector.Clear();
inspector.Load(currentLayer, oid);
for (int i = 0; i < gridFields.Rows.Count; i++)
{
if (gridFields.Rows.Cells[1].Value != null)
{
insp[gridFields.Rows.Cells[0].Value.ToString()] = gridFields.Rows.Cells[1].Value;
}
}
editOperation.Modify(inspector);
}
}
if (!editOperation.IsEmpty)
{
bool result = editOperation.Execute();
if (!result)
{
// throw an error message
}
}
}); //end of QueuedTask
}
catch
{
}
finally
{
this.Cursor = Cursors.Default;
}
}snippet three - an optimized approach
private void btnSave_Click_NoChainOptimized(object sender, EventArgs e)
{
try
{
//Give the user a chance to get out.
if (ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Are you sure you want to update all the selected layers?", "Update Selected Features?", System.Windows.MessageBoxButton.YesNo) == System.Windows.MessageBoxResult.No)
return;
this.Cursor = Cursors.WaitCursor;
QueuedTask.Run(() =>
{
Map map = MapView.Active.Map;
//Create the MAIN edit operation...this will show up on the Undo Stack
var editOperation = new ArcGIS.Desktop.Editing.EditOperation();
editOperation.Name = "Update Multiple Features";
editOperation.EditOperationType = ArcGIS.Desktop.Editing.EditOperationType.Long;
var inspector = new ArcGIS.Desktop.Editing.Attributes.Inspector(true);
//Go through each layer in the Layers listbox
foreach (string layer in lstLayers.Items)
{
var currentLayer = map.FindLayers(layer).FirstOrDefault() as BasicFeatureLayer;
var selection = currentLayer.GetSelection();
IReadOnlyList<long> selectedOIDs = selection.GetObjectIDs();
inspector.Clear();
// load all the selected oids into the inspector
// we can do this because each feature will have the exact same fields updated to the same values
inspector.Load(currentLayer, selectedOIDs);
for (int i = 0; i < gridFields.Rows.Count; i++)
{
if (gridFields.Rows.Cells[1].Value != null)
{
insp[gridFields.Rows.Cells[0].Value.ToString()] = gridFields.Rows.Cells[1].Value;
}
}
// queue the modify
editOperation.Modify(inspector);
}
// finished the layer loop - commit all the edits
if (!editOperation.IsEmpty)
{
bool result = editOperation.Execute();
if (!result)
{
// throw an error message
}
}
}); //end of QueuedTask
}
catch
{
}
finally
{
this.Cursor = Cursors.Default;
}
}
There's a lot of information here. Let me know if you still have questions about edit operations and chaining or if something I've said isn't clear.
Narelle
