C# PackageManagement.ProgressMonitorStatusMessage类代码示例

		public void Run (ProgressMonitorStatusMessage progressMessage, IPackageAction action)
		{
			RunProgressMessage = progressMessage;
			ActionRun = action;

			RunAction (progressMessage, action);
		}

		public void Run (ProgressMonitorStatusMessage progressMessage, IEnumerable<IPackageAction> actions)
		{
			AddInstallActionsToPendingQueue (actions);
			packageManagementEvents.OnPackageOperationsStarting ();
			runCount++;
			BackgroundDispatch (() => TryRunActionsWithProgressMonitor (progressMessage, actions.ToList ()));
		}

		void RestorePackages(IProgressMonitor progressMonitor, ProgressMonitorStatusMessage progressMessage)
		{
			var commandLine = new NuGetPackageRestoreCommandLine(solution);

			progressMonitor.Log.WriteLine(commandLine.ToString());

			RestorePackages(progressMonitor, progressMessage, commandLine);
		}

		void Update (UpdateAllPackagesInSolution updateAllPackages, ProgressMonitorStatusMessage progressMessage)
		{
			try {
				List<UpdatePackageAction> updateActions = updateAllPackages.CreateActions ().ToList ();
				PackageManagementServices.BackgroundPackageActionRunner.Run (progressMessage, updateActions);
			} catch (Exception ex) {
				PackageManagementServices.BackgroundPackageActionRunner.ShowError (progressMessage, ex);
			}
		}

		public CheckForUpdatesProgressMonitor (
			IPackageManagementProgressMonitorFactory progressMonitorFactory,
			IPackageManagementEvents packageEvents)
		{
			progressMessage = ProgressMonitorStatusMessageFactory.CreateCheckingForPackageUpdatesMessage ();
			this.progressMonitor = progressMonitorFactory.CreateProgressMonitor (progressMessage.Status);

			eventMonitor = new PackageUpdatesEventMonitor (progressMonitor, packageEvents);
		}

		void CheckForPackageUpdates (IProgressMonitor progressMonitor, ProgressMonitorStatusMessage progressMessage)
		{
			updatedPackagesInSolution.CheckForUpdates ();
			if (updatedPackagesInSolution.AnyUpdates ()) {
				progressMonitor.ReportSuccess (GettextCatalog.GetString ("Package updates are available."));
			} else {
				progressMonitor.ReportSuccess (progressMessage.Success);
			}
		}

		public void Restore (ProgressMonitorStatusMessage progressMessage)
		{
			try {
				if (AnyMissingPackages ()) {
					RestoreWithProgressMonitor (progressMessage);
				}
			} catch (Exception ex) {
				LoggingService.LogInternalError (ex);
				RestoreFailed = true;
			}
		}

		public UpdatePackagesProgressMonitorStatusMessage (
			IEnumerable<IPackageManagementProject> projects,
			string packagesUpToDateMessage,
			string packagesUpToDateWarningMessage,
			ProgressMonitorStatusMessage message)
			: base (message.Status, message.Success, message.Error, message.Warning)
		{
			this.packagesUpToDateMessage = packagesUpToDateMessage;
			this.packagesUpToDateWarningMessage = packagesUpToDateWarningMessage;
			monitor = new UpdatedPackagesMonitor (projects);
		}

		void RemovePackage (PackageReferenceNode packageReferenceNode, ProgressMonitorStatusMessage progressMessage)
		{
			IPackageManagementProject project = PackageManagementServices.Solution.GetActiveProject ();
			UninstallPackageAction action = project.CreateUninstallPackageAction ();
			action.Package = project.FindPackage (packageReferenceNode.Id);

			if (action.Package != null) {
				PackageManagementServices.BackgroundPackageActionRunner.Run (progressMessage, action);
			} else {
				ShowMissingPackageError (progressMessage, packageReferenceNode);
			}
		}

		public void Run (PackageReferenceNode packageReferenceNode, ProgressMonitorStatusMessage progressMessage)
		{
			try {
				IPackageManagementProject project = solution.GetActiveProject ();
				ReinstallPackageAction action = project.CreateReinstallPackageAction ();
				action.PackageId = packageReferenceNode.Id;
				action.PackageVersion = packageReferenceNode.Version;

				runner.Run (progressMessage, action);
			} catch (Exception ex) {
				runner.ShowError (progressMessage, ex);
			}
		}

		void RunInternal (IProgressMonitor progressMonitor, ProgressMonitorStatusMessage progressMessage)
		{
			var commandLine = new MonoPclCommandLine () {
				List = true
			};
			commandLine.BuildCommandLine ();

			progressMonitor.ShowPackageConsole ();
			progressMonitor.Log.WriteLine (commandLine.ToString ());
			progressMonitor.Log.WriteLine ();

			RunMonoPcl (progressMonitor, progressMessage, commandLine);
		}

		void CheckForPackageUpdates (
			ProgressMonitor progressMonitor,
			ProgressMonitorStatusMessage progressMessage,
			PackageUpdatesEventMonitor eventMonitor)
		{
			updatedPackagesInSolution.CheckForUpdates ();
			if (updatedPackagesInSolution.AnyUpdates ()) {
				progressMonitor.ReportSuccess (GettextCatalog.GetString ("Package updates are available."));
			} else if (eventMonitor.WarningReported) {
				progressMonitor.ReportWarning (progressMessage.Warning);
			} else {
				progressMonitor.ReportSuccess (progressMessage.Success);
			}
		}

		public void Run (ProgressMonitorStatusMessage progressMessage)
		{
			IProgressMonitor progressMonitor = CreateProgressMonitor (progressMessage);

			try {
				RestorePackages(progressMonitor, progressMessage);
			} catch (Exception ex) {
				LoggingService.LogInternalError (ex);
				progressMonitor.Log.WriteLine(ex.Message);
				progressMonitor.ReportError (progressMessage.Error, null);
				progressMonitor.ShowPackageConsole ();
				progressMonitor.Dispose();
				RestoreFailed = true;
			}
		}

		public void Run (PackageReferenceNode packageReferenceNode, ProgressMonitorStatusMessage progressMessage)
		{
			try {
				var solutionManager = PackageManagementServices.Workspace.GetSolutionManager (packageReferenceNode.Project.ParentSolution);

				var action = new ReinstallNuGetPackageAction (
					packageReferenceNode.Project,
					solutionManager);
				action.PackageId = packageReferenceNode.Id;
				action.Version = packageReferenceNode.Version;

				runner.Run (progressMessage, action);
			} catch (Exception ex) {
				runner.ShowError (progressMessage, ex);
			}
		}

		public void Run (ProgressMonitorStatusMessage progressMessage)
		{
			using (ProgressMonitor progressMonitor = CreateProgressMonitor (progressMessage)) {
				using (PackageManagementEventsMonitor eventMonitor = CreateEventMonitor (progressMonitor)) {
					try {
						RestorePackages (progressMonitor, progressMessage);
					} catch (Exception ex) {
						LoggingService.LogError (progressMessage.Error, ex);
						progressMonitor.Log.WriteLine (ex.Message);
						progressMonitor.ReportError (progressMessage.Error, null);
						progressMonitor.ShowPackageConsole ();
						progressMonitor.Dispose ();
						RestoreFailed = true;
					}
				}
			}
		}