C# IProgressMonitor.EndTask方法代码示例

        /// <summary>
        ///   Builds the specified solution item.
        /// </summary>
        /// <param name = "monitor">The monitor.</param>
        /// <param name = "item">The item.</param>
        /// <param name = "configuration">The configuration.</param>
        /// <returns>The build result.</returns>
        protected override BuildResult Build(IProgressMonitor monitor, SolutionEntityItem item, ConfigurationSelector configuration)
        {
            BuildResult result = new BuildResult ();

            // Pre-build
            monitor.BeginTask (GettextCatalog.GetString ("Pre-Building..."), 1);
            this.PreBuild (result, monitor, item, configuration);
            monitor.EndTask();
            if (result.ErrorCount > 0) {
                return result;
            }

            // Build
            monitor.BeginTask (GettextCatalog.GetString ("Building"), 1);
            result.Append (base.Build (monitor, item, configuration));
            monitor.EndTask();
            if (result.ErrorCount > 0) {
                return result;
            }

            // Post-build
            monitor.BeginTask (GettextCatalog.GetString ("Post-Building..."), 1);
            this.PostBuild (result, monitor, item, configuration);
            monitor.EndTask();

            return result;
        }

 public List<WorkItem> LoadByWorkItem(IProgressMonitor progress)
 {
     var ids = this.clientService.GetWorkItemIds(this.query, CachedMetaData.Instance.Fields);
     var list = new List<WorkItem>();
     progress.BeginTask("Loading WorkItems", ids.Count);
     foreach (var id in ids)
     {
         list.Add(clientService.GetWorkItem(id));
         progress.Step(1);
     }
     progress.EndTask();
     return list;
 }

        public static void Archive(IProgressMonitor monitor, BuildResult result, MonobjcProject project, ConfigurationSelector configuration, String outputDirectory)
        {
            monitor.BeginTask(GettextCatalog.GetString("Archiving..."), 0);

            // Infer application name from configuration
            String applicationName = project.GetApplicationName(configuration);

            // Create the bundle maker
            BundleMaker maker = new BundleMaker(applicationName, outputDirectory);

            // Archive the application
            BuildHelper.ArchiveBundle(monitor, project, maker);

            monitor.EndTask();
        }

 public List<WorkItem> LoadByPage(IProgressMonitor progress)
 {
     var ids = this.clientService.GetWorkItemIds(this.query, CachedMetaData.Instance.Fields);
     int pages = (int)Math.Ceiling((double)ids.Count / (double)50);
     var result = new List<WorkItem>();
     progress.BeginTask("Loading WorkItems", pages);
     for (int i = 0; i < pages; i++)
     {
         var idList = new List<int>(ids.Skip(i * 50).Take(50));
         var items = this.clientService.PageWorkitemsByIds(this.query, idList);
         result.AddRange(items);
         progress.Step(1);
     }
     progress.EndTask();
     return result;
 }

        /// <summary>
        ///   Archive the application bundle.
        /// </summary>
        /// <param name = 'monitor'>The progress monitor.</param>
        /// <param name = 'project'>The project.</param>
        /// <param name = 'maker'>The bundle maker.</param>
        public static void ArchiveBundle(IProgressMonitor monitor, MonobjcProject project, BundleMaker maker)
        {
            if (project.Archive && project.ArchiveIdentity != null) {
                FilePath definitionFile = project.BaseDirectory.Combine ("Definition.plist");
                String definitionFilename = File.Exists (definitionFile) ? definitionFile.ToString () : null;
                monitor.BeginTask (GettextCatalog.GetString ("Signing archive..."), 0);

                using (StringWriter outputWriter = new StringWriter()) {
                    using (StringWriter errorWriter = new StringWriter()) {
                        ProductBuild.ArchiveApplication (maker.ApplicationDirectory, project.ArchiveIdentity, definitionFilename, outputWriter, errorWriter);
                        LoggingService.LogInfo ("ProductBuild returns: " + outputWriter.ToString ());
                    }
                }

                monitor.EndTask ();
            }
        }

		protected override BuildResult Build (IProgressMonitor monitor, SolutionEntityItem project, ConfigurationSelector configuration)
		{
			var aspProject = project as AspNetAppProject;
			
			//get the config object and validate
			AspNetAppProjectConfiguration config = (AspNetAppProjectConfiguration)aspProject.GetConfiguration (configuration);
			if (config == null || config.DisableCodeBehindGeneration) {
				return base.Build (monitor, project, configuration);
			}
			
			var writer = CodeBehindWriter.CreateForProject (monitor, aspProject);
			if (!writer.SupportsPartialTypes) {
				return base.Build (monitor, project, configuration);
			}

			var result = new BuildResult ();

			monitor.BeginTask ("Updating CodeBehind designer files", 0);

			foreach (var file in aspProject.Files) {
				ProjectFile designerFile = CodeBehind.GetDesignerFile (file);
				if (designerFile == null)
					continue;

				if (File.GetLastWriteTimeUtc (designerFile.FilePath) > File.GetLastWriteTimeUtc (file.FilePath))
					continue;

				monitor.Log.WriteLine ("Updating CodeBehind for file '{0}'", file);
				result.Append (CodeBehind.UpdateDesignerFile (writer, aspProject, file, designerFile));
			}
			
			writer.WriteOpenFiles ();

			monitor.EndTask ();

			if (writer.WrittenCount > 0)
				monitor.Log.WriteLine ("{0} CodeBehind designer classes updated.", writer.WrittenCount);
			else
				monitor.Log.WriteLine ("No changes made to CodeBehind classes.");
			
			if (result.Failed)
				return result;

			return result.Append (base.Build (monitor, project, configuration));
		}

 public IEnumerable<Tuple<ProjectDom, FilePath>> GetFileNames(Solution solution, ProjectDom dom, ICompilationUnit unit, IProgressMonitor monitor)
 {
     int counter = 0;
     ReadOnlyCollection<Project> allProjects = solution.GetAllProjects();
     if (monitor != null)
         monitor.BeginTask(GettextCatalog.GetString("Finding references in solution..."),
       			allProjects.Sum<Project>(p => p.Files.Count));
         foreach (Project project in allProjects) {
             if (monitor != null && monitor.IsCancelRequested) yield break;
             ProjectDom currentDom = ProjectDomService.GetProjectDom(project);
             foreach (ProjectFile projectFile in (Collection<ProjectFile>) project.Files) {
                 if (monitor != null && monitor.IsCancelRequested) yield break;
                 yield return Tuple.Create<ProjectDom, FilePath>(currentDom, projectFile.FilePath);
                 if (monitor != null) {
                     if (counter % 10 == 0) monitor.Step(10);
                     ++counter;
                 }
             }
         }
       if (monitor != null) monitor.EndTask();
 }

		void InstallEntry (IProgressMonitor monitor, DeployContext ctx, SolutionItem entry, ConfigurationSelector configuration)
		{
			foreach (DeployFile df in DeployService.GetDeployFiles (ctx, new SolutionItem[] { entry }, configuration)) {
				string targetPath = df.ResolvedTargetFile;
				if (targetPath == null) {
					monitor.ReportWarning ("Could not copy file '" + df.RelativeTargetPath + "': Unknown target directory.");
					continue;
				}
				
				CopyFile (monitor, df.SourcePath, df.ResolvedTargetFile, df.FileAttributes);
			}
			
			SolutionFolder c = entry as SolutionFolder;
			if (c != null) {
				monitor.BeginTask ("Installing solution '" + c.Name + "'", c.Items.Count);
				foreach (SolutionItem ce in c.Items) {
					InstallEntry (monitor, ctx, ce, configuration);
					monitor.Step (1);
				}
				monitor.EndTask ();
			}
		}

		protected override SolutionEntityItem LoadSolutionItem (IProgressMonitor monitor, string fileName)
		{
			SolutionEntityItem entry = base.LoadSolutionItem (monitor, fileName);
			if (entry == null)
				return null;
			
			Project project = entry as Project;
			if (project == null)
				return entry;

			//Project
			MakefileData data = entry.ExtendedProperties ["MonoDevelop.Autotools.MakefileInfo"] as MakefileData;
			if (data == null)
				return entry;

			monitor.BeginTask (GettextCatalog.GetString ("Updating project from Makefile"), 1);
			try { 
				data.OwnerProject = project;
				if (data.SupportsIntegration)
					data.UpdateProject (monitor, false);
				monitor.Step (1);
			} catch (Exception e) {
				monitor.ReportError (GettextCatalog.GetString (
					"Error loading Makefile for project {0}", project.Name), e);
			} finally {
				monitor.EndTask ();
			}

			entry.SetNeedsBuilding (false);
			return entry;
		}

		protected override void Clean (IProgressMonitor monitor, SolutionEntityItem entry, ConfigurationSelector configuration)
		{
			Project proj = entry as Project;
			if (proj == null) {
				base.Clean (monitor, entry, configuration);
				return;
			}

			MakefileData data = proj.ExtendedProperties ["MonoDevelop.Autotools.MakefileInfo"] as MakefileData;
			if (data == null || !data.SupportsIntegration || String.IsNullOrEmpty (data.CleanTargetName)) {
				base.Clean (monitor, entry, configuration); 
				return;
			}

			monitor.BeginTask (GettextCatalog.GetString ("Cleaning project"), 1);
			try {
				string baseDir = proj.BaseDirectory;
	
				ProcessWrapper process = Runtime.ProcessService.StartProcess (data.AbsoluteMakeCommand, 
						data.CleanTargetName, 
						baseDir, 
						monitor.Log, 
						monitor.Log, 
						null);
				process.WaitForOutput ();

				if (process.ExitCode > 0)
					throw new Exception ( GettextCatalog.GetString ("An unspecified error occurred while running '{0} {1}'", data.AbsoluteMakeCommand, data.CleanTargetName) );

				monitor.Step (1);
			} catch (Exception e) {
				monitor.ReportError (GettextCatalog.GetString ("Project could not be cleaned: "), e);
				return;
			} finally {
				monitor.EndTask ();
			}
			monitor.ReportSuccess (GettextCatalog.GetString ("Project successfully cleaned"));
		}

 /// <summary>
 ///   Compiles the XIB files.
 /// </summary>
 /// <param name = 'monitor'>The progress monitor.</param>
 /// <param name = 'project'>The project.</param>
 /// <param name = 'maker'>The bundle maker.</param>
 /// <param name = 'result'>The build result.</param>
 public static void CompileXIBFiles(IProgressMonitor monitor, MonobjcProject project, BundleMaker maker, BuildResult result)
 {
     XibCompiler xibCompiler = new XibCompiler ();
     IEnumerable<FilePair> files = project.GetIBFiles (Constants.InterfaceDefinition, maker.ResourcesFolder);
     if (files == null || files.Count() == 0) {
         return;
     }
     List<FilePair> pairs = new List<FilePair> (files);
     monitor.BeginTask (GettextCatalog.GetString ("Compiling XIB files..."), files.Count ());
     foreach (FilePair pair in pairs) {
         monitor.Log.WriteLine (GettextCatalog.GetString ("Compiling {0}", pair.Source.ToRelative (project.BaseDirectory)));
         xibCompiler.Logger = new BuildLogger (pair.Source, monitor, result);
         xibCompiler.Compile (pair.Source, pair.DestinationDir);
         monitor.Step (1);
     }
     monitor.EndTask ();
 }

        /// <summary>
        ///   Sign the application bundle.
        /// </summary>
        /// <param name = 'monitor'>The progress monitor.</param>
        /// <param name = 'project'>The project.</param>
        /// <param name = 'maker'>The bundle maker.</param>
        public static void SignBundle(IProgressMonitor monitor, MonobjcProject project, BundleMaker maker)
        {
            if (project.Signing && !String.IsNullOrEmpty(project.SigningIdentity)) {
                monitor.BeginTask (GettextCatalog.GetString ("Signing bundle..."), 0);

                using (StringWriter outputWriter = new StringWriter()) {
                    using (StringWriter errorWriter = new StringWriter()) {
                        FilePath file = project.BaseDirectory.Combine(Constants.APP_ENTITLEMENTS);
                        if (project.UseEntitlements && File.Exists(file)) {
                            monitor.Log.WriteLine (GettextCatalog.GetString ("Signing with identity '{0}' and entitlements '{1}'", project.SigningIdentity, file.FileName));
                            CodeSign.PerformSigning (maker.ApplicationDirectory, project.SigningIdentity, file, outputWriter, errorWriter);
                        } else {
                            monitor.Log.WriteLine (GettextCatalog.GetString ("Signing with identity='{0}'", project.SigningIdentity));
                            CodeSign.PerformSigning (maker.ApplicationDirectory, project.SigningIdentity, outputWriter, errorWriter);
                        }
                        LoggingService.LogInfo ("CodeSign returns: " + outputWriter.ToString ());
                    }
                }

                monitor.EndTask ();
            }
        }

        /// <summary>
        ///   Embeds the XIB files.
        /// </summary>
        /// <param name = 'monitor'>The progress monitor.</param>
        /// <param name = 'project'>The project.</param>
        /// <param name = 'maker'>The bundle maker.</param>
        /// <param name = 'result'>The build result.</param>
        public static void EmbedXIBFiles(IProgressMonitor monitor, MonobjcProject project, BuildResult result)
        {
            XibCompiler xibCompiler = new XibCompiler ();
            IEnumerable<FilePair> files = project.GetIBFiles (Constants.EmbeddedInterfaceDefinition, null);
            if (files == null || files.Count() == 0) {
                return;
            }

            monitor.BeginTask (GettextCatalog.GetString ("Embed XIB files..."), files.Count ());
            foreach (FilePair pair in files) {
                // If the destination file is a place-holder, change its dates
                FileInfo sourceInfo = new FileInfo (pair.Source);
                FileInfo destInfo = new FileInfo (pair.Destination);
                if (destInfo.Length == 0) {
                    DateTime dateTime = sourceInfo.CreationTime.Subtract (new TimeSpan (0, 0, 1));
                    File.SetCreationTime (pair.Destination, dateTime);
                    File.SetLastAccessTime (pair.Destination, dateTime);
                    File.SetLastWriteTime (pair.Destination, dateTime);
                }

                FilePath relativeFile = pair.Source.ToRelative (project.BaseDirectory);
                monitor.Log.WriteLine (GettextCatalog.GetString ("Compiling {0}", relativeFile));
                xibCompiler.Logger = new BuildLogger (pair.Source, monitor, result);
                xibCompiler.Compile (pair.Source, pair.DestinationDir);

                monitor.Step (1);
            }
            monitor.EndTask ();
        }

		public override void Update (FilePath[] localPaths, bool recurse, IProgressMonitor monitor)
		{
			IEnumerable<DiffEntry> statusList = null;
			
			monitor.BeginTask (GettextCatalog.GetString ("Updating"), 5);
			
			// Fetch remote commits
			string remote = GetCurrentRemote ();
			if (remote == null)
				throw new InvalidOperationException ("No remotes defined");
			monitor.Log.WriteLine (GettextCatalog.GetString ("Fetching from '{0}'", remote));
			RemoteConfig remoteConfig = new RemoteConfig (RootRepository.GetConfig (), remote);
			Transport tn = Transport.Open (RootRepository, remoteConfig);
			using (var gm = new GitMonitor (monitor))
				tn.Fetch (gm, null);
			monitor.Step (1);
			
			string upstreamRef = GitUtil.GetUpstreamSource (RootRepository, GetCurrentBranch ());
			if (upstreamRef == null)
				upstreamRef = GetCurrentRemote () + "/" + GetCurrentBranch ();
			
			if (GitService.UseRebaseOptionWhenPulling)
				Rebase (upstreamRef, GitService.StashUnstashWhenUpdating, monitor);
			else
				Merge (upstreamRef, GitService.StashUnstashWhenUpdating, monitor);

			monitor.Step (1);
			
			// Notify changes
			if (statusList != null)
				NotifyFileChanges (monitor, statusList);
			
			monitor.EndTask ();
		}

		public override void MoveDirectory (FilePath localSrcPath, FilePath localDestPath, bool force, IProgressMonitor monitor)
		{
			VersionInfo[] versionedFiles = GetDirectoryVersionInfo (localSrcPath, false, true);
			base.MoveDirectory (localSrcPath, localDestPath, force, monitor);
			monitor.BeginTask ("Moving files", versionedFiles.Length);
			foreach (VersionInfo vif in versionedFiles) {
				if (vif.IsDirectory)
					continue;
				FilePath newDestPath = vif.LocalPath.ToRelative (localSrcPath).ToAbsolute (localDestPath);
				Add (newDestPath, false, monitor);
				monitor.Step (1);
			}
			monitor.EndTask ();
		}