C# ProcessArgumentBuilder.ToString方法代码示例

 private string GetLoggerArgs(IIntegrationResult result)
 {
     ProcessArgumentBuilder builder = new ProcessArgumentBuilder();
     builder.Append("/l:");
     builder.Append(Logger);
     builder.Append(";");
     builder.Append(MsBuildOutputFile(result));
     return builder.ToString();
 }

        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();
        }

        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();
        }

 private string BuildPushProcessArgs()
 {
     ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
     buffer.AppendArgument("push");
     return buffer.ToString();
 }

 private string BuildGetSourceArguments()
 {
     ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
     buffer.Append("pull");
     return buffer.ToString();
 }

 private void RemoveReadOnlyAttribute()
 {
     ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
     buffer.AddArgument("-R");
     buffer.AddArgument("/s", SandboxRoot + "\\*");
     Execute(new ProcessInfo("attrib", buffer.ToString()));
 }

 //RESYNC_TEMPLATE = "resync --overwriteChanged --restoreTimestamp-R -S {SandboxRoot\SandboxFile} --user={user} --password={password} --quiet"
 private string BuildResyncCommand()
 {
     ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
     buffer.AppendArgument("resync");
     buffer.AppendArgument("--overwriteChanged");
     buffer.AppendArgument("--restoreTimestamp");
     buffer.AppendArgument("--forceConfirm=yes");
     buffer.AppendArgument("--includeDropped");
     AppendCommonArguments(buffer, true);
     return buffer.ToString();
 }

 private string BuildDisconnectCommand()
 {
     ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
     buffer.AppendArgument("disconnect");
     buffer.AppendArgument("--user={0}", User);
     buffer.AppendArgument("--password={0}", Password);
     buffer.AppendArgument("--quiet");
     buffer.AppendArgument("--forceConfirm=yes");
     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>
		/// Clone a repository into a new directory with "git clone 'repository' 'working directory'".
		/// </summary>
		/// <param name="result">IIntegrationResult of the current build.</param>
		private void GitClone(IIntegrationResult result)
		{
			string wd = BaseWorkingDirectory(result);

			ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
			buffer.AddArgument("clone");
			buffer.AddArgument(Repository);
			buffer.AddArgument(wd);

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

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

			ProcessInfo pi = NewProcessInfo(buffer.ToString(), result);
			// Use upper level of the working directory, because the
			// working directory currently does not exist and
			// will be created by "git clone". "git clone" will fail if
			// the working directory already exist.
			pi.WorkingDirectory = Path.GetDirectoryName(wd.Trim().TrimEnd(Path.DirectorySeparatorChar));
			Execute(pi);

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

		private ProcessResult GitLogHistory(string branchNameOrRevision, IIntegrationResult to)
		{
			ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
			buffer.AddArgument("log");
			buffer.AddArgument(branchNameOrRevision);
			AppendLogOptions(buffer);
			return Execute(NewProcessInfo(buffer.ToString(), to));
		}

		/// <summary>
		/// Get the hash of the latest commit in the remote repository.
		/// </summary>
		/// <param name="branchNameOrRevision">Name of the branch or revision</param>
		/// <param name="result">IIntegrationResult of the current build.</param>
		private string GitLogOriginHash(string branchNameOrRevision, IIntegrationResult result)
		{
			ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
			buffer.AddArgument("log");
			buffer.AddArgument(branchNameOrRevision);
			buffer.AddArgument("-1");
			buffer.AddArgument("--pretty=format:\"%H\"");
			return Execute(NewProcessInfo(buffer.ToString(), result)).StandardOutput.Trim();
		}

        protected override string GetProcessArguments(IIntegrationResult result)
        {
            ProcessArgumentBuilder args = new ProcessArgumentBuilder();
            args.AddArgument("--rakefile", Rakefile);

            if (Silent)
                args.AddArgument("--silent");
            else if (Quiet)
                args.AddArgument("--quiet");

            if (Trace)
                args.AddArgument("--trace");

            args.AppendArgument(BuildArgs);

            foreach (string t in Targets)
                args.AppendArgument(t);

            return args.ToString();
        }

        /// <summary>
        /// Retrieve the arguments
        /// </summary>
        /// <param name="result">The result to use.</param>
        /// <returns>The arguments to pass to the process.</returns>
        protected override string GetProcessArguments(IIntegrationResult result)
        {
            var buffer = new ProcessArgumentBuilder();
            buffer.AppendIf(this.Recurse, "-r");
            buffer.AppendArgument("-t" + this.Threshold.ToString(CultureInfo.CurrentCulture));
            buffer.AppendArgument("-w" + this.Width.ToString(CultureInfo.CurrentCulture));
            buffer.AppendArgument("-oConsole");

            // Add the focus
            if (!string.IsNullOrEmpty(this.Focus))
            {
                buffer.AppendArgument("-f" + this.QuoteSpaces(this.Focus));
            }

            // Add the lines to exclude
            foreach (var line in this.LinesToExclude ?? new string[0])
            {
                buffer.AppendArgument("-x" + this.QuoteSpaces(line));
            }

            // Add the lines to exclude
            foreach (var line in this.FilesToExclude ?? new string[0])
            {
                buffer.AppendArgument("-e" + this.QuoteSpaces(line));
            }

            buffer.AppendArgument(this.FileMask);
            return buffer.ToString();
        }