public class LayerFactory : ILayerFactory  

var map = MapView.Active.Map;
if (map.MapType != MapType.Map)
  return;// not 2D

var gl_param = new GraphicsLayerCreationParams { Name = "Graphics Layer" };
QueuedTask.Run(() =>
{
  //By default will be added to the top of the TOC
  var 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");
});

var flyrCreatnParam = new FeatureLayerCreationParams(new Uri(@"c:\data\world.gdb\cities"))
{
  Name = "World Cities",
  IsVisible = false,
  MinimumScale = 1000000,
  MaximumScale = 5000,
  // At 2.x - DefinitionFilter = new CIMDefinitionFilter()
  //{
  //  DefinitionExpression = "Population > 100000",
  //  Name = "More than 100k"
  //},
  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 featureLayer = LayerFactory.Instance.CreateLayer<FeatureLayer>(
  flyrCreatnParam, map);

//Note: Call within QueuedTask.Run()
var layerDoc = new LayerDocument(@"E:\Data\SDK\Default2DPointSymbols.lyrx");
var createParams = new LayerCreationParams(layerDoc.GetCIMLayerDocument());
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
var createdFC = LayerFactory.Instance.CreateLayer<FeatureLayer>(layerParamsVisibility, 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;
  await QueuedTask.Run(() =>
  {
    //Create a feature layer for the map note
    var layer = LayerFactory.Instance.CreateLayer<Layer>(layer_params, MapView.Active.Map);
  });
}

var subtypeGroupLayerCreateParam = new SubtypeGroupLayerCreationParams
(
    new Uri(@"c:\data\SubtypeAndDomain.gdb\Fittings")
);

// Define Subtype layers
//At 2.x - var rendererDefn1 = new UniqueValueRendererDefinition(new string[] { "type" });
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
  //At 2.x - new SubtypeFeatureLayerCreationParams(new UniqueValueRendererDefinition(new string[] { "type" }), 1),
  new SubtypeFeatureLayerCreationParams(new UniqueValueRendererDefinition(new List<string> { "type" }), 1),

  //define second subtype layer with simple symbol renderer
  new SubtypeFeatureLayerCreationParams(renderDefn2, 2)
};

// Define additional parameters
//At - 2.x subtypeGroupLayerCreateParam.DefinitionFilter = new CIMDefinitionFilter()
//{
//  Name = "IsActive",
//  DefinitionExpression = "Enabled = 1"
//};
subtypeGroupLayerCreateParam.DefinitionQuery = new DefinitionQuery(whereClause: "Enabled = 1", name: "IsActive");
subtypeGroupLayerCreateParam.IsVisible = true;
subtypeGroupLayerCreateParam.MinimumScale = 50000;

SubtypeGroupLayer subtypeGroupLayer2 = LayerFactory.Instance.CreateLayer<SubtypeGroupLayer>(
              subtypeGroupLayerCreateParam, MapView.Active.Map);

var lyrDocFromLyrxFile = new LayerDocument(@"d:\data\cities.lyrx");
var cimLyrDoc = lyrDocFromLyrxFile.GetCIMLayerDocument();

//modifying its renderer symbol to red
var r = ((CIMFeatureLayer)cimLyrDoc.LayerDefinitions[0]).Renderer as CIMSimpleRenderer;
r.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);
await QueuedTask.Run(() =>
{
  var layer = 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);
await QueuedTask.Run(() =>
{
  Layer layer = LayerFactory.Instance.CreateLayer<FeatureLayer>(layerPamsDC, MapView.Active.Map);
});

await QueuedTask.Run(() =>
{
  Map map = 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"
  };
  FeatureLayer flyr = LayerFactory.Instance.CreateLayer<FeatureLayer>(lcp, map);
});

//Note: call within QueuedTask.Run()
//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
//At 2.x - var newElevationSource = new ArcGIS.Core.CIM.CIMElevationSource
//{
//  VerticalUnit = ArcGIS.Core.Geometry.LinearUnit.Meters,
//  DataConnection = serviceConnection,
//  Name = "WorldElevation/Terrain",
//  Visibility = true
//};
//The elevation surface
//At 2.x - var newElevationSurface = new ArcGIS.Core.CIM.CIMMapElevationSurface
//{
//  Name = "New Elevation Surface",
//  BaseSources = new ArcGIS.Core.CIM.CIMElevationSource[1] { newElevationSource },
//  Visibility = true,
//  ElevationMode = ElevationMode.CustomSurface,
//  VerticalExaggeration = 1,
//  EnableSurfaceShading = false,
//  SurfaceTINShadingMode = SurfaceTINShadingMode.Smooth,
//  Expanded = false,
//  MapElevationID = "{3DEC3CC5-7C69-4132-A700-DCD5BDED14D6}"
//};
//Get the active map
var map = MapView.Active.Map;
//Get the elevation surfaces defined in the map
//At 2.x - var listOfElevationSurfaces = definition.ElevationSurfaces.ToList();
var listOfElevationSurfaces = map.GetElevationSurfaceLayers();
//Add the new elevation surface 
//At 2.x - listOfElevationSurfaces.Add(newElevationSurface);
var elevationLyrCreationParams = new ElevationLayerCreationParams(serviceConnection);
var elevationSurface = LayerFactory.Instance.CreateLayer<ElevationSurfaceLayer>(
       elevationLyrCreationParams, map);

// wrap in QueuedTask.Run

// 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 = LayerFactory.Instance.CreateLayer<Layer>(createParams, surfaceLayer);

  // Create a new stretch colorizer definition using default constructor.
  StretchColorizerDefinition stretchColorizerDef = new StretchColorizerDefinition();
  var rasterLayerCreationParams = new RasterLayerCreationParams(new Uri(url))
  {
    ColorizerDefinition = stretchColorizerDef,
    Name = layerName,
    MapMemberIndex = 0
  };
  await QueuedTask.Run(() =>
  {
    // 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 =
LayerFactory.Instance.CreateLayer<RasterLayer>(rasterLayerCreationParams, aMap);
  });

  // Create a new colorizer definition using default constructor.
  StretchColorizerDefinition stretchColorizerDef = new StretchColorizerDefinition();
  var rasterLayerCreationParams = new RasterLayerCreationParams(new Uri(url))
  {
    Name = layerName,
    ColorizerDefinition = stretchColorizerDef,
    MapMemberIndex = 0

  };
  await QueuedTask.Run(() =>
  {
    // 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 =
LayerFactory.Instance.CreateLayer<MosaicLayer>(rasterLayerCreationParams, aMap);
  });

  // Create a new colorizer definition using default constructor.
  StretchColorizerDefinition stretchColorizerDef = new StretchColorizerDefinition();
  var rasterLayerCreationParams = new RasterLayerCreationParams(new Uri(url))
  {
    Name = layerName,
    ColorizerDefinition = stretchColorizerDef,
    MapMemberIndex = 0
  };
  await QueuedTask.Run(() =>
  {
    // Create an image service layer using the colorizer definition created above.
    ImageServiceLayer imageServiceLayer =
LayerFactory.Instance.CreateLayer<ImageServiceLayer>(rasterLayerCreationParams, aMap);
  });

//Must be on the 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 voxelLayer = LayerFactory.Instance.CreateLayer<VoxelLayer>(createParams, map);

var sceneLayerUrl = @"https://myportal.com/server/rest/services/Hosted/SceneLayerServiceName/SceneServer";
//portal items also ok as long as the portal is the current active portal...
//var sceneLayerUrl = @"https://myportal.com/home/item.html?id=123456789abcdef1234567890abcdef0";

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, 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
  //...
});
      

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