public static IReadOnlyList<KeyValuePair<string,string>> MakeEnvironmentArray( 
   object workspace,
   object packageWorkspace,
   object scratchFolder,
   object scratchGDB,
   object scratchWorkspace,
   object outputCoordinateSystem,
   object geographicTransformations,
   object extent,
   Nullable<int> retryOnFailures,
   object parallelProcessingFactor,
   Nullable<int> recycleProcessingWorkers,
   object cellAlignment,
   object cellSize,
   object cellSizeProjectionMethod,
   object mask,
   object snapRaster,
   object configKeyword,
   Nullable<int> autoCommit,
   Nullable<bool> maintainAttachments,
   Nullable<bool> maintainSpatialIndex,
   Nullable<bool> preserveGlobalIds,
   Nullable<bool> transferGDBAttributeProperties,
   Nullable<bool> qualifiedFieldNames,
   Nullable<bool> transferDomains,
   object XYDomain,
   object XYResolution,
   object XYTolerance,
   object MDomain,
   object outputMFlag,
   Nullable<double> MTolerance,
   Nullable<double> MResolution,
   object ZDomain,
   Nullable<double> outputZValue,
   object outputZFlag,
   object ZResolution,
   object ZTolerance,
   object randomGenerator,
   object cartographicCoordinateSystem,
   Nullable<double> referenceScale,
   object cartographicPartitions,
   Nullable<int> annotationTextStringFieldLength,
   object pyramid,
   object rasterStatistics,
   object compression,
   object tileSize,
   object resamplingMethod,
   object nodata,
   Nullable<bool> terrainMemoryUsage,
   object tinSaveVersion,
   object coincidentPoints,
   object S100FeatureCatalogueFile,
   object processorType,
   Nullable<int> gpuId,
   string processingServer,
   string processingServerUser,
   object processingServerPassword,
   Nullable<bool> matchMultidimensionalVariable,
   Nullable<bool> unionDimension,
   object baDataSource,
   object baNetworkSource,
   Nullable<bool> baUseDetailedAggregation,
   Nullable<bool> maintainCurveSegments,
   Nullable<bool> overwriteoutput
)

var environment = Geoprocessing.MakeEnvironmentArray(overwriteoutput: true);

      var prj = Project.Current;
      var map = MapView.Active;

      var defaultGDB = Project.Current.DefaultGeodatabasePath;

      var featLayers = map.Map.Layers.OfType<FeatureLayer>();

      var targetLayer = featLayers.ElementAt(0);  // First layer in TOC
      var joinLayer = featLayers.ElementAt(1);    // Second layer in TOC

      var outputFeatureClass = @"C:/temp/outputFC3.shp";

      // Specify the field map in Spatial Join with target and join feature class/layers in the App
      // Run Spatial Join manually - then Copy the fieldmap string from the result in Geoprocessing history and paste it for the fieldmap parameter. 
      // in this example of fieldmap, FireStations is the name of join layer
      // FireStations layer has two numeric fileds (used in Fieldmap): TYPE and NUMBER - these two fields are used in the FiedlMap
      //
      var joinLayerName = joinLayer.Name;
      var fieldMap = "TYPE 'TYPE' true true false 4 Long 0 0,Count,#,{joinLayerName},TYPE,-1,-1;NUMBER 'NUMBER' true true false 4 Long 0 0,Max,#,{joinLayerName},NUMBER,-1,-1";

      var toolParameters = Geoprocessing.MakeValueArray(targetLayer, joinLayer, outputFeatureClass, "JOIN_ONE_TO_ONE", "KEEP_COMMON", fieldMap, "INTERSECT");

      GPExecuteToolFlags executeFlags = GPExecuteToolFlags.AddOutputsToMap | GPExecuteToolFlags.GPThread | GPExecuteToolFlags.AddToHistory | GPExecuteToolFlags.RefreshProjectItems;

      IGPResult gpResult = await Geoprocessing.ExecuteToolAsync("analysis.SpatialJoin", toolParameters, environment, null, null, executeFlags);

      Geoprocessing.ShowMessageBox(gpResult.Messages, "GP Messages", gpResult.IsFailed ? GPMessageBoxStyle.Error : GPMessageBoxStyle.Default);

// get the syntax of the tool from Python window or from tool help page
string in_features = @"C:\data\data.gdb\HighwaysWeb84";
      string out_features = @"C:\data\data.gdb\HighwaysUTM";
      var param_values = Geoprocessing.MakeValueArray(in_features, out_features);

      // crate the spatial reference object to pass as an argument to management.CopyFeatures tool
      var sp_ref = await QueuedTask.Run(() => {
          return SpatialReferenceBuilder.CreateSpatialReference(26911);    // UTM 83 11N: 26911
      });

      // set output coordinate system environment           
      var environments = Geoprocessing.MakeEnvironmentArray(outputCoordinateSystem: sp_ref);
      // set environments in the 3rd parameter
      var gp_result = await Geoprocessing.ExecuteToolAsync("management.CopyFeatures", param_values, environments, null, null, GPExecuteToolFlags.AddOutputsToMap);
      
      Geoprocessing.ShowMessageBox(gp_result.Messages, "Contents", GPMessageBoxStyle.Default, "Window Title");

      //return gp_result;

var parameters = Geoprocessing.MakeValueArray(@"C:\data\data.gdb\HighwaysUTM11", @"C:\data\data.gdb\Highways_extent");
      var ext = Geoprocessing.MakeEnvironmentArray(extent: "460532 3773964 525111 3827494");
      var gp_result = await Geoprocessing.ExecuteToolAsync("management.CopyFeatures", parameters, ext);

var environments = Geoprocessing.MakeEnvironmentArray(overwriteoutput: true);

      string toolName = "Snap_edit";  // or use edit.Snap

      // Snap tool takes multiple inputs each of which has
      // Three (3) parts: a feature class or layer, a string value and a distance
      // Each part is separated by a semicolon - you can get example of sytax from the tool documentation page
      var snapEnv = @"'C:/SnapProject/fgdb.gdb/line_1' END '2 Meters';'C:/SnapProject/fgdb.gdb/points_1' VERTEX '1 Meters';'C:/SnapProject/fgdb.gdb/otherline_1' END '20 Meters'";

      var infc = @"C:/SnapProject/fgdb.gdb/poly_1";

      var snapParams = Geoprocessing.MakeValueArray(infc, snapEnv);

      GPExecuteToolFlags tokens = GPExecuteToolFlags.RefreshProjectItems | GPExecuteToolFlags.GPThread | GPExecuteToolFlags.AddToHistory;

      IGPResult snapResult = await Geoprocessing.ExecuteToolAsync(toolName, parameters, environments, null, null, tokens);

      //return gpResult;

string tool2 = "analysis.Buffer";
List<MapPoint> list = new List<MapPoint>();
list.Add(MapPointBuilderEx.CreateMapPoint(1.0, 1.0));
list.Add(MapPointBuilderEx.CreateMapPoint(1.0, 2.0));
list.Add(MapPointBuilderEx.CreateMapPoint(2.0, 2.0));
list.Add(MapPointBuilderEx.CreateMapPoint(2.0, 1.0));

Multipoint multiPoint = MultipointBuilderEx.CreateMultipoint(list);
var spatial_ref = SpatialReferenceBuilder.CreateSpatialReference(3857);
var args3 = await QueuedTask.Run(() =>
{
    return Geoprocessing.MakeValueArray(multiPoint, "memory\\Buffers", "800 meters");
});
var env1 = Geoprocessing.MakeEnvironmentArray(outputCoordinateSystem: spatial_ref);
var messages = new List<string>(); // list to collect all output messages
var cts = new CancellationTokenSource();
await Geoprocessing.ExecuteToolAsync(tool2, args3, env1, cts.Token);
    

string openProjectPath = @"D\DATA\IGPHistoryItemTestProject\IGPHistoryItemTestProject.aprx";
await Project.OpenAsync(openProjectPath); 
MapProjectItem mapProjItem = Project.Current.GetItems<MapProjectItem>().FirstOrDefault(item => item.Name.Equals("Map", StringComparison.CurrentCultureIgnoreCase));

var map = await QueuedTask.Run(() => mapProjItem.GetMap());
var ftrLayer = map.Layers[0] as FeatureLayer;
string tool1 = "management.GetCount";     
var args1 = Geoprocessing.MakeValueArray(ftrLayer);
var env = Geoprocessing.MakeEnvironmentArray(overwriteoutput: true);          
GPExecuteToolFlags executeFlags = GPExecuteToolFlags.AddToHistory;
var t = await Geoprocessing.ExecuteToolAsync(tool1, args1,env,null,null,executeFlags);

IEnumerable<IGPHistoryItem> hisItems = Project.Current.GetProjectItemContainer(Geoprocessing.HistoryContainerKey) as IEnumerable<IGPHistoryItem>;        

String hitemID="";
String hitemToolPath="" ;
IGPResult hitemGPResult=null;
DateTime hitemTimeStamp;

foreach (var hitem in hisItems)
{
    // common IGPHistoryItem and Item properties
    hitemID = (hitem as Item).ID;
    hitemToolPath = hitem.ToolPath;
    hitemGPResult = hitem.GPResult;
    hitemTimeStamp = hitem.TimeStamp;
}