// Variables not used in samples
  OpenItemDialog selectItemDialog = new(); // in #region BrowseDialogItems

  // Adds a single item to a map
  OpenItemDialog addToMapDialog = new()
  {
    Title = "Add To Map",
    InitialLocation = @"C:\Data\NewYork\Counties\Erie\Streets",
    Filter = ItemFilters.Composite_AddToMap
  };

OpenItemDialog addToProjectDialog = new()
  {
    Title = "Add To Project",
    InitialLocation = @"C:\Data\NewYork\Counties\Maps",
    MultiSelect = true,
    Filter = ItemFilters.Composite_Maps_Import
  };

  bool? ok = addToProjectDialog.ShowDialog();

  if (ok == true)
  {
    IEnumerable<Item> selectedItems = addToProjectDialog.Items;
    foreach (Item selectedItem in selectedItems)
      MapFactory.Instance.CreateMapFromItem(selectedItem);
  }

SaveItemDialog saveLayerFileDialog = new()
  {
    Title = "Save Layer File",
    InitialLocation = @"C:\Data\ProLayers\Geographic\Streets",
    Filter = ItemFilters.Files_All
  };

SaveItemDialog saveMapFileDialog = new()
  {
    Title = "Save Map File",
    InitialLocation = @"C:\Data\NewYork\Counties\Maps",
    DefaultExt = @"mapx",
    Filter = ItemFilters.Maps_All,
    OverwritePrompt = true
  };
  bool? result = saveMapFileDialog.ShowDialog();

  if (result == true)
  {
    ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Returned file name: " + saveMapFileDialog.FilePath);
  }

OpenItemDialog addToProjectDialog = new()
  {
    Title = "Add To Project",
    MultiSelect = true,
    Filter = ItemFilters.Composite_Maps_Import
  };
  bool? ok = addToProjectDialog.ShowDialog();
  if (ok == true)
  {
    IEnumerable<Item> selectedDialogItems = addToProjectDialog.Items;
    foreach (Item selectedDialogItem in selectedDialogItems)
      MapFactory.Instance.CreateMapFromItem(selectedDialogItem);
  }

// not to be included in sample regions
  var projectFolderConnection = Project.Current.GetItems<FolderConnectionProjectItem>().First();

  // Get all the maps in a project
  IEnumerable<MapProjectItem> projectMaps = Project.Current.GetItems<MapProjectItem>();

// Get all the folder connections in a project
  IEnumerable<FolderConnectionProjectItem> projectFolders = Project.Current.GetItems<FolderConnectionProjectItem>();
  // use projectFolders;

// Get all the server connections in a project
  IEnumerable<ServerConnectionProjectItem> projectServers = Project.Current.GetItems<ServerConnectionProjectItem>();
  // use projectServers;

// Get all the locator connections in a project
  IEnumerable<LocatorsConnectionProjectItem> projectLocators = Project.Current.GetItems<LocatorsConnectionProjectItem>();
  // use projectLocators;

// Get all the items that can be accessed from a folder connection. The items immediately 
  // contained by a folder, that is, the folder's children, are returned including folders
  // and individual items that can be used in ArcGIS Pro. This method does not return all 
  // items contained by any sub-folder that can be accessed from the folder connection.
  FolderConnectionProjectItem folderConnection = Project.Current.GetItems<FolderConnectionProjectItem>()
                                                      .FirstOrDefault(folder => folder.Name.Equals("Data"));
  //Note: Needs QueuedTask to run
  IEnumerable<Item> folderContents = folderConnection.GetItems();

// Add a folder connection to a project

  Item folderToAdd = ItemFactory.Instance.Create(@"C:\Data\Oregon\Counties\Streets");
  // Note: Needs QueuedTask to run
  bool wasAdded = Project.Current.AddItem(folderToAdd as IProjectItem);
  // use wasAdded;

// Add a file geodatabase or a SQLite or enterprise database connection to a project
  Item gdbToAdd = folderToAdd.GetItems().FirstOrDefault(folderItem => folderItem.Name.Equals("CountyData.gdb"));
  // Note: Needs QueuedTask to run
  var addedGeodatabase = Project.Current.AddItem(gdbToAdd as IProjectItem);
  // use addedGeodatabase;

// Remove a folder connection from a project; the folder stored on the local disk 
  // or the network is not deleted

  //Note: Needs QueuedTask to run
  {
    bool result = false;
    FolderConnectionProjectItem folderToRemove = Project.Current.GetItems<FolderConnectionProjectItem>()
      .FirstOrDefault(folder => folder.Name.Equals("Data"));
    if (folderToRemove != null)
      result = Project.Current.RemoveItem(folderToRemove as IProjectItem);
    // use result
  }

// Remove a map from a project; the map is deleted
  IProjectItem mapToRemove = Project.Current.GetItems<MapProjectItem>().FirstOrDefault(map => map.Name.Equals("OldStreetRoutes"));
  // Note: Needs QueuedTask to run
  var removedMapProjectItemResult = Project.Current.RemoveItem(mapToRemove);
  // Use removedMapProjectItemResult

// Import a mxd
  Item mxdToImport = ItemFactory.Instance.Create(@"C:\Projects\RegionalSurvey\LatestResults.mxd");
  // Note: Needs QueuedTask to run
  var addedMxd = Project.Current.AddItem(mxdToImport as IProjectItem);

  // Add map package
  Item mapPackageToAdd = ItemFactory.Instance.Create(@"c:\Data\Map.mpkx");
  // Note: Needs QueuedTask to run
  var addedMapPackage = Project.Current.AddItem(mapPackageToAdd as IProjectItem);

  // Add an exported Pro map
  Item proMapToAdd = ItemFactory.Instance.Create(@"C:\ExportedMaps\Election\Districts.mapx");
  // Note: Needs QueuedTask to run
  var addedMapProjectItem = Project.Current.AddItem(proMapToAdd as IProjectItem);

Item mxdItem = ItemFactory.Instance.Create(@"C:\Projects\RegionalSurvey\LatestResults.mxd");
  // use mxdItem;

// Creates an Item from an existing portal item base on its ID
  string portalItemID = "9801f878ff4a22738dff3f039c43e395";
  Item portalItem = ItemFactory.Instance.Create(portalItemID, ItemFactory.ItemType.PortalItem);
  // use portalItem;

// Creates an Item from an existing portal folder base on its ID
  string portalFolderID = "39c43e39f878f4a2279838dfff3f0015";
  Item portalFolder = ItemFactory.Instance.Create(portalFolderID, ItemFactory.ItemType.PortalFolderItem);
  // use portalFolder;

FolderConnectionProjectItem projectfolderConnection = Project.Current.GetItems<FolderConnectionProjectItem>().First();
  var folderConnectionContent = projectfolderConnection.GetItems();
  var folder = folderConnectionContent.FirstOrDefault(folderItem => folderItem.Name.Equals("Tourist Sites"));
  var folderContents = folder.GetItems();
  //use folderContents;

//cast ICatalogWindow to ArcGIS.Desktop.Framework.Contracts.DockPane
  var catalogWindow = Project.GetCatalogPane() as DockPane;
  //Activate it
  catalogWindow.Activate();

var catalogWindow = Project.GetCatalogPane() as ICatalogWindow;
  if (catalogWindow.IsActiveWindow)
  {
    //TODO - query/change catalog window content
  }

//Gets the Catalog pane
  var catalogWindow = Project.GetCatalogPane() as ICatalogWindow;
  var catContentType = catalogWindow.GetCurrentContentType();
  // use catContentType;

//Gets the Catalog pane
  var catalogWindow = Project.GetCatalogPane() as ICatalogWindow;
  if (!catalogWindow.IsActiveWindow)
  {
    //catalog dockpane must be the active window
  }

  //Change the content to whatever is the next tab
  var catContentType = (int)catalogWindow.GetCurrentContentType();
  catContentType++;

  if (catContentType > (int)CatalogContentType.Favorites)
    catContentType = (int)CatalogContentType.Project;

  //Must be on the UI - no QueuedTask!
  catalogWindow.SetContentTypeAsync((CatalogContentType)catContentType);

//Gets the Catalog pane
  var catalogWindow = Project.GetCatalogPane() as ICatalogWindow;
  var catContentType = catalogWindow.GetCurrentContentType();
  //Is Portal the content type?
  if (catContentType == CatalogContentType.Portal)
  {
    //check what is the portal content type being shown...
    var secondaryContentType =
      catalogWindow.GetCurrentSecondaryPortalContentType();
    //TODO use secondary portal content type...
  }

//Gets the Catalog pane
  var catalogWindow = Project.GetCatalogPane() as ICatalogWindow;
  if (!catalogWindow.IsActiveWindow)
  {
    //catalog dockpane must be the active window
  }

  var catContentType = catalogWindow.GetCurrentContentType();
  //Is portal content being shown?
  if (catContentType == CatalogContentType.Portal)
  {
    //check what is the portal content type being shown...
    var portalContentType = (int)catalogWindow.GetCurrentSecondaryPortalContentType();
    //advance to the next tab
    portalContentType++;
    if (portalContentType > (int)CatalogSecondaryPortalContentType.LivingAtlas)
      portalContentType = (int)CatalogSecondaryPortalContentType.UserContent;

    //set the secondary portal content type
    //Must be on the UI - no QueuedTask!
    catalogWindow.SetSecondaryPortalContentTypeAsync(
      (CatalogSecondaryPortalContentType)portalContentType);
  }

var openDlg = new OpenItemDialog
  {
    Title = "Select a Feature Class",
    InitialLocation = @"C:\Data",
    MultiSelect = false,
    BrowseFilter = BrowseProjectFilter.GetFilter(ItemFilters.GeodatabaseItems_All)
  };
  //show the browse dialog
  bool? ok = openDlg.ShowDialog();
  if (!ok.HasValue || openDlg.Items.Count == 0)
  {
    // nothing selected, leave
  }

  // Note: Needs QueuedTask to run
  // get the item
  var item = openDlg.Items.First();
  // see if the item has a dataset
  if (ItemFactory.Instance.CanGetDataset(item))
  {
    // get it
    using var ds = ItemFactory.Instance.GetDataset(item);
    // access some properties
    var name = ds.GetName();
    var path = ds.GetPath();
    // if it's a featureclass
    if (ds is FeatureClass fc)
    {
      // create a layer 
      var featureLayerParams = new FeatureLayerCreationParams(fc)
      {
        MapMemberIndex = 0
      };
      var layer = LayerFactory.Instance.CreateLayer<FeatureLayer>(featureLayerParams, MapView.Active.Map);

      // continue
    }
  }

// subscribe to event
  ProjectWindowSelectedItemsChangedEvent.Subscribe(args =>
  {
    if (args.IProjectWindow.SelectionCount > 0)
    {
      // get the first selected item
      var selectedItem = args.IProjectWindow.SelectedItems.First();

      // Note: Needs QueuedTask to run
      // datasetType
      var dataType = ItemFactory.Instance.GetDatasetType(selectedItem);
      // get the dataset Definition
      if (ItemFactory.Instance.CanGetDefinition(selectedItem))
      {
        using var def = ItemFactory.Instance.GetDefinition(selectedItem);
        if (def is FeatureClassDefinition fcDef)
        {
          var oidField = fcDef.GetObjectIDField();
          var shapeField = fcDef.GetShapeField();
          var shapeType = fcDef.GetShapeType();
        }
        else if (def is ArcGIS.Core.Data.Parcels.ParcelFabricDefinition pfDef)
        {
          string ver = pfDef.GetSchemaVersion();
          bool enabled = pfDef.GetTopologyEnabled();
        }
      }
      // get the dataset
      if (ItemFactory.Instance.CanGetDataset(selectedItem))
      {
        using var ds = ItemFactory.Instance.GetDataset(selectedItem);
        if (ds is FeatureDataset fds)
        {
          // open featureclasses within the feature dataset
          // var fcPoint = fds.OpenDataset<FeatureClass>("Point");
          // var fcPolyline = fds.OpenDataset<FeatureClass>("Polyline");
        }
        else if (ds is FeatureClass fc)
        {
          var name = fc.GetName() + "_copy";
          // create
          var featureLayerParams = new FeatureLayerCreationParams(fc)
          {
            Name = name,
            MapMemberIndex = 0
          };
          LayerFactory.Instance.CreateLayer<FeatureLayer>(featureLayerParams, MapView.Active.Map);
        }
        else if (ds is Table table)
        {
          var name = table.GetName() + "_copy";
          var tableParams = new StandaloneTableCreationParams(table)
          {
            Name = name
          };
          // create
          StandaloneTableFactory.Instance.CreateStandaloneTable(tableParams, MapView.Active.Map);
        }
      }
    }
  });

var itemFolder = ItemFactory.Instance.Create(@"d:\data");

  // is the folder item already a favorite?
  var fav = FavoritesManager.Current.GetFavorite(itemFolder);
  if (fav == null)
  {
    if (FavoritesManager.Current.CanAddAsFavorite(itemFolder))
    {
      fav = FavoritesManager.Current.AddFavorite(itemFolder);
    }
  }

gdbPath = "@C:\\myDataFolder\\myData.gdb";
  var itemGDB = ItemFactory.Instance.Create(gdbPath);

  // is the item already a favorite?
  var favorite = FavoritesManager.Current.GetFavorite(itemGDB);
  // no; add it with IsAddedToAllNewProjects set to true
  if (favorite != null)
  {
    if (FavoritesManager.Current.CanAddAsFavorite(itemGDB))
      FavoritesManager.Current.InsertFavorite(itemGDB, 1, true);
  }

StyleProjectItem styleItem = Project.Current.GetItems<StyleProjectItem>().
                          FirstOrDefault(style => style.Name == "ArcGIS 3D");
  if (FavoritesManager.Current.CanAddAsFavorite(styleItem))
  {
    // add to favorites with IsAddedToAllNewProjects set to false
    FavoritesManager.Current.AddFavorite(styleItem);
  }

var newItemFolder = ItemFactory.Instance.Create(@"d:\data");

  // is the folder item already a favorite?
  var favorite = FavoritesManager.Current.GetFavorite(newItemFolder);
  if (favorite != null)
  {
    if (favorite.IsAddedToAllNewProjects)
      FavoritesManager.Current.ClearIsAddedToAllNewProjects(favorite.Item);
    else
      FavoritesManager.Current.SetIsAddedToAllNewProjects(favorite.Item);
  }

var favorites = FavoritesManager.Current.GetFavorites();
  foreach (var favorite in favorites)
  {
    bool isAddedToAllProjects = favorite.IsAddedToAllNewProjects;
    // retrieve the underlying item of the favorite
    Item item = favorite.Item;

    // Item properties
    var itemType = item.TypeID;
    var path = item.Path;

    // if it's a folder item
    if (item is FolderConnectionProjectItem)
    {
    }
    // if it's a geodatabase item
    else if (item is GDBProjectItem)
    {
    }
    // else 
  }

var favorites = FavoritesManager.Current.GetFavorites();
  foreach (var favorite in favorites)
    FavoritesManager.Current.RemoveFavorite(favorite.Item);

FavoritesChangedEvent.Subscribe((args) =>
  {
    // favorites have changed
    int count = FavoritesManager.Current.GetFavorites().Count;
  });

Item gdbItem = ItemFactory.Instance.Create(@"C:\projectAlpha\GDBs\regionFive.gdb");
  gdbMetadataItem = gdbItem as IMetadata;

string gdbXMLMetadataXmlAsString = string.Empty;
  // Note: Needs QueuedTask to run
  gdbXMLMetadataXmlAsString = gdbMetadataItem.GetXml();
  //check metadata was returned
  if (!string.IsNullOrEmpty(gdbXMLMetadataXmlAsString))
  {
    //use the metadata
  }

// Note: Needs QueuedTask to run
  var xmlMetadata = File.ReadAllText(@"E:\Data\Metadata\MetadataForFeatClass.xml");
  //Will throw InvalidOperationException if the metadata cannot be changed
  //so check "CanEdit" first
  if (featureClassMetadataItem.CanEdit())
    featureClassMetadataItem.SetXml(xmlMetadata);

bool canEdit;
  //Call CanEdit before calling SetXml
  // Note: Needs QueuedTask to run
  canEdit = metadataItemToCheck.CanEdit();

string syncedMetadataXml = string.Empty;
  // Note: Needs QueuedTask to run
  syncedMetadataXml = metadataItemToSync.Synchronize();

Item featureClassItem = ItemFactory.Instance.Create(@"C:\projectAlpha\GDBs\regionFive.gdb\SourceFeatureClass");
  // Note: Needs QueuedTask to run
  metadataCopyFrom.CopyMetadataFromItem(featureClassItem);

Item featureClassWithMetadataItem = ItemFactory.Instance.Create(@"C:\projectBeta\GDBs\regionFive.gdb\SourceFeatureClass");
  //Delete thumbnail content from item's metadata
  featureClassWithMetadataItem.DeleteMetadataContent(MDDeleteContentOption.esriMDDeleteThumbnail);

// the input path can be the path to an item with metadata, or a URI to an XML file
  // Note: Needs QueuedTask to run
  metadataItemImport.ImportMetadata(@"E:\YellowStone.gdb\MyDataset\MyFeatureClass", MDImportExportOption.esriCurrentMetadataStyle);

// the input path can be the path to an item with metadata, or a URI to an XML file
  // Note: Needs QueuedTask to run
  metadataItemImport.ImportMetadata(@"E:\YellowStone.gdb\MyDataset\MyFeatureClass", MDImportExportOption.esriCustomizedStyleSheet, @"E:\StyleSheets\Import\MyImportStyleSheet.xslt");

// Note: Needs QueuedTask to run
  metadataItemExport.ExportMetadata(@"E:\Temp\OutputXML.xml", MDImportExportOption.esriCustomizedStyleSheet, MDExportRemovalOption.esriExportExactCopy, @"E:\StyleSheets\Export\MyExportStyleSheet.xslt");
  // Or export using the current metadata style
  metadataItemExport.ExportMetadata(@"E:\Temp\OutputXML.xml", MDImportExportOption.esriCurrentMetadataStyle, MDExportRemovalOption.esriExportExactCopy);

metadataItemToSaveAsXML.SaveMetadataAsXML(@"E:\Temp\OutputXML.xml", MDSaveAsXMLOption.esriExactCopy);

// Note: Needs QueuedTask to run
  metadataItemToSaveAsHTML.SaveMetadataAsHTML(@"E:\Temp\OutputHTML.htm", MDSaveAsHTMLOption.esriCurrentMetadataStyle);

// Note: Needs QueuedTask to run
  metadataItemToSaveAsUsingCustomXSLT.SaveMetadataAsUsingCustomXSLT(@"E:\Data\Metadata\CustomXSLT.xsl", @"E:\Temp\OutputXMLCustom.xml");

var fgdcItem = ItemFactory.Instance.Create(@"C:\projectAlpha\GDBs\testData.gdb");
  // Note: Needs QueuedTask to run
  fgdcItem.UpgradeMetadata(MDUpgradeOption.esriUpgradeFgdcCsdgm);

projectPath = @"https://<userName>.<domain>.com/portal/sharing/rest/content/items/1a434faebbe7424d9982f57d00223baa";
  string docVer = string.Empty;

  // A portal project path looks like this:
  //@"https://<ServerName>.<Domain>.com/portal/sharing/rest/content/items/1a434faebbe7424d9982f57d00223baa";
  //A local project path looks like this:
  //@"C:\Users\<UserName>\Documents\ArcGIS\Projects\MyProject\MyProject.aprx";

  //Check if the project can be opened
  if (Project.CanOpen(projectPath, out docVer))
  {
    //Open the project
    Project.OpenAsync(projectPath);
  }
  else //The project cannot be opened
  {
    //One possible reason: If the project is a portal project, the active portal must match the portal of the project
    //Check if this is a portal project
    bool isPortalProject = Uri.TryCreate(projectPath, UriKind.Absolute, out Uri uriResult)
         && (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);

    if (isPortalProject)
    {
      //Parse the project path to get the portal
      var uri = new Uri(projectPath);
      var portalUrlOfProjectToOpen = $"{uri.Scheme}://{uri.Host}/portal/";

      //Get the current active portal
      var activePortal = ArcGISPortalManager.Current.GetActivePortal();
      //Compare to see if the active Portal is the same as the portal of the project
      bool isSamePortal = activePortal != null && activePortal.PortalUri.ToString() == portalUrlOfProjectToOpen;
      if (!isSamePortal) //not the same. 
      {
        //Set new active portal to be the portal of the project
        //Find the portal to sign in with using its Uri...
        var projectPortal = ArcGISPortalManager.Current.GetPortal(new Uri(portalUrlOfProjectToOpen, UriKind.Absolute));
        // Note: Needs QueuedTask to run
        {
          if (!projectPortal.IsSignedOn())
          {
            //Calling "SignIn" will trigger the OAuth popup if your credentials are
            //not cached (eg from a previous sign in in the session)
            if (projectPortal.SignIn().success)
            {
              //Set this portal as my active portal
              ArcGISPortalManager.Current.SetActivePortal(projectPortal);
              return;
            }
          }
          //Set this portal as my active portal
          ArcGISPortalManager.Current.SetActivePortal(projectPortal);
        }
        //Now try opening the project again
        if (Project.CanOpen(projectPath, out docVer))
        {
          Project.OpenAsync(projectPath);
        }
        else
        {
          System.Diagnostics.Debug.WriteLine("The project cannot be opened.");
        }
      }
      else //The portals are the same. So the problem could be something else - permissions, portal is down?
      {
        System.Diagnostics.Debug.WriteLine("The project cannot be opened.");
      }
    }
    else //Project is on disk and cannot be opened. 
    {
      System.Diagnostics.Debug.WriteLine("The project cannot be opened.");
    }
  }

projectPath = Project.Current.Url;
  // A portal project path looks like this:
  //@"https://<ServerName>.<Domain>.com/portal/sharing/rest/content/items/1a434faebbe7424d9982f57d00223baa";
  //A local project path looks like this:
  //@"C:\Users\<UserName>\Documents\ArcGIS\Projects\MyProject\MyProject.aprx";
  bool isPortalProject = Uri.TryCreate(projectPath, UriKind.Absolute, out Uri uriResult)
                         && (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
  if (isPortalProject)
  {
    System.Diagnostics.Debug.WriteLine("This is a portal project");
  }
  else
  {
    System.Diagnostics.Debug.WriteLine("This is not a portal project");
  }
  // Use isPortalProject;

var isPortalProject = Project.Current.IsPortalProject;
  // Use isPortalProject;

projectPath = Project.Current.Url;
  // A portal project path looks like this:
  //@"https://<ServerName>.<Domain>.com/portal/sharing/rest/content/items/1a434faebbe7424d9982f57d00223baa";
  //A local project path looks like this:
  //@"C:\Users\<UserName>\Documents\ArcGIS\Projects\MyProject\MyProject.aprx";

  //Check if the project is a portal project
  bool isPortalProject = Uri.TryCreate(projectPath, UriKind.Absolute, out Uri uriResult)
                         && (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
  if (isPortalProject)
  {
    //Parse the project path to get the portal
    var uri = new Uri(projectPath);
    var fullUri = $"{uri.Scheme}://{uri.Host}/portal/";
    System.Diagnostics.Debug.WriteLine($"The Url of the project is: {fullUri}");
    //Now get the ArcGISPortal object from the portal Uri
    var arcgisPortal = ArcGISPortalManager.Current.GetPortal(new Uri(fullUri, UriKind.Absolute));
    System.Diagnostics.Debug.WriteLine($"The portal of the project is: {arcgisPortal.PortalUri}");
    //Note: You can set the active portal to be the portal of the project. Refer to this snippet: [ArcGISPortalManager: Get a portal and Sign In, Set it Active](ProSnippets-sharing#arcgisportalmanager-get-a-portal-and-sign-in-set-it-active)
  }

BrowseProjectFilter portalAndLocalProjectsFilter = new();
  //A filter to pick projects from the portal
  //This filter will allow selection of ppkx and portal project items on the portal
  portalAndLocalProjectsFilter.AddFilter(BrowseProjectFilter.GetFilter("esri_browseDialogFilters_projects_online_proprojects"));
  //A filter to pick projects from the local machine
  portalAndLocalProjectsFilter.AddFilter(BrowseProjectFilter.GetFilter("esri_browseDialogFilters_projects"));
  //Create the OpenItemDialog and set the filter to the one we just created
  var openDlg = new OpenItemDialog()
  {
    Title = "Select a Project",
    MultiSelect = false,
    BrowseFilter = portalAndLocalProjectsFilter
  };
  //Show the dialog
  var result = openDlg.ShowDialog();
  //Check if the user clicked OK and selected an item
  bool? ok = openDlg.ShowDialog();
  if (!ok.HasValue || openDlg.Items.Count == 0)
    return; //nothing selected
  var selectedItem = openDlg.Items.FirstOrDefault();
  //Open the project use the OpenAsync method.

var projectPortal = ArcGISPortalManager.Current.GetPortal(new Uri(@"https://<serverName>.<domain>.com/portal/", UriKind.Absolute));
  string owner = string.Empty;
  // Note: Needs QueuedTask to run
  {
    //Get the signed on user name
    owner = projectPortal.GetSignOnUsername();
  }
  //Get the user content from the portal
  PortalUserContent userContent = projectPortal.GetUserContentAsync(owner).Result;
  //Get the first portal project item
  var firstPortalProject = userContent.PortalItems.FirstOrDefault(pi => pi.PortalItemType == PortalItemType.ProProject);
  var portalProjectUri = firstPortalProject.ItemUri.ToString();
  //Check if project can be opened
  string docVer = string.Empty;
  if (Project.CanOpen(portalProjectUri, out docVer))
  {
    Project.OpenAsync(portalProjectUri);
  }
  //Note: If Project.CanOpen returns false, the project cannot be opened. One reason could be 
  // the active portal is not the same as the portal of the project. Refer to the snippet: [Workflow to open an ArcGIS Pro project](ProSnippets-sharing#workflow-to-open-an-arcgis-pro-project)

IReadOnlyList<Tuple<string, string>> result = [];
  //A list of Tuple instances containing two strings.
  //The first string: full path to the .aprx. In case of Portal projects, 
  //this is the cached location of the project on the local machine.
  //Second string:  url for portal projects
  result = Project.GetRecentProjectsEx();
  foreach (var project in result)
  {
    string projectUrl;
    if (!string.IsNullOrEmpty(project.Item2))
    {
      //this is a portal project
      //Url
      projectUrl = project.Item2;
      //local cached location of the portal project
      projectPath = project.Item1;
    }
    else
    {
      //this is a local project
      //path to local project
      projectPath = project.Item1;
    }
    projectName = new FileInfo(project.Item1).Name;
  }

//Create a new project using Pro's default settings
  var defaultProjectSettings = Project.GetDefaultProjectSettings();
  var project = Project.CreateAsync(defaultProjectSettings).Result;

  // Use project

//Create an empty project. The project will be created in the default folder
  //It will be named MyProject1, MyProject2, or similar...
  var project = Project.CreateAsync().Result;

  // Use project

//Settings used to create a new project
  CreateProjectSettings projectSettings = new()
  {
    //Sets the name of the project that will be created
    // example: projectName =  @"C:\Data\MyProject1\MyProject1.aprx"
    Name = projectName
  };
  //Create the new project
  var project = Project.CreateAsync(projectSettings).Result;

  // Use project

//Get Pro's default project settings.
  var defaultProjectSettings = Project.GetDefaultProjectSettings();
  //Create a new project using the default project settings
  var project = Project.CreateAsync(defaultProjectSettings).Result;

  // Use project

//Settings used to create a new project
  CreateProjectSettings projectSettings = new()
  {
    //Sets the project's name
    Name = projectName,
    //Path where new project will be stored in
    LocationPath = @"C:\Data\NewProject",
    //Sets the project template that will be used to create the new project
    TemplatePath = @"C:\Data\MyProject1\CustomTemplate.aptx"
  };
  //Create the new project
  var project = Project.CreateAsync(projectSettings).Result;

  // Use project

//Settings used to create a new project
  CreateProjectSettings proTemplateSettings = new()
  {
    //Sets the project's name
    Name = projectName,
    //Path where new project will be stored in
    LocationPath = @"C:\Data\NewProject",
    //Select which Pro template you like to use
    TemplateType = TemplateType.Catalog
    //TemplateType = TemplateType.LocalScene
    //TemplateType = TemplateType.GlobalScene
    //TemplateType = TemplateType.Map
  };
  //Create the new project
  var project = Project.CreateAsync(proTemplateSettings).Result;

  // Use project

//Opens an existing project or project package
  // example: @"C:\Data\MyProject1\MyProject1.aprx"
  var project = Project.OpenAsync(projectPath).Result;
  // Use project

//Gets the current project
  var project = Project.Current;
  // Use project

//Gets the location of the current project; that is, the path to the current project file (*.aprx)  
  projectPath = Project.Current.URI;
  // Use projectPath

var projGDBPath = Project.Current.DefaultGeodatabasePath;
  // Use projGDBPath;

//Create a new GDB item and add it to the project
  if (ItemFactory.Instance.Create(newGDDItemPath) is not IProjectItem newGDBItem)
  {
    // could not create the item
    return;
  }
  var success = Project.Current.AddItem(newGDBItem);
  //make the newly added GDB item the default
  if (success)
    Project.Current.SetDefaultGeoDatabasePath(newGDDItemPath);
  //Now remove the old item
  if (Project.Current.GetItems<Item>().FirstOrDefault(i => i.Path == oldGDBItemPath) is not IProjectItem oldGDBItem)
  {
    // could not find the item
    return;
  }
  var removeSuccess = Project.Current.RemoveItem(oldGDBItem);

//Saves the project
  var project = Project.Current.SaveAsync().Result;
  // Use project

//The project's dirty state indicates changes made to the project have not yet been saved. 
  bool isProjectDirty = Project.Current.IsDirty;
  // Use isProjectDirty;

//Saves a copy of the current project file (*.aprx) to the specified location with the specified file name, 
  //then opens the new project file
  var project = Project.Current.SaveAsAsync(newProjectPath).Result;

  // Use project

//A project cannot be closed using the ArcGIS Pro API. 
//A project is only closed when another project is opened, a new one is created, or the application is shutdown.

// Note: Needs QueuedTask to run
  //Note: see also MapFactory in ArcGIS.Desktop.Mapping
  var map = MapFactory.Instance.CreateMap("New Map", MapType.Map, MapViewingMode.Map, Basemap.Oceans);
  ArcGIS.Desktop.Framework.FrameworkApplication.Panes.CreateMapPaneAsync(map);

var recentProjects = Project.GetRecentProjects();
  // Use recentProjects;

Project.ClearRecentProjects();

Project.RemoveRecentProject(projectPath);

var pinnedProjects = Project.GetPinnedProjects();
  // Use pinnedProjects;

Project.ClearPinnedProjects();

Project.PinProject(newProjectPath);
  Project.UnpinProject(oldProjectPath);

var recentTemplates = Project.GetRecentProjectTemplates();
  // Use recentTemplates;

Project.ClearRecentProjectTemplates();

Project.RemoveRecentProjectTemplate(templatePath);

var pinnedTemplates = Project.GetPinnedProjectTemplates();
  // Use pinnedTemplates;

Project.ClearPinnedProjectTemplates();

Project.PinProjectTemplate(templatePath);
  Project.UnpinTemplateProject(newTemplatePath);

//Adding a folder connection

  //Create the folder connection project item
  var item = ItemFactory.Instance.Create(folderPath) as IProjectItem;

  // Note: Needs QueuedTask to run
  var folder = Project.Current.AddItem(item) ? item as FolderConnectionProjectItem : null;

//Adding a Geodatabase:
  //Create the File GDB project item
  // Note: Needs QueuedTask to run
  var item = ItemFactory.Instance.Create(gdbPath) as IProjectItem;
  var newlyAddedGDB = Project.Current.AddItem(item) ? item as GDBProjectItem : null;

IEnumerable<Item> allProjectItems = Project.Current.GetItems<Item>();
  foreach (var pi in allProjectItems)
  {
    //Do Something 
  }

var project = Project.Current;
  IEnumerable<MapProjectItem> newMapItemsContainer = project.GetItems<MapProjectItem>();
  // Note: Needs QueuedTask to run
  foreach (var mp in newMapItemsContainer)
  {
    //Do Something with the map. For Example:
    Map myMap = mp.GetMap();
  }

MapProjectItem mapProjItem = Project.Current.GetItems<MapProjectItem>().FirstOrDefault(item => item.Name.Equals("EuropeMap"));
  // Use mapProjItem;

IEnumerable<StyleProjectItem> newStyleItemsContainer = null;
  newStyleItemsContainer = Project.Current.GetItems<StyleProjectItem>();
  foreach (var styleItem in newStyleItemsContainer)
  {
    //Do Something with the style.
  }

var container = Project.Current.GetItems<StyleProjectItem>();
  // example: projectStyleName = "ArcGIS 3D";
  StyleProjectItem testStyle = container.FirstOrDefault(style => style.Name == projectStyleName);
  StyleItem cone = null;
  if (testStyle != null)
  {
    // example: symbolName = "Cone_Volume_3";
    cone = testStyle.LookupItem(StyleItemType.PointSymbol, symbolName);
  }
  // Use (testStyle, cone);

// Note: Needs QueuedTask to run
  var containerStyle = Project.Current.GetProjectItemContainer("Style");
  var fav_style_item = containerStyle.GetItems().OfType<StyleProjectItem>().First(item => item.TypeID == "personal_style");

IEnumerable<GDBProjectItem> newGDBItemsContainer = null;
  newGDBItemsContainer = Project.Current.GetItems<GDBProjectItem>();
  foreach (var GDBItem in newGDBItemsContainer)
  {
    //Do Something with the GDB.
  }

GDBProjectItem gdbProjItem = Project.Current.GetItems<GDBProjectItem>().FirstOrDefault(item => item.Name.Equals("myGDB"));
  // Use gdbProjItem;

IEnumerable<ServerConnectionProjectItem> newServerConnections = null;
  var project = Project.Current;
  newServerConnections = project.GetItems<ServerConnectionProjectItem>();
  foreach (var serverItem in newServerConnections)
  {
    //Do Something with the server connection.
  }

ServerConnectionProjectItem serverProjItem = Project.Current.GetItems<ServerConnectionProjectItem>().FirstOrDefault(item => item.Name.Equals("myServer"));
  // Use serverProjItem;

//Gets all the folder connections in the current project
  var projectFolders = Project.Current.GetItems<FolderConnectionProjectItem>();
  foreach (var FolderItem in projectFolders)
  {
    //Do Something with the Folder connection.
  }

FolderConnectionProjectItem folderProjItem = Project.Current.GetItems<FolderConnectionProjectItem>().FirstOrDefault(item => item.Name.Equals("myDataFolder"));
  // Use folderProjItem;

// Remove a folder connection from a project; the folder stored on the local disk or the network is not deleted
  FolderConnectionProjectItem folderToRemove = Project.Current.GetItems<FolderConnectionProjectItem>().FirstOrDefault(myfolder => myfolder.Name.Equals("PlantSpecies"));
  if (folderToRemove != null)
    Project.Current.RemoveItem(folderToRemove as IProjectItem);

LayoutProjectItem layoutProjItem = Project.Current.GetItems<LayoutProjectItem>().FirstOrDefault(item => item.Name.Equals("myLayout"));
  // Use layoutProjItem;

//Gets all the layouts in the current project
  IEnumerable<LayoutProjectItem> projectLayouts = Project.Current.GetItems<LayoutProjectItem>();
  foreach (var layoutItem in projectLayouts)
  {
    //Do Something with the layout
  }

//Gets a specific GeoprocessingProjectItem in the current project
  // example: "myToolbox" is the name of the GeoprocessingProjectItem
  GeoprocessingProjectItem gpProjItem = Project.Current.GetItems<GeoprocessingProjectItem>().FirstOrDefault(item => item.Name.Equals("myToolbox"));
  // Use gpProjItem;

//Gets all the GeoprocessingProjectItem in the current project
  var GPItems = Project.Current.GetItems<GeoprocessingProjectItem>();
  foreach (var tbx in GPItems)
  {
    //Do Something with the toolbox
  }

List<Item> _mxd = [];
  //Gets all the folder connections in the current project
  var allFoldersItem = Project.Current.GetItems<FolderConnectionProjectItem>();
  if (allFoldersItem != null)
  {
    //iterate through all the FolderConnectionProjectItems found
    foreach (var folderItem in allFoldersItem)
    {
      //Search for mxd files in that folder connection and add it to the List<T>
      //Note:ArcGIS Pro automatically creates and dynamically updates a searchable index as you build and work with projects. 
      //Items are indexed when they are added to a project.
      //The first time a folder or database is indexed, indexing may take a while if it contains a large number of items. 
      //While the index is being created, searches will not return any results.
      _mxd.AddRange(folderItem.GetItems());
    }
  }

//Get Pro's default project settings.
  var defaultSettings = Project.GetDefaultProjectSettings();
  var defaultProjectPath = defaultSettings.LocationPath;
  // If not set, projects are saved in the user's My Documents\ArcGIS\Projects folder;
  // this folder is created if it doesn't already exist.
  defaultProjectPath ??= Path.Combine(
              Environment.GetFolderPath(
                   Environment.SpecialFolder.MyDocuments),
              @"ArcGIS\Projects");
  // Use defaultProjectPath;

var contentItem = Project.Current.GetItems<FolderConnectionProjectItem>().First();
  //Check if the MCT is required for Refresh()
  if (contentItem.IsMainThreadRequired)
  {
    // Note: Needs QueuedTask to run
    contentItem.Refresh();
  }
  else
  {
    //if item.IsMainThreadRequired returns false, any
    //thread can be used to invoke Refresh(), though
    //BackgroundTask is preferred.
    contentItem.Refresh();

    //Or, via BackgroundTask
    ArcGIS.Core.Threading.Tasks.BackgroundTask.Run(() =>
      contentItem.Refresh(), ArcGIS.Core.Threading.Tasks.BackgroundProgressor.None);
  }

// Get the ItemCategories with which an item is associated
  gdb = ItemFactory.Instance.Create(@"E:\CurrentProject\RegionalPolling\polldata.gdb");
  List<ItemCategory> gdbItemCategories = gdb.ItemCategories;
  // Use gdbItemCategories;

// Browse items using an ItemCategory as a filter
  IEnumerable<Item> gdbContents = gdb.GetItems();
  IEnumerable<Item> filteredGDBContents1 = gdbContents.Where(item => item.ItemCategories.OfType<ItemCategoryDataSet>().Any());
  IEnumerable<Item> filteredGDBContents2 = new ItemCategoryDataSet().Items(gdbContents);

var projectFolder = Path.Combine(
      Environment.GetFolderPath(
          Environment.SpecialFolder.MyDocuments),
      @"ArcGIS\Projects");
  CreateProjectSettings ps = new()
  {
    Name = projectName,
    LocationPath = projectFolder,
    TemplatePath = templatePath
  };
  var project = Project.CreateAsync(ps).Result;
  //Use project;

//Use Project.Current.ProjectItemContainers
  var folderContainer = Project.Current.ProjectItemContainers.First(c => c.Path == "FolderConnection");
  var gdbContainer = Project.Current.ProjectItemContainers.First(c => c.Path == "GDB");
  var mapContainer = Project.Current.ProjectItemContainers.First(c => c.Path == "Map");
  var layoutContainer = Project.Current.ProjectItemContainers.First(c => c.Path == "Layout");
  var toolboxContainer = Project.Current.ProjectItemContainers.First(c => c.Path == "GP");
  //etc.

  //or...use Project.Current.GetProjectItemContainer

  folderContainer = Project.Current.GetProjectItemContainer("FolderConnection");
  gdbContainer = Project.Current.GetProjectItemContainer("GDB");
  mapContainer = Project.Current.GetProjectItemContainer("Map");
  layoutContainer = Project.Current.GetProjectItemContainer("Layout");
  toolboxContainer = Project.Current.GetProjectItemContainer("GP");
  //etc.

//GetItems searches project content
  var map = Project.Current.GetItems<MapProjectItem>().FirstOrDefault(m => m.Name == "Map1");
  var layout = Project.Current.GetItems<LayoutProjectItem>().FirstOrDefault(m => m.Name == "Layout1");
  var folders = Project.Current.GetItems<FolderConnectionProjectItem>();
  var style = Project.Current.GetItems<StyleProjectItem>().FirstOrDefault(s => s.Name == "ArcGIS 3D");

  //Find item uses a catalog path. The path can be to a file or dataset
  var fcPath = @"C:\Pro\CommunitySampleData\Interacting with Maps\Interacting with Maps.gdb\Crimes";
  var pdfPath = @"C:\Temp\Layout1.pdf";
  var imgPath = @"C:\Temp\AddinDesktop16.png";

  var fc = Project.Current.FindItem(fcPath);
  var pdf = Project.Current.FindItem(pdfPath);
  var img = Project.Current.FindItem(imgPath);

//Get the catalog pane
  IProjectWindow projectWindow = Project.GetCatalogPane();
  //or get the active catalog view...
  //ArcGIS.Desktop.Core.IProjectWindow projectWindow = Project.GetActiveCatalogWindow();

  //eg Find a toolbox in the project
  string gpName = "Interacting with Maps.tbx";
  var toolbox = Project.Current.GetItems<GeoprocessingProjectItem>().FirstOrDefault(tbx => tbx.Name == gpName);
  //Select it under Toolboxes
  projectWindow.SelectItemAsync(toolbox, true, true, null);//null selects it in the first container - optionally await
                                                           //Note: Project.Current.GetProjectItemContainer("GP") would get toolbox container...

  //assume toolbox is also under Folders container. Select it under Folders instead of Toolboxes
  var foldersContainer = Project.Current.ProjectItemContainers.First(c => c.Path == "FolderConnection");
  //We must specify the container because Folders comes second (after Toolboxes)
  projectWindow.SelectItemAsync(toolbox, true, true, foldersContainer);//optionally await

  //Find a map and select it
  var mapItem = Project.Current.GetItems<MapProjectItem>().FirstOrDefault(m => m.Name == "Map");
  //Map only occurs under "Maps" so the container need not be specified
  projectWindow.SelectItemAsync(mapItem, true, false, null);

//Note: Must be on the QueuedTask.Run()
  var unit_formats = Enum.GetValues(typeof(UnitFormatType))
                .OfType<UnitFormatType>().ToList();
  System.Diagnostics.Debug.WriteLine("All available units\r\n");

  foreach (var unit_format in unit_formats)
  {
    var units = DisplayUnitFormats.Instance.GetPredefinedProjectUnitFormats(unit_format);
    System.Diagnostics.Debug.WriteLine(unit_format.ToString());

    foreach (var display_unit_format in units)
    {
      var line = $"{display_unit_format.DisplayName}, {display_unit_format.UnitCode}";
      System.Diagnostics.Debug.WriteLine(line);
    }
    System.Diagnostics.Debug.WriteLine("");
  }

// Note: Must be on the QueuedTask.Run()
  var unit_formats = Enum.GetValues(typeof(UnitFormatType))
                  .OfType<UnitFormatType>().ToList();
  System.Diagnostics.Debug.WriteLine("Project units\r\n");
  foreach (var unit_format in unit_formats)
  {
    var units = DisplayUnitFormats.Instance.GetProjectUnitFormats(unit_format);
    System.Diagnostics.Debug.WriteLine(unit_format.ToString());

    foreach (var display_unit_format in units)
    {
      var line = $"{display_unit_format.DisplayName}, {display_unit_format.UnitCode}";
      System.Diagnostics.Debug.WriteLine(line);
    }
    System.Diagnostics.Debug.WriteLine("");
  }

//Must be on the QueuedTask.Run()

  //UnitFormatType.Angular, UnitFormatType.Area, UnitFormatType.Distance, 
  //UnitFormatType.Direction, UnitFormatType.Location, UnitFormatType.Page
  //UnitFormatType.Symbol2D, UnitFormatType.Symbol3D
  var units = DisplayUnitFormats.Instance.GetProjectUnitFormats(UnitFormatType.Distance);
  // Use units;

// Note: Must be on the QueuedTask.Run()
  var unit_formats = Enum.GetValues(typeof(UnitFormatType))
                      .OfType<UnitFormatType>().ToList();
  System.Diagnostics.Debug.WriteLine("Default project units\r\n");

  foreach (var unit_format in unit_formats)
  {
    var default_unit = DisplayUnitFormats.Instance.GetDefaultProjectUnitFormat(unit_format);
    var line = $"{unit_format}: {default_unit.DisplayName}, {default_unit.UnitCode}";
    System.Diagnostics.Debug.WriteLine(line);
  }
  System.Diagnostics.Debug.WriteLine("");

// Note: Must be on the QueuedTask.Run()
  //UnitFormatType.Angular, UnitFormatType.Area, UnitFormatType.Distance, 
  //UnitFormatType.Direction, UnitFormatType.Location, UnitFormatType.Page
  //UnitFormatType.Symbol2D, UnitFormatType.Symbol3D
  var default_unit = DisplayUnitFormats.Instance.GetDefaultProjectUnitFormat(
                                                   UnitFormatType.Distance);
  // Use default_unit;

// Note: Must be on the QueuedTask.Run()
  //UnitFormatType.Angular, UnitFormatType.Area, UnitFormatType.Distance, 
  //UnitFormatType.Direction, UnitFormatType.Location

  //Get the full list of all available location units
  var all_units = DisplayUnitFormats.Instance.GetPredefinedProjectUnitFormats(
                                                      UnitFormatType.Location);
  //keep units with an even factory code
  var list_units = all_units.Where(du => du.UnitCode % 2 == 0).ToList();

  //set them as the new location unit collection. A new default is not being specified...
  DisplayUnitFormats.Instance.SetProjectUnitFormats(list_units);

  //set them as the new location unit collection along with a new default
  DisplayUnitFormats.Instance.SetProjectUnitFormats(
                                          list_units, list_units.First());

  //Note: UnitFormatType.Page, UnitFormatType.Symbol2D, UnitFormatType.Symbol3D
  //cannot be set.

// Note: Must be on the QueuedTask.Run()
  var unit_formats = Enum.GetValues(typeof(UnitFormatType)).OfType<UnitFormatType>().ToList();
  foreach (var unit_type in unit_formats)
  {
    var current_default = DisplayUnitFormats.Instance.GetDefaultProjectUnitFormat(unit_type);
    //Arbitrarily pick the last unit in each unit format list
    var replacement = DisplayUnitFormats.Instance.GetProjectUnitFormats(unit_type).Last();
    DisplayUnitFormats.Instance.SetDefaultProjectUnitFormat(replacement);

    var line = $"{current_default.DisplayName}, {current_default.UnitName}, {current_default.UnitCode}";
    var line2 = $"{replacement.DisplayName}, {replacement.UnitName}, {replacement.UnitCode}";

    System.Diagnostics.Debug.WriteLine($"Format: {unit_type}");
    System.Diagnostics.Debug.WriteLine($" Current default: {line}");
    System.Diagnostics.Debug.WriteLine($" Replacement default: {line2}");
  }

//UnitFormatType.Angular, UnitFormatType.Area, UnitFormatType.Distance, 
  //UnitFormatType.Direction, UnitFormatType.Location
  var angle_units = DisplayUnitFormats.Instance.GetProjectUnitFormats(UnitFormatType.Angular);

  //Edit the display name of each unit - append the abbreviation
  foreach (var unit in angle_units)
  {
    unit.DisplayName = $"{unit.DisplayName} ({unit.Abbreviation})";
  }
  //apply the changes to the units and set the default to be the first entry
  DisplayUnitFormats.Instance.SetProjectUnitFormats(angle_units, angle_units.First());
  //The project must be saved to persist the changes...

var startMode = ApplicationOptions.GeneralOptions.StartupOption;
  var aprx_path = ApplicationOptions.GeneralOptions.StartupProjectPath;

  var hf_option = ApplicationOptions.GeneralOptions.HomeFolderOption;
  var folder = ApplicationOptions.GeneralOptions.CustomHomeFolder;

  var gdb_option = ApplicationOptions.GeneralOptions.DefaultGeodatabaseOption;
  var def_gdb = ApplicationOptions.GeneralOptions.CustomDefaultGeodatabase;

  var tbx_option = ApplicationOptions.GeneralOptions.DefaultToolboxOption;
  var def_tbx = ApplicationOptions.GeneralOptions.CustomDefaultToolbox;

  var create_in_folder = ApplicationOptions.GeneralOptions.ProjectCreateInFolder;

//Set the application to use a custom project, home folder, gdb, and toolbox
  //In each case, the custom _path_ must be set _first_ before 
  //setting the "option". This ensures the application remains 
  //in a consistent state. This is the same behavior as on the Pro UI.
  if (string.IsNullOrEmpty(ApplicationOptions.GeneralOptions.StartupProjectPath))
    ApplicationOptions.GeneralOptions.StartupProjectPath = @"D:\data\usa.aprx";//custom project path first
  ApplicationOptions.GeneralOptions.StartupOption = StartProjectMode.WithDefaultProject;//option to use it second

  if (string.IsNullOrEmpty(ApplicationOptions.GeneralOptions.CustomHomeFolder))
    ApplicationOptions.GeneralOptions.CustomHomeFolder = @"D:\home_folder";//custom home folder first
  ApplicationOptions.GeneralOptions.HomeFolderOption = OptionSetting.UseCustom;//option to use it second

  if (string.IsNullOrEmpty(ApplicationOptions.GeneralOptions.CustomDefaultGeodatabase))
    ApplicationOptions.GeneralOptions.CustomDefaultGeodatabase = @"D:\data\usa.gdb";//custom gdb path first
  ApplicationOptions.GeneralOptions.DefaultGeodatabaseOption = OptionSetting.UseCustom;//option to use it second

  if (string.IsNullOrEmpty(ApplicationOptions.GeneralOptions.CustomDefaultToolbox))
    ApplicationOptions.GeneralOptions.CustomDefaultToolbox = @"D:\data\usa.tbx";//custom toolbox path first
  ApplicationOptions.GeneralOptions.DefaultToolboxOption = OptionSetting.UseCustom;//option to use it second

//Default options can be set regardless of the value of the "companion"
  //path (to a project, folder, gdb, toolbox, etc.). The path value is ignored if
  //the option setting does not use it. This is the same behavior as on the Pro UI.
  ApplicationOptions.GeneralOptions.StartupOption = StartProjectMode.ShowStartPage;
  ApplicationOptions.GeneralOptions.HomeFolderOption = OptionSetting.UseDefault;
  ApplicationOptions.GeneralOptions.DefaultGeodatabaseOption = OptionSetting.UseDefault;
  ApplicationOptions.GeneralOptions.DefaultToolboxOption = OptionSetting.UseDefault;//set default option first

  //path values can (optionally) be set (back) to null if their 
  //"companion" option setting is the default option.
  if (ApplicationOptions.GeneralOptions.StartupOption != StartProjectMode.WithDefaultProject)
    ApplicationOptions.GeneralOptions.StartupProjectPath = null;
  if (ApplicationOptions.GeneralOptions.HomeFolderOption == OptionSetting.UseDefault)
    ApplicationOptions.GeneralOptions.CustomHomeFolder = null;
  if (ApplicationOptions.GeneralOptions.DefaultGeodatabaseOption == OptionSetting.UseDefault)
    ApplicationOptions.GeneralOptions.CustomDefaultGeodatabase = null;
  if (ApplicationOptions.GeneralOptions.DefaultToolboxOption == OptionSetting.UseDefault)
    ApplicationOptions.GeneralOptions.CustomDefaultToolbox = null;

var staging = ApplicationOptions.DownloadOptions.StagingLocation;

  var ppkx_loc = ApplicationOptions.DownloadOptions.UnpackPPKXLocation;
  var ask_ppkx_loc = ApplicationOptions.DownloadOptions.AskForUnpackPPKXLocation;

  var other_loc = ApplicationOptions.DownloadOptions.UnpackOtherLocation;
  var ask_other_loc = ApplicationOptions.DownloadOptions.AskForUnpackOtherLocation;
  var use_proj_folder = ApplicationOptions.DownloadOptions.UnpackOtherToProjectLocation;

  var offline_loc = ApplicationOptions.DownloadOptions.OfflineMapsLocation;
  var ask_offline_loc = ApplicationOptions.DownloadOptions.AskForOfflineMapsLocation;
  var use_proj_folder_offline = ApplicationOptions.DownloadOptions.OfflineMapsToProjectLocation;

ApplicationOptions.DownloadOptions.StagingLocation = @"D:\data\staging";

//Options are mutually exclusive.

  //Setting ApplicationOptions.DownloadOptions.AskForUnpackPPKXLocation = true
  //supersedes any value in ApplicationOptions.DownloadOptions.UnpackPPKXLocation
  //and will prompt the user on an unpack. The value of 
  //ApplicationOptions.DownloadOptions.UnpackPPKXLocation will be unaffected
  //and is ignored. This is the same behavior as on the Pro UI.
  ApplicationOptions.DownloadOptions.AskForUnpackPPKXLocation = true;//override location

  //The default location is typically <My Documents>\ArcGIS\Packages
  //Setting ApplicationOptions.DownloadOptions.UnpackPPKXLocation to any
  //location overrides ApplicationOptions.DownloadOptions.AskForUnpackPPKXLocation
  //and sets it to false. This is the same behavior as on the Pro UI.
  ApplicationOptions.DownloadOptions.UnpackPPKXLocation = @"D:\data\for_ppkx";

  //Or, if ApplicationOptions.DownloadOptions.UnpackPPKXLocation already
  //contains a valid path, set ApplicationOptions.DownloadOptions.AskForUnpackPPKXLocation
  //explicitly to false to use the UnpackPPKXLocation
  if (!string.IsNullOrEmpty(ApplicationOptions.DownloadOptions.UnpackPPKXLocation))
    ApplicationOptions.DownloadOptions.AskForUnpackPPKXLocation = false;

//UnpackOther settings control unpacking of anything _other than_
  //a ppkx or aptx. Options are mutually exclusive.

  //Set ApplicationOptions.DownloadOptions.UnpackOtherLocation explicitly to
  //toggle ApplicationOptions.DownloadOptions.AskForUnpackOtherLocation and
  //ApplicationOptions.DownloadOptions.UnpackOtherToProjectLocation to false
  //Note: default is typically <My Documents>\ArcGIS\Packages, _not_ null.
  //This is the same behavior as on the Pro UI.
  ApplicationOptions.DownloadOptions.UnpackOtherLocation = @"D:\data\for_other";

  //or...to use a location already stored in UnpackOtherLocation as the
  //default without changing it, 
  //set ApplicationOptions.DownloadOptions.AskForUnpackOtherLocation and
  //ApplicationOptions.DownloadOptions.UnpackOtherToProjectLocation to false
  //explicitly. This is the same behavior as on the Pro UI.
  if (!string.IsNullOrEmpty(ApplicationOptions.DownloadOptions.UnpackOtherLocation))
  {
    ApplicationOptions.DownloadOptions.AskForUnpackOtherLocation = false;
    ApplicationOptions.DownloadOptions.UnpackOtherToProjectLocation = false;
  }

  //Setting ApplicationOptions.DownloadOptions.AskForUnpackOtherLocation to
  //true overrides any UnpackOtherLocation value and sets 
  //ApplicationOptions.DownloadOptions.UnpackOtherToProjectLocation to false.
  //This is the same behavior as on the Pro UI.
  ApplicationOptions.DownloadOptions.AskForUnpackOtherLocation = true;

  //Setting ApplicationOptions.DownloadOptions.UnpackOtherToProjectLocation to
  //true overrides any UnpackOtherLocation value and sets 
  //ApplicationOptions.DownloadOptions.AskForUnpackOtherLocation to false.
  //This is the same behavior as on the Pro UI.
  ApplicationOptions.DownloadOptions.UnpackOtherToProjectLocation = false;

//OfflineMaps settings control where map content that is taken
  //offline is copied to on the local machine. Options are mutually exclusive.

  //Set ApplicationOptions.DownloadOptions.OfflineMapsLocation explicitly to
  //toggle ApplicationOptions.DownloadOptions.AskForOfflineMapsLocation and
  //ApplicationOptions.DownloadOptions.OfflineMapsToProjectLocation to false
  //Note: default is typically <My Documents>\ArcGIS\OfflineMaps, _not_ null.
  //This is the same behavior as on the Pro UI.
  ApplicationOptions.DownloadOptions.OfflineMapsLocation = @"D:\data\for_offline";

  //or...to use a location already stored in OfflineMapsLocation as the
  //default without changing it, 
  //set ApplicationOptions.DownloadOptions.AskForOfflineMapsLocation and
  //ApplicationOptions.DownloadOptions.OfflineMapsToProjectLocation to false
  //explicitly.
  if (!string.IsNullOrEmpty(ApplicationOptions.DownloadOptions.OfflineMapsLocation))
  {
    ApplicationOptions.DownloadOptions.AskForOfflineMapsLocation = false;
    ApplicationOptions.DownloadOptions.OfflineMapsToProjectLocation = false;
  }

  //Setting ApplicationOptions.DownloadOptions.AskForOfflineMapsLocation to
  //true overrides any OfflineMapsLocation value and sets 
  //ApplicationOptions.DownloadOptions.OfflineMapsToProjectLocation to false.
  //This is the same behavior as on the Pro UI.
  ApplicationOptions.DownloadOptions.AskForOfflineMapsLocation = true;

  //Setting ApplicationOptions.DownloadOptions.OfflineMapsToProjectLocation to
  //true overrides any OfflineMapsLocation value and sets 
  //ApplicationOptions.DownloadOptions.AskForOfflineMapsLocation to false.
  //This is the same behavior as on the Pro UI.
  ApplicationOptions.DownloadOptions.OfflineMapsToProjectLocation = true;

// access the current options
  var def_home = ApplicationOptions.GeneralOptions.PortalProjectCustomHomeFolder;
  var def_gdb = ApplicationOptions.GeneralOptions.PortalProjectCustomDefaultGeodatabase;
  var def_tbx = ApplicationOptions.GeneralOptions.PortalProjectCustomDefaultToolbox;
  var deleteOnClose = ApplicationOptions.GeneralOptions.PortalProjectDeleteLocalCopyOnClose;
  var def_location = ApplicationOptions.GeneralOptions.PortalProjectDownloadLocation;

  // set the options
  ApplicationOptions.GeneralOptions.PortalProjectCustomHomeFolder = @"E:\data";
  ApplicationOptions.GeneralOptions.PortalProjectCustomDefaultGeodatabase = @"E:\data\usa.gdb";
  ApplicationOptions.GeneralOptions.PortalProjectCustomDefaultToolbox = @"E:\data\usa.tbx";
  ApplicationOptions.GeneralOptions.PortalProjectDeleteLocalCopyOnClose = false;
  ApplicationOptions.GeneralOptions.PortalProjectDownloadLocation = @"E:\data";