static void GenerateInternal (ProgressMonitor monitor, ProjectFile file, SingleFileCustomToolResult result)
		{
			if (file.Project.SupportedLanguages.All (l => l != "C#")) {
				string msg = GettextCatalog.GetString ("Razor templates are only supported in C# projects");
				result.Errors.Add (new CompilerError (file.Name, -1, -1, null, msg));
				monitor.Log.WriteLine (msg);
				return;
			}

			var host = new PreprocessedRazorHost (file.FilePath);

			var defaultOutputName = file.FilePath.ChangeExtension (".cs");

			var ns = CustomToolService.GetFileNamespace (file, defaultOutputName);
			host.DefaultNamespace = ns;

			CompilerErrorCollection errors;
			var code = host.GenerateCode (out errors);
			result.Errors.AddRange (errors);

			var writer = new MonoDevelop.DesignerSupport.CodeBehindWriter ();
			writer.WriteFile (defaultOutputName, code);
			writer.WriteOpenFiles ();

			result.GeneratedFilePath = defaultOutputName;

			foreach (var err in result.Errors) {
				monitor.Log.WriteLine (err);
			}
		}

		protected override PackageManagementEventsMonitor CreateEventMonitor (
			ProgressMonitor monitor,
			IPackageManagementEvents packageManagementEvents)
		{
			EventsMonitor = new TestablePackageManagementEventsMonitor (monitor, packageManagementEvents);
			return EventsMonitor;
		}

		public async Task<BuildResult> Build (ProgressMonitor monitor, ConfigurationSelector configuration, bool buildReferencedTargets = false, OperationContext operationContext = null)
		{
			var res = new BuildResult { BuildCount = 0 };
			foreach (var bt in Items.OfType<IBuildTarget> ())
				res.Append (await bt.Build (monitor, configuration, operationContext:operationContext));
			return res;
		}

    protected override Task OnExecute(ProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration)
    {
      if (base.OnGetCanExecute(context, configuration))
      {
        return base.OnExecute(monitor, context, configuration);
      }

      try
      {
        var project = Project as DotNetProject;
        if (project != null && IsSupportedProject)
        {
          const string SoftDebuggerName = RhinoSoftDebuggerEngine.DebuggerName;
          var config = project.GetConfiguration(configuration) as DotNetProjectConfiguration;
          var cmd = new RhinoCommonExecutionCommand(project.GetOutputFileName(configuration), project);
          cmd.Arguments = config.CommandLineParameters;
          cmd.WorkingDirectory = Path.GetDirectoryName(config.CompiledOutputName);
          cmd.EnvironmentVariables = config.GetParsedEnvironmentVariables();
          cmd.TargetRuntime = project.TargetRuntime;
          cmd.UserAssemblyPaths = project.GetUserAssemblyPaths(configuration);

          var executionModes = Runtime.ProcessService.GetExecutionModes();
          var executionMode = executionModes.SelectMany(r => r.ExecutionModes).FirstOrDefault(r => r.Id == SoftDebuggerName);
          var console = context.ConsoleFactory.CreateConsole(new OperationConsoleFactory.CreateConsoleOptions(true));
          var operation = executionMode.ExecutionHandler.Execute(cmd, console);
          monitor.CancellationToken.Register(() => operation.Cancel());
          return operation.Task;
        }
      }
      catch (Exception ex)
      {
        monitor.ReportError($"An error occurred starting Rhino.\n{ex}", ex);
      }
      return null;
    }

		public TestablePackageManagementEventsMonitor (
			ProgressMonitor progressMonitor,
			IPackageManagementEvents packageManagementEvents,
			IProgressProvider progressProvider)
			: base (progressMonitor, packageManagementEvents, progressProvider)
		{
		}

		public void Start() {
			tracker = CreateProgressMonitor ();
			tracker.BeginTask(GetDescription(), 1);

			// Sync invoke background worker which will end up doing async invoke on the internal run.
			BackgroundWorker ();
		}

		internal protected virtual Task Execute (ProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration, SolutionRunConfiguration runConfiguration)
		{
			context.RunConfiguration = runConfiguration;
#pragma warning disable 618 // Type or member is obsolete
			return Execute (monitor, context, configuration);
#pragma warning restore 618 // Type or member is obsolete
		}

		public virtual bool BuildPackage (ProgressMonitor monitor, PackageBuilder builder)
		{
			if (Next != null)
				return Next.BuildPackage (monitor, builder);
			else
				return builder.Build (monitor);
		}

		internal protected override void OnWriteProject (ProgressMonitor monitor, MSBuildProject project)
		{
			base.OnWriteProject (monitor, project);

			HashSet<string> validProjitems = new HashSet<string> ();
			foreach (var r in Project.References.Where (rp => rp.ReferenceType == ReferenceType.Project)) {
				var ip = r.GetItemsProjectPath ();
				if (!string.IsNullOrEmpty (ip)) {
					ip = MSBuildProjectService.ToMSBuildPath (Project.ItemDirectory, ip);
					validProjitems.Add (ip);
					if (!project.Imports.Any (im => im.Project == ip)) {
						// If there is already a Shared import, place the new import in the same location
						MSBuildObject before = project.Imports.FirstOrDefault (i => i.Label == "Shared" && i.Project.EndsWith (".projitems"));
						if (before == null) {
							var fsharpProject = project.ProjectTypeGuids.Contains("{F2A71F9B-5D33-465A-A702-920D77279786}");
							if (fsharpProject)
								//For F# use the first item group as the shared project files have to be listed first
								before = project.ItemGroups.FirstOrDefault (i => i.Label != "Shared");
							else
								before = project.Imports.FirstOrDefault (i => i.Label != "Shared");
						}
						
						var im = project.AddNewImport (ip, beforeObject: before);
						im.Label = "Shared";
						im.Condition = "Exists('" + ip + "')";
					}
				}
			}
			foreach (var im in project.Imports.ToArray ()) {
				if (im.Label == "Shared" && im.Project.EndsWith (".projitems") && !(validProjitems.Contains (im.Project)))
					project.RemoveImport (im.Project);
			}
		}

		protected async override Task<BuildResult> OnBuild (ProgressMonitor monitor, ConfigurationSelector configuration, OperationContext operationContext)
		{
			foreach (Package p in packages)
				if (!await p.Build (monitor))
					break;
			return BuildResult.CreateSuccess ();
		}

		protected override Task<BuildResult> OnBuild (ProgressMonitor monitor, ConfigurationSelector configuration, OperationContext operationContext)
		{
			Task restoreTask = PackageRestoreTask;
			if (restoreTask != null) {
				return WaitForRestoreThenBuild (restoreTask, monitor, configuration, operationContext);
			}
			return base.OnBuild (monitor, configuration, operationContext);
		}

		public ProgressMonitorWrapperJob (IAnalysisJob wrappedJob, string message)
		{
			this.wrappedJob = wrappedJob;
			monitor = IdeApp.Workbench.ProgressMonitors.GetStatusProgressMonitor (message, null, false);
			var work = wrappedJob.GetFiles ().Sum (f => wrappedJob.GetIssueProviders (f).Count ());
			
			monitor.BeginTask (message, work);
		}

		public void Install (ProgressMonitor monitor, SolutionFolderItem entry, string appName, string prefix, ConfigurationSelector configuration)
		{
			this.appName = appName;
			
			using (DeployContext ctx = new DeployContext (this, DeployService.CurrentPlatform, prefix)) {
				InstallEntry (monitor, ctx, entry, configuration);
			}
		}

		public override Task<WorkspaceItem> LoadWorkspaceItem (ProgressMonitor monitor, string fileName)
		{
			return Task.Run (async () => {
				var workspaceItem = ReadWorkspaceItemFile (fileName, monitor);
				await workspaceItem.LoadUserProperties ();
				return workspaceItem;
			});
		}

		/// <summary>
		/// If the project is a NuGet packaging project then just use the normal build target.
		/// This ensures that the dependent projects are built.
		/// 
		/// Otherwise the Pack target is called.
		/// </summary>
		public async Task<BuildResult> Build (ProgressMonitor monitor, ConfigurationSelector configuration, bool buildReferencedTargets = false, OperationContext operationContext = null)
		{
			if (project is PackagingProject) {
				return await project.Build (monitor, configuration, buildReferencedTargets, new TargetEvaluationContext (operationContext));
			} else {
				return await Pack (monitor, configuration, buildReferencedTargets, operationContext);
			}
		}

		public BuildEventArgs (ProgressMonitor monitor, bool success)
		{
			this.monitor = monitor;
			this.success = success;
			this.WarningCount = -1;
			this.ErrorCount = -1;
			this.BuildCount = -1;
			this.FailedBuildCount = -1;
		}

		protected override Task<TargetEvaluationResult> OnRunTarget(ProgressMonitor monitor, string target, ConfigurationSelector configuration, TargetEvaluationContext context)
		{
			if (Commands.SelectActiveCompilerHandler.IsRoslynCompilerSet) {
				context.GlobalProperties.SetValue("CscToolExe", "csc.exe");
				context.GlobalProperties.SetValue("CscToolPath", Path.Combine(Path.GetDirectoryName(typeof(ProjectExtension).Assembly.Location), "RoslynCompilerFiles"));
				context.GlobalProperties.SetValue("DebugType", "portable");
			}
			return base.OnRunTarget(monitor, target, configuration, context);
		}

		public Task Generate (ProgressMonitor monitor, ProjectFile file, SingleFileCustomToolResult result)
		{
			return Task.Run (delegate {
				try {
					GenerateInternal (monitor, file, result);
				} catch (Exception ex) {
					result.UnhandledException = ex;
				}
			});
		}

		public async Task Generate (ProgressMonitor monitor, ProjectFile file, SingleFileCustomToolResult result)
		{
			var buildResult = await file.Project.PerformGeneratorAsync (monitor, IdeApp.Workspace.ActiveConfiguration, this.targetName);

			foreach (var err in buildResult.BuildResult.Errors) {
				result.Errors.Add (new CompilerError (err.FileName, err.Line, err.Column, err.ErrorNumber, err.ErrorText) {
					IsWarning = err.IsWarning
				});
			}
		}

		public override Task<SolutionItem> LoadSolutionItem (ProgressMonitor monitor, SolutionLoadContext ctx, string fileName, MSBuildFileFormat expectedFormat, string typeGuid, string itemGuid)
		{
			return Task.Run (() => {
				foreach (var f in MSBuildFileFormat.GetSupportedFormats ()) {
					if (f.CanReadFile (fileName, typeof(SolutionItem)))
						return MSBuildProjectService.LoadItem (monitor, fileName, f, typeGuid, itemGuid, ctx);
				}
				throw new NotSupportedException ();
			});
		}