CommandLineBuilder.AppendSwitch(String) Method

Definition

Namespace:

Microsoft.Build.Utilities

Assembly:

Microsoft.Build.Utilities.Core.dll

Package:

Microsoft.Build.Utilities.Core v17.11.4

Source:

CommandLineBuilder.cs

Appends a command-line switch that has no separate value, without any quoting. This method appends a space to the command line (if it's not currently empty) before the switch.

public:
 void AppendSwitch(System::String ^ switchName);

public void AppendSwitch (string switchName);

member this.AppendSwitch : string -> unit

Public Sub AppendSwitch (switchName As String)

Parameters

switchName

String

The switch to append to the command line, may not be null

Examples

The following example creates a ToolTask that runs Ilasm.exe (IL Assembler). The CommandLineBuilder, ToolLocationHelper, and TaskLoggingHelper classes are used to generate the information needed to run the task.

using System;
using System.Collections;
using System.Text;
using Microsoft.Build.Utilities;
using Microsoft.Build.Framework;

namespace MSBuildTasks
{
    /// <summary>
    /// A very simple and incomplete ToolTask to wrap the ILASM.EXE tool.
    /// </summary>
    public class ILAsm : ToolTask
    {
        #region Member Data
        /// <summary>
        /// Gets the collection of parameters used by the task class.
        /// </summary>
        /// <value>Parameter bag.</value>
        protected internal Hashtable Bag
        {
            get
            {
                return bag;
            }
        }

        private Hashtable bag = new Hashtable();
        #endregion

        #region ILAsm Task Properties
        /// <summary>
        /// The Source file that is to be compled (.il)
        /// </summary>
        public ITaskItem Source
        {
            get { return Bag["Source"] as ITaskItem; }
            set { Bag["Source"] = value; }
        }
        /// <summary>
        /// Either EXE or DLL indicating the assembly type to be generated
        /// </summary>
        public string TargetType
        {
            get { return Bag["TargetType"] as string; }
            set { Bag["TargetType"] = value; }
        }
        #endregion

        #region ToolTask Members
        protected override string ToolName
        {
            get { return "ILAsm.exe"; }
        }

        /// <summary>
        /// Use ToolLocationHelper to find ILASM.EXE in the Framework directory
        /// </summary>
        /// <returns></returns>
        protected override string GenerateFullPathToTool()
        {
            // Ask ToolLocationHelper to find ILASM.EXE - it will look in the latest framework directory available
            return ToolLocationHelper.GetPathToDotNetFrameworkFile(ToolName, TargetDotNetFrameworkVersion.VersionLatest);
        }
        #endregion

        #region ILAsm Task Members
        /// <summary>
        /// Construct the command line from the task properties by using the CommandLineBuilder
        /// </summary>
        /// <returns></returns>
        protected override string GenerateCommandLineCommands()
        {
            CommandLineBuilder builder = new CommandLineBuilder();

            // We don't need the tool's logo information shown
            builder.AppendSwitch("/nologo");

            string targetType = Bag["TargetType"] as string;
            // Be explicit with our switches
            if (targetType != null)
            {
                if (String.Compare(targetType, "DLL", true) == 0)
                {
                    builder.AppendSwitch("/DLL");
                }
                else if (String.Compare(targetType, "EXE", true) == 0)
                {
                    builder.AppendSwitch("/EXE");
                }
                else
                {
                    Log.LogWarning("Invalid TargetType (valid values are DLL and EXE) specified: {0}", targetType);
                }
            }

            // Add the filename that we want the tool to process
            builder.AppendFileNameIfNotNull(Bag["Source"] as ITaskItem);

            // Log a High importance message stating the file that we are assembling
            Log.LogMessage(MessageImportance.High, "Assembling {0}", Bag["Source"]);

            // We have all of our switches added, return the commandline as a string
            return builder.ToString();
        }
        #endregion
    }
}

Imports System.Collections
Imports System.Text
Imports Microsoft.Build.Utilities
Imports Microsoft.Build.Framework

Namespace MSBuildTasks

    ''' <summary>
    ''' A very simple and incomplete ToolTask to wrap the ILASM.EXE tool.
    ''' </summary>
    Public Class ILAsm
        Inherits ToolTask

        ''' <summary>
        ''' Parameter bag.
        ''' </summary>
        Protected Friend ReadOnly Property Bag() As Hashtable
            Get
                Return propertyBag
            End Get
        End Property

        Private propertyBag As New Hashtable()

        ''' <summary>
        ''' The Source file that is to be compled (.il)
        ''' </summary>
        Public Property [Source]() As ITaskItem
            Get
                Return Bag("Source")
            End Get
            Set(ByVal value As ITaskItem)
                Bag("Source") = value
            End Set
        End Property

        ''' <summary>
        ''' Either EXE or DLL indicating the assembly type to be generated
        ''' </summary>
        Public Property TargetType() As String
            Get
                Return Bag("TargetType")
            End Get
            Set(ByVal value As String)
                Bag("TargetType") = value
            End Set
        End Property '

        Protected Overrides ReadOnly Property ToolName() As String
            Get
                Return "ILAsm.exe"
            End Get
        End Property

        ''' <summary>
        ''' Use ToolLocationHelper to find ILASM.EXE in the Framework directory
        ''' </summary>
        Protected Overrides Function GenerateFullPathToTool() As String
            ' Ask ToolLocationHelper to find ILASM.EXE - it will look in the latest framework directory available
            Return ToolLocationHelper.GetPathToDotNetFrameworkFile(ToolName, TargetDotNetFrameworkVersion.VersionLatest)
        End Function

        ''' <summary>
        ''' Construct the command line from the task properties by using the CommandLineBuilder
        ''' </summary>
        Protected Overrides Function GenerateCommandLineCommands() As String
            Dim builder As New CommandLineBuilder()

            ' We don't need the tool's logo information shown
            builder.AppendSwitch("/nologo")

            Dim targetType As String = Bag("TargetType")
            ' Be explicit with our switches
            If Not (targetType Is Nothing) Then
                If [String].Compare(targetType, "DLL", True) = 0 Then
                    builder.AppendSwitch("/DLL")
                ElseIf [String].Compare(targetType, "EXE", True) = 0 Then
                    builder.AppendSwitch("/EXE")
                Else
                    Log.LogWarning("Invalid TargetType (valid values are DLL and EXE) specified: {0}", targetType)
                End If
            End If
            ' Add the filename that we want the tool to process
            builder.AppendFileNameIfNotNull(Bag("Source"))

            ' Log a High importance message stating the file that we are assembling
            Log.LogMessage(MessageImportance.High, "Assembling {0}", Bag("Source"))

            ' We have all of our switches added, return the commandline as a string
            Return builder.ToString()
        End Function
    End Class
End Namespace

AppendSwitch("/utf8output") => "/utf8output"

Remarks

If the command line is not empty, then this method also appends the command line with a space, before the switch.