ArcGIS Pro 3.8 API Reference Guide
ArcGIS.Core.Data Namespace / Version Class / Connect Method
Example

In This Topic
    Connect Method (Version)
    In This Topic
    Physically connects to this version in the geodatabase. This method must be called on the MCT. Use QueuedTask.Run.
    Syntax
    public override Geodatabase Connect()
    Public Overrides NotOverridable Function Connect() As Geodatabase

    Return Value

    This version's data repository.
    Exceptions
    ExceptionDescription
    A geodatabase-related exception has occurred.
    This method or property must be called within the lambda passed to QueuedTask.Run
    Example
    Illustrate version conflict information from a reconcile operation
    {
      Task GetVersionConflictsInfoInUpdateDeleteTypeAsync(
        ServiceConnectionProperties featureServiceConnectionProperties,
        string featureClassName) => QueuedTask.Run(() =>
      {
        // 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;
            }
          }
        }
      });
    }
    Connecting to a Version
    {
      Task<Geodatabase> ConnectToVersionAsync(Geodatabase geodatabase, string versionName) => QueuedTask.Run(() =>
      {
        Geodatabase connectedVersion = null;
    
        if (geodatabase.IsVersioningSupported())
        {
          using (VersionManager versionManager = geodatabase.GetVersionManager())
          using (Version version = versionManager.GetVersion(versionName))
          {
            connectedVersion = version.Connect();
          }
        }
    
        return connectedVersion;
      });
    }
    Working with Versions
    {
      await QueuedTask.Run(() =>
      {
        using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file"))))
        using (VersionManager versionManager = geodatabase.GetVersionManager())
        {
          IReadOnlyList<string> versionNames = versionManager.GetVersionNames();
    
          Version defaultVersion = versionManager.GetDefaultVersion();
    
          string testVersionName = versionNames.First(v => v.Contains("Test"));
          Version testVersion = versionManager.GetVersion(testVersionName);
    
          Version qaVersion = defaultVersion.GetChildren().First(version => version.GetName().Contains("QA"));
    
          Geodatabase qaVersionGeodatabase = qaVersion.Connect();
    
          FeatureClass currentFeatureClass = geodatabase.OpenDataset<FeatureClass>("featureClassName");
          FeatureClass qaFeatureClass = qaVersionGeodatabase.OpenDataset<FeatureClass>("featureClassName");
        }
      });
    }
    Requirements

    Target Platforms: Windows 11 Home, Pro, Enterprise (64 bit)

    ArcGIS Pro version: 3.0 or higher.
    See Also