public sealed class ReconcileResult 

public 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.Private);

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

public 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 ReconcileDescription object
      //At 2.x - 
      //ReconcileDescription reconcileDescription = new ReconcileDescription(parentVersion);
      //reconcileDescription.ConflictResolutionMethod = ConflictResolutionMethod.Continue; // continue if conflicts are found
      //reconcileDescription.WithPost = true;

      //// Reconcile and post
      //ReconcileResult reconcileResult = currentVersion.Reconcile(reconcileDescription);

      // ReconcileResult.HasConflicts can be checked as-needed

      // 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
        currentVersion.Post(postOptions);
      }

    }
  }
}

public void ReconcileAndPost2(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 ReconcileDescription object
      //At 2.x - 
      //ReconcileDescription reconcileDescription = new ReconcileDescription(parentVersion);
      //reconcileDescription.ConflictResolutionMethod = ConflictResolutionMethod.Continue; // continue if conflicts are found
      //reconcileDescription.WithPost = true;

      //// Reconcile and post
      //ReconcileResult reconcileResult = currentVersion.Reconcile(reconcileDescription);

      // ReconcileResult.HasConflicts can be checked as-needed

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

      PostOptions postOptions = new PostOptions(parentVersion);
      //var postOptions = new PostOptions(); for default version
      postOptions.ServiceSynchronizationType = ServiceSynchronizationType.Synchronous;//Default

      // Reconcile
      ReconcileResult reconcileResult = currentVersion.Reconcile(reconcileOptions, postOptions);
      if (reconcileResult.HasConflicts)
      {
        //TODO resolve conflicts

      }

    }
  }
}