C# ProcessArgumentBuilder.AddArgument方法代码示例

        public static ProcessResult RunSvnProcess(SvnOptions svnLoginOptions, ProcessArgumentBuilder argBuilder)
        {
            argBuilder.AddArgument("--non-interactive");
            argBuilder.AddArgument("--no-auth-cache");

            ProcessInfo info = new ProcessInfo("svn.exe", argBuilder.ToString());

            ProcessExecutor executor = new ProcessExecutor();
            ProcessResult result = executor.Execute(info);
            return result;
        }

        public override string ToString()
        {
            ProcessArgumentBuilder argsBuilder = new ProcessArgumentBuilder();
            argsBuilder.AddArgument("/xml", "=", outputfile);
            argsBuilder.AddArgument("/nologo");

            foreach (string assemblyName in assemblies)
            {
                argsBuilder.AddArgument(assemblyName);
            }
            return argsBuilder.ToString();
        }

 /// <summary>
 /// Appends the categories, with value not an empty string nor a whitespace,
 /// to the excluded or included categories lists.
 /// </summary>
 /// <param name="argsBuilder">The args builder.</param>
 private void AppendCategoriesArg(ProcessArgumentBuilder argsBuilder)
 {
     if (ExcludedCategories != null && ExcludedCategories.Length != 0)
     {
         string[] excludedCategories = System.Array.FindAll(ExcludedCategories, IsNotWhitespace);
         argsBuilder.AddArgument("/exclude", "=", string.Join(",", excludedCategories));
     }
     if (IncludedCategories != null && IncludedCategories.Length != 0)
     {
         string[] includedCategories = System.Array.FindAll(IncludedCategories, IsNotWhitespace);
         argsBuilder.AddArgument("/include", "=", string.Join(",", includedCategories));
     }
 }

        private string Args(IIntegrationResult result)
        {
            ProcessArgumentBuilder builder = new ProcessArgumentBuilder();

            builder.AddArgument("/nologo");
            if (! StringUtil.IsBlank(Targets)) builder.AddArgument("/t:" + Targets);
            builder.AddArgument(GetPropertyArgs(result));
            builder.AppendArgument(BuildArgs);
            builder.AddArgument(ProjectFile);
            builder.AddArgument(GetLoggerArgs(result));

            return builder.ToString();
        }

        public static int GetSvnRevision(SvnOptions svnOptions)
        {
            ProcessArgumentBuilder argBuilder = new ProcessArgumentBuilder();
            argBuilder.AppendArgument("log");
            argBuilder.AppendArgument("--xml");
            argBuilder.AppendArgument("--limit 1");
            argBuilder.AddArgument(StringHelper.Quote(svnOptions.Url));
            ProcessResult result = RunSvnProcess(svnOptions, argBuilder);

            XmlDocument xml = new XmlDocument();
            xml.LoadXml(result.StandardOutput);

            XmlNode node = xml.SelectSingleNode("/log/logentry/@revision");
            return Convert.ToInt32(node.InnerText);
        }

 //MEMBER_INFO_TEMPLATE = "memberinfo -S {SandboxRoot\SandboxFile} --user={user} --password={password} {member}"
 private string BuildMemberInfoCommandXml(Modification modification)
 {
     ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
     buffer.AppendArgument("memberinfo --xmlapi");
     AppendCommonArguments(buffer, false, true);
     string modificationPath = (modification.FolderName == null) ? SandboxRoot : Path.Combine(SandboxRoot, modification.FolderName);
     buffer.AddArgument(Path.Combine(modificationPath, modification.FileName));
     return buffer.ToString();
 }

        /// <summary>
        /// Updates and fetches git submodules.
        /// </summary>
        /// <param name="result"></param>
        private void GitUpdateSubmodules(IIntegrationResult result)
        {
            ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
            buffer.AddArgument("submodule");
            buffer.AddArgument("update");

            // initialize progress information
            var bpi = GetBuildProgressInformation(result);
            bpi.SignalStartRunTask(string.Concat("git ", buffer.ToString()));

            // enable Stdout monitoring
            ProcessExecutor.ProcessOutput += ProcessExecutor_ProcessOutput;

            Execute(NewProcessInfo(buffer.ToString(), result));

            // remove Stdout monitoring
            ProcessExecutor.ProcessOutput -= ProcessExecutor_ProcessOutput;
        }

		/// <summary>
		/// Push a specific tag with "git push origin tag 'tag name'".
		/// </summary>
		/// <param name="tagName">Naem of the tag to push.</param>
		/// <param name="result">IIntegrationResult of the current build.</param>
		private void GitPushTag(string tagName, IIntegrationResult result)
		{
			ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
			buffer.AddArgument("push");
			buffer.AddArgument("origin");
			buffer.AddArgument("tag");
			buffer.AddArgument(tagName);

			// initialize progress information
			var bpi = GetBuildProgressInformation(result);
			bpi.SignalStartRunTask(string.Concat("git ", buffer.ToString()));

			// enable Stdout monitoring
			ProcessExecutor.ProcessOutput += ProcessExecutor_ProcessOutput;

			Execute(NewProcessInfo(buffer.ToString(), result));

			// remove Stdout monitoring
			ProcessExecutor.ProcessOutput -= ProcessExecutor_ProcessOutput;
		}

		/// <summary>
		/// Add all modified and all untracked files that are not ignored by .gitignore
		/// to the git index with the "git add --all" command.
		/// </summary>
		/// <param name="result">IIntegrationResult of the current build.</param>
		private void GitAddAll(IIntegrationResult result)
		{
			ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
			buffer.AddArgument("add");
			buffer.AddArgument("--all");
			Execute(NewProcessInfo(buffer.ToString(), result));
		}

		/// <summary>
		/// Clean the working tree with "git clean -d -f -x".
		/// </summary>
		/// <param name="result">IIntegrationResult of the current build.</param>
		private void GitClean(IIntegrationResult result)
		{
			ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
			buffer.AddArgument("clean");
			buffer.AddArgument("-d");
			buffer.AddArgument("-f");
			buffer.AddArgument("-x");
			Execute(NewProcessInfo(buffer.ToString(), result));
		}

		/// <summary>
		/// Call "git config --get 'name'" to get the value of a local repository property.
        /// The command returns error code 1 if the key was not found and error code 2 if multiple key values were found. 
		/// </summary>
		/// <param name="name">Name of the config parameter.</param>
		/// <param name="result">IIntegrationResult of the current build.</param>
		/// <returns>Result of the "git config --get 'name'" command.</returns>
        private string GitConfigGet(string name, IIntegrationResult result)
		{
		    ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
		    buffer.AddArgument("config");
		    buffer.AddArgument("--get");
		    buffer.AddArgument(name);
		    return
		        Execute(NewProcessInfo(buffer.ToString(), result, ProcessPriorityClass.Normal, new int[] {0, 1, 2})).
		            StandardOutput.Trim();
		}

        private ProcessInfo NewCheckoutProcessInfo(IIntegrationResult result)
        {
            // CCNET-1796: work around a CVS limitation: the -d parameter only accepts limited relative paths
            // so the working directory is one level up of the checkout dir and
            // override checkout directory
            var wd = result.BaseFromWorkingDirectory(WorkingDirectory);
            var lastDirectorySeparatorIndex = wd.TrimEnd().TrimEnd(Path.DirectorySeparatorChar).LastIndexOf(Path.DirectorySeparatorChar);
            var checkoutWd = wd.Substring(0, lastDirectorySeparatorIndex);
            var checkoutDir = wd.Substring(lastDirectorySeparatorIndex).Trim(Path.DirectorySeparatorChar);
            Log.Debug("[CVS] Configured Working Directory: '{0}'", wd);
            Log.Debug("[CVS] Checkout Working Directory: '{0}'", checkoutWd);
            Log.Debug("[CVS] Checkout Directory: '{0}'", checkoutDir);

            ProcessArgumentBuilder builder = new ProcessArgumentBuilder();
            AppendCvsRoot(builder);
            builder.AddArgument("-q");
            builder.AddArgument("checkout");
            builder.AddArgument("-R");
            builder.AddArgument("-P");
            builder.AddArgument("-r", Branch);
            builder.AddArgument("-d", StringUtil.AutoDoubleQuoteString(checkoutDir));
            builder.AddArgument(Module);
            var pi = NewProcessInfoWithArgs(result, builder.ToString());
            pi.WorkingDirectory = checkoutWd;
            return pi;
        }

 // cvs [-d :ext:mycvsserver:/cvsroot/myrepo] -q log -N "-d>2004-12-24 12:00:00 GMT" -rmy_branch (with branch)
 // cvs [-d :ext:mycvsserver:/cvsroot/myrepo] -q log -Nb "-d>2004-12-24 12:00:00 GMT" (without branch)
 //        public const string HISTORY_COMMAND_FORMAT = @"{0}-q log -N{3} ""-d>{1}""{2}";		// -N means 'do not show tags'
 private string BuildLogProcessInfoArgs(DateTime from)
 {
     ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
     AppendCvsRoot(buffer);
     buffer.AddArgument("-q"); // quiet
     buffer.AddArgument("rlog");
     buffer.AddArgument("-N"); // do not show tags
     buffer.AppendIf(SuppressRevisionHeader, "-S");
     if (string.IsNullOrEmpty(Branch))
     {
         buffer.AddArgument("-b"); // only list revisions on HEAD
     }
     else
     {
         buffer.AppendArgument("-r{0}", Branch); // list revisions on branch
     }
     buffer.AppendArgument(@"""-d>{0}""", FormatCommandDate(from));
     if (!string.IsNullOrEmpty(RestrictLogins))
     {
         foreach (string login in RestrictLogins.Split(','))
         {
             buffer.AppendArgument("-w{0}", login.Trim());
         }
     }
     buffer.AddArgument(Module);
     return buffer.ToString();
 }

 private void AppendCvsRoot(ProcessArgumentBuilder buffer)
 {
     buffer.AddArgument("-d", CvsRoot);
 }

 /// <summary>
 /// Get the date and iime of the latest commit in the remote repository
 /// </summary>
 /// <param name="branchName">Name of the branch.</param>
 /// <param name="result">IIntegrationResult of the current build.</param>
 private string GitLogOriginHashDateTime(string branchName, IIntegrationResult result)
 {
     ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
     buffer.AddArgument("log");
     buffer.AddArgument(string.Concat("origin/", branchName));
     buffer.AddArgument("--date-order");
     buffer.AddArgument("-1");
     buffer.AddArgument("--pretty=format:\"%ci\"");
     return Execute(NewProcessInfo(buffer.ToString(), result)).StandardOutput;
 }