C# CommandLineBuilderExtension.AppendSwitchAliased方法代码示例

 private void AddReferencesToCommandLine(CommandLineBuilderExtension commandLine)
 {
     if ((base.References != null) && (base.References.Length != 0))
     {
         foreach (ITaskItem item in base.References)
         {
             string metadata = item.GetMetadata("Aliases");
             string switchName = "/reference:";
             if (MetadataConversionUtilities.TryConvertItemMetadataToBool(item, "EmbedInteropTypes"))
             {
                 switchName = "/link:";
             }
             if ((metadata == null) || (metadata.Length == 0))
             {
                 commandLine.AppendSwitchIfNotNull(switchName, item.ItemSpec);
             }
             else
             {
                 foreach (string str3 in metadata.Split(new char[] { ',' }))
                 {
                     string str4 = str3.Trim();
                     if (str3.Length != 0)
                     {
                         if (str4.IndexOfAny(new char[] { ',', ' ', ';', '"' }) != -1)
                         {
                             Microsoft.Build.Shared.ErrorUtilities.VerifyThrowArgument(false, "Csc.AssemblyAliasContainsIllegalCharacters", item.ItemSpec, str4);
                         }
                         if (string.Compare("global", str4, StringComparison.OrdinalIgnoreCase) == 0)
                         {
                             commandLine.AppendSwitchIfNotNull(switchName, item.ItemSpec);
                         }
                         else
                         {
                             commandLine.AppendSwitchAliased(switchName, str4, item.ItemSpec);
                         }
                     }
                 }
             }
         }
     }
 }

        /// <summary>
        /// The C# compiler (starting with Whidbey) supports assembly aliasing for references.
        /// See spec at http://devdiv/spectool/Documents/Whidbey/VCSharp/Design%20Time/M3%20DCRs/DCR%20Assembly%20aliases.doc.
        /// This method handles the necessary work of looking at the "Aliases" attribute on
        /// the incoming "References" items, and making sure to generate the correct
        /// command-line on csc.exe.  The syntax for aliasing a reference is:
        ///     csc.exe /reference:Foo=System.Xml.dll
        ///
        /// The "Aliases" attribute on the "References" items is actually a comma-separated
        /// list of aliases, and if any of the aliases specified is the string "global",
        /// then we add that reference to the command-line without an alias.
        /// </summary>
        /// <param name="commandLine"></param>
        private void AddReferencesToCommandLine
            (
            CommandLineBuilderExtension commandLine
            )
        {
            // If there were no references passed in, don't add any /reference: switches
            // on the command-line.
            if ((this.References == null) || (this.References.Length == 0))
            {
                return;
            }

            // Loop through all the references passed in.  We'll be adding separate
            // /reference: switches for each reference, and in some cases even multiple
            // /reference: switches per reference.
            foreach (ITaskItem reference in this.References)
            {
                // See if there was an "Alias" attribute on the reference.
                string aliasString = reference.GetMetadata(ItemMetadataNames.aliases);


                string switchName = "/reference:";
                bool embed = MetadataConversionUtilities.TryConvertItemMetadataToBool
                    (
                        reference,
                        ItemMetadataNames.embedInteropTypes
                    );

                if (embed == true)
                {
                    switchName = "/link:";
                }

                if ((aliasString == null) || (aliasString.Length == 0))
                {
                    // If there was no "Alias" attribute, just add this as a global reference.
                    commandLine.AppendSwitchIfNotNull(switchName, reference.ItemSpec);
                }
                else
                {
                    // If there was an "Alias" attribute, it contains a comma-separated list
                    // of aliases to use for this reference.  For each one of those aliases,
                    // we're going to add a separate /reference: switch to the csc.exe
                    // command-line
                    string[] aliases = aliasString.Split(',');

                    foreach (string alias in aliases)
                    {
                        // Trim whitespace.
                        string trimmedAlias = alias.Trim();

                        if (alias.Length == 0)
                        {
                            continue;
                        }

                        // The alias should be a valid C# identifier.  Therefore it cannot
                        // contain comma, space, semicolon, or double-quote.  Let's check for
                        // the existence of those characters right here, and bail immediately
                        // if any are present.  There are a whole bunch of other characters
                        // that are not allowed in a C# identifier, but we'll just let csc.exe
                        // error out on those.  The ones we're checking for here are the ones
                        // that could seriously interfere with the command-line parsing or could
                        // allow parameter injection.
                        if (trimmedAlias.IndexOfAny(new char[] { ',', ' ', ';', '"' }) != -1)
                        {
                            ErrorUtilities.VerifyThrowArgument
                            (
                                false,
                                "Csc.AssemblyAliasContainsIllegalCharacters",
                                reference.ItemSpec,
                                trimmedAlias
                            );
                        }

                        // The alias called "global" is special.  It means that we don't
                        // give it an alias on the command-line.
                        if (String.Compare("global", trimmedAlias, StringComparison.OrdinalIgnoreCase) == 0)
                        {
                            commandLine.AppendSwitchIfNotNull(switchName, reference.ItemSpec);
                        }
                        else
                        {
                            // We have a valid (and explicit) alias for this reference.  Add
                            // it to the command-line using the syntax:
                            //      /reference:Foo=System.Xml.dll
                            commandLine.AppendSwitchAliased(switchName, trimmedAlias, reference.ItemSpec);
//.........这里部分代码省略.........

 private void AddReferencesToCommandLine(CommandLineBuilderExtension commandLine)
 {
     if (base.References == null || base.References.Length == 0)
     {
         return;
     }
     ITaskItem[] references = base.References;
     for (int i = 0; i < references.Length; i++)
     {
         ITaskItem taskItem = references[i];
         string metadata = taskItem.GetMetadata("Aliases");
         string switchName = "/reference:";
         bool flag = MetadataConversionUtilities.TryConvertItemMetadataToBool(taskItem, "EmbedInteropTypes");
         if (flag)
         {
             switchName = "/link:";
         }
         if (metadata == null || metadata.Length == 0)
         {
             commandLine.AppendSwitchIfNotNull(switchName, taskItem.ItemSpec);
         }
         else
         {
             string[] array = metadata.Split(new char[]
             {
                 ','
             });
             string[] array2 = array;
             for (int j = 0; j < array2.Length; j++)
             {
                 string text = array2[j];
                 string text2 = text.Trim();
                 if (text.Length != 0)
                 {
                     if (text2.IndexOfAny(new char[]
                     {
                         ',',
                         ' ',
                         ';',
                         '"'
                     }) != -1)
                     {
                         ErrorUtilities.VerifyThrowArgument(false, "Csc.AssemblyAliasContainsIllegalCharacters", taskItem.ItemSpec, text2);
                     }
                     if (string.Compare("global", text2, StringComparison.OrdinalIgnoreCase) == 0)
                     {
                         commandLine.AppendSwitchIfNotNull(switchName, taskItem.ItemSpec);
                     }
                     else
                     {
                         commandLine.AppendSwitchAliased(switchName, text2, taskItem.ItemSpec);
                     }
                 }
             }
         }
     }
 }