ArcGIS Pro 3.8 API Reference Guide
ArcGIS.Core.Data Namespace / Geodatabase Class / IsVersioningSupported Method
Example

In This Topic
    IsVersioningSupported Method
    In This Topic
    Gets a value indicating whether this geodatabase supports versioning. This method must be called on the MCT. Use QueuedTask.Run.
    Syntax
    public bool IsVersioningSupported()
    Public Function IsVersioningSupported() As Boolean

    Return Value

    true if this geodatabase supports versioning and was not returned from HistoricalVersion.Connect. false otherwise.
    Exceptions
    ExceptionDescription
    No valid geodatabase has been opened prior to invoking this operation.
    Example
    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;
      });
    }
    Reconciling and Posting a Version with its Parent in separate edit sessions
    {
      Task ReconcileAndPostAsync(Geodatabase geodatabase) => QueuedTask.Run(() =>
      {
        // 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 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
    
              // Post - Deprecated since Pro SDK 3.6 / Enterprise 12.0 . Use Reconcile(reconcileOptions, postOptions) instead.
              // currentVersion.Post(postOptions);
    
              currentVersion.Reconcile(reconcileOptions, postOptions);
            }
          }
        }
      });
    }
    Reconciling and Posting a Version with its Parent in the same edit session
    {
      Task ReconcileAndPost2Async(Geodatabase geodatabase) => QueuedTask.Run(() =>
      {
        // 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 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
            }
          }
        }
      });
    }
    Working with the Default Version
    {
      Task<Version> FindDefaultVersionAsync(Geodatabase geodatabase) => QueuedTask.Run(() =>
      {
        if (!geodatabase.IsVersioningSupported())
        {
          return null;
        }
    
        using (VersionManager versionManager = geodatabase.GetVersionManager())
        {
          Version currentVersion = versionManager.GetCurrentVersion();
          Version defaultVersion = GetDefaultVersion(currentVersion);
          if (currentVersion != defaultVersion)
          {
            currentVersion.Dispose(); // If we are not pointing to default, we want to dispose this Version object
          }
          return defaultVersion;
        }
    
        // Check to see if the current version is default.
        // Works with both branch and traditional versioning.
        bool IsDefaultVersion(Version version)
        {
          Version parentVersion = version.GetParent();
          if (parentVersion == null)
          {
            return true;
          }
    
          parentVersion.Dispose();
          return false;
        }
    
        // Gets the default version.
        // Works with both branch and traditional versioning.
        // Note that this routine depends on IsDefaultVersion(), above.
        Version GetDefaultVersion(Version version)
        {
          if (IsDefaultVersion(version))
          {
            return version;
          }
    
          Version parent = version.GetParent();
          Version ancestor = GetDefaultVersion(parent);
          if (parent != ancestor)
          {
            parent.Dispose(); //If the versioning tree is more than 2 deep, we want to dispose any intermediary versions
          }
    
          return ancestor;
        }
      });
    }
    Creating a Version
    {
      Task<Version> CreateVersionAsync(Geodatabase geodatabase, string versionName, string description, VersionAccessType versionAccessType) => QueuedTask.Run(() =>
      {
        if (!geodatabase.IsVersioningSupported())
        {
          return null;
        }
    
        using (VersionManager versionManager = geodatabase.GetVersionManager())
        {
          VersionDescription versionDescription =
            new VersionDescription(versionName, description, versionAccessType);
          return versionManager.CreateVersion(versionDescription);
        }
      });
    }
    Requirements

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

    ArcGIS Pro version: 3.0 or higher.
    See Also