public Version GetParent()

{
  // Must be called within QueuedTask.Run
  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 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);
        }
      }
    }
  }
}

{
  // Must be called within QueuedTask.Run
  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 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
        }
      }
    }
  }
}

{
  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");
    }
  });
}

{
  // Must be called within QueuedTask.Run
  Version FindDefaultVersion(Geodatabase geodatabase)
  {
    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;
    }
  }
}