public IEnumerable<T> GetItems<T>()
where T: Item

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

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

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

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

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

{
  LayoutProjectItem layoutItemByName = Project.Current.GetItems<LayoutProjectItem>()
    .FirstOrDefault((lpi) => lpi.Name == "MyLayout");
  //Note: Needs QueuedTask to run
  Layout layoutByName = layoutItemByName.GetLayout();
}

{
  //Reference layout project items and their associated layout.
  //A layout project item is an item that appears in the Layouts
  //folder in the Catalog pane.
  //Reference all the layout project items
  IEnumerable<LayoutProjectItem> layoutProjectItems =
                       Project.Current.GetItems<LayoutProjectItem>();

  //Or reference a specific layout project item by name
  LayoutProjectItem specificLayoutItem = Project.Current.GetItems<LayoutProjectItem>()
                             .FirstOrDefault(item => item.Name.Equals("MyLayoutItem"));
}

{
  //Note: Call within QueuedTask.Run()
  //Reference a ReportProjectItem in a project by name
  ReportProjectItem reportItem = Project.Current.GetItems<ReportProjectItem>().FirstOrDefault(item => item.Name.Equals(reportName));
  if (reportItem != null)
    //Delete the report from the project
    Project.Current.RemoveItem(reportItem);
}