ArcGIS Pro 3.8 API Reference Guide
ArcGIS.Desktop.Mapping Namespace / ILayerFactory Interface / CreateLayer Method / CreateLayer<T>(LayerCreationParams,ILayerContainerEdit) Method
Expected Layer Type
Can be one of LayerCreationParams derived objects.
A map or group layer instance to which the Layer will be added.
Example

In This Topic
    CreateLayer<T>(LayerCreationParams,ILayerContainerEdit) Method
    In This Topic
    Creates a new Layer instance using the specified LayerCreationParams and adds that to a container such as a map or group layer. This method must be called on the MCT. Use QueuedTask.Run.
    Syntax
    Overloads Function CreateLayer(Of T As Layer)( _
       ByVal layerParams As LayerCreationParams, _
       ByVal container As ILayerContainerEdit _
    ) As T

    Parameters

    layerParams
    Can be one of LayerCreationParams derived objects.
    container
    A map or group layer instance to which the Layer will be added.

    Type Parameters

    T
    Expected Layer Type

    Return Value

    A specific Layer instance corresponding to type T.
    Exceptions
    ExceptionDescription
    This method or property must be called within the lambda passed to QueuedTask.Run.
    LayerCreationParams or container is null.
    Cannot create the layer of the specified type with the set of LayerCreationParams.
    Example
    Create a KG Layer containing a subset of Entity and Relate types
    {
      await QueuedTask.Run(() =>
      {
        //To create a KG layer (on a map or link chart) with a subset of
        //entities and relates, you must create an "id set". The workflow
        //is very similar to how you would create a SelectionSet.
    
        //First, create a dictionary containing the names of the types to be
        //added plus a corresponding list of ids (just like with a selection set).
        //Note: null or an empty list means add all records for "that" type..
        var kg_datamodel = kg.GetDataModel();
        //Arbitrarily get the name of the first entity and relate type
        var first_entity = kg_datamodel.GetEntityTypes().Keys.First();
        var first_relate = kg_datamodel.GetRelationshipTypes().Keys.First();
    
        //Make entries in the dictionary for each
        var dict = new Dictionary<string, List<long>>();
        dict.Add(first_entity, new List<long>());//Empty list means all records
        dict.Add(first_relate, null);//null list means all records
                                     //or specific records - however the ids are obtained
                                     //dict.Add(entity_or_relate_name, new List<long>() { 1, 5, 18, 36, 78});
    
        //Create the id set...
        var idSet = KnowledgeGraphLayerIDSet.FromDictionary(kg, dict);
    
        //Create the layer params and assign the id set
        var kg_params = new KnowledgeGraphLayerCreationParams(kg)
        {
          Name = "KG_With_ID_Set",
          IsVisible = false,
          IDSet = idSet
        };
    
        //Call layer factory with map or group layer container
        //A KG layer containing just the feature layer(s) and/or standalone table(s)
        //for the entity and/or relate types + associated records will be created
        var kg_layer = LayerFactory.Instance.CreateLayer<KnowledgeGraphLayer>(
            kg_params, map);
    
      });
    }
    Create layer with create-params
    {
      var flyrCreatnParam = new FeatureLayerCreationParams(new Uri(@"c:\data\world.gdb\cities"))
      {
        Name = "World Cities",
        IsVisible = false,
        MinimumScale = 1000000,
        MaximumScale = 5000,
        DefinitionQuery = new DefinitionQuery(whereClause: "Population > 100000", name: "More than 100k"),
        RendererDefinition = new SimpleRendererDefinition()
        {
          SymbolTemplate = SymbolFactory.Instance.ConstructPointSymbol(
         CIMColor.CreateRGBColor(255, 0, 0), 8, SimpleMarkerStyle.Hexagon).MakeSymbolReference()
        }
      };
      var featureLayerWithParams = await QueuedTask.Run(() =>
        LayerFactory.Instance.CreateLayer<FeatureLayer>(flyrCreatnParam, map));
    }
    Create FeatureLayer and add to Map using LayerCreationParams
    {
      //Get the LayerDocument from a lyrx file
      var layerDoc = new LayerDocument(@"E:\Data\SDK\Default2DPointSymbols.lyrx");
      //Get the CIMLayerDocument from the LayerDocument and use it to create LayerCreationParams
      var createParams = new LayerCreationParams(layerDoc.GetCIMLayerDocument());
      //Create a FeatureLayer using the LayerCreationParams
      await QueuedTask.Run(() => LayerFactory.Instance.CreateLayer<FeatureLayer>(createParams, map));
    }
    Create FeatureLayer and set to not display in Map.
    {
      //The catalog path of the feature layer to add to the map
      var featureClassUriVisibility = new Uri(@"C:\Data\Admin\AdminData.gdb\USA\cities");
      //Define the Feature Layer's parameters.
      var layerParamsVisibility = new FeatureLayerCreationParams(featureClassUriVisibility)
      {
        //Set visibility
        IsVisible = false,
      };
      //Create the layer with the feature layer parameters and add it to the active map
      var createdFC = await QueuedTask.Run(() =>
        LayerFactory.Instance.CreateLayer<FeatureLayer>(layerParamsVisibility, map));
    }
    Create FeatureLayer with a Renderer
    {
      //Define a simple renderer to draw the Point US Cities feature class.
      var simpleRender = new SimpleRendererDefinition
      {
        SymbolTemplate = SymbolFactory.Instance.ConstructPointSymbol(ColorFactory.Instance.RedRGB, 4.0, SimpleMarkerStyle.Circle).MakeSymbolReference()
    
      };
      //The catalog path of the feature layer to add to the map
      var featureClassUri = new Uri(@"C:\Data\Admin\AdminData.gdb\USA\cities");
      //Define the Feature Layer's parameters.
      var layerParams = new FeatureLayerCreationParams(featureClassUri)
      {
        //Set visibility
        IsVisible = true,
        //Set Renderer
        RendererDefinition = simpleRender,
      };
      //Create the layer with the feature layer parameters and add it to the active map
      var createdFCWithRenderer = await QueuedTask.Run(() =>
        LayerFactory.Instance.CreateLayer<FeatureLayer>(layerParams, map));
    }
    Create FeatureLayer with a Query Definition
    {
      //The catalog path of the feature layer to add to the map
      var featureClassUriDefinition = new Uri(@"C:\Data\Admin\AdminData.gdb\USA\cities");
      //Define the Feature Layer's parameters.
      var layerParamsQueryDefn = new FeatureLayerCreationParams(featureClassUriDefinition)
      {
        IsVisible = true,
        DefinitionQuery = new DefinitionQuery(whereClause: "STATE_NAME = 'California'", name: "CACities")
      };
      //Create the layer with the feature layer parameters and add it to the active map
      var createdFCWithQueryDefn = await QueuedTask.Run(() =>
        LayerFactory.Instance.CreateLayer<FeatureLayer>(layerParamsQueryDefn, map));
    }
    Create TopologyLayer with an Uri pointing to a Topology dataset
    {
      var path = @"D:\Data\CommunitySamplesData\Topology\GrandTeton.gdb\BackCountry\Backcountry_Topology";
      var lcp = new TopologyLayerCreationParams(new Uri(path));
      lcp.Name = "GrandTeton_Backcountry";
      lcp.AddAssociatedLayers = true;
      var topoLayer = await QueuedTask.Run(() =>
        LayerFactory.Instance.CreateLayer<ArcGIS.Desktop.Mapping.TopologyLayer>(lcp, map));
    }
    Create Topology Layer using Topology dataset
    {
      //Get the Topology of another Topology layer
      var existingTopology = map.GetLayersAsFlattenedList().OfType<TopologyLayer>().FirstOrDefault();
      if (existingTopology != null)
      {
        await QueuedTask.Run(() =>
        {
          var topology = existingTopology.GetTopology();
          //Configure the settings for a new Catalog layer using the CatalogDataset of an existing layer
          var topologyLyrParams = new TopologyLayerCreationParams(topology);
          topologyLyrParams.Name = "NewTopologyLayerFromAnotherTopologyLayer";
          topologyLyrParams.AddAssociatedLayers = true;
          LayerFactory.Instance.CreateLayer<TopologyLayer>(topologyLyrParams, map);
        });
      }
    }
    Create Catalog Layer using Uri to a Catalog Feature Class
    {
      var createParams = new CatalogLayerCreationParams(new Uri(@"C:\CatalogLayer\CatalogDS.gdb\HurricaneCatalogDS"));
      //Set the definition query
      createParams.DefinitionQuery = new DefinitionQuery("Query1", "cd_itemname = 'PuertoRico'");
      //Set name of the new Catalog Layer
      createParams.Name = "PuertoRico";
      //Create Layer
      var catalogLayer = await QueuedTask.Run(() =>
        LayerFactory.Instance.CreateLayer<CatalogLayer>(createParams, map));
    }
    Create Catalog Layer using CatalogDataset
    {
      //Get the CatalogDataset of another Catalog layer
      var existingCatalogLayer = map.GetLayersAsFlattenedList().OfType<CatalogLayer>().FirstOrDefault();
      if (existingCatalogLayer != null)
      {
        await QueuedTask.Run(() =>
        {
          var catalogDataset = existingCatalogLayer.GetCatalogDataset();
          //Configure the settings for a new Catalog layer using the CatalogDataset of an existing layer
          var catalogLyrParams = new CatalogLayerCreationParams(catalogDataset);
          catalogLyrParams.Name = "NewCatalogLayerFromAnotherCatalogLayer";
          catalogLyrParams.DefinitionQuery = new DefinitionQuery("Query1", "cd_itemname = 'Asia'");
          LayerFactory.Instance.CreateLayer<CatalogLayer>(catalogLyrParams, map);
        });
      }
    }
    Add MapNotes to the active map
    {
      //Gets the collection of layer template packages installed with Pro for use with maps
      var items = map.LayerTemplatePackages;
      //Iterate through the collection of items to add each Map Note to the active map
      foreach (var item in items)
      {
        //Create a parameter item for the map note
        var layer_params = new LayerCreationParams(item);
        layer_params.IsVisible = false;
        //Create a feature layer for the map note
        var layerCreated = await QueuedTask.Run(() =>
          LayerFactory.Instance.CreateLayer<Layer>(layer_params, map));
      }
    }
    Apply Symbology from a Layer in the TOC
    {
      await QueuedTask.Run(() =>
      {
        if (map == null)
        {
          return;
        }
    
      //Get an existing Layer. This layer has a symbol you want to use in a new layer.
      var lyr = map.GetLayersAsFlattenedList().OfType<FeatureLayer>()
            .Where(l => l.ShapeType == esriGeometryType.esriGeometryPoint).FirstOrDefault();
      //This is the renderer to use in the new Layer
      var renderer = lyr.GetRenderer() as CIMSimpleRenderer;
      //Set the DataConnection for the new layer
      Geodatabase geodatabase = new Geodatabase(
        new FileGeodatabaseConnectionPath(new Uri(@"E:\Data\Admin\AdminData.gdb")));
      FeatureClass featureClass = geodatabase.OpenDataset<FeatureClass>("Cities");
      var dataConnection = featureClass.GetDataConnection();
      //Create the definition for the new feature layer
      var featureLayerParams = new FeatureLayerCreationParams(dataConnection)
      {
        RendererDefinition = new SimpleRendererDefinition(renderer.Symbol),
        IsVisible = true,
      };
      //create the new layer
        LayerFactory.Instance.CreateLayer<FeatureLayer>(
          featureLayerParams, map);
      });
    }
    Create a new SubTypeGroupLayer
    {
      var subtypeGroupLayerCreateParam = new SubtypeGroupLayerCreationParams
        (new Uri(@"c:\data\SubtypeAndDomain.gdb\Fittings"));
    
      // Define Subtype layers
      var rendererDefn1 = new UniqueValueRendererDefinition(new List<string> { "type" });
      var renderDefn2 = new SimpleRendererDefinition()
      {
        SymbolTemplate = SymbolFactory.Instance.ConstructPointSymbol(
                CIMColor.CreateRGBColor(255, 0, 0), 8, SimpleMarkerStyle.Hexagon).MakeSymbolReference()
      };
      subtypeGroupLayerCreateParam.SubtypeLayers = new List<SubtypeFeatureLayerCreationParams>()
    {
          //define first subtype layer with unique value renderer
          new SubtypeFeatureLayerCreationParams(new UniqueValueRendererDefinition(new List<string> { "type" }), 1),
    
          //define second subtype layer with simple symbol renderer
          new SubtypeFeatureLayerCreationParams(renderDefn2, 2)
    };
    
      // Define additional parameters
      subtypeGroupLayerCreateParam.DefinitionQuery = new DefinitionQuery(whereClause: "Enabled = 1", name: "IsActive");
      subtypeGroupLayerCreateParam.IsVisible = true;
      subtypeGroupLayerCreateParam.MinimumScale = 50000;
      SubtypeGroupLayer subtypeGroupLayer2 = await QueuedTask.Run(() =>
        LayerFactory.Instance.CreateLayer<SubtypeGroupLayer>(subtypeGroupLayerCreateParam, map));
    }
    Create layer from a lyrx file
    {
      await QueuedTask.Run(() =>
      {
        var lyrDocFromLyrxFile = new LayerDocument(@"d:\data\cities.lyrx");
        var cimLyrDoc = lyrDocFromLyrxFile.GetCIMLayerDocument();
    
      //modifying its renderer symbol to red
      var cimSimpleRenderer = ((CIMFeatureLayer)cimLyrDoc.LayerDefinitions[0]).Renderer as CIMSimpleRenderer;
      cimSimpleRenderer?.Symbol.Symbol.SetColor(new CIMRGBColor() { R = 255 });
    
      //optionally save the updates out as a file
      lyrDocFromLyrxFile.Save(@"c:\data\cities_red.lyrx");
    
      //get a json representation of the layer document and you want store away...
      var aJSONString = lyrDocFromLyrxFile.AsJson();
    
      //... and load it back when needed
      lyrDocFromLyrxFile.Load(aJSONString);
      cimLyrDoc = lyrDocFromLyrxFile.GetCIMLayerDocument();
    
      //create a layer and add it to a map
        var lcp = new LayerCreationParams(cimLyrDoc);
        var lyr = LayerFactory.Instance.CreateLayer<FeatureLayer>(lcp, map);
      });
    }
    Add a WMS service
    {
      // Create a connection to the WMS server
      var serverConnection = new CIMInternetServerConnection { URL = "URL of the WMS service" };
      var connection = new CIMWMSServiceConnection { ServerConnection = serverConnection };
    
      // Add a new layer to the map
      var layerParams = new LayerCreationParams(connection);
      var layerCreated = await QueuedTask.Run(() =>
        LayerFactory.Instance.CreateLayer<FeatureLayer>(layerParams, map));
    }
    Add a WFS Service
    {
      CIMStandardDataConnection cIMStandardDataConnection = new CIMStandardDataConnection()
      {
        WorkspaceConnectionString = @"SWAPXY=TRUE;SWAPXYFILTER=FALSE;URL=http://sampleserver6.arcgisonline.com/arcgis/services/SampleWorldCities/MapServer/WFSServer;VERSION=2.0.0",
        WorkspaceFactory = WorkspaceFactory.WFS,
        Dataset = "Continent",
        DatasetType = esriDatasetType.esriDTFeatureClass
      };
    
      // Add a new layer to the map
      var layerPamsDC = new LayerCreationParams(cIMStandardDataConnection);
      Layer layerCreated = await QueuedTask.Run(() =>
        LayerFactory.Instance.CreateLayer<FeatureLayer>(layerPamsDC, map));
    }
    Add a WMTS service
    {
      // Create a connection to the WMS server
      var serverConnection = new CIMProjectServerConnection
      {
        URL = "URL of the WMTS service.xml",
        ServerType = ServerType.WMTS,
      };
      var service_connection = new CIMWMTSServiceConnection
      {
        ServerConnection = serverConnection,
        LayerName = "AdminBoundaries", // Specify the layer name you want to add
      };
    
      // Add a new layer to the map
      var layerParams = new LayerCreationParams(service_connection);
      layerParams.MapMemberPosition = MapMemberPosition.AddToBottom;
      var layerCreated = await QueuedTask.Run(() =>
        LayerFactory.Instance.CreateLayer<FeatureLayer>(layerParams, map));
    }
    Connect to an AGS Service using a .ags File
    {
      //This workflow would work for
      var agsFilePath = @"C:\Data\ServerConnectionFiles\AcmeSampleService.ags";
    
      //ServerConnectionProjectItem supports .ags, .wms, .wmts, .wfs, and .wcs files
      var server_conn_item = ItemFactory.Instance.Create(agsFilePath)
        as ArcGIS.Desktop.Catalog.ServerConnectionProjectItem;
    
      //Get the server connection - passwords are never returned
      var serverConnection = server_conn_item.ServerConnection as CIMProjectServerConnection;
    
      //Add to an AGS service connection
      var service_connection = new CIMAGSServiceConnection()
      {
        URL = "URL to the AGS _service_ on the AGS _server_",
        ServerConnection = serverConnection
      };
    
      // Add a new layer to the map
      var layerParams = new LayerCreationParams(service_connection);
      layerParams.MapMemberPosition = MapMemberPosition.AddToBottom;
      var layerCreated = await QueuedTask.Run(() =>
        LayerFactory.Instance.CreateLayer<FeatureLayer>(layerParams, map));
    }
    Connect to an AGS Service using ServiceConnectionProperties
    {
      //Connect to the AGS service. Note: the connection will persist for the
      //duration of the Pro session.
      var serverUrl = "https://sampleserver6.arcgisonline.com/arcgis/rest/services";
    
      var username = "user1";
      var password = "user1";
    
      //at any point before creating a layer, first make a connection to the server
      //if one has not been already established for the current session
      var uri = new Uri(serverUrl);
      var props = new ServiceConnectionProperties(uri)
      {
        User = username
      };
      //It is preferred that you use the Windows Credential Manager to store the password
    
      //However, it can be set as clear text if you so choose
      props.Password = password; //not recommended
    
    
      //Establish a connection to the server at any point in time _before_
      //creating a layer from a service on the server
      await QueuedTask.Run(() =>
      {
        using var gdb = new Geodatabase(props);
      });
    
      //later in the session, as needed...create a layer from one of the services
      //on the server
      var serviceUrl = "https://sampleserver6.arcgisonline.com/arcgis/rest/services/Wildfire_secure/MapServer";
      var lc = new LayerCreationParams(new Uri(serviceUrl));
      await QueuedTask.Run(() => LayerFactory.Instance.CreateLayer<MapImageLayer>(lc, map));
    }
    Adding and changing styles for WMS Service Layer
    {
      var serverConnection = new CIMInternetServerConnection { URL = "https://spritle.esri.com/arcgis/services/sanfrancisco_sld/MapServer/WMSServer" };
      var connection = new CIMWMSServiceConnection { ServerConnection = serverConnection };
      LayerCreationParams parameters = new LayerCreationParams(connection);
      parameters.MapMemberPosition = MapMemberPosition.AddToBottom;
      await QueuedTask.Run(() =>
      {
        var compositeLyr = LayerFactory.Instance.CreateLayer<WMSLayer>(parameters, map);
        //wms layer in ArcGIS Pro always has a composite layer inside it
        var wmsLayers = compositeLyr.Layers[0] as ServiceCompositeSubLayer;
        //each wms sublayer belongs in that composite layer
        var highwayLayerWMSSub = wmsLayers.Layers[1] as WMSSubLayer;
        //toggling a sublayer's visibility
        if ((highwayLayerWMSSub != null))
        {
          bool visibility = highwayLayerWMSSub.IsVisible;
          highwayLayerWMSSub.SetVisibility(!visibility);
        }
        //applying an existing style to a wms sub layer
        var pizzaLayerWMSSub = wmsLayers.Layers[0] as WMSSubLayer;
        var currentStyles = pizzaLayerWMSSub.GetStyleNames();
        pizzaLayerWMSSub.SetStyleName(currentStyles[1]);
      });
    }
    Create a query layer
    {
      Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri(@"C:\Connections\mySDE.sde")));
      CIMSqlQueryDataConnection sqldc = new CIMSqlQueryDataConnection()
      {
        WorkspaceConnectionString = geodatabase.GetConnectionString(),
        GeometryType = esriGeometryType.esriGeometryPolygon,
        OIDFields = "OBJECTID",
        Srid = "102008",
        SqlQuery = "select * from MySDE.dbo.STATES",
        Dataset = "States"
      };
      var lcp = new LayerCreationParams(sqldc)
      {
        Name = "States"
      };
      FeatureLayer flyr = await QueuedTask.Run(() =>
        LayerFactory.Instance.CreateLayer<FeatureLayer>(lcp, map));
    }
    Create a feature layer with class breaks renderer with defaults
    {
      var featureLayerCreationParams = new FeatureLayerCreationParams(new Uri(@"c:\data\countydata.gdb\counties"))
      {
        Name = "Population Density (sq mi) Year 2010",
        RendererDefinition = new GraduatedColorsRendererDefinition("POP10_SQMI")
      };
      await QueuedTask.Run(() => LayerFactory.Instance.CreateLayer<FeatureLayer>(
        featureLayerCreationParams, map));
    }
    Create a New Elevation Surface
    {
      //Define a ServiceConnection to use for the new Elevation surface
      var serverConnection = new CIMInternetServerConnection
      {
        Anonymous = true,
        HideUserProperty = true,
        URL = "https://elevation.arcgis.com/arcgis/services"
      };
      CIMAGSServiceConnection serviceConnection = new CIMAGSServiceConnection
      {
        ObjectName = "WorldElevation/Terrain",
        ObjectType = "ImageServer",
        URL = "https://elevation.arcgis.com/arcgis/services/WorldElevation/Terrain/ImageServer",
        ServerConnection = serverConnection
      };
      //Defines a new elevation source set to the CIMAGSServiceConnection defined above
      //Get the elevation surfaces defined in the map
      var listOfElevationSurfaces = map.GetElevationSurfaceLayers();
      //Add the new elevation surface
      var elevationLyrCreationParams = new ElevationLayerCreationParams(serviceConnection);
      var elevationSurface = await QueuedTask.Run(() =>
        LayerFactory.Instance.CreateLayer<ElevationSurfaceLayer>(elevationLyrCreationParams, map));
    }
    Add an elevation source to an existing elevation surface layer
    {
      ElevationSurfaceLayer surfaceLayer = null;
      // surfaceLayer could also be the ground layer
      string uri = "https://elevation3d.arcgis.com/arcgis/rest/services/WorldElevation3D/Terrain3D/ImageServer";
      var createParams = new ElevationLayerCreationParams(new Uri(uri));
      createParams.Name = "Terrain 3D";
      var eleSourceLayer = await QueuedTask.Run(() =>
        LayerFactory.Instance.CreateLayer<Layer>(createParams, surfaceLayer));
    }
    Create a raster layer with a new colorizer definition
    {
      // Create a new stretch colorizer definition using default constructor.
      StretchColorizerDefinition stretchColorizerDef = new StretchColorizerDefinition();
      // Create a raster layer creation parameters object with the raster file path.
      var rasterLayerCreationParams = new RasterLayerCreationParams(new Uri("rasterPath"))
      {
        ColorizerDefinition = stretchColorizerDef,
        Name = "rasterLayerName",
        MapMemberIndex = 0
      };
    
      // Create a raster layer using the colorizer definition created above.
      // Note: You can create a raster layer from a url, project item, or data connection.
      RasterLayer rasterLayerfromURL = await QueuedTask.Run(() =>
        LayerFactory.Instance.CreateLayer<RasterLayer>(rasterLayerCreationParams, map));
    
    }
    Create a mosaic layer with a new colorizer definition
    // Create a new colorizer definition using default constructor.
    {
      StretchColorizerDefinition stretchColorizerDef = new StretchColorizerDefinition();
      var rasterLayerCreationParams = new RasterLayerCreationParams(new Uri("url"))
      {
        Name = "layerRasterName",
        ColorizerDefinition = stretchColorizerDef,
        MapMemberIndex = 0
    
      };
      // Create a mosaic layer using the colorizer definition created above.
      // Note: You can create a mosaic layer from a url, project item, or data connection.
      MosaicLayer newMosaicLayer = await QueuedTask.Run(() =>
        LayerFactory.Instance.CreateLayer<MosaicLayer>(rasterLayerCreationParams, map));
    }
    Create an image service layer with a new colorizer definition
    {
      // Create a new colorizer definition using default constructor.
      StretchColorizerDefinition stretchColorizerDef = new StretchColorizerDefinition();
      var rasterLayerCreationParams = new RasterLayerCreationParams(new Uri(url))
      {
        Name = "RasterLayer",
        ColorizerDefinition = stretchColorizerDef,
        MapMemberIndex = 0
      };
      // Create an image service layer using the colorizer definition created above.
      ImageServiceLayer imageServiceLayerWithColorizer = await QueuedTask.Run(() =>
        LayerFactory.Instance.CreateLayer<ImageServiceLayer>(rasterLayerCreationParams, 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);
        }
      });
    }
    Create a TinLayer
    {
      string tinPath = @"d:\Data\Tin\TinDataset";
      var tinURI = new Uri(tinPath);
    
      var tinCP = new TinLayerCreationParams(tinURI);
      tinCP.Name = "My TIN Layer";
      tinCP.IsVisible = false;
      await QueuedTask.Run(() =>
      {
        //Create the layer to the TIN
        tinLayer = LayerFactory.Instance.CreateLayer<TinLayer>(tinCP, map);
      });
    }
    Create a TinLayer from a dataset
    {
      var tinCP_ds = new TinLayerCreationParams(tinDataset);
      tinCP_ds.Name = "My TIN Layer";
      tinCP_ds.IsVisible = false;
    
      //Create the layer to the TIN
      await QueuedTask.Run(() =>
      {
        var tinLayer_ds = LayerFactory.Instance.CreateLayer<TinLayer>(tinCP_ds, map);
      });
    }
    Create a TinLayer with renderers
    {
      var tinCP_renderers = new TinLayerCreationParams(tinDataset)
      {
        Name = "My TIN layer",
        IsVisible = true
      };
    
      // define the node renderer - use defaults
      var node_rd = new TinNodeRendererDefinition();
    
      // define the face/surface renderer
      var face_rd = new TinFaceClassBreaksRendererDefinition();
      face_rd.ClassificationMethod = ClassificationMethod.NaturalBreaks;
      // accept default color ramp, breakCount
    
      // set up the renderer dictionary
      var rendererDict = new Dictionary<SurfaceRendererTarget, TinRendererDefinition>
    {
      { SurfaceRendererTarget.Points, node_rd },
      { SurfaceRendererTarget.Surface, face_rd }
    };
    
      // assign the dictionary to the creation params
      tinCP_renderers.RendererDefinitions = rendererDict;
      await QueuedTask.Run(() =>
      {
        // create the layer
        var tinLayer_rd = LayerFactory.Instance.CreateLayer<TinLayer>(tinCP_renderers, mapView.Map);
      });
    }
    Create a TerrainLayer
    {
      await QueuedTask.Run(() =>
      {
        string terrainPath = @"d:\Data\Terrain\filegdb_Containing_A_Terrain.gdb\FeatureDataset\Terrain_name";
        var terrainURI = new Uri(terrainPath);
    
        var terrainCP = new TerrainLayerCreationParams(terrainURI);
        terrainCP.Name = "My Terrain Layer";
        terrainCP.IsVisible = false;
        //Create the layer to the terrain
        terrainLayer = LayerFactory.Instance.CreateLayer<TerrainLayer>(terrainCP, map);
      });
    }
    Create a TerrainLayer from a dataset
    {
      var terrainCP_ds = new TerrainLayerCreationParams(terrain);
      terrainCP_ds.Name = "My Terrain Layer";
      terrainCP_ds.IsVisible = true;
    
      //Create the layer to the terrain
      await QueuedTask.Run(() =>
      {
        var terrainLayer_ds = LayerFactory.Instance.CreateLayer<TerrainLayer>(terrainCP_ds, map);
      });
    }
    Create a TerrainLayer with renderers
    {
      var terrainCP_renderers = new TerrainLayerCreationParams(terrain);
      terrainCP_renderers.Name = "My LAS Layer";
      terrainCP_renderers.IsVisible = true;
    
      // define the edge type renderer - use defaults
      var edgeRD = new TinBreaklineRendererDefinition();
    
      // define the face/surface renderer
      var faceRD = new TinFaceClassBreaksRendererDefinition();
      faceRD.ClassificationMethod = ClassificationMethod.NaturalBreaks;
      // accept default color ramp, breakCount
    
      // define the dirty area renderer - use defaults
      var dirtyAreaRD = new TerrainDirtyAreaRendererDefinition();
    
      // add renderers to dictionary
      var t_dict = new Dictionary<SurfaceRendererTarget, TinRendererDefinition>();
      t_dict.Add(SurfaceRendererTarget.Edges, edgeRD);
      t_dict.Add(SurfaceRendererTarget.Surface, faceRD);
      t_dict.Add(SurfaceRendererTarget.DirtyArea, dirtyAreaRD);
    
      // assign dictionary to creation params
      terrainCP_renderers.RendererDefinitions = t_dict;
      await QueuedTask.Run(() =>
      {
        //Create the layer to the terrain
        var terrainLayer_rd = LayerFactory.Instance.CreateLayer<TerrainLayer>(terrainCP_renderers, map);
      });
    }
    Create a LasDatasetLayer
    {
      string lasPath = @"d:\Data\LASDataset.lasd";
      var lasURI = new Uri(lasPath);
    
      var lasCP = new LasDatasetLayerCreationParams(lasURI);
      lasCP.Name = "My LAS Layer";
      lasCP.IsVisible = false;
      await QueuedTask.Run(() =>
      {
        //Create the layer to the LAS dataset
        lasDatasetLayer = LayerFactory.Instance.CreateLayer<LasDatasetLayer>(lasCP, map);
      });
    }
    Create a LasDatasetLayer from a LasDataset
    {
      if (lasDataset == null)
      {
        throw new ArgumentNullException(nameof(lasDataset));
      }
    
      var lasCP_ds = new LasDatasetLayerCreationParams(lasDataset);
      lasCP_ds.Name = "My LAS Layer";
      lasCP_ds.IsVisible = false;
      await QueuedTask.Run(() =>
      {
        //Create the layer to the LAS dataset
        var lasDatasetLayer_ds = LayerFactory.Instance.CreateLayer<LasDatasetLayer>(lasCP_ds, map);
      });
    }
    Create a LasDatasetLayer with renderers
    {
      var lasCP_renderers = new LasDatasetLayerCreationParams(lasDataset);
      lasCP_renderers.Name = "My LAS Layer";
      lasCP_renderers.IsVisible = false;
    
      // create a point elevation renderer
      var ptR = new LasStretchRendererDefinition();
      // accept all defaults
    
      // create a simple edge renderer
      var edgeR = new TinEdgeRendererDefintion();
      // accept all defaults
    
      // add renderers to dictionary
      var l_dict = new Dictionary<SurfaceRendererTarget, TinRendererDefinition>();
      l_dict.Add(SurfaceRendererTarget.Points, ptR);
      l_dict.Add(SurfaceRendererTarget.Edges, edgeR);
    
      // assign dictionary to creation params
      lasCP_renderers.RendererDefinitions = l_dict;
      await QueuedTask.Run(() =>
      {
        //Create the layer to the LAS dataset
        var lasDatasetLayer_rd = LayerFactory.Instance.CreateLayer<LasDatasetLayer>(lasCP_renderers, map);
      });
    }
    Create GraphicsLayer
    {
      if (map.MapType != MapType.Map)
      {
        return;// not 2D
      }
    
      var gl_param = new GraphicsLayerCreationParams { Name = "Graphics Layer" };
      await QueuedTask.Run(() =>
      {
        //By default will be added to the top of the TOC
        graphicsLayer = LayerFactory.Instance.CreateLayer<ArcGIS.Desktop.Mapping.GraphicsLayer>(gl_param, map);
    
        //Add to the bottom of the TOC
        gl_param.MapMemberIndex = -1; //bottom
        LayerFactory.Instance.CreateLayer<ArcGIS.Desktop.Mapping.GraphicsLayer>(gl_param, map);
    
        //Add a graphics layer to a group layer...
        var group_layer = map.GetLayersAsFlattenedList().OfType<GroupLayer>().First();
        LayerFactory.Instance.CreateLayer<ArcGIS.Desktop.Mapping.GraphicsLayer>(gl_param, group_layer);
    
        //TODO...use the graphics layer
        //
    
        // or use the specific CreateGroupLayer method
        LayerFactory.Instance.CreateGroupLayer(map, -1, "Graphics Layer");
      });
    }
    Create a Scene Layer
    {
      var map = MapView.Active?.Map;
      if (map == null)
        return;
    
      await QueuedTask.Run(() =>
      {
        //Create with initial visibility set to false. Add to current scene
        var createparams = new LayerCreationParams(new Uri(sceneLayerUrl, UriKind.Absolute))
        {
          IsVisible = false
        };
    
        //cast to specific type of scene layer being created - in this case FeatureSceneLayer
        var sceneLayer = LayerFactory.Instance.CreateLayer<Layer>(
                 createparams, map) as FeatureSceneLayer;
        //or...specify the cast directly
        var sceneLayer2 = LayerFactory.Instance.CreateLayer<FeatureSceneLayer>(
                 createparams, map);
        //ditto for BuildingSceneLayer, PointCloudSceneLayer, IntegratedMeshSceneLayer
        //...
      });
    }
    Create Stream Layer with URI
    {
      await QueuedTask.Run(() =>
      {
        var url = "https://geoeventsample1.esri.com:6443/arcgis/rest/services/AirportTraffics/StreamServer";
        var createParam = new FeatureLayerCreationParams(new Uri(url))
        {
          IsVisible = false //turned off by default
        };
        streamLayer = LayerFactory.Instance.CreateLayer<StreamLayer>(createParam, map);
    
        //or use "original" create layer (will be visible by default)
        Uri uri = new Uri(url);
        streamLayer = LayerFactory.Instance.CreateLayer(uri, map) as StreamLayer;
        streamLayer.SetVisibility(false);//turn off
      });
    }
    Create a stream layer with a definition query
    {
      await QueuedTask.Run(() =>
      {
        var url = "https://geoeventsample1.esri.com:6443/arcgis/rest/services/AirportTraffics/StreamServer";
        var lyrCreateParam = new FeatureLayerCreationParams(new Uri(url))
        {
          IsVisible = true,
          DefinitionQuery = new DefinitionQuery(whereClause: "RWY = '29L'", name: "Runway")
        };
    
        streamLayer = LayerFactory.Instance.CreateLayer<StreamLayer>(lyrCreateParam, map);
      });
    }
    Create a stream layer with a simple renderer
    {
      await QueuedTask.Run(() =>
      {
        var url = @"https://geoeventsample1.esri.com:6443/arcgis/rest/services/LABus/StreamServer";
        var uri = new Uri(url, UriKind.Absolute);
        var createParams = new FeatureLayerCreationParams(uri)
        {
          RendererDefinition = new SimpleRendererDefinition()
          {
            SymbolTemplate = SymbolFactory.Instance.ConstructPointSymbol(
                                ColorFactory.Instance.BlueRGB,
                                12,
                         SimpleMarkerStyle.Pushpin).MakeSymbolReference()
          }
        };
        streamLayer = LayerFactory.Instance.CreateLayer<StreamLayer>(
                            createParams, map);
      });
    }
    Setting a unique value renderer for latest observations
    {
      await QueuedTask.Run(() =>
      {
        var url = @"https://geoeventsample1.esri.com:6443/arcgis/rest/services/AirportTraffics/StreamServer";
        var uri = new Uri(url, UriKind.Absolute);
    
        var createParams = new FeatureLayerCreationParams(uri)
        {
          IsVisible = false
        };
        streamLayer = LayerFactory.Instance.CreateLayer<StreamLayer>(
                            createParams, map);
        //Define the unique values by hand
        var uvr = new CIMUniqueValueRenderer()
        {
          Fields = new string[] { "ACTYPE" },
          UseDefaultSymbol = true,
          DefaultLabel = "Others",
          DefaultSymbol = SymbolFactory.Instance.ConstructPointSymbol(
                      CIMColor.CreateRGBColor(185, 185, 185), 8, SimpleMarkerStyle.Hexagon).MakeSymbolReference()
        };
    
        var classes = new List<CIMUniqueValueClass>
        {
          //add in classes - one for ACTYPE of 727, one for DC 9
          new CIMUniqueValueClass()
          {
            Values = new CIMUniqueValue[] {
                    new CIMUniqueValue() { FieldValues = new string[] { "B727" } } },
            Visible = true,
            Label = "Boeing 727",
            Symbol = SymbolFactory.Instance.ConstructPointSymbol(
                      ColorFactory.Instance.RedRGB, 10, SimpleMarkerStyle.Hexagon).MakeSymbolReference()
          },
          new CIMUniqueValueClass()
          {
            Values = new CIMUniqueValue[] {
                    new CIMUniqueValue() { FieldValues = new string[] { "DC9" } } },
            Visible = true,
            Label = "DC 9",
            Symbol = SymbolFactory.Instance.ConstructPointSymbol(
                      ColorFactory.Instance.GreenRGB, 10, SimpleMarkerStyle.Hexagon).MakeSymbolReference()
          }
        };
        //add the classes to a group
        var groups = new List<CIMUniqueValueGroup>()
      {
        new CIMUniqueValueGroup() {
           Classes = classes.ToArray()
        }
      };
        //add the groups to the renderer
        uvr.Groups = groups.ToArray();
        //Apply the renderer (for current observations)
        streamLayer.SetRenderer(uvr);
        streamLayer.SetVisibility(true);//turn on the layer
      });
    }
    Create Voxel Layer
    {
      await QueuedTask.Run(() =>
      {
        //Must be a .NetCDF file for voxels
        var url = @"C:\MyData\AirQuality_Redlands.nc";
        var cim_connection = new CIMVoxelDataConnection()
        {
          URI = url
        };
        //Create a VoxelLayerCreationParams
        var createParams = VoxelLayerCreationParams.Create(cim_connection);
        createParams.IsVisible = true;
    
        //Can also just use the path directly...
        //var createParams = VoxelLayerCreationParams.Create(url);
    
        //Use VoxelLayerCreationParams to enumerate the variables within
        //the voxel
        var variables = createParams.Variables;
        foreach (var variable in variables)
        {
          var line = $"{variable.Variable}: {variable.DataType}, " +
             $"{variable.Description}, {variable.IsDefault}, {variable.IsSelected}";
          System.Diagnostics.Debug.WriteLine(line);
        }
        //Optional: set the default variable
        createParams.SetDefaultVariable(variables.Last());
    
        //Create the layer - map must be a local scene
        voxelLayer = LayerFactory.Instance.CreateLayer<VoxelLayer>(createParams, map);
      });
    }
    Requirements

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

    ArcGIS Pro version: 3.0 or higher.
    See Also