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

            }

        }
    }
}