C# ITaskItem类代码示例

 internal void AppendSwitchIfNotNull(string switchName, ITaskItem[] parameters, string[] metadataNames, bool[] treatAsFlags)
 {
     Microsoft.Build.Shared.ErrorUtilities.VerifyThrow((treatAsFlags == null) || (metadataNames.Length == treatAsFlags.Length), "metadataNames and treatAsFlags should have the same length.");
     if (parameters != null)
     {
         foreach (ITaskItem item in parameters)
         {
             base.AppendSwitchIfNotNull(switchName, item.ItemSpec);
             if (metadataNames != null)
             {
                 for (int i = 0; i < metadataNames.Length; i++)
                 {
                     string metadata = item.GetMetadata(metadataNames[i]);
                     if ((metadata != null) && (metadata.Length > 0))
                     {
                         if ((treatAsFlags == null) || !treatAsFlags[i])
                         {
                             base.CommandLine.Append(',');
                             base.AppendTextWithQuoting(metadata);
                         }
                         else if (MetadataConversionUtilities.TryConvertItemMetadataToBool(item, metadataNames[i]))
                         {
                             base.CommandLine.Append(',');
                             base.AppendTextWithQuoting(metadataNames[i]);
                         }
                     }
                     else if ((treatAsFlags == null) || !treatAsFlags[i])
                     {
                         break;
                     }
                 }
             }
         }
     }
 }

 static string GetTarget(ITaskItem x)
 {
     var target = x.GetMetadata("TargetPath");
     if (Path.GetFileName(x.ItemSpec) == Path.GetFileName(target))
         target = Path.GetDirectoryName(target);
     return target;
 }

 private bool RemoveDirectory(ITaskItem directory, bool logUnauthorizedError, out bool unauthorizedAccess)
 {
     bool flag = true;
     unauthorizedAccess = false;
     try
     {
         Directory.Delete(directory.ItemSpec, true);
     }
     catch (UnauthorizedAccessException exception)
     {
         flag = false;
         if (logUnauthorizedError)
         {
             base.Log.LogErrorWithCodeFromResources("RemoveDir.Error", new object[] { directory, exception.Message });
         }
         unauthorizedAccess = true;
     }
     catch (Exception exception2)
     {
         if (Microsoft.Build.Shared.ExceptionHandling.NotExpectedException(exception2))
         {
             throw;
         }
         base.Log.LogErrorWithCodeFromResources("RemoveDir.Error", new object[] { directory.ItemSpec, exception2.Message });
         flag = false;
     }
     return flag;
 }

        protected ITaskItem ConvertPackageElement(ITaskItem project, PackageReference packageReference)
        {
            var id = packageReference.Id;
            var version = packageReference.Version;
            var targetFramework = packageReference.TargetFramework;
            var isDevelopmentDependency = packageReference.IsDevelopmentDependency;
            var requireReinstallation = packageReference.RequireReinstallation;
            var versionConstraint = packageReference.VersionConstraint;

            var item = new TaskItem(id);
            project.CopyMetadataTo(item);

            var packageDirectoryPath = GetPackageDirectoryPath(project.GetMetadata("FullPath"), id, version);
            item.SetMetadata("PackageDirectoryPath", packageDirectoryPath);
            item.SetMetadata("ProjectPath", project.GetMetadata("FullPath"));

            item.SetMetadata("IsDevelopmentDependency", isDevelopmentDependency.ToString());
            item.SetMetadata("RequireReinstallation", requireReinstallation.ToString());

            if (version != null)
                item.SetMetadata(Metadata.Version, version.ToString());

            if (targetFramework != null)
                item.SetMetadata(Metadata.TargetFramework, targetFramework.GetShortFrameworkName());

            if (versionConstraint != null)
                item.SetMetadata("VersionConstraint", versionConstraint.ToString());

            return item;
        }

        private string ComputeNeutralXlfName(ITaskItem neutralResouce)
        {
            var filename = neutralResouce.GetMetadata("Filename");
            var xlfRootPath = LocalizationUtils.ComputeXlfRootPath(neutralResouce);

            return Path.Combine(xlfRootPath, filename + ".xlf");
        }

 private void CheckIfSourceNeedsCompilation(ConcurrentQueue<ITaskItem> sourcesNeedingCompilationList, bool allOutputFilesExist, ITaskItem source)
 {
     if (!this.tlogAvailable || (this.outputFileGroup == null))
     {
         source.SetMetadata("_trackerCompileReason", "Tracking_SourceWillBeCompiledAsNoTrackingLog");
         sourcesNeedingCompilationList.Enqueue(source);
     }
     else if (!this.useMinimalRebuildOptimization && !allOutputFilesExist)
     {
         source.SetMetadata("_trackerCompileReason", "Tracking_SourceOutputsNotAvailable");
         sourcesNeedingCompilationList.Enqueue(source);
     }
     else if (!this.IsUpToDate(source))
     {
         if (string.IsNullOrEmpty(source.GetMetadata("_trackerCompileReason")))
         {
             source.SetMetadata("_trackerCompileReason", "Tracking_SourceWillBeCompiled");
         }
         sourcesNeedingCompilationList.Enqueue(source);
     }
     else if (!this.useMinimalRebuildOptimization && (this.outputNewestTime == DateTime.MinValue))
     {
         source.SetMetadata("_trackerCompileReason", "Tracking_SourceNotInTrackingLog");
         sourcesNeedingCompilationList.Enqueue(source);
     }
 }

 public void AppendFileNamesIfNotNull(ITaskItem[] fileItems, string delimiter)
 {
     ErrorUtilities.VerifyThrowArgumentNull(delimiter, "delimiter");
     if ((fileItems != null) && (fileItems.Length > 0))
     {
         for (int i = 0; i < fileItems.Length; i++)
         {
             if (fileItems[i] != null)
             {
                 this.VerifyThrowNoEmbeddedDoubleQuotes(string.Empty, fileItems[i].ItemSpec);
             }
         }
         this.AppendSpaceIfNotEmpty();
         for (int j = 0; j < fileItems.Length; j++)
         {
             if (j != 0)
             {
                 this.AppendTextUnquoted(delimiter);
             }
             if (fileItems[j] != null)
             {
                 this.AppendFileNameWithQuoting(fileItems[j].ItemSpec);
             }
         }
     }
 }

 public static void CopyMetadataTo(this ITaskItem source, ITaskItem destination, string prefix)
 {
     foreach (string key in source.CloneCustomMetadata().Keys.OfType<string>())
     {
         destination.SetMetadata(String.Concat(prefix, key), source.GetMetadata(key));
     }
 }

		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Initializes a new instance of the <see cref="RegFree"/> class.
		/// </summary>
		/// ------------------------------------------------------------------------------------
		public RegFree()
		{
			Dlls = new ITaskItem[0];
			Fragments = new ITaskItem[0];
			AsIs = new ITaskItem[0];
			NoTypeLib = new ITaskItem[0];
		}

		public override bool Execute() {
			var inputsGroupedByConfigFile = new Dictionary<string, List<WorkItem>>();
		
			OutputFiles = new ITaskItem[InputFiles.Length];
			for (int i = 0; i < InputFiles.Length; i++) {
				string infileLocal = InputFiles[i].ItemSpec;
				OutputFiles[i] = new TaskItem(Path.ChangeExtension(infileLocal, ExecutablesCommon.GeneratedFileExtension));
				string infile     = Path.GetFullPath(infileLocal);
				string outfile    = Path.ChangeExtension(infile, ExecutablesCommon.GeneratedFileExtension);
				string configFile = ExecutablesCommon.FindConfigFilePath(infile) ?? "";
				List<WorkItem> l;
				if (!inputsGroupedByConfigFile.TryGetValue(configFile, out l))
					inputsGroupedByConfigFile[configFile] = l = new List<WorkItem>();
				l.Add(new WorkItem() { InFile = infile, OutFile = outfile, Namespace = FindNamespace(InputFiles[i]) });
			}

			bool success = true;
			foreach (var kvp in inputsGroupedByConfigFile) {
                ExecutablesCommon.ProcessWorkItemsInSeparateAppDomain(kvp.Key, kvp.Value, (item, ex) => {
                    if (ex is TemplateErrorException) {
						Log.LogError(null, null, null, item.InFile, 0, 0, 0, 0, ex.Message);
						success = false;
					}
					else {
						Log.LogErrorFromException(ex, true, true, item.InFile);
						success = false;
					}
                    return true;
                });
			}
			return success;
		}

 public BuildProjectSystem(string root, FrameworkName targetFramework, ITaskItem[] currentReferences)
     : base(root)
 {
     _targetFramework = targetFramework;
     _currentReferences = currentReferences;
     OutputReferences = new List<string>();
 }

 private static ITaskItem[] ExpandWildcards(ITaskItem[] expand)
 {
     if (expand == null)
     {
         return null;
     }
     ArrayList list = new ArrayList();
     foreach (ITaskItem item in expand)
     {
         if (Microsoft.Build.Shared.FileMatcher.HasWildcards(item.ItemSpec))
         {
             foreach (string str in Microsoft.Build.Shared.FileMatcher.GetFiles(null, item.ItemSpec))
             {
                 TaskItem item2 = new TaskItem(item) {
                     ItemSpec = str
                 };
                 Microsoft.Build.Shared.FileMatcher.Result result = Microsoft.Build.Shared.FileMatcher.FileMatch(item.ItemSpec, str);
                 if ((result.isLegalFileSpec && result.isMatch) && ((result.wildcardDirectoryPart != null) && (result.wildcardDirectoryPart.Length > 0)))
                 {
                     item2.SetMetadata("RecursiveDir", result.wildcardDirectoryPart);
                 }
                 list.Add(item2);
             }
         }
         else
         {
             list.Add(item);
         }
     }
     return (ITaskItem[]) list.ToArray(typeof(ITaskItem));
 }

            public ValidationPattern(ITaskItem item, TaskLoggingHelper log)
            {
                string idRegex = item.GetMetadata("IdentityRegex");
                if (string.IsNullOrEmpty(idRegex))
                {
                    // Temporarily support reading the regex from the Include/ItemSpec for backwards compatibility
                    // when the IdentityRegex isn't specified. This can be removed once all consumers are using IdentityRegex.
                    idRegex = item.ItemSpec;
                }

                _idPattern = new Regex(idRegex);
                _expectedVersion = item.GetMetadata("ExpectedVersion");
                _expectedPrerelease = item.GetMetadata("ExpectedPrerelease");
                _log = log;

                if (string.IsNullOrWhiteSpace(_expectedVersion))
                {
                    if (string.IsNullOrWhiteSpace(_expectedPrerelease))
                    {
                        _log.LogError(
                            "Can't find ExpectedVersion or ExpectedPrerelease metadata on item {0}",
                            item.ItemSpec);
                    }
                }
                else if (!string.IsNullOrWhiteSpace(_expectedPrerelease))
                {
                    _log.LogError(
                        "Both ExpectedVersion and ExpectedPrerelease metadata found on item {0}, but only one permitted",
                        item.ItemSpec);
                }
            }

		static string GetLinkPath (ITaskItem file, string path)
		{
			string link = file.GetMetadata ("Link");
			if (!string.IsNullOrEmpty (link)) {
				return link;
			}

			string projectDir;
			var definingProject = file.GetMetadata ("DefiningProjectFullPath");
			if (!string.IsNullOrEmpty (definingProject)) {
				projectDir = Path.GetDirectoryName (definingProject);
			} else {
				projectDir = Environment.CurrentDirectory;
			}

			projectDir = Path.GetFullPath (projectDir);
			if (projectDir [projectDir.Length - 1] != Path.DirectorySeparatorChar) {
				projectDir += Path.DirectorySeparatorChar;
			}

			if (path.StartsWith (projectDir, StringComparison.Ordinal)) {
				link = path.Substring (projectDir.Length);
			} else {
				link = Path.GetFileName (path);
			}

			return link;
		}

        public override bool Execute()
        {
            try {
                string authors;
                using (var fs = new FileStream (AuthorsFile.GetMetadata ("FullPath"), FileMode.Open)) {
                    using (var sr = new StreamReader (fs)) {

                        var authorsStrBuilder = new StringBuilder ();

                        while (!sr.EndOfStream) {
                            var line = sr.ReadLine ().Trim ();
                            if (!string.IsNullOrWhiteSpace (line))
                                authorsStrBuilder.Append ("\"" + line + "\", ");
                        }

                        authors = authorsStrBuilder.ToString ();
                    }
                }

                Output = new TaskItem (authors);
            } catch (Exception ex) {
                Log.LogErrorFromException (ex);
                return false;
            }
            return true;
        }