public ReconcileResult Reconcile( 
   ReconcileOptions reconcileOptions
)

{
  // Must be called within QueuedTask.Run
  void GetVersionConflictsInfoInUpdateDeleteType(
    ServiceConnectionProperties featureServiceConnectionProperties,
    string featureClassName)
  {
    // To illustrate the conflict between versions,
    // the feature is updated in the child version and deleted in the parent version.

    long featureObjectIDForEdit = Int64.MinValue;

    // Get branch versioned service
    using (Geodatabase fsGeodatabase = new Geodatabase(featureServiceConnectionProperties))
    using (VersionManager versionManager = fsGeodatabase.GetVersionManager())
    using (Version defaultVersion = versionManager.GetDefaultVersion())
    using (Geodatabase defaultGeodatabase = defaultVersion.Connect())
    using (FeatureClass defaultFeatureClass = defaultGeodatabase.OpenDataset<FeatureClass>(featureClassName))
    using (FeatureClassDefinition defaultFeatureClassDefinition = defaultFeatureClass.GetDefinition())
    {
      // Create a feature in the default version to edit in a branch
      defaultGeodatabase.ApplyEdits(() =>
      {
        using (RowBuffer rowBuffer = defaultFeatureClass.CreateRowBuffer())
        {
          rowBuffer["NAME"] = "Loblolly Pine";
          rowBuffer["TREEAGE"] = 1;
          rowBuffer[defaultFeatureClassDefinition.GetShapeField()] = new MapPointBuilderEx(new Coordinate2D(1, 1),
            SpatialReferenceBuilder.CreateSpatialReference(4152, 0)).ToGeometry();

          using (Feature feature = defaultFeatureClass.CreateRow(rowBuffer))
          {
            featureObjectIDForEdit = feature.GetObjectID();
          }
        }
      });
      // Add newly created feature in the filter
      QueryFilter queryFilter = new QueryFilter { ObjectIDs = new List<long> { featureObjectIDForEdit } };

      // Create a branch version
      VersionDescription versionDescription = new VersionDescription("UpdateDeleteConflictType",
        "Update-Delete version conflict type", VersionAccessType.Public);

      // Edit the feature in the branch 
      using (Version editVersion = versionManager.CreateVersion(versionDescription))
      using (Geodatabase branchGeodatabase = editVersion.Connect())
      using (FeatureClass featureClass = branchGeodatabase.OpenDataset<FeatureClass>(featureClassName))
      using (RowCursor rowCursor = featureClass.Search(queryFilter, false))
      {
        branchGeodatabase.ApplyEdits(() =>
        {
          while (rowCursor.MoveNext())
          {
            using (Row row = rowCursor.Current)
            {
              row["TREEAGE"] = 100;
              row["NAME"] = $"{row["Name"]}_EditInBranch";
              row.Store();
            }
          }
        });

        // Delete the feature from the default version
        defaultGeodatabase.ApplyEdits(() =>
        {
          defaultFeatureClass.DeleteRows(queryFilter);
        });

        // Reconcile options
        ReconcileOptions reconcileOptions = new ReconcileOptions(defaultVersion)
        {
          ConflictResolutionType = ConflictResolutionType.FavorEditVersion,
          ConflictDetectionType = ConflictDetectionType.ByRow,
          ConflictResolutionMethod = ConflictResolutionMethod.Continue
        };

        // Reconcile with default
        ReconcileResult reconcileResult = editVersion.Reconcile(reconcileOptions);

        // Check for conflicts
        bool hasConflictsReconcileResults = reconcileResult.HasConflicts;
        bool hasConflictsAfterReconcile = editVersion.HasConflicts();

        // Fetch conflicts
        IReadOnlyList<Conflict> conflictsAfterReconcile = editVersion.GetConflicts();

        // Iterate conflicts
        foreach (Conflict conflict in conflictsAfterReconcile)
        {
          // Object ID of row where conflict occurs
          long objectId = conflict.ObjectID;

          ConflictType conflictType = conflict.ConflictType;

          IReadOnlyList<FieldValue> ancestorVersionValues = conflict.AncestorVersionValues;
          object nameAncestor = ancestorVersionValues.FirstOrDefault(f => f.FieldName.Contains("NAME")).Value;
          object treeAgeAncestor =
            ancestorVersionValues.FirstOrDefault(f => f.FieldName.Contains("TREEAGE")).Value;

          IReadOnlyList<FieldValue> childVersionValues = conflict.ChildVersionValues;
          object nameChild = childVersionValues.FirstOrDefault(f => f.FieldName.Contains("NAME")).Value;
          object treeAgeChild = childVersionValues.FirstOrDefault(f => f.FieldName.Contains("TREEAGE")).Value;

          IReadOnlyList<FieldValue> parentVersionValues = conflict.ParentVersionValues;

          IReadOnlyList<Field> originalFields = defaultFeatureClassDefinition.GetFields();

          string datasetName = conflict.DatasetName;
        }
      }
    }
  }
}

{
  // Must be called within QueuedTask.Run
  void ReconcileAndPost(Geodatabase geodatabase)
  {
    // Get a reference to our version and our parent
    if (geodatabase.IsVersioningSupported())
    {
      using (VersionManager versionManager = geodatabase.GetVersionManager())
      using (Version currentVersion = versionManager.GetCurrentVersion())
      using (Version parentVersion = currentVersion.GetParent())
      {
        // Create a ReconcileOptions object
        ReconcileOptions reconcileOptions = new ReconcileOptions(parentVersion);
        reconcileOptions.ConflictResolutionMethod = ConflictResolutionMethod.Continue; // continue if conflicts are found
        reconcileOptions.ConflictDetectionType = ConflictDetectionType.ByRow; //Default
        reconcileOptions.ConflictResolutionType = ConflictResolutionType.FavorTargetVersion; //or FavorEditVersion

        // Reconcile
        ReconcileResult reconcileResult = currentVersion.Reconcile(reconcileOptions);
        if (!reconcileResult.HasConflicts)
        {
          //No conflicts, perform the post
          PostOptions postOptions = new PostOptions(parentVersion);
          //var postOptions = new PostOptions(); for default version
          postOptions.ServiceSynchronizationType = ServiceSynchronizationType.Synchronous; //Default

          // Post - Deprecated since Pro SDK 3.6 / Enterprise 12.0 . Use Reconcile(reconcileOptions, postOptions) instead.
          // currentVersion.Post(postOptions);

          currentVersion.Reconcile(reconcileOptions, postOptions);
        }
      }
    }
  }
}