ArcGIS Pro 3.3 API Reference Guide
ArcGIS.Core.Data Namespace / ReconcileResult Class / HasConflicts Property
Example

In This Topic
    HasConflicts Property
    In This Topic
    Gets a value indicating whether conflicts exist during the Version.Reconcile operation.
    Syntax
    public bool HasConflicts {get;}
    Public ReadOnly Property HasConflicts As Boolean
    Example
    Illustrate version conflict information from a reconcile operation
    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;
          }
        }
      }
    }
    
    Reconciling and Posting a Version with its Parent in separate edit sessions
    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);
          }
    
        }
      }
    }
    Reconciling and Posting a Version with its Parent in the same edit session
    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
    
          }
    
        }
      }
    }
    Requirements

    Target Platforms: Windows 11, Windows 10

    ArcGIS Pro version: 3 or higher.
    See Also