public class LayerFactory : ILayerFactory  

{
    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()
        }
    };
    //Note: Needs QueuedTask to run
    var featureLayerWithParams = LayerFactory.Instance.CreateLayer<FeatureLayer>(flyrCreatnParam, map);
}

{
    //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
    //Note: Needs QueuedTask to run
    LayerFactory.Instance.CreateLayer<FeatureLayer>(createParams, MapView.Active.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
    //Note: Needs QueuedTask to run
    var createdFC = LayerFactory.Instance.CreateLayer<FeatureLayer>(layerParamsVisibility, MapView.Active.Map);
}

{
    //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
    //Note: Needs QueuedTask to run
    var createdFCWithRenderer = LayerFactory.Instance.CreateLayer<FeatureLayer>(layerParams, MapView.Active.Map);
}

{
    //Gets the collection of layer template packages installed with Pro for use with maps
    var items = MapView.Active.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;
        //Note: Needs QueuedTask to run
        //Create a feature layer for the map note
        var layerCreated = LayerFactory.Instance.CreateLayer<Layer>(layer_params, MapView.Active.Map);
    }
}

{
          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;
          //Note: Needs QueuedTask to run
          SubtypeGroupLayer subtypeGroupLayer2 = LayerFactory.Instance.CreateLayer<SubtypeGroupLayer>(
                        subtypeGroupLayerCreateParam, MapView.Active.Map);
      }

{
    //Note: Call within 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);
}

{
    // 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);
    //Note: Needs QueuedTask to run
    var layerCreated = LayerFactory.Instance.CreateLayer<FeatureLayer>(layerParams, MapView.Active.Map);
}

{
    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);
    //Note: Needs QueuedTask to run
    Layer layerCreated = LayerFactory.Instance.CreateLayer<FeatureLayer>(layerPamsDC, MapView.Active.Map);
}

{
    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"
    };
    //Note: Needs QueuedTask to run
    FeatureLayer flyr = LayerFactory.Instance.CreateLayer<FeatureLayer>(lcp, map);
}

{
    //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);
    //Note: needs to be called on the MCT
    var elevationSurface = LayerFactory.Instance.CreateLayer<ElevationSurfaceLayer>(
        elevationLyrCreationParams, map);
}

{
    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";
    //Note: needs to be called on the MCT
    var eleSourceLayer = LayerFactory.Instance.CreateLayer<Layer>(createParams, surfaceLayer);
}

{
    // 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.
    //Note: Run within a QueuedTask
    RasterLayer rasterLayerfromURL =
  LayerFactory.Instance.CreateLayer<RasterLayer>(rasterLayerCreationParams, map);

}

// 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.
    //Note: Run within a QueuedTask
    MosaicLayer newMosaicLayer = LayerFactory.Instance.CreateLayer<MosaicLayer>(rasterLayerCreationParams, map);
}

{
    // 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.
    //Note: Run within a QueuedTask
    ImageServiceLayer imageServiceLayerWithColorizer =
  LayerFactory.Instance.CreateLayer<ImageServiceLayer>(rasterLayerCreationParams, map);
}

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

  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.Active.Map);
  });
}

{
  if (map.MapType != MapType.Map)
    return;// not 2D

  var gl_param = new GraphicsLayerCreationParams { Name = "Graphics Layer" };
  // Note: must be called on the QueuedTask
  {
    //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");
  }
}

{
  // Note: call within 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, MapView.Active.Map) as FeatureSceneLayer;
    //or...specify the cast directly
    var sceneLayer2 = LayerFactory.Instance.CreateLayer<FeatureSceneLayer>(
             createparams, MapView.Active.Map);
    //ditto for BuildingSceneLayer, PointCloudSceneLayer, IntegratedMeshSceneLayer
    //...
  }
}

{
  // Note: call within 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);
  }
}