public void Modify( 
   Inspector inspector
)

// Modifies a single feature in the specified feature layer.
await QueuedTask.Run(() =>
  {
    var modifyFeature = new EditOperation() { Name = "Modify a feature" };

    //use an inspector
    var modifyInspector = new Inspector();
    modifyInspector.Load(featureLayer, objectId);//base attributes on an existing feature

    //change attributes for the new feature
    modifyInspector["SHAPE"] = polygon;//Update the geometry
    modifyInspector["NAME"] = "Updated name";//Update attribute(s)

    modifyFeature.Modify(modifyInspector);

    //update geometry and attributes using overload
    var featureAttributes = new Dictionary<string, object>
    {
      ["NAME"] = "Updated name"//Update attribute(s)
    };
    modifyFeature.Modify(featureLayer, objectId, polygon, featureAttributes);

    //Execute to execute the operation
    //Must be called within QueuedTask.Run
    if (!modifyFeature.IsEmpty)
    {
      //Execute and ExecuteAsync will return true if the operation was successful and false if not
      var result = modifyFeature.Execute();
      //or use async flavor
      //await modifyFeatures.ExecuteAsync();
    }
  });

// Modifies multiple features in the specified feature layer by updating their attributes.
await QueuedTask.Run(() =>
  {
    //Search by attribute
    var queryFilter = new QueryFilter() { WhereClause = "OBJECTID < 1000000" };
    //Create list of oids to update
    var oidSet = new List<long>();
    using (var rc = featureLayer.Search(queryFilter))
    {
      while (rc.MoveNext())
      {
        using var record = rc.Current;
        oidSet.Add(record.GetObjectID());
      }
    }
    //create and execute the edit operation
    var modifyFeatures = new EditOperation
    {
      Name = "Modify features",
      ShowProgressor = true
    };

    var multipleFeaturesInsp = new Inspector();
    multipleFeaturesInsp.Load(featureLayer, oidSet);
    multipleFeaturesInsp["MOMC"] = 24;
    modifyFeatures.Modify(multipleFeaturesInsp);
    if (!modifyFeatures.IsEmpty)
    {
      var result = modifyFeatures.ExecuteAsync(); //Execute and ExecuteAsync will return true if the operation was successful and false if not
    }
  });

// Updates the text of an annotation feature in the specified annotation layer.
await QueuedTask.Run(() =>
{
  // annotationLayer is ~your~ Annotation layer...
  // use the inspector methodology
  var insp = new Inspector();
  insp.Load(annotationLayer, objectId);
  // get the annotation properties
  AnnotationProperties annoProperties = insp.GetAnnotationProperties();
  // set the attribute
  annoProperties.TextString = annotationText;
  // assign the annotation properties back to the inspector
  insp.SetAnnotationProperties(annoProperties);
  //create and execute the edit operation
  EditOperation op = new EditOperation();
  op.Name = "Update annotation";
  op.Modify(insp);
  if (!op.IsEmpty)
  {
    var result = op.Execute(); //Execute and ExecuteAsync will return true if the operation was successful and false if not
  }
});

// Modifies the geometry of an annotation feature in the specified annotation layer.
await QueuedTask.Run(() =>
{
  //Don't use 'Shape'....Shape is the bounding box of the annotation text. This is NOT what you want...
  //
  //var insp = new Inspector();
  //insp.Load(annotationLayer, objectId);
  //var shape = insp["SHAPE"] as Polygon;
  //...wrong shape...
  //Instead, we must use the AnnotationProperties
  //annotationLayer is ~your~ Annotation layer
  var insp = new Inspector();
  insp.Load(annotationLayer, objectId);
  AnnotationProperties annoProperties = insp.GetAnnotationProperties();
  var shape = annoProperties.Shape;
  if (shape.GeometryType != GeometryType.GeometryBag)
  {
    var newGeometry = GeometryEngine.Instance.Move(shape, 10, 10);
    annoProperties.Shape = newGeometry;
    insp.SetAnnotationProperties(annoProperties);
    EditOperation op = new EditOperation
    {
      Name = "Change annotation angle"
    };
    op.Modify(insp);
    if (!op.IsEmpty)
    {
      var result = op.Execute(); //Execute and ExecuteAsync will return true if the operation was successful and false if not
    }
  }
});

// Modifies the text graphic of a selected annotation feature in the specified annotation layer.
await QueuedTask.Run(() =>
{
  var selection = annotationLayer.GetSelection();
  if (selection.GetCount() == 0)
    return;
  // use the first selected feature 
  var insp = new Inspector();
  insp.Load(annotationLayer, selection.GetObjectIDs().FirstOrDefault());
  // getAnnoProperties should return null if not an annotation feature
  AnnotationProperties annoProperties = insp.GetAnnotationProperties();
  // get the textGraphic
  CIMTextGraphic textGraphic = annoProperties.TextGraphic;
  // change text
  textGraphic.Text = "Hello world";
  // set x,y offset via the symbol
  var symbol = textGraphic.Symbol.Symbol;
  var textSymbol = symbol as CIMTextSymbol;
  textSymbol.OffsetX = 2;
  textSymbol.OffsetY = 3;
  textSymbol.HorizontalAlignment = HorizontalAlignment.Center;
  // load the updated textGraphic
  annoProperties.LoadFromTextGraphic(textGraphic);
  // assign the annotation properties back 
  insp.SetAnnotationProperties(annoProperties);
  EditOperation op = new EditOperation
  {
    Name = "modify symbol"
  };
  op.Modify(insp);
  if (!op.IsEmpty)
  {
    bool result = op.Execute(); //Execute and ExecuteAsync will return true if the operation was successful and false if not
  }
});

// Moves the first selected feature in the specified feature layer to the given coordinates.
await QueuedTask.Run<bool>(() =>
 {
   //Get all of the selected ObjectIDs from the layer.
   var mySelection = featureLayer.GetSelection();
   var selOid = mySelection.GetObjectIDs()?[0];
   var xCoordinate = 0.0;
   var yCoordinate = 0.0; // specify the target coordinates to move the geometry
   var moveToPoint = new MapPointBuilderEx(xCoordinate, yCoordinate, 0.0, 0.0, featureLayer.GetSpatialReference());

   var moveEditOperation = new EditOperation() { Name = "Move features" };
   moveEditOperation.Modify(featureLayer, selOid ?? -1, moveToPoint.ToGeometry());  //Modify the feature to the new geometry 
   if (!moveEditOperation.IsEmpty)
   {
     var result = moveEditOperation.Execute(); //Execute and ExecuteAsync will return true if the operation was successful and false if not
     return result; // return the operation result: true if successful, false if not
   }
   return false; // return false to indicate that the operation was not empty
 });

// Modifies the "NAME" attribute of a specified feature and then splits the feature using the provided polyline, all within a single sequential edit operation.
// perform an edit and then a split as one operation.
await QueuedTask.Run(() =>
 {
   var newName = "Modified then Split";
   var queryFilter = new QueryFilter() { WhereClause = "OBJECTID = " + objectId.ToString() };

   // create an edit operation and name.
   var op = new EditOperation
   {
     Name = "modify followed by split",         // set the ExecuteMode
     ExecuteMode = ExecuteModeType.Sequential
   };
   using (var rowCursor = layer.Search(queryFilter))
   {
     while (rowCursor.MoveNext())
     {
       using var feature = rowCursor.Current as ArcGIS.Core.Data.Feature;
       op.Modify(feature, "NAME", newName);
     }
   }
   op.Split(layer, objectId, splitLine);
   if (!op.IsEmpty)
   {
     bool result = op.Execute();
   }
   // else
   //  The operation doesn't make any changes to the database so if executed it will fail
 });

await QueuedTask.Run(() =>
{
  // get selected feature into inspector
  var selectedFeatures = activeMap.GetSelection();
  var insp = new Inspector();
  insp.Load(selectedFeatures.ToDictionary().Keys.First(), selectedFeatures.ToDictionary().Values.First());
  // read a blob field and save to a file
  var msw = new MemoryStream();
  msw = insp["BlobField"] as MemoryStream;
  using (FileStream file = new(@"d:\temp\blob.jpg", FileMode.Create, FileAccess.Write))
  {
    msw.WriteTo(file);
  }
  // read file into memory stream
  var msr = new MemoryStream();
  using (FileStream file = new(@"d:\images\Hydrant.jpg", FileMode.Open, FileAccess.Read))
  {
    file.CopyTo(msr);
  }
  //put the memory stream in the blob field and save to feature
  var op = new EditOperation() { Name = "Blob Inspector" };
  insp["Blobfield"] = msr;
  op.Modify(insp);
  if (!op.IsEmpty)
  {
    var result = op.Execute(); //Execute and ExecuteAsync will return true if the operation was successful and false if not
  }
});

await QueuedTask.Run(() =>
{
  //Open the raster dataset on disk and create a compressed raster value dataset object
  var dataStore = new ArcGIS.Core.Data.FileSystemDatastore(new ArcGIS.Core.Data.FileSystemConnectionPath(new Uri(@"e:\temp"), ArcGIS.Core.Data.FileSystemDatastoreType.Raster));
  using (var fileRasterDataset = dataStore.OpenDataset<ArcGIS.Core.Data.Raster.RasterDataset>("Hydrant.jpg"))
  {
    var storageDef = new ArcGIS.Core.Data.Raster.RasterStorageDef();
    storageDef.SetCompressionType(ArcGIS.Core.Data.Raster.RasterCompressionType.JPEG);
    storageDef.SetCompressionQuality(90);

    var rv = new ArcGIS.Core.Data.Raster.RasterValue();
    rv.SetRasterDataset(fileRasterDataset);
    rv.SetRasterStorageDef(storageDef);

    var sel = MapView.Active.Map.GetSelection();

    //insert a raster value object into the raster field
    var insp = new ArcGIS.Desktop.Editing.Attributes.Inspector();
    insp.Load(sel.ToDictionary().Keys.First(), sel.ToDictionary().Values.First());
    insp["Photo"] = rv;

    var op = new EditOperation() { Name = "Raster Inspector" };
    op.Modify(insp);
    if (!op.IsEmpty)
    {
      var result = op.Execute(); //Execute and ExecuteAsync will return true if the operation was successful and false if not
    }
  }
});

{
  var oid = 1;

  // See "Change Annotation Text Graphic" for an alternative if TEXTSTRING is missing from the schema

  // Note: QueuedTask is required to access the Inspector
  {
    // use the inspector methodology
    var insp = new Inspector();
    insp.Load(annotationLayer, oid);

    // make sure TextString attribute exists.
    //It is not guaranteed to be in the schema
    ArcGIS.Desktop.Editing.Attributes.Attribute att = insp.FirstOrDefault(a => a.FieldName == "TEXTSTRING");
    if (att != null)
    {
      insp["TEXTSTRING"] = "Hello World";

      //create and execute the edit operation
      EditOperation op = new EditOperation();
      op.Name = "Update annotation";
      op.Modify(insp);

      //OR using a Dictionary - again TEXTSTRING has to exist in the schema
      //Dictionary<string, object> newAtts = new Dictionary<string, object>();
      //newAtts.Add("TEXTSTRING", "hello world");
      //op.Modify(annotationLayer, oid, newAtts);

      op.Execute();
    }
  }
}

{
  //must support editing!
  if (!featSceneLayer.HasAssociatedFeatureService ||
      !featSceneLayer.IsEditable)
    return;

  // Note: call within QueuedTask.Run()
  {
    var editOp = new EditOperation()
    {
      Name = "Edit FeatureSceneLayer Attributes",
      SelectModifiedFeatures = true
    };
    //make an inspector
    var inspector = new Inspector();
    //get the attributes for the specified oid
    inspector.Load(featSceneLayer, oid);
    inspector["PermitNotes"] = "test";//modify
    editOp.Modify(inspector);
    editOp.Execute();//synchronous flavor
  }
}