ArcGIS Pro 3.8 API Reference Guide
ArcGIS.Desktop.Core Namespace / IItemFactory Interface / Create Method
Example

In This Topic
    Create Method (IItemFactory)
    In This Topic
    Defines the factory create method all factories must implement.
    Syntax
    Function Create( _
       ByVal uri As String, _
       Optional ByVal itemType As ItemFactory.ItemType _
    ) As Item

    Parameters

    uri
    itemType

    Return Value

    Example
    Add Folder to Project as IProjectItem
    {
      // Add a folder connection to a project
    
      Item folderToAdd = ItemFactory.Instance.Create(@"C:\Data\Oregon\Counties\Streets");
      var project = Project.Current;
      bool wasAdded = await QueuedTask.Run(() => project.AddItem(folderToAdd as IProjectItem));
      // use wasAdded;
    }
    Importing Maps To Project
    {
      // Import a mxd
      Item mxdToImport = ItemFactory.Instance.Create(@"C:\Projects\RegionalSurvey\LatestResults.mxd");
      var project = Project.Current;
      var addedMxd = await QueuedTask.Run(() => project.AddItem(mxdToImport as IProjectItem));
    
      // Add map package
      Item mapPackageToAdd = ItemFactory.Instance.Create(@"c:\Data\Map.mpkx");
      var addedMapPackage = await QueuedTask.Run(() => project.AddItem(mapPackageToAdd as IProjectItem));
    
      // Add an exported Pro map
      Item proMapToAdd = ItemFactory.Instance.Create(@"C:\ExportedMaps\Election\Districts.mapx");
      var addedMapProjectItem = await QueuedTask.Run(() => project.AddItem(proMapToAdd as IProjectItem));
    }
    Create An Item
    {
      Item mxdItem = ItemFactory.Instance.Create(@"C:\Projects\RegionalSurvey\LatestResults.mxd");
      // use mxdItem;
    }
    Create A PortalItem
    {
      // 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;
    }
    Create A PortalFolder
    {
      // 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;
    }
    Add a Favorite - Folder
    {
      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);
        }
      }
    }
    Insert a Favorite - Geodatabase path
    {
      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);
        }
      }
    }
    Toggle the flag IsAddedToAllNewProjects for a favorite
    {
      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);
        }
      }
    }
    Item: Get its IMetadata interface
    {
      Item gdbItem = ItemFactory.Instance.Create(@"C:\projectAlpha\GDBs\regionFive.gdb");
      gdbMetadataItem = gdbItem as IMetadata;
    }
    Item: Copy metadata from the source item's metadata: CopyMetadataFromItem
    {
      Item featureClassItem = ItemFactory.Instance.Create(@"C:\projectAlpha\GDBs\regionFive.gdb\SourceFeatureClass");
      await QueuedTask.Run(() => metadataCopyFrom.CopyMetadataFromItem(featureClassItem));
    }
    Item: Delete certain content from the metadata of the current item: DeleteMetadataContent
    {
      Item featureClassWithMetadataItem = ItemFactory.Instance.Create(@"C:\projectBeta\GDBs\regionFive.gdb\SourceFeatureClass");
      //Delete thumbnail content from item's metadata
      featureClassWithMetadataItem.DeleteMetadataContent(MDDeleteContentOption.esriMDDeleteThumbnail);
    }
    Item: Upgrade the metadata of the current item: UpgradeMetadata
    {
      var fgdcItem = ItemFactory.Instance.Create(@"C:\projectAlpha\GDBs\testData.gdb");
      await QueuedTask.Run(() => fgdcItem.UpgradeMetadata(MDUpgradeOption.esriUpgradeFgdcCsdgm));
    }
    Change the Project's default gdb path
    {
      //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);
    }
    Add a folder connection item to the current project
    {
      //Adding a folder connection
    
      //Create the folder connection project item
      var item = ItemFactory.Instance.Create(folderPath) as IProjectItem;
    
      var folder = await QueuedTask.Run(() =>
        Project.Current.AddItem(item) ? item as FolderConnectionProjectItem : null);
    }
    Add a geodatabase item to the current project
    {
      //Adding a Geodatabase:
      await QueuedTask.Run(() =>
      {
        //Create the File GDB project item
        var item = ItemFactory.Instance.Create(gdbPath) as IProjectItem;
        var newlyAddedGDB = Project.Current.AddItem(item) ? item as GDBProjectItem : null;
      });
    }
    Get Item Categories
    {
      // 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;
    }
    Create an IProjectItem from a layout template pagx file and add it to the project
    {
      var templateFileName = "Layout.pagx";
      // Get layout Template Path from the project's home folder and combine it with a file name
      var projectPath = CoreModule.CurrentProject.HomeFolderPath;
      var layoutTemplateFilePath = System.IO.Path.Combine(projectPath, templateFileName);
      // Create a new layout project item with the layout file path
      // Create an IProjectItem using a layout template pagx file
      IProjectItem pagx = ItemFactory.Instance.Create(layoutTemplateFilePath) as IProjectItem;
      // Add the IProjectItem to the current project
      var project = Project.Current;
      await QueuedTask.Run(() => project.AddItem(pagx));
    }
    Import a pagx into a project
    {
      //Create a layout project item from importing a pagx file
      var project = Project.Current;
      await QueuedTask.Run(() =>
      {
        IProjectItem pagx = ItemFactory.Instance.Create(
                                  @"C:\Temp\Layout.pagx") as IProjectItem;
        project.AddItem(pagx);
      });
    }
    Add a GeoPackage to the Map
    {
      string pathToGeoPackage = @"C:\Data\Geopackage\flooding.gpkg";
      //Create lists to hold the URIs of the layers and tables in the geopackage
      var layerUris = new List<Uri>();
      var tableUris = new List<Uri>();
      await QueuedTask.Run(() =>
      {
        //Create an item from the geopackage
        var item = ItemFactory.Instance.Create(pathToGeoPackage, ItemFactory.ItemType.PathItem);
        var children = item.GetItems();
        //Collect the table and spatial data in the geopackage
        foreach (var child in children)
        {
          var childPath = child.Path;
    
          if (child.TypeID == "sqlite_table")
          {
            tableUris.Add(new Uri(childPath));
          }
          else
          {
            layerUris.Add(new Uri(childPath));
          }
        }
        //Add the spatial data in the geopackage using the BulkLayerCreationParams
        if (layerUris.Count > 0)
        {
          BulkLayerCreationParams bulklcp = new BulkLayerCreationParams(layerUris);
          LayerFactory.Instance.CreateLayers(bulklcp, map);
        }
        // add the tables separately
        foreach (var tableUri in tableUris)
        {
          StandaloneTableFactory.Instance.CreateStandaloneTable(tableUri, map);
        }
      });
    }
    EsriHttpClient: Get a Service Layer and Add it to Pro
    {
      UriBuilder searchURL = new UriBuilder(ArcGISPortalManager.Current.GetActivePortal().PortalUri)
      {
        Path = "sharing/rest/search"
      };
      string layers = "(type:\"Map Service\" OR type:\"Image Service\" OR type:\"Feature Service\" OR type:\"WMS\" OR type:\"KML\")";
      //any public layer content
      searchURL.Query = string.Format("q={0}&f=json", layers);
    
      EsriHttpClient httpClient = new EsriHttpClient();
    
      var searchResponse = httpClient.Get(searchURL.Uri.ToString());
      dynamic resultItems = JObject.Parse(await searchResponse.Content.ReadAsStringAsync());
    
      long numberOfTotalItems = resultItems.total.Value;
      if (numberOfTotalItems == 0)
      {
        return;
      }
    
      List<dynamic> resultItemList = new List<dynamic>();
      resultItemList.AddRange(resultItems.results);
      //get the first result
      dynamic item = resultItemList[0];
    
      string itemID = item.id;
      Item currentItem = ItemFactory.Instance.Create(itemID, ItemFactory.ItemType.PortalItem);
    
      var mapView = MapView.Active;
      if (mapView == null)
        return;
    
      await QueuedTask.Run(() =>
      {
        //Create a LayerCreationParam
        var layerParam = new LayerCreationParams(currentItem);
        // if we have an item that can be turned into a layer
        // add it to the map
        if (LayerFactory.Instance.CanCreateLayerFrom(currentItem))
        {
          LayerFactory.Instance.CreateLayer<FeatureLayer>(layerParam, mapView.Map);
        }
      });
    }
    Import a report file
    {
      var reportFilePath = @"c:\temp\Report.rptx";
      await QueuedTask.Run(() =>
      {
        Item reportToImport = ItemFactory.Instance.Create(reportFilePath);
        Project.Current.AddItem(reportToImport as IProjectItem);
      });
    }
    Requirements

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

    ArcGIS Pro version: 3.0 or higher.
    See Also