public RowBuffer CreateRowBuffer( 
   Subtype subtype
)

public async Task CreatingARow()
{
    string message = String.Empty;
    bool creationResult = false;
    EditOperation editOperation = new EditOperation();

    await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
    {

        using (Geodatabase geodatabase = new Geodatabase(
    new DatabaseConnectionFile(new Uri("path\\to\\sde\\file\\sdefile.sde"))))
        using (Table enterpriseTable = geodatabase.OpenDataset<Table>("LocalGovernment.GDB.piCIPCost"))
        {

            //var geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(uri)) for a File GDB
            //
            //var shapeFileConnPath = new FileSystemConnectionPath(uri, FileSystemDatastoreType.Shapefile);
            //var shapefile = new FileSystemDatastore(shapeFileConnPath);
            //var table = shapefile.OpenDataset<Table>(strShapeFileName); for a Shape file

            //declare the callback here. We are not executing it .yet.
            editOperation.Callback(context =>
      {
          TableDefinition tableDefinition = enterpriseTable.GetDefinition();
          int assetNameIndex = tableDefinition.FindField("ASSETNA");

          using (RowBuffer rowBuffer = enterpriseTable.CreateRowBuffer())
          {
              // Either the field index or the field name can be used in the indexer.
              rowBuffer[assetNameIndex] = "wMain";
              rowBuffer["COST"] = 700;
              rowBuffer["ACTION"] = "Open Cut";

              // subtype value for "Abandon".
              rowBuffer[tableDefinition.GetSubtypeField()] = 3;

              using (Row row = enterpriseTable.CreateRow(rowBuffer))
              {
                  // To Indicate that the attribute table has to be updated.
                  context.Invalidate(row);
              }
          }
      }, enterpriseTable);

            try
            {
                creationResult = editOperation.Execute();
                if (!creationResult) message = editOperation.ErrorMessage;
            }
            catch (GeodatabaseException exObj)
            {
                message = exObj.Message;
            }
        }
    });

    if (!string.IsNullOrEmpty(message))
        MessageBox.Show(message);

}

public async Task CreatingAFeature()
{
    string message = String.Empty;
    bool creationResult = false;

    await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
    {
        using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file\\sdefile.sde"))))
        using (FeatureClass enterpriseFeatureClass = geodatabase.OpenDataset<FeatureClass>("LocalGovernment.GDB.FacilitySite"))
        {
            //var geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(uri)) for a File GDB
            //
            //var shapeFileConnPath = new FileSystemConnectionPath(uri, FileSystemDatastoreType.Shapefile);
            //var shapefile = new FileSystemDatastore(shapeFileConnPath);
            //var table = shapefile.OpenDataset<Table>(strShapeFileName); for a Shape file

            //declare the callback here. We are not executing it yet
            EditOperation editOperation = new EditOperation();
            editOperation.Callback(context =>
      {
          FeatureClassDefinition facilitySiteDefinition = enterpriseFeatureClass.GetDefinition();
          int facilityIdIndex = facilitySiteDefinition.FindField("FACILITYID");

          using (RowBuffer rowBuffer = enterpriseFeatureClass.CreateRowBuffer())
          {
              // Either the field index or the field name can be used in the indexer.
              rowBuffer[facilityIdIndex] = "wMain";
              rowBuffer["NAME"] = "Griffith Park";
              rowBuffer["OWNTYPE"] = "Municipal";
              rowBuffer["FCODE"] = "Park";
              // Add it to Public Attractions Subtype.
              rowBuffer[facilitySiteDefinition.GetSubtypeField()] = 820;

              List<Coordinate2D> newCoordinates = new List<Coordinate2D>
            {
          new Coordinate2D(1021570, 1880583),
          new Coordinate2D(1028730, 1880994),
          new Coordinate2D(1029718, 1875644),
          new Coordinate2D(1021405, 1875397)
              };

              rowBuffer[facilitySiteDefinition.GetShapeField()] = new PolygonBuilderEx(newCoordinates).ToGeometry();

              using (Feature feature = enterpriseFeatureClass.CreateRow(rowBuffer))
              {
                  //To Indicate that the attribute table has to be updated
                  context.Invalidate(feature);
              }
          }

      }, enterpriseFeatureClass);

            try
            {
                creationResult = editOperation.Execute();
                if (!creationResult) message = editOperation.ErrorMessage;
            }
            catch (GeodatabaseException exObj)
            {
                message = exObj.Message;
            }
        }
    });

    if (!string.IsNullOrEmpty(message))
        MessageBox.Show(message);
}

public async Task WriteBlobField(Table table, string blobFieldName, string imageFileName)
{
    await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
    {
        // Read the image file into a MemoryStream
        MemoryStream memoryStream = new MemoryStream(); ;
        using (FileStream imageFile = new FileStream(imageFileName, FileMode.Open, FileAccess.Read))
        {
            imageFile.CopyTo(memoryStream);
        }

        // Create a new row in the table, and write the Memory Stream into a blob fiele
        using (RowBuffer rowBuffer = table.CreateRowBuffer())
        {
            rowBuffer[blobFieldName] = memoryStream;
            table.CreateRow(rowBuffer).Dispose();
        }
    });
}

public async Task CreatingAnAnnotationFeature(Geodatabase geodatabase)
{
    await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
    {
        using (AnnotationFeatureClass annotationFeatureClass = geodatabase.OpenDataset<AnnotationFeatureClass>("Annotation // feature // class // name"))
        using (AnnotationFeatureClassDefinition annotationFeatureClassDefinition = annotationFeatureClass.GetDefinition())
        using (RowBuffer rowBuffer = annotationFeatureClass.CreateRowBuffer())
        using (AnnotationFeature annotationFeature = annotationFeatureClass.CreateRow(rowBuffer))
        {
            annotationFeature.SetAnnotationClassID(0);
            annotationFeature.SetStatus(AnnotationStatus.Placed);

            // Get the annotation labels from the label collection
            IReadOnlyList<CIMLabelClass> labelClasses =
        annotationFeatureClassDefinition.GetLabelClassCollection();

            // Setup the symbol reference with the symbol id and the text symbol
            CIMSymbolReference cimSymbolReference = new CIMSymbolReference();
            cimSymbolReference.Symbol = labelClasses[0].TextSymbol.Symbol;
            cimSymbolReference.SymbolName = labelClasses[0].TextSymbol.SymbolName;

            // Setup the text graphic
            CIMTextGraphic cimTextGraphic = new CIMTextGraphic();
            cimTextGraphic.Text = "Charlotte, North Carolina";
            cimTextGraphic.Shape = new MapPointBuilderEx(new Coordinate2D(-80.843, 35.234), SpatialReferences.WGS84).ToGeometry();
            cimTextGraphic.Symbol = cimSymbolReference;

            // Set the symbol reference on the graphic and store
            annotationFeature.SetGraphic(cimTextGraphic);
            annotationFeature.Store();
        }
    });
}

public void CreateRowBufferFromARow(Table table)
{
    using (RowCursor rowCursor = table.Search())
    {
        if (rowCursor.MoveNext())
        {
            using (Row templateRow = rowCursor.Current)
            {
                RowBuffer rowBuffer = table.CreateRowBuffer(templateRow);

                // Manipulate row buffer
                // Doesn't allow copying values of ObjectID and GlobalID
                //
                // rowBuffer["Field"] = "Update";
                //

                // create a new row
                table.CreateRow(rowBuffer);
            }
        }
    }
}

public void CreateRowBufferFromARow(Table table)
{
    using (RowCursor rowCursor = table.Search())
    {
        if (rowCursor.MoveNext())
        {
            using (Row templateRow = rowCursor.Current)
            {
                RowBuffer rowBuffer = table.CreateRowBuffer(templateRow);

                // Manipulate row buffer
                // Doesn't allow copying values of ObjectID and GlobalID
                //
                // rowBuffer["Field"] = "Update";
                //

                // create a new row
                table.CreateRow(rowBuffer);
            }
        }
    }
}