public void Modify( 
   Row row,
   Dictionary<int,object> attributes
)

// 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();
    }
  });

// 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
  }
}