public IReadOnlyList<Conflict> GetConflicts()

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